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

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

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

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)

你可能感兴趣的:(数据结构/算法)