十大排序算法总结

摘要：排序算法的稳定性例如排序一个数组，数组中有两个，排序之后是，如果排序之后的两个的前后顺序没有发生变化，那么称这个排序是稳定的，反之则是不稳定的。冒泡排序冒泡排序是很经典的排序算法了，相邻的两个数据依次进行比较并交换位置。

排序算法中涉及到了两个概念：

原地排序：根据算法对内存的消耗情况，可以将算法分为原地排序和非原地排序，原地排序特指空间复杂度为 O(1) 的排序。

排序算法的稳定性：例如排序一个数组 [1, 5, 3, 7, 4, 9, 5]，数组中有两个 5，排序之后是 [1, 3, 4, 5, 5, 7, 9]，如果排序之后的两个 5 的前后顺序没有发生变化，那么称这个排序是稳定的，反之则是不稳定的。

冒泡排序是很经典的排序算法了，相邻的两个数据依次进行比较并交换位置。遍历一遍数组后，则有一个数据排序完成，然后再遍历 n 次，排序完成。示意图如下：

代码实现：

public class BubbleSort {

    private static void bubbleSort(int[] data){
        int length = data.length;
        for (int i = length - 1; i > 0; i --) {
            //判断是否有数据交换，如果没有则提前退出
            boolean flag = false;
            for (int j = 0; j < i; j ++) {
                if (data[j] > data[j + 1]){
                    int temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                    flag = true;
                }
            }
            if (!flag){
                break;
            }
        }
    }
}

将要排序的数据分为了已排序区间和未排序区间，每次从未排序区间找到最小值，然后将其放到已排序区间的末尾，循环遍历未排序区间则排序完成。

示意图如下：

代码实现：

public class SelectionSort {

    public static void selectionSort(int[] data){
        int length = data.length;
        for (int i = 0; i < length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < length; j++) {
                if (data[min] > data[j]){
                    min = j;
                }
            }
            int temp = data[min];
            data[min] = data[i];
            data[i] = temp;
        }
    }
}

和选择排序类似，插入排序也将数据分为了已排序区间和未排序区间，遍历未排序区间，每次取一个数据，将其插入到已排序区间的合适位置，让已排序区间一直保持有序，直到未排序区间遍历完排序则完成。

示意图如下：

代码实现：

public class InsertionSort {

    public static void insertionSort(int[] data){
        int length = data.length;
        for (int i = 0; i < length - 1; i++) {
            int val = data[i + 1];
            int j = i + 1;
            while (j > 0 && data[j - 1] > val){
                data[j] = data[j - 1];
                j --;
            }
            data[j] = val;
        }
    }
}

插入排序为什么比冒泡排序更常用？

这两种排序的时间复杂度都是一样的，最好情况是 O(n)，最坏情况是 O(n2)，但是在实际的生产中，插入排序使用更多，原因在于两者数据交换的次数不同。冒泡排序需要进行三次交换，插入排序只要一次：

//冒泡排序数据交换
if (data[j] > data[j + 1]){
    int temp = data[j];
    data[j] = data[j + 1];
    data[j + 1] = temp;
    flag = true;
}

//插入排序数据交换
while (j > 0 && data[j - 1] > val){
    data[j] = data[j - 1];
    j --;
}

在数据量较大的时候，两者性能差距就体现出来了。

希尔排序其实是插入排序的一种优化，其思路是将排序的数组按照一定的增量将数据分组，每个分组用插入排序进行排序，然后增量逐步减小，当增量减小为1的时候，算法便终止，所以希尔排序又叫做“缩小增量排序”。

示意图如下：

图中的示例，每次依次将数组分为若干组，每组分别进行插入排序。代码实现如下：

public class ShellSort {

    public static void shellSort(int[] data) {

        int length = data.length;
        int step = length / 2;
        while (step >= 1){
            for (int i = step; i < length; i++) {
                int val = data[i];
                int j = i - step;
                for (; j >= 0; j -= step){
                    if (data[j] > val){
                        data[j + step] = data[j];
                    }
                    else {
                        break;
                    }
                }
                data[j + step] = val;
            }
            step = step / 2;
        }
    }
}

