8种常用排序算法解析

原文https://juejin.im/post/5e5c56096fb9a07cd443bebd

冒泡排序

1. 思想：两两比较相邻的元素，如果逆序则进行交换，这样每一趟‘冒泡’都能将一最大元素一直移动到最右侧，之后控制冒泡次数，当元素不存在逆序时即完成了排序
2. 时空复杂度分析：

• 时间复杂度：
  最好O(n)，原数组有序，一趟排序（内部n-1次的比较）后发现已不存在逆序元素；
  最坏O(n2)，原数组逆序，要进行n-1趟冒泡，每趟约发生n/2次比较，3*n/2次移动，最坏为O(n2)；
  平均O(n2)，平均情况下，约发生n*(n-1)/4次比较，3*n*(n-1)/4次移动，平均为O(n2)
• 空间复杂度：
  O(1)，在交换逆序元素时，要借助一辅助空间

3. 稳定性：只有交换才会影响两元素前后顺序，所以书写时两元素相等不交换即可保证稳定性，是稳定排序
4. 代码示例

public void bubbleSort(int []arr) {
    int len = arr.length;
    for(int i = 0; i < len; i++) {
        boolean isChanged = false;
        for(int j = 0; j < len - 1; j++) {
            if(arr[j] > arr[j + 1]) {
                swap(arr, j, j + 1);
                isChanged = true;
            }
        }
        if (!isChanged) break;
    }
}

插入排序

1. 思想：在首部维护一个有序集合，未排序元素从有序集合末尾向开头比较，如果未排序元素大，则追加到有序集合末尾，否则搬移数据直至未排序元素到达合适位置
2. 时空复杂度分析：

• 时间复杂度：
  最好O(n)，原数组有序，一趟排序，内部n-1次的比较；
  最坏O(n2)，原数组逆序，要进行n-1趟，和冒泡一样每趟平均发生n/2次比较，n/2次数据移动，最坏为O(n2)；
  平均O(n2)，平均情况下，约发生n*(n-1)/4次比较，n*(n-1)/4次数据移动，平均为O(n2)
• 空间复杂度：
  O(1)，要借助一辅助空间存储未排元素值

3. 稳定性： 出现值相同的元素，将后面未排序元素插入到排序元素的后面，这样保证了两元素的先后顺序不变，是稳定排序
4. 比较
   • 和冒泡排序的时间、空间复杂度完全一致，但是插入排序要比冒泡排序性能更高，因为冒泡排序在进行交换时有三个赋值语句，插入排序在进行移动时只有一条语句，这样导致计算机在执行耗时上出现差异
5. 代码示例

pubic void insertSort(int []arr) {
    for(int i = 1; i < arr.length; i++) {
        int unSort = arr[i];
        int j = i - 1;
        for(; j >= 0; j--) {
            if(arr[j] > unSort) {
                arr[j + 1] = arr[j];
            } else {
                break;
            }
        }
        arr[j + 1] = unSort;
    }
}

选择排序

1. 思想：遍历所有未排序元素，找到最小值对应下标，将其与排序集合末尾元素交换
2. 时空复杂度分析：

• 时间复杂度：
  最好O(n2)，原数组有序，不移动，但是进行n*(n-1)/2次比较，最好为O(n2)；
  最坏O(n2)，原数组逆序，发生n*(n-1)/2次比较，3*n*(n-1)/2次移动操作，最坏为O(n2)；
  平均O(n2)，平均情况下，发生n*(n-1)/4次比较，3*n*(n-1)/4次移动操作，平均为O(n2)
• 空间复杂度：
  O(1)，要借助一辅助空间存储用于交换

3. 稳定性： 选择排序每次都要在未排序元素中的最小值，并和前面的元素交换位置，破坏了稳定性，是不稳定排序
4. 比较：
   • 在O(n2)重量级中，选择排序表现不佳，他的最好时间为O(n2)这一点比不上冒泡和插入，而且还不是稳定排序算法；他的优点就是书写简单
5. 代码示例

public void selectSort(int []arr) {
    for(int i = 0; i < arr.length; i++) {
        int minIndex = i;
        for(int j = i + 1; j < arr.length; j++) {
            if(arr[minIndex] > arr[j]) {
                minIndex = j;
            }
        }
        swap(arr, i, minIndex);
    }
}

快速排序

1. 思想：选择一个基准点pivot，并且通过调整使得左侧所有数都小于pivot，右侧所有数都大于pivot（也可以说将pivot放置到了排序后他应该在的位置），之后按照同样的思想去处理左侧和右侧数据（分治思想），最后可以得到有序数组
2. 时空复杂度分析：

