数据结构与算法(四) - 十大排序算法

数据结构与算法(四) - 排序算法

1. 概述

评判排序算法好坏的标准，之后算法性能评判的都在此基础之上进行：

• 时间复杂度：分析算法的时间复杂度时要分别给出最好情况、最坏情况、平均情况下的时复杂度。在对同一阶时间复杂度的排序算法性能对比时，我们要把系数、常数、低阶也考虑进来。
• 空间复杂度：简单理解为算法的内存消耗，引入另一个概念**in-place和out-place**。in-place，原地排序，指空间复杂度为O(1)的排序算法，只占用常数内存；out-place，非原地排序，算法需要占用额外内存。
• 算法稳定性：如果待排序的序列中存在值相等的元素，结果排序之后，相等元素之间原有的先后顺序不变。例如3，7，2，7，8排序之后为2，3，7，7，8其中两个7的先后次序没有发生变化则称该算法是文档的排序算法。（一般会优先选择具有稳定性的算法）

冒泡、选择、插入、归并、快速、希尔、堆排序，都是基于比较的排序，平均时间复杂度最低是O(nlogn)。

计数排序、桶排序、基数排序，都不是基于比较的排序，它们是典型的用空间换时间，在某些时候，平均时间复杂度可以比O(nlogn)更低。

---

2. 冒泡排序

从待排序序列的第一个元素开始，依次比较相邻元素的值，发现不满足大小关系则交换，将值较大的元素逐渐从前向后移动。每一次冒泡会让至少一个元素移动到它应该在的位置上。

coding:

public int[] bubbleSort(int[] arr){
   
   
    for (int i = 0; i < arr.length; i++) {
   
   
        //相临元素的比较
        for (int j = 0; j < arr.length - 1 - i; j++) {
   
   
            if (arr[j] > arr[j + 1]) {
   
   
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
    return arr;
}

优化：如果某次排序中没有发生交换，则可以结束排序

public int[] bubbleSort(int[] arr){
   
   
    for (int i = 0; i < arr.length; i++) {
   
   
        boolean flag = true;
        //相临元素的比较
        for (int j = 0; j < arr.length - 1 - i; j++) {
   
   
            if (arr[j] > arr[j + 1]) {
   
   
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
                flag = false;//说明要排序
            }
        }
        if(flag) return arr;//说明此时数据已经有序 直接返回即可
    }
    return arr;
}

1.时间复杂度

最好情况下数据已经有序，只需要进行一次冒泡操作，就可以结束。冒泡排序最好的时间复杂度是O(n)。而最坏的情况就是所有数据刚好倒序与目的顺序，就需要进行n次冒泡排序，最坏的时间复杂度为O(n*n)。

2.空间复杂度

过程中只涉及相邻数据的交换，只需要常量级的临时空间，空间复杂度为O(1)，是in-place排序算法。

3.是否为稳定排序算法

冒泡排序在相邻数据相同时我们不做交换，则属于稳定排序算法。（可修改）

---

3. 快速排序

快速排序简称快排，是对冒泡排序的一种改进，利用分治思想。基本思想是：选择一个数作为 基准点（我选的最后一个数），通过一趟排序将要排序的数据分割成独立的三部分，其中 左部分 的所有数据都比 基准点 的数据小，基准点的数据比 右部分 的所有数据都要小，然后再按此方法对这左右两部分数据分别进行快速排序，直到左右数据长度为1时结束。整个排序过程可以递归进行，以此达到整个数据变成有序序列。

coding：

public int[] quickSort(int[] arr, int start, int end) {
   
   
   if (start < end) {
   
   //这是必须一开始就判断是的点！！！
       int left = start, right = end, datum = arr[start];
       //实现
       while (left < right) {
   
   
           //右边数大于或等于基准点 指针左移一
           while (left < right && arr[right] >= datum) right--;
           //右边数组小于基准点 放在左边去
           arr[left] = arr[right];
           left++;
           //左边数小于基准点 指针右移一
           while (left < right && arr[left] < datum) left++;
           //左边数大于或等于基准点 放到右边
           arr[right] = arr[left];
           right--;
       }
       //一趟循环结束 此时left=right 将基准点数据载入
       arr[left] = datum;
       //分治递归
       quickSort(arr, start, left - 1);
       quickSort(arr, left + 1, end);
   }
   return arr;
}

1.时间复杂度

最好时间复杂和平均时间复杂度为O(nlogn)，极端情况下为O(n^2)

2.空间复杂度

不需要额外空间，所以空间复杂度是O(n)，in-place原地排序算法。

3.是否为稳定排序算法

分区后，我们使用的策略是如果两个数据相同也可能会会交换，所以快速排序不是一个稳定的排序算法。

---

4. 选择排序

分为已排序区间和未排序区间。已排序区间初始为空。每次排序会从 未排序区间 找到最小的元素，将其放到 已排序区间 末尾，实现升序，降序反之。

基本思想：

第一次从 arr[0]~arr[n-1]中选取最小值，与 arr[0]交换
第二次从 arr[1]~arr[n-1]中选取最小值，与 arr[1]交换
第三次从 arr[2]~arr[n-1]中选取最小值，与 arr[2] 交换
第 i 次从 arr[i-1]~arr[n-1]中选取最小值，与 arr[i-1]交换
第 n-1 次从 arr[n-2]~arr[n-1]中选取最小值，与 arr[n-2]交换

总共通过 n-1 次，得到一个按排序码从小到大排列的有序序列。coding：

public int[] selectSort(int[] arr){
   
   
    for (int i = 0; i < arr