【大话数据结构&算法】冒泡排序

起泡排序又称为冒泡排序。它是通过一系列的“交换”动作完成的。首先将第一和第二个记录进行比较，如果第一个记录大于第二个记录，则两者交换位置，否则保持原位置不变；然后比较第二和第三个记录……一直按这种方式比较下去，最终最大的记录被交换到最后，一趟冒泡排序完成。这个过程，大的记录就像一块石头一样“沉底”，小的记录逐渐向上“浮动 ”，冒泡排序的名字也是由此而来的。

冒泡排序的步骤归纳如下(以升序排序为例)：

1、依次比较序列中相邻的两个元素 ，将较大的放在后面，这样一趟下来 ，最大的元素就被放到了最后；
2、接着重复第一步，第二趟下来， 第二大的元素就被放到倒数第二的位 置上；
3、依次循环，直到最小的元素被放 在第一个位置上，排序结束。

冒泡排序基本算法实现如下：

//冒泡排序
void bubbleSort(int[] a, int n){
    int temp;
    for (int i = 0; i < n; i++) {
          for (int j = 1; j < n - i; j++) {
                if (a[j-1] > a[j]) {
                     temp = a[j-1];
                     a[j-1] = a[j];
                     a[j] = temp;
               }
         }
   }
}

java代码实现如下：

public class BubbleSort {

       public static void main(String[] args) {
             int[] a = {2,5,9,3,0,4,6};
             bubbleSort(a,7);
             bubbleSortAdvanced(a,7);
             for (int i = 0; i < a.length; i++) {
                  System. out.println(a[i]);
            }
            System. out.println("***********" );
             bubbleSortAdvanced(a,7);
             for (int i = 0; i < a.length; i++) {
                  System. out.println(a[i]);
            }

      }

       //原始冒泡排序(注意n的取值)
       public static void bubbleSort(int[] a, int n){
             int temp;
             for (int i = 0; i < n; i++) {
                   for (int j = 1; j < n - i; j++) {
                         if (a[j-1] > a[j]) {
                              temp = a[j-1];
                              a[j-1] = a[j];
                              a[j] = temp;
                        }
                  }
            }
      }

       /**
       * 冒泡排序优化:
       *
       * 设置一个标志位flag，如果这一趟发生了交换，flag=true，否则flag=false。
       * 如果有一趟没有发生交换，说明排序已经完成。
       *
       * 注意n的取值
       */
       public static void bubbleSortAdvanced(int[] a, int n){
             int temp;
             boolean flag = true;
             while(flag){
                  flag = false;
                   for (int i = 0; i < n; i++) {
                         for (int j = 1; j < n; j++) {
                               if (a[j-1] > a[j]) {
                                    temp = a[j-1];
                                    a[j-1] = a[j];
                                    a[j] = temp;
                                    flag = true;//如果本趟没有发生数据交换，说明排序已经完成，不再进行比较
                              }
                        }
                  }
            }
      }      
}

时间复杂度：

最坏情况下，待排序列逆序，此时对于外层循环的每次执行，内层循环中if语句的条件a[j-1] > a[j]始终成立，即基本操作执行的次数为n-i。i的取值为1 ~ n-1。因此，基本操作总的执行次数为(n-1+1)(n-1)/2=n(n-1)/2，由此可知时间复杂度为O(n2){n的平方}。

最好情况下，待排序列有序，此时内层循环中if语句的条件始终不成立，交换不发生，且内层循环执行n-1次后整个算法结束，时间复杂度为O(n)。

综上所述，冒泡排序的平均时间复杂度为O(n2){n的平方}。

---

空间复杂度：

由算法代码可以看出，额外辅助空间只有一个temp，因此空间复杂度为0(1)。