十大排序1--冒泡排序及其两种优化附代码

十大排序-冒泡排序

Bubble Sort

冒泡排序

基本思想:两个数比较大小,较大的数下沉,较小的数冒起来

思路描述:

1. 比较两个相邻的元素,如果第一个比迪二个大,就交换他们两个
2. 对没一对相邻元素作同样的工作,从开始第一对到结束的最后一对,这样在最后元素应该会是虽大的数
3. 针对所有的元素重复以上的步骤,除了最后一个;
4. 重复步骤1~3,直到排序结束

代码实现

代码一[未优化]

    public static int[] bubbleSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        return array;
    }

代码二[优化1]

• 如果原来的数组时有序数组1 2 3 4
• 如果按照原来的方法bubbleSort,还是要遍历n-1趟,有点浪费时间
• 于是,每跑完一趟,就判断一次数组现在是否有序,如果有序;
• 直接return 设置一个标签flag 进行判断

private static int[] bubbleSort1(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int flag = 0;//判别的标签
            for (int j = 0; j < array.length - 1 - i; j++) {

                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = 1;//如果发生交换，标签值改变
                }
            }
            if (flag == 0) {//如果这趟走完，没有发生交换，则原数组有序；
                return array;
            }
        }
        return array;
    }

代码三[优化2]

针对代码2的优化

原数组: 4 3 2 5 6

第一趟:3 2 4 5 6 第一次交换后发生在2 和4 记住2的下标j

第二趟:2 3 4 5 6 第二次 内部比较的时候,只比较j次:下标从 j到最后的已经有序了,就不需要进行比较了

按照上面的描述可以较少比较的次数,从而达到需要的优化

 private static int[] bubbleSort2(int[] array) {
        int n = 0;
        int k = array.length - 1;
        for (int i = 0; i < array.length; i++) {
            int flag = 0;//判别的标签

            for (int j = 0; j < k; j++) {

                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = 1;
                    n = j;
                }
            }
            if (flag == 0) {
                return array;
            }
            k = n;
        }
        return array;
    }

总结:

平均时间复杂度O(n²)

最好情况 O(n)

最坏情况 O(n²)

空间复杂度 O(1)

排序方式 ln-place

稳定性 稳定