排序——冒泡排序

冒泡排序思想

将相邻的元素两两进行比较，大的元素向后移动一位，第一轮循环比较后，最大的元素移到了最后位置，以此进行。（按升序来说）

• 排序稳定性：稳定
• 复杂度：O(n²)

实现版：

    /**
     * 冒泡排序
     * @param a 待排序数组
     * @param n 数组长度
     */
    private void bubbleSort(int a[], int n) {
        int i, j, tmp;
        for (i = n - 1; i >= 0; i--) {
            for (j = 0; j < n - 1; j++) {
                if (a[j] > a[j + 1]) {
                    tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] =tmp;
                }
            }
        }
    }

 

优化版一：

     * 设置一个标志flag，默认为false
     * 如果每轮发生元素交换则置为true
     * 如果一轮比较没有发生元素交换则说明元素已排好序，结束循环即可

    /**
     * 冒泡排序优化版
     * 设置一个标志flag，默认为false
     * 如果每轮发生元素交换则置为true
     * 如果一轮比较没有发生元素交换则说明元素已排好序，结束循环即可
     * @param a
     * @param n
     */
    private static void bubbleSort1(int a[], int n) {
        int i, j, tmp;
        boolean flag = false;
        for (i = n - 1; i >= 0; i--) {
            for (j = 0; j < n - 1; j++) {
                if (a[j] > a[j + 1]) {
                    tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] =tmp;
                    flag = true;
                }
            }
            if (!flag){
                break;
            }
        }
    }

优化版二：

某一轮结束位置为j，但是这一轮的最后一次交换发生在lastSwap的位置，则lastSwap到j之间是排好序的，下一轮的结束点就不必是j--了，而直接到lastSwap即可

   private static void bubbleSort2(int a[], int n) {
       int i, j, lastSwap, tmp;
       for (j=n-1; j>0; j=lastSwap) {
           lastSwap=0;//每一轮要初始化为0，防止某一轮未发生交换，lastSwap保留上一轮的值进入死循环
           for (i=0; i<j; i++) {
               if (a[i] > a[i+1]) {
                   tmp=a[i];
                   a[i]=a[i+1];
                   a[i+1]=tmp;//最后一次交换位置的坐标
                   lastSwap = i;
               }
           }
       }
   }