归并排序使用到了分治思想，分治思想即将大的问题分解成小的问题，小的问题解决了，大的问题也就解决了。蕴含分治思想的问题，一般可以使用递归技巧来实现。

归并排序的思路是：首先将数组分解，局部进行排序，然后将排序的结果进行合并，这样整个数组就有序了，你可以结合下图理解：

代码实现：

public class MergeSort {

    public static void mergeSort(int[] data){
        mergeInternally(data, 0, data.length - 1);
    }

    private static void mergeInternally(int[] data, int p, int r){
        if (p >= r){
            return;
        }
        int q = (p + r) / 2;
        //分治递归
        mergeInternally(data, p, q);
        mergeInternally(data, q + 1, r);
        //结果合并
        merge(data, p, q, r);
    }

    private static void merge(int[] data, int p, int q, int r){
        int[] temp = new int[r - p + 1];
        int k = 0;
        int i = p;
        int j = q + 1;
        //比较并合并
        while (i <= q && j <= r){
            if (data[i] < data[j]){
                temp[k ++] = data[i ++];
            }
            else {
                temp[k ++] = data[j ++];
            }
        }
        //合并可能出现的剩余元素
        int start = i;
        int end = q;
        if (j <= r){
            start = j;
            end = r;
        }
        while (start <= end){
            temp[k ++] = data[start ++];
        }
        //拷贝回原数组
        if (r - p + 1 >= 0) {
            System.arraycopy(temp, 0, data, p, r - p + 1);
        }
    }
}

快速排序也用到了分治的思想，只不过它和归并排序的思路刚好是相反的，快速排序使用数组中一个数据作为分区点（一般可以选取数组第一个或最后一个元素），比分区点小的，放在左侧，比分区点大的，放在右侧。然后左右两侧的数据再次选择分区点，循环进行这个操作，直到排序完成。

示意图如下（图中是以第一个元素作为分区点）：

代码实现：

public class QuickSort {
    public static void quickSort(int[] data){
        quickSortInternally(data, 0, data.length - 1);
    }

    private static void quickSortInternally(int[] data, int p, int r){
        if (p >= r){
            return;
        }
        int q = partition(data, p, r);
        quickSortInternally(data, p, q - 1);
        quickSortInternally(data, q + 1, r);
    }

    /**
     * 获取分区点函数
     */
    private static int partition(int [] data, int p, int q){
        int pivot = data[q];
        int i = 0;
        int j = 0;
        while (j < q){
            if (data[j] <= pivot){
                swap(data, i, j);
                i ++;
            }
            j ++;
        }
        swap(data, i, q);
        return i;
    }
    /**
     * 交换数组两个元素
     */
    private static void swap(int[] data, int i, int j){
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}

基于堆的排序比较常用，时间复杂度为 O(nlogn)，并且是原地排序，主要的步骤分为建堆和排序。

建堆

思路是从堆中第一个非叶子节点，依次从上往下进行堆化，如下图：

排序

建堆完成之后，假设堆中元素个数为 n，堆顶元素即是最大的元素，这时候直接将堆顶元素和堆中最后一个元素进行交换，然后将剩余的 n - 1 个元素构建成新的堆，依次类推，直到堆中元素减少至 1，则排序完成。示意图如下：

代码实现：

public class HeapSort {

    /**
     * 排序
     */
    public void heapSort(int[] data){
        int length = data.length;
        if (length <= 1){
            return;
        }
        buildHeap(data);
        while (length > 0){
            swap(data, 0, -- length);
            heapify(data, length, 0);
        }
    }

    /**
     * 建堆
     */
    private void buildHeap(int[] data){
        int length = data.length;
        for (int i = (length - 2) / 2; i >= 0; i --) {
            heapify(data, length, i);
        }
    }

    /**
     * 堆化函数
     */
    private void heapify(int[] data, int size, int i){
        while (true){
            int max = i;
            if ((2 * i + 1) < size && data[i] < data[2 * i + 1]) {
                max = 2 * i + 1;
            }
            if ((2 * i + 2) < size && data[max] < data[2 * i + 2]) {
                max = 2 * i + 2;
            }
            if (max == i){
                break;
            }
            swap(data, i, max);
            i = max;
        }
    }