• 时间复杂度：

    假设n个元素排序所需时间为T(n),则分解为两个数组后时间为T(n/2)
        T(1) = C,           n=1
        T(n) = 2*T(n/2)+n,  n>1(定位pivot位置时间复杂度为O(n))
            = 2*(2*T(n/4)+n/2)+n = 4*T(n/4)+2n
            = 4*(2*T(n/8)+n/4)+2n = 8*T(n/8)+3n
            ...
            = 2^k*T(n/(2^k))+kn
            当n=2^k，即k=logn时，T(n) = Cn + nlogn

最好O(nlogn)，pivot刚好把区间划分为等大的两个，最好为O(nlogn)；
最坏O(n2)，原数据有序，每次划分得到一个比上一次少一个的序列，递归树成了单只树，这样要进行n-1次分区操作，平均每次比较n/2次，最坏为O(n2)；
平均O(nlogn)，理论上平均复杂度为O(nlogn)

• 空间复杂度：
  O(nlogn)，递归写法取决于压栈的次数

3. 稳定性： 在定位pivot位置时存在交换操作，是不稳定排序
4. 示例代码

public void quickSort(int []arr) {
    quickSortInner(arr, 0, arr.length - 1);
}
private void quickSortInner(int []arr, int lo, int hi) {
    if(lo >= hi) return;
    int pivot = partition(arr, lo, hi);
    quickSortInner(arr, lo, pivot - 1);
    quickSortInner(arr, pivot + 1, hi);
}
private int partition(int []arr, int lo, int hi) {
    // arr首元素为分区点
    int pivotValue = arr[lo];
    swap(arr, lo, hi);
    int temp = hi;
    hi--;
    while (lo <= hi) {
        if(arr[lo] > pivotValue) {
            swap(arr, lo, hi);
            hi--;
        } else {
            lo++;
        }
    }
    swap(arr, lo, temp);
    return lo;
}

归并排序

1. 思想：利用分治思想，先将一个数组不断细分，当分割得到的两个数组长度为1时两两合并为有序序列，再拿着这个有序序列和其他的有序序列合并，最终能够得到一整个有序序列
2. 时空复杂度分析：

• 时间复杂度：
  归并排序要将数组不断细分再依次合并，和原来数组的有序程度无关，所以他的最好、最坏和平均时间复杂度都为O(nlogn),分析方法和快速排序一致（merge方法时间复杂度为O(n)）
• 空间复杂度：
  O(n)，merge方法中需要一辅助空间存储有序序列

3. 稳定性：在merge方法中，出现值相等情况时选择后者保持了他的稳定性，是稳定排序
4. 示例代码

