三种高阶比较排序算法

时间复杂度的估算

这三种排序算法都是利用在遍历过程中在一定程度上排序的同时记录尽可能多的元素有关位置的信息。

master表达式：用于对采用递归实现的相关算法的时间复杂度的估算

Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜…＜Ο(2n)＜Ο(n!)

T(N)=aT(N/b)+N^d

log_ab=d时:T(N)=O(N*logN)

1.归并排序

1.1思想

时间复杂度:O(N*logN)

空间复杂度:N

文字叙述：归并排序采用将数组拆分为左右两项，左右两部分各自内部保证相对有顺序，左右两边按照双指针的指示，采取排序规则，将新排好的数据插入新申请的数组内部，最后将中间排好序的数组放回原数组。

要点如下： 1.申请辅助空间存储排好序的新数组。

​ 2.对超出对比的部分直接放入辅助空间。

​ 3.将辅助空间内的数据赋值回原数组时，注意数组下标。

tips：mid=l+((r-1)>>1)，这样可以有效避免溢出问题。并炫技。

1.2代码

public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        mergeSort(arr, 0, arr.length - 1);
    }
​
    private static void mergeSort(int[] arr, int l, int r) {
​
        if (l == r) {
            return;
        }
        int mid = (l + r) / 2;
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);
        merge(arr, l, mid, r);
    }