    /**
     * 交换数组中两个元素
     */
    private void swap(int[] data, int i, int j){
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}

桶排序并不是基于数据比较的，因此比较的高效，时间复杂度接近 O(n)，但是相应地，应用的条件十分苛刻。其思路非常的简单：将要排序的数据分到各个有序的桶内，数据在桶内进行排序，然后按序取出，整个数据就是有序的了。

最好情况下，数据被均匀的分到各个桶中，最坏情况是数据全都被分到一个桶中。

下面是一个桶排序的示例：

public class BucketSort {

    /**
     * 测试场景：数组中有10000个数据，范围在(0-100000)
     * 使用100个桶，每个桶存放的数据范围为：0-999, 1000-1999, 2000-2999，依次类推
     */
    public static void bucketSort(int[] data){
        //新建100个桶
        int bucketSize = 100;
        ArrayList> buckets = new ArrayList<>(bucketSize);
        for (int i = 0; i < bucketSize; i++) {
            buckets.add(new ArrayList<>());
        }
        //遍历数据，将数据放到桶中
        for (int i : data) {
            buckets.get(i / 1000).add(i);
        }
        //在桶内部进行排序
        int k = 0;
        for (int i = 0; i < bucketSize; i++) {
            ArrayList list = buckets.get(i);
            Integer[] num = list.toArray(new Integer[1]);
            Arrays.sort(num);
            //拷贝到data中
            for (int n : num) {
                data[k++] = n;
            }
        }
    }
    //测试
    public static void main(String[] args) {
        Random random = new Random();
        int[] data = new int[10000];
        for (int i = 0; i < data.length; i++) {
            data[i] = random.nextInt(100000);
        }
        BucketSort.bucketSort(data);
        System.out.println(Arrays.toString(data));
    }
}

计数排序其实是一种特殊的桶排序，适用于数据的区间不是很大的情况。

例如给 10 万人按照年龄进行排序，我们知道年龄的区间并不是很大，最小的 0 岁，最大的可以假设为 120 岁，那么我们可以新建 121 个桶，扫描一遍数据，将年龄相同的放到一个桶中，然后按序从桶中将数据取出，这样数据就有序了。

计数排序的基本思路如下：

代码实现：

public class CountingSort {

    private static void countingSort(int[] data){
        int length = data.length;
        //找到数组的最大值
        int max = data[0];
        for (int i : data){
            if (max < i){
                max = i;
            }
        }
        //新建一个计数数组，大小为max+1
        //count数组的下标对应data的值，存储的值为对应data值的个数
        int[] count = new int[max + 1];
        for (int i : data){
            count[i] ++;
        }
        //根据count数组取出数据
        int k = 0;
        for (int i = 0; i < count.length; i++) {
            while (count[i] != 0){
                data[k ++] = i;
                count[i] --;
            }
        }
    }
}

基数排序适用于位数较多的数字或者字符串，思路是将排序的数据按位拆分，每一位多带带按照稳定的排序算法进行比较，如下图：

图中的示例，以每个数字为下标，建了 10 个 “桶”，每个桶是一个队列（也可以是数组），然后将要排序的数据按位加入到队列中，然后出队，比较完每一位，则排序完成。

代码实现：

public class RadixSort {

    private static void radixSort(int[] data) {
        int maxDigit = maxDigit(data);

        //新建并初始化10个桶
        Queue[] queues = new LinkedList[10];
        for (int i = 0; i < queues.length; i++) {
            queues[i] = new LinkedList<>();
        }

        for (int i = 0, mod = 1; i < maxDigit; i ++, mod *= 10) {
            for (int n : data){
                int m = (n / mod) % 10;
                queues[m].add(n);
            }

            int count = 0;
            for (Queue queue : queues) {
                while (queue.size() > 0) {
                    data[count++] = queue.poll();
                }
            }
        }
    }

    /**
     * 获取数组最大位数
     */
    private static int maxDigit(int[] data){
        int maxDigit = data[0];
        for (int i : data){
            if (maxDigit < i){
                maxDigit = i;
            }
        }
        return String.valueOf(maxDigit).length();
    }
}

在我的 Github 上面有更加详细的数据结构与算法代码