常见的排序：冒泡、选择、插入、快排及其优化

Bruce.Yee

于 2023-02-22 09:47:00 发布

阅读量424

点赞数

文章标签：排序算法算法数据结构

本文链接：https://blog.csdn.net/weixin_59369584/article/details/129155090

版权

文章详细描述了四种常见的排序算法：冒泡排序、选择排序、插入排序和快速排序的原理和优化方法。对于冒泡排序，提出了减少冒泡次数和比较次数的优化策略；选择排序和插入排序对比了它们的实现和优化方式；快速排序则介绍了单边循环和双边循环两种方案，并强调了基准点的选择对效率的影响。所有算法都考虑了如何减少交换和比较的次数以提高性能。

摘要由CSDN通过智能技术生成

冒泡排序

文字描述

依次比较数组中相邻两个元素大小，若array[j] > array[j + 1]，则交换两个元素，两两比较一遍称为一轮冒泡，结果是让最大的元素排到最后。
重复以上操作，直到整个数组有序

优化方式

减少冒泡次数

比如，原本就是有序的数组，本可以冒泡一次，就可以确定它是有序的。

所以需要定义一个boolean变量swapped（是否交换），如果一个循环下来，所有的冒泡都不需要交换，那么就可以证明它是有序数组，所以直接break，具体代码如下：

public class BubbleSort {
    public static void main(String[] args) {
        // int[] array = {5,2,7,4,1,3,8,9};
        int[] array = {1,2,3,4,5};
        bubble(array);
    }

    private static void bubble(int[] array) {
        for (int j = 0; j < array.length - 1; j++) {
            // 定义一个循环下来是否交换
            boolean swapped = false;
            for (int i = 0; i < array.length - 1 - j; i++) {
                if (array[i] > array[i + 1]){
                    swap(array,i,i + 1);
                    swapped = true;
                }
            }
            System.out.println("第" + j + "轮冒泡的结果" + Arrays.toString(array));
            if (!swapped){
                break;
            }
        }
    }

    private static void swap(int[] array, int i, int i1) {
        int temp = array[i];
        array[i] = array[i1];
        array[i1] = temp;
    }
}

运行结果

第0轮冒泡的结果[1, 2, 3, 4, 5]

减少比较次数【最终实现】

例如{5,2,7,4,1,3,8,9}这个数组，第一轮冒泡结束后的结果是{2, 5, 4, 1, 3, 7, 8, 9}，比较了7次，但是第二次冒泡就没必要比较6次，因为第一轮冒泡没有交换最后3个数，所以就应该记录最后一次交换时的下标i【也就是3的下标哦，而不是i + 1，也就不是7的下标】，再下一轮冒泡循环的时候，就只比较i次就行了~

注意：为什么说这是最终实现？

因为这个代码可以直接实现减少冒泡次数，等最后一次交换的索引为0，表示整个数组有序，就可以break退出循环。【就相当于上面的swapped变量优化”减少冒泡次数“】

文字描述如下：

优化方式:每轮冒泡时，最后一次交换索引可以作为下一轮冒泡的比较次数,如果这个值为零，表示整个数组有序,直接退出外层循环即可

代码如下：

public class BubbleSort {
    public static void main(String[] args) {
        // int[] array = {5,2,7,4,1,3,8,9};
        int[] array = {1,2,3,4,5};
        bubble(array);
    }

    private static void bubble(int[] array) {
        // 由于n第一次需要赋值为array.length - 1且每次循环都会被改变，所以应该定义在最外层
        int n = array.length - 1;
        while (true){
            // 需要一个中间变量记录下标
            int index = 0;
            for (int i = 0; i < n; i++) {
                if (array[i] > array[i + 1]){
                    swap(array,i,i + 1);
                    index = i;
                }
                System.out.println("第" + i + "次比较");
            }
            System.out.println("这一轮冒泡的结果是" + Arrays.toString(array));
            // 把最后一次交换的下标赋值
            n = index;
            if (n == 0){
                break;
            }
        }
    }

    private static void swap(int[] array, int i, int i1) {
        int temp = array[i];
        array[i] = array[i1];
        array[i1] = temp;
    }
}

运行结果

第0次比较
第1次比较
第2次比较
第3次比较
第4次比较
第5次比较
第6次比较
这一轮冒泡的结果是[2, 5, 4, 1, 3, 7, 8, 9]
第0次比较
第1次比较
第2次比较
第3次比较
这一轮冒泡的结果是[2, 4, 1, 3, 5, 7, 8, 9]
第0次比较
第1次比较
第2次比较
这一轮冒泡的结果是[2, 1, 3, 4, 5, 7, 8, 9]
第0次比较
第1次比较
这一轮冒泡的结果是[1, 2, 3, 4, 5, 7, 8, 9]

选择排序

文字描述

将数组分为两个子集，排序的和未排序的，每一轮从未排序的子集中选出最小的元素，放入排序子集
重复以上步骤，直到整个数组有序

代码如下：

/**
 * 选择排序
 */
public class SelectSort {
    public static void main(String[] args) {
        int[] array = {5,2,7,4,1,3,8,9};
        select(array);
    }

    private static void select(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int min = array[i];
            int minIndex = i;
            for (int j = minIndex + 1; j < array.length; j++) {
                if (min > array[j]){
                    minIndex = j;
                    min = array[j];
                }
            }
            if (minIndex != i){
                swap(array,i,minIndex);
            }
            System.out.println("第" + i + "轮选择排序后的结果" + Arrays.toString(array));
        }
    }

    private static void swap(int[] array, int i, int minIndex) {
        int temp = array[i];
        array[i] = array[minIndex];
        array[minIndex] = temp;
    }
}

运行结果

第0轮选择排序后的结果[1, 2, 7, 4, 5, 3, 8, 9]
第1轮选择排序后的结果[1, 2, 7, 4, 5, 3, 8, 9]
第2轮选择排序后的结果[1, 2, 3, 4, 5, 7, 8, 9]
第3轮选择排序后的结果[1, 2, 3, 4, 5, 7, 8, 9]
第4轮选择排序后的结果[1, 2, 3, 4, 5, 7, 8, 9]
第5轮选择排序后的结果[1, 2, 3, 4, 5, 7, 8, 9]
第6轮选择排序后的结果[1, 2, 3, 4, 5, 7, 8, 9]

优化方式

为了减少交换次数，每一轮先找出最小的索引，在每一轮最后再交换元素。

与冒泡排序对比

二者平均时间复杂度都是O(n2)
选择排序一般要快于冒泡，因为其交换次数少
但如果集合有序度高，冒泡优于选择
冒泡属于稳定排序算法，而选择属于不稳定排序

所谓稳定，也就是假如一个数组中，有两个数字2，如果不稳定，那每次排序时，两个2的排序可能不一样~【以扑克牌为例】

插入排序

文字描述

文字描述（以升序为例)

将数组分为两个区域，排序区域和未排序区域，每一轮
从未排序区域中取出第一个元素，插入到排序区域（需保证顺序)
重复以上步骤，直到整个数组有序

优化方式

待插入元素进行比较时，遇到比自己小的元素，就代表找到了插入位置，无需进行后续比较
插入时可以直接移动元素，而不是交换元素

代码如下

/**
 * 插入排序
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] array = {5,2,7,4,1,3,8,9};
        // int[] array = {1,2,3,4,5,6,7,8,9};
        insert(array);
    }

    private static void insert(int[] array) {
        for (int i = 1; i < array.length; i++) {
            // 临时保存待插入的值
            int temp = array[i];
            int j = i - 1;
            while (j >= 0){
                if (array[j] > temp){
                    array[j + 1] = array[j];
                }
                else {
                    break;
                }
                j--;
            }
            array[j + 1] = temp;
            System.out.println("第" + i + "轮插入排序的结果是" + Arrays.toString(array));
        }
    }
}

与选择排序对比

二者平均时间复杂度都是O(n2)
大部分情况下，插入都略优于选择
有序集合插入的时间复杂度为O(n)
插入属于稳定排序算法，而选择属于不稳定排序

快速排序

1、单边循环快排

文字描述

单边循环快排(lomuto洛穆托分区方案)

选择最右元素作为基准点元素
j指针负责找到比基准点小的元素，一旦找到则与i进行交换
i指针维护小于基准点元素的边界，也是每次交换的目标索引
最后基准点与i交换，i即为分区位置

代码如下

/**
 * 单边循环，基准点在右边
 */
public class QuickSort {
    public static void main(String[] args) {
        int[] array = {5,3,7,2,9,8,1,4};
        // 传入左边界和右边界
        quick(array,0,array.length - 1);
    }

    private static void quick(int[] array, int l, int h) {
        // 下面会采用递归，所以先判断左边界是否小于右边界。
        /**
       		为什么这里是大于等于？而不是大于呢？
       		因为左边界和右边界相等，说明这个区间只剩下这一个数，所以就没有必要再递归下去，而且递归下去的话，还会执行partition方法
       	**/
        if (l >= h){
            return;
        }
        
        int index = partition(array,l,h);
        quick(array,l,index - 1);
        quick(array,index + 1,h);
    }

    private static int partition(int[] array, int l, int h) {
        int i = l;
        for (int j = l; j < h; j++) {
            if (array[j] < array[h]){
                if (i != j){
                    swap(array,i,j);
                }
                i++;
            }
        }
        if (i != h){
            swap(array,i,h);
        }
        System.out.println(Arrays.toString(array) + " i = " + i);
        return i;
    }

    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

2、双边循环快排

文字描述

双边循环快排(并不完全等价于hoare霍尔分区方案)

选择最左元素作为基准点元素
j指针负责从右向左找比基准点小的元素，i指针负责从左向右找比基准点大的元素，一旦找到二者交换，直至i，j相交
最后基准点与i(此时i与j相等）交换，i即为分区位置

public class QuickSort2 {
    public static void main(String[] args) {
        int[] array = {5,3,7,2,9,8,1,4};
        // 传入左边界和右边界
        quick(array,0,array.length - 1);
    }

    private static void quick(int[] array, int l, int h) {
        // 下面会采用递归，所以先判断左边界是否小于右边界。
        /**
       		为什么这里是大于等于？而不是大于呢？
       		因为左边界和右边界相等，说明这个区间只剩下这一个数，所以就没有必要再递归下去，而且递归下去的话，还会执行partition方法
       	**/
        if (l >= h){
            return;
        }
        
        int index = partition(array,l,h);
        quick(array,l,index - 1);
        quick(array,index + 1,h);
    }

    private static int partition(int[] array, int l, int h) {
        int i = l,j = h;
        while(i < j){
            while(i < j && array[j] > array[l]){
                j--;
            }
            while(i < j && array[i] <= array[l]){
                i++;
            }
            swap(array,i,j);
        }
        swap(array,l,j);
        System.out.println(Arrays.toString(array) + " j = " + j);
        return j;
    }

    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

运行结果

[1, 3, 4, 2, 5, 8, 9, 7] j = 4
[1, 3, 4, 2, 5, 8, 9, 7] j = 0
[1, 2, 3, 4, 5, 8, 9, 7] j = 2
[1, 2, 3, 4, 5, 7, 8, 9] j = 6

注意事项

双边循环几个要点

基准点在左边，并且要先j后i
while( i < j && ali] > pv ) j–
while ( i < j && a[i] <= pv ) i++

单边循环快排的基准点在右边，双边循环快排的基准点在左边。先j后i，因为如果先i后j的话，每次 i 与 j 相等时会同时指向比基准点大的数，每次外层循环的最后一次swap会把比基准点大的数交换到前面。

Bruce.Yee

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

常见的排序：冒泡、选择、插入、快排 及其优化

常见的排序

冒泡排序

文字描述

优化方式

减少冒泡次数

减少比较次数【最终实现】

选择排序

文字描述

优化方式

与冒泡排序对比

插入排序

文字描述

优化方式

与选择排序对比

快速排序

1、单边循环快排

文字描述

2、双边循环快排

文字描述

注意事项

常见的排序：冒泡、选择、插入、快排及其优化