public void mergeSort(int []arr) {
    mergeSortInner(arr, 0, arr.length - 1);
}
private void mergeSortInner(int []arr, int lo, int hi) {
    if(lo >= hi) return;
    int mid = lo + (hi - lo) / 2;
    mergeSortInner(arr, lo, mid);
    mergeSortInner(arr, mid + 1, hi);
    merge(arr, lo, mid, hi);
}
private void merge(int []arr, int lo, int mid, int hi) {
    int i = lo, j = mid + 1, k = 0;
    int []temp = new int[hi - lo + 1];
    while(i <= mid && j <= hi) {
        if(arr[i] < arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    int start = i, end = mid;
    if(j <= hi) {
        start = j;
        end = hi;
    }
    while(start <= end) {
        temp[k++] = arr[start++];
    }
    System.arraycopy(temp, 0, arr, lo, hi - lo + 1);
}

堆排序

1. 思想：利用堆的特性（堆中每个节点的值都大于等于（或小于等于）其子树中每个节点的值）建立一个大顶堆，然后将堆顶元素和最后一个元素交换（此时末尾序列有序），交换完后调整堆继续交换，最后能够得到一个有序序列。
2. 时空复杂度分析：

• 时间复杂度：
  堆化的时间复杂度经过计算可以得知为O(n),排序过程中交换并对剩余元素堆化，时间复杂度为O(nlogn),总体上时间复杂度为O(nlogn)
  和归并排序类似，堆排序和原数组的有序程度无关，一个有序数组经过堆化也会被打乱之后再次调整，所以他的最好、最坏、平均时间复杂度都是O(nlogn)的
• 空间复杂度：
  O(1)，交换时要借助辅助变量

3. 稳定性：在堆化和排序过程中存在大量交换操作，无法保证先后，是不稳定排序
4. 示例代码

public void heapSort(int []arr) {
    int len = arr.length;
    // 建堆
    for(int i = (len - 1) / 2; i >= 0; i--) {
        heapAdjust(arr, len - 1, i);
    }
    // 排序
    for(int i = len - 1; i >= 0; i--) {
        swap(arr, i, 0);
        heapAdjust(arr, i - 1, 0);
    }
}
private void heapAdjust(int []arr, int en, int st) {
    while(true) {
        int maxIndex = st;
        if(st * 2 + 1 <= en && arr[i] < arr[st * 2 + 1]) {
            maxIndex = st * 2 + 1;
        } 
        if(st * 2 + 2 <= en && arr[maxIndex] < arr[st * 2 + 2]) {
            maxIndex = st * 2 + 2;
        }
        if(maxIndex == st) break;
        swap(arr, maxIndex, st);
        st = maxIndex;
    }
}

桶排序

1. 思想：它是针对大数据量和外部排序等情形提出的。它将数据先分配到不同的桶中，每个桶内部进行排序，所有桶内部排序后，再将不同的桶之间进行合并，最后形成了一整个有序序列。
2. 时空复杂度分析：

• 时间复杂度：
  最好O(n),数据分布均匀，假设n个数据均分到m个桶中，一个桶有n/m个数据，桶内数据快速排序，则一个桶复杂度为(n/m)*log(n/m),m个桶就是nlog(n/m),当m一直逼近n时，时间复杂度接近O(n)
  最坏O(nlogn),数据分布极其不均匀，集中在一个桶内，而桶内是快排，时间复杂度为O(nlogn)
• 空间复杂度：
  O(n)，要借助辅助数组将原数据划分到桶里

3. 稳定性：和它依托的内部排序有关，这里使用了块排，所以是不稳定排序
4. 示例代码

public void bucketSort(int []arr, int bucketSize) {
    // 找边界
    int min = arr[0], max = arr[0], len = arr.length;
    for(int i = 0; i < len; i++) {
        if(min >= arr[i]) min = arr[i];
        if(max <= arr[i]) max = arr[i];
    }
    
    // 桶的个数
    int bucketCount = (max - min) / bucketSize + 1;
    // 哪个桶哪个下标放了什么元素
    int [][]buckets = new int[bucketCount][bucketSize];
    // 标记哪个桶
    int []indexArr = new int[bucketCount];
    
    // 装桶
    for(int i = 0; i < len; i++) {
        int bucketIndex = (arr[i] - min) / bucketSize;
        // 扩容
        if(indexArr[bucketIndex] == buckets[bucketIndex].length) {
            ensureCap(buckets, bucketIndex);
        }
        buckets[bucketIndex][indexArr[bucketIndex]++] = arr[i];
    }
    
    // 桶内排序
    int k = 0;
    for(int i = 0; i < buckets.length; i++) {
        quickSortInner(buckets[i], 0, indexArr[i] - 1);
        // 桶之间合并
        for(int j = 0; j < indexArr[i]; j++) {
            arr[k++] = buckets[i][j];
        }
    }
}
private void ensureCap(int [][]buckets, int bucketIndex) {
    int []temp = buckets[bucketIndex];
    int []newArr = new int[temp.length * 2];
    System.arraycopy(temp, 0, newArr, 0, temp.length);
    buckets[bucketIndex] = newArr;
}

计数排序

1. 思想：它是针对大数据量且数据分布区间很窄的情形提出的。它是桶排序的特例，当数据分布相对集中时，我们可以分配多个桶并将相同数据放置到同一个桶内，省去了桶内排序。只需要一次扫描每个桶，将桶内数据输出到数组中即可。
2. 时空复杂度分析：

• 时间复杂度：
  O(n),存在多个单层for循环(3n+k)，根据大O表示法，时间复杂度为O(n)
• 空间复杂度：
  O(n),排序过程中要借助计数数组(长度为maxValue+1)和一辅助数组(长度为len)

3. 稳定性：由于采用从后向前填充的技巧，他是稳定排序算法
4. 示例代码

public void countSort(int []arr) {
    int max = arr[0], len = arr.length;
    for(int i = 0; i < len; i++) {
        if(max < arr[i]) {
            max = arr[i];
        }
    }
    // 计数数组
    int []count = new int[max + 1];
    for(int i = 0; i < len; i++) {
        count[arr[i]]++;
    }
    // 累加数组
    for(int i = 1; i <= max; i++) {
        count[i] = count[i - 1] + count[i];
    }
    // 排序
    int []res = new int[len];
    for(int i = len - 1; i >= 0; i--) {
        int index = count[arr[i]] - 1;
        res[index] = arr[i];
        count[arr[i]]--;
    }
    System.arraycopy(res, 0, arr, 0, res.length);
}

参考资料

1. 严蔚敏 李冬梅 吴伟民编著的《数据结构C语言版|第二版》
2. 王争的极客时间专栏《数据结构与算法之美》
3. 快排写法https://www.bilibili.com/video/BV1w4411H7k5