1.常用排序算法总结

序

常见的排序算法有8种：

---

表格：

排序方法	时间复杂度（平均）	时间复杂度（最坏)	时间复杂度（最好)	空间复杂度	稳定性
冒泡排序	O(n2)	O(n2)	O(n)	O(1)	稳定
直接选择排序	O(n2)	O(n2)	O(n2)	O(1)	不稳定
直接插入排序	O(n2)	O(n2)	O(n)	O(1)	稳定
希尔排序	O(nlog2n)	O(n2)	O(n)	O(1)	不稳定
堆排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(1)	不稳定
快速排序	O(nlog2n)	O(n2)	O(nlog2n)	O(nlog2n)	不稳定
归并排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(n)	稳定
基数排序	O(d(n+r))	O(d(n+r))	O(d(n+r))	O(n+r)	稳定

---

图片为转载，如侵删：

---

• 冒泡排序和选择排序用的不是很多，因为时间复杂度高，但是因为常数项少，小规模排序执行时间不一定比其他排序长。

• 插入排序 虽然时间复杂度高，但是因为常数项比较小，通常用在大致排序完成后最后的调整阶段。比如Java中Array.sort()的底层实现便用了二分插入排序（长度小于32的Tim sort算法）。

• 快速排序和归并排序是最常用的。堆排序的思想比较重要，涉及到优先队列的问题。

• 基数排序 能够解决一些特定的问题。

---

下面排序都会用到的辅助代码：

    //交换位置
    public static void swap(int[] arr, int i, int j) {
        /* 不能用于浮点数和交换自身
            arr[i] = arr[i] ^ arr[j];
            arr[j] = arr[i] ^ arr[j];
            arr[i] = arr[i] ^ arr[j];
        */
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

---

1. Bubble Sort（冒泡排序）

过程：
1. 从0位置开始，比较相邻两个数的大小，如果后面的数小于前面，则交换位置。
2. 遍历一遍下来，最后一个数为整个数组中的最大值。
3. 把最后一个数排除，继续比较剩下的数组。
4. 总共比较次数为N*N，时间复杂度为O（n²）。

    //Bubble Sort
    public static void bubbleSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = arr.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
            }
        }
    }

---

2. Selection Sort （选择排序）

过程：

1. 遍历一遍，找到整个数组中最小的数，与位置0的数交换位置。
2. 从1位置开始，继续遍历，找到最小的数，与1位置交换。以此类推。
3. 同冒泡排序，复杂度为O（n²）。

    //Selection Sort
    public static void selectionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i +