​
    private static void merge(int[] arr, int l, int mid, int r) {
​
        int[] tmp = new int[r - l + 1];
        int p1 = l;
        int p2 = mid + 1;
        int i = 0;
        while (p1 <= mid && p2 <= r) {
            // 这里的<=保证了算法的稳定性
            tmp[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1 <= mid) {
            tmp[i++] = arr[p1++];
        }
        while (p2 <= r) {
            tmp[i++] = arr[p2++];
        }
        // 将辅助数组中的数进行拷贝到原数组中
        for (int j = 0; j < tmp.length; j++) {
            arr[l + j] = tmp[j];
        }
    }

---

2.快速排序

2.1思想

时间复杂度:O(N*logN)

空间复杂度:logN

这里空间复杂度需要加深理解，这是由于在递归过程中，必须有每次有一个变量记录partition返回的数组位置。为方便理解，可以认为在每次都返回中间位置mid的情况下，这是一个类似二分的过程，所以为logN。

文字叙述：快速排序采用每次选出一个标志位，并将数组按照标志位的大小分为大于与不大于（小于等于）两部分，逐次将数组排序好。

算法优化： 1.通过random抵消每次出现partition最坏情况的出现，即每次都是分在头上，只排序好一个位置的

元素。

​ 2.采用荷兰国旗经典问题的启示，将数组从原来的分为两组，变成分为三组，即小于，等于，大于这三个部分，这样等于在一次遍历后可以认为一次排好序了相同元素个数的元素，在只要有相同元素存在的情况都会降低一定复杂度。

图片叙述：

2.2代码

// 快速排序,这里直接写改进过后的快速排序（荷兰国旗问题：< = > ）
    public static void quickSort(int[] arr) {
​
        if (arr == null || arr.length < 2) {
            return;
        }
        quickSort(arr, 0, arr.length - 1);
    }
​
    private static void quickSort(int[] arr, int l, int r) {
​
        if (l < r) {
            int p[] = partition(arr, l, r);
            quickSort(arr, l, p[0]);
            quickSort(arr, p[1], r);
        }
​
    }
​
    private static int[] partition(int[] arr, int l, int r) {
​
        int less = l - 1;
        int more = r;
        // 这里分为三种区域：< = > 边界为。。less less。。l more。。
        while (l < more) {
            if (arr[l] < arr[r]) {
                swap(arr, ++less, l++);
            } else if (arr[l] == arr[r]) {
                l++;
            } else {
                swap(arr, l, --more);
            }
        }
        // 再将评分标准arr[r]换回=区.结束排序
        swap(arr, more++, r);
        // 这里返回的是=区的两侧边界的两侧，即如果要求等于区有多少元素的话，应该为 more-less-1
        return new int[] { less, more };
    }
​
    public static void swap(int[] arr, int l, int r) {
        int tmp = arr[l];
        arr[l] = arr[r];
        arr[r] = tmp;
    }// 由于第一次写这种思想的快速排序，耗时较长，花费35分钟，需要加强练习。
​
    // 堆排序，堆排序总体上看分为两个过程，建立大根堆与堆的重新建立
​

 

---

3.堆排序

3.1思想

时间复杂度:O(N*logN)

空间复杂度:1

对于一个节点n，如果有左右孩子节点

​ 左孩子：2n+1

​ 右孩子：2n+2

对于一个节点n，如果有父节点

​ 父节点：(n-1)/2

文字叙述：堆排序算法采用堆的思想，主题分为两部分：建立大根堆与堆的重建立。

堆：即完全二叉树，与数组相互建立联系，因为数组是一个接一个的，不可能出现null，所以一定是一个从上到下，从左至右将树填满的过程，借用二叉树优秀的数据结构，将排序的复杂度降低。

堆的建立：从左至右依次遍历，并一步步建立堆，新加进来的元素需要与父节点比较，并上升至直到顶点，注意下部分代码的判断条件，一步实现了两种边界判断的优秀代码。总结，堆的建立时一个节点上升的过程，不需要考虑数组的下界限问题（这里指树结构时的上下）。

堆的重建立：堆的重建立是建立在一次次将根节点与数组最后节点交换的情况下，剩下元素（不包括刚刚交换下来的前根节点，因为在大根堆的情况下已经可以保证之前根节点一定为数组内最大）的大根堆重建立，这里新的根节点需要判断是否比其孩子节点的最大值小（如果有孩子节点，这里孩子节点只需要判断左孩子节点，因为是完全二叉树，一定有左孩子节点，而不一定有右孩子节点），这样当大根堆重建立的时候又可以保证根节点的最大，依次完成所有根节点的pop。总结，堆的重建立是一个根节点的下落过程，不需要考虑上边界的越界。

3.2代码

// 堆排序，堆排序总体上看分为两个过程，建立大根堆与堆的重新建立
​
    public static void heapSort(int[] arr) {
​
        if (arr == null || arr.length < 2) {
            return;
        }
        heapSort(arr, 0, arr.length - 1);
    }
​
    private static void heapSort(int[] arr, int l, int r) {
​
        for (int i = l; i <= r; i++) {
            heapInsert(arr, i);
        }
        int size = arr.length;
        swap(arr, 0, --size);
        while (size > 0) {
            heapify(arr, 0, size);
            swap(arr, 0, --size);
        }
​
    }
​
    private static void heapInsert(int[] arr, int i) {
        while (arr[(i - 1) / 2] < arr[i]) {// 这条是大神写的，竟然可以控制上限，请仔细思考
            swap(arr, (i - 1) / 2, i);
            i /= 2;
        }
    }
​
    private static void heapify(int[] arr, int i, int size) {
        int left = i * 2 + 1;
        while (left < size) {
            int largest = left + 1 < size && arr[left] < arr[left + 1] ? left + 1 : left;//编程美不美？
            largest = arr[largest]>arr[i]?largest:i;
            if(largest==i) {
                break;
            }
            swap(arr, i, largest);
            i = largest;
            left = i*2+1;
        }
​
    }
​

 

---

4.算法的稳定性

算法的稳定性笼统上来说就是在排序过后相等的各元素是否保持相对顺序不变，这在简单数据类型中不必考虑，没有意义，但是复杂数据类型就有了相应的应用环境，比如电商平台商品的筛选，需求：在搜索商品后，填上筛选条件，选择了价格排序的同时，我希望相同种类的商品相对位置不变。或者说，在成绩排名这个场景中，我先拍好了全校的成绩，但是需要分为班级，这时我不希望每个班级中学生成绩又变成乱乱的，我希望还是按照之前学校成绩排好的那种相对位置不变，就可以直接排好每个班级的成绩。

以下是不稳定的排序算法的某些例子，可自行思考。

选择排序：[5,5,5,1,5]

快速排序：[7,7,7,3,5]

堆排序：[4,3,3,5]

 

---

5.工程上混合排序算法的优化

1.简单数据类型使用快速排序，复杂数据类型使用归并排序，这是考虑到算法的稳定性。并且需要补充的是，快速排序是时间复杂度为O(N*logN)的三种排序算法中常数项最少的，即是这三种算法中最快的。

2.快速排序的使用时，中间递归的结束条件不以简单的if(L==R)为结束，而是将简单排序与复杂排序相结合，使用插入排序，判断条件为所要排序算法的规模，默认为60个。我认为，这是由于递归对栈空间的大量占用，以及时间复杂度在数据量小的时候体现不明显甚至有可能还不如插入排序。

下篇将介绍简单排序与非比较排序（桶排序的简单介绍）