写好最简单的冒泡排序

冒泡排序，真的很简单，不是嘛，如果给你15分钟，也许你会很快就写出来一个，真的，我相信你，而且说不定考虑的还是相当周全滴，在此仅以此博客记录一下，我所认识的冒泡排序。

冒泡排序，为什么取这个名？

你可以想想池塘里的气泡，从最底部向最上部浮起的过程，是不是由小变大的过程中，这是一个物理知识，就不用说了吧，不知道的，回去看看初中科本吧，因此浮到水面的气泡是不是最大的，这也就是取名冒泡的原因啦，浮到最上面的就是最大的，当然你别认为冒泡只能实现从小到大排序，大与小本身就是一种相对概念~

冒泡排序的思路(从小到大排序)

1:比较相邻的元素,如果第一个元素比第二个元素小，就将其交换之

2:对每一对相邻元素都做同样的工作，从第一对直至最后一对

3:做完第2步，这里最大的元素已经浮至最上面的位置，去除最后一个元素，重新执行上面的步骤，如果所有相邻元素的比较过程中均没有交换发生，排序完成。

冒泡排序的时间复杂度

最好的情况下，是待排序的元素已经处于有序的状态，这里只需要n-1次比较就可以了，也不需要进行元素的交换，因此最好时间复杂度为O(n)

最坏的情况下，是待排序的元素处于逆序的状态，因此每次循环都需要进行n-i-1次比较，根据数学知识(高中的)可以得知总共需要的比较次数是n*(n-1)/2,对于每次的比软均需要3次移动交换操作，因此总共的移动交换操作数为3n*(n-1)/2.因此总共的时间复杂度为O(n^2)

因此算法的平均时间复杂度为O(n^2)

冒泡排序的空间复杂度

空间复杂度这个很好计算，看一眼就知道了吧，整个程序中就用到了一个变量，用于交换用，因此空间复杂度为O(1),但是不一定呦，下面有程序二将空间复杂度降为0

冒泡排序的稳定性

稳定性，这个也是显然的，是稳定的，两个相邻元素，如果是相等的，就不进行交换，除非是你有意为之~~~

普通的冒泡排序源程序

[

void BubbleSort(int *a ,int N) 
{ 
    bool flag=true; 
    int tmp; 
    for(int i=0;i<N;i++) 
    { 
        for(int j=0;j<N-i;j++) 
        { 
            if(a[j]>a[j+1]) 
            { 
                tmp=a[j]; 
                a[j]=a[j+1]; 
                a[j+1]=tmp; 
                flag=false; 
            } 
        } 
        if(flag) 
            break; 
    } 
    return ; 
} 

void BubbleSort(int *a ,int N)
{
 bool flag=true;
 int tmp;
 for(int i=0;i<N;i++)
 {
  for(int j=0;j<N-i;j++)
  {
   if(a[j]>a[j+1])
   {
    tmp=a[j];
    a[j]=a[j+1];
    a[j+1]=tmp;
    flag=false;
   }
  }
  if(flag)
   break;
 }
 return ;
}

更快的空间复杂度为0的冒泡排序

void BubbleSort(int *a ,int N) 
{ 
    bool flag=true; 
    for(int i=0;i<N;i++) 
    { 
        for(int j=0;j<N-i;j++) 
        { 
            if(a[j]>a[j+1]) 
            { 
                a[j]=a[j]^a[j+1]; 
                a[j+1]=a[j+1]^a[j]; 
                a[j]=a[j+1]^a[j]; 
                flag=false; 
            } 
        } 
        if(flag) 
            break; 
    } 
    return ; 
} 

void BubbleSort(int *a ,int N)
{
 bool flag=true;
 for(int i=0;i<N;i++)
 {
  for(int j=0;j<N-i;j++)
  {
   if(a[j]>a[j+1])
   {
    a[j]=a[j]^a[j+1];
    a[j+1]=a[j+1]^a[j];
    a[j]=a[j+1]^a[j];
    flag=false;
   }
  }
  if(flag)
   break;
 }
 return ;

}上面代码用到了异或操作，降低算法空间复杂度

补充：软件开发 , C++ ,