各种常用排序算法

这几天打算整理一下各种常用基础排序算法，并且通过代码断点调试，加深一下对各种算法的认识。

1.插入排序（插入类排序--稳定）

 当待排序的数据基本有序时，插入排序的效率比较高，只需要进行很少的数据移动。

算法描述

1. 从第一个元素开始，该元素可以认为已经被排序；
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5. 将新元素插入到该位置后；
6. 重复步骤2~5。

算法分析

时间复杂度：

最好：T(n) = O(n)   最坏：T(n) = O(n²)   平均：T(n) = O(n²)

空间复杂度：O(1)

稳定性：稳定

    /**
     * 插入排序
     * 时间复杂度O(n²),空间复杂度0(1)
     * 稳定
     * 原理：
     * 默认第1个元素是有序的，
     * 然后将第2个元素和第1个元素比较，插入
     * 假定现在是有序的
     * 然后将第3个元素和前2个元素比较，插入
     */
    public static void insertSort(int[] arr) {

        for (int i = 1; i < arr.length; i++) {//因为从1开始，所以是arr.length
            //定义待插入的数
            int insertVal = arr[i];
            int insertIndex = i - 1;//即arr[1]的前边这个数的下标,假定第1个就是最小有序的

            //给insertVal找到插入的位置
            //说明
            //1.insertIndex >= 0保证在给insertVal 找到插入的位置，不越界
            //2.insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置
            //3.就需要将arr[insertIndex]后移
            while (insertIndex >= 0 && arr[insertIndex] > insertVal) {
                arr[insertIndex + 1] = arr[insertIndex];//101后移，{101,34,119,1}=>{101,101,119,1}
                insertIndex--;//101再和之前的比较，如果超出下标，则退出循环
            }
            //当退出while循环时，说明插入的位置找到，insertIndex+1
            arr[insertIndex + 1] = insertVal;


        }
        
    }

2.选择排序（选择类排序--不稳定）

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

算法描述

1. 对于给定的一组记录，经过第一轮比较后得到最小的记录，然后将该记录与第一个记录的位置进行交换；
2. 接着对不包括第一个记录以外的其他记录进行第二轮比较，得到最小的记录并与第二个记录进行位置交换；
3. 重复该过程，直到进行比较的记录只有一个时为止。

算法分析

时间复杂度：

最好：T(n) = O(n²)  最差：T(n) = O(n²)  平均：T(n) = O(n²)

空间复杂度：O(1)

稳定性：不稳定

    /**
     * 选择排序
     * 时间复杂度O(n²),空间复杂度0(1)
     * 不稳定
     * 原理：
     * 假定数组中第1个数是最小的，然后从第2个开始向后遍历，
     * 依次和第1个比较，如果之后有更小的即和第1个交换，放在array[0]，
     * 然后再遍历找第二个最小的，放在array[1]。。。。
     * B站讲解地址：https://www.bilibili.com/video/av54095344/?p=58
     */
    public static void selectionSort(int[] array) {

        for (int i = 0; i < array.length - 1; i++) {
            int minIndex = i;
            int min = array[i];
            // 找出最小值的下标
            for (int j = i + 1; j < array.length; j++) {
                if (min > array[j]) {//说明假定的最小值，并不是最小值
                    min = array[j];//重置min
                    minIndex = j;//重置minIndex
                }
            }
            // 一轮下来后，已定位到此轮最小的值，将其放在第i位,即交换
			if (minIndex != i) { // 此处为优化部分：当出现两个一样的值时，不做交换，也可忽略
				array[minIndex] = array[i];
				array[i] = min;
			}
        }
    }

3.冒泡排序(交换类排序)

算法描述

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3. 针对所有的元素重复以上的步骤，除了最后一个；
4. 重复步骤1~3，直到排序完成。

 算法分析

时间复杂度：

最好：T(n) = O(n)   最差：T(n) = O(n²)   平均：T(n) = O(n²)

空间复杂度：O(1)

稳定性：稳定

    /**
     * 冒泡排序
     * 时间复杂度O(n²),空间复杂度0(1)
     * 稳定
     */
    public static void BubbleSort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {
            //int a = arr.length - 1;
            for (int j = 0; j < arr.length - i - 1; j++) {
                //int b = arr.length - i - 1;
                if (arr[j] > arr[j + 1]) {//如果想改为降序排序这里改为<即可
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;

                }
            }
        }
    }

4.快速排序(交换类排序)

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

1. 从数列中挑出一个元素，称为 “基准”（pivot），一般为第一个元素；
2. 重新排序数列，将基准拿出，从后向前扫描，将小于基准的元素，和基准换；然后从前向后扫，将大于基准的数，再和前一个已替换的位置加入此元素。循回往复，直到“碰头”，即基准位于中间。
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

算法分析

时间复杂度：

最好：T(n) = O(nlog2n)  最差：T(n) = O(n²)  平均：T(n) = O(nlog2n)

空间复杂度：O(nlog2n)

稳定性：不稳定

    /**
     * 快速排序
     * 时间复杂度O(nlog2n),空间复杂度0(nlog2n)
     * 不稳定
     */
    public static int[] sortQuick(int[] arr, int left, int right){
        //{17,3,2,45,65,33,12};
        int key = arr[left]; //选定数组第一个数字作为key
        int start = left;
        int end = right;
        while(start<end){
            //从右向左遍历,找到小于key的,放入下标strat中。
            while(start < end && key<=arr[end]){
                end--;
            }
            arr[start] = arr[end];

            //从左向右遍历,找到大于key的,放入下标end中。
            while(start < end && key > arr[start]){
                start++;
            }
            arr[end] = arr[start];
        }
        //此时start==end,这就是所谓的轴，把key放入轴中，轴左边的都<key,轴右边的都>key
        arr[start] = key;
        //此时大家想象一下，轴在数组中间，说明把数组分成两部分，此时要对这两部分分别进行快排。{12,3,2,17,65,33,45};
        if(start>left)sortQuick(arr,left,start-1);
        if(end<right)sortQuick(arr, end+1, right);
        return arr;
    }

5.希尔排序（选择类排序--不稳定）

算法描述

我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2...1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2. 按增量序列个数k，对序列进行k 趟排序；
3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

算法分析

时间复杂度：

最好：T(n) = O(n²)  最差：T(n) = O(n²)  

空间复杂度：O(1)

稳定性：不稳定

 

    /**
     * 希尔排序（选择类排序的改进）
     * 时间复杂度最差：O(n²),最好：O(n)，空间复杂度0(1)
     * 不稳定
     */
    public static void shellSort(int[] arrays) {
        //增量每次都/2
        for (int step = arrays.length / 2; step > 0; step /= 2) {
            //从增量那组开始进行插入排序，直至完毕
            for (int i = step; i < arrays.length; i++) {
                int j = i;
                int temp = arrays[j];
                // j - step 就是代表与它同组隔壁的元素
                while (j - step >= 0 && arrays[j - step] > temp) {
                    arrays[j] = arrays[j - step];
                    j = j - step;
                }
                arrays[j] = temp;
            }
        }

    }

最后，附上常见排序算法表