排序算法
整理一下常见的排序算法。
1、插入排序
插入排序是基础的排序之一，插入排序的过程，脑补打扑克，分成两部分：一部分是手里的牌（已经排好序），一部分是要拿的牌（无序）。这种往一个有序的集合里面插入元素，插入后序列仍然有序这就是插入排序算法思路。
public static void main(String[] args) { int[] a = {3, 43, 32, 2, 4, 6, 23, 9, 8, 2, 6, 7, 43}; int n = a.length; // 无序的部分，从第二个开始，因为第一个是有序的 for (int i = 1; i < n; i++) { int data = a[i]; int j = i - 1; // 有序的部分，从后往前挨个遍历 for (; j >= 0; j--) { // 如果当前元素大于data，表示data要往前移 if (a[j] > data) { a[j + 1] = a[j]; } else { break; } } a[j + 1] = data; } System.out.println(Arrays.toString(a)); }
输出结果：[2, 2, 3, 4, 6, 6, 7, 8, 9, 23, 32, 43, 43]
插入排序的时间复杂度是O(n^2)，是稳定的，它是最基础的排序算法。如果对插入排序进行优化，我们从上面可以看到就是break的地方越多越好，就表示前面都是有序的，且当前比较元素已经找到了插入的位置。
2、希尔排序
希尔排序是插入排序的改良版。把数据下标按照一定的增量分组，对每组使用插入排序，当增量减至1时，排序终止。 其改良的地方尽可能分出来更多的有序段，因为从插入排序可知其对有序段的处理速度是很快的。
public static void main(String[] args) { int[] a = {3, 43, 32, 2, 4, 6, 23, 9, 8, 2, 6, 7, 43}; int n = a.length; // 分组，每次下标按照gap递增 for (int gap = n / 2; gap >= 1; gap /= 2) { // 下面的处理就和插入排序一样了 for (int i = 1; i < n; i+=gap) { int data = a[i]; int j = i - gap; for (; j >= 0; j-=gap) { if (a[j] > data) { a[j + gap] = a[j]; } else { break; } } a[j + gap] = data; } } System.out.println(Arrays.toString(a)); }
希尔排序能一定程度的提高插入排序的性能，时间复杂度为O(n^2)，但是这样分组，中间还会有交换，排序是不稳定的。
3、归并排序
归并排序是jdk源码中使用的排序，时间复杂度为O(nlogn)，是非常高效的一种排序算法，原理有点类似于二分，分到最后一个，就是有序的，然后再进行合并，写这个代码要用到递归的思想。
public class MergeSort { static int[] a = {3, 43, 32, 2, 4, 6, 23, 9, 8, 2, 6, 7, 43}; // 借用数组临时保存数据 static int[] temp = new int[a.length]; public static void main(String[] args) { mergeSort(a, 0, a.length - 1); System.out.println(Arrays.toString(a)); } // 归并排序的核心在于先分后合，数据拆到只剩一个就是有序的，再进行合并 public static void mergeSort(int[] a, int left, int right) { // 终止条件，只有一个数，就不用再分了 if (left < right) { int mid = (left + right) / 2; mergeSort(a, left, mid); mergeSort(a, mid + 1, right); merge(a, left, mid, right); } } // left-mid之间是有序的，mid-right之间是有序的，合并两个有序的数组 public static void merge(int[] a, int left, int mid, int right) { // loc下标用来指向临时数组赋值的位置 int loc = left; // 用来标记左边数组合并到哪个位置 int p1 = left; // 用来标记用边数组合并到哪个位置 int p2 = mid + 1; // 循环条件是左边和右边都没合并完成 while (p1 <= mid && p2 <= right) { // 现在要做的就是左边和右边比较和交换 if (a[p1] <= a[p2]) { temp[loc++] = a[p1++]; } else { temp[loc++] = a[p2++]; } } // 上面的循环终止了，但是不知道是左边的还是右边的合并完了，需要处理未合并的数据 while (p1 <= mid) { temp[loc++] = a[p1++]; } while (p2 <= right) { temp[loc++] = a[p2++]; } // 最后，将临时数组中合并完的有序数据存入原数组 for (int i = left; i <= right; i++) { a[i] = temp[i]; } } }
时间复杂度o(nlogn)，是稳定的
4、选择排序
选择排序和插入排序很类似，也分有序和无序两部分，不同的思想是插入排序对数据的操作是移动，选择排序是交换，每次都能找到最小的数。
public static void main(String[] args) { int[] a = {3, 43, 32, 2, 4, 6, 23, 9, 8, 2, 6, 7, 43}; int n = a.length; // 从第一个开始遍历到倒数第二个 for (int i = 0; i < n - 1; i++) { // 一次找到一个最小的值，记录下标 for (int j = i + 1; j < n; j++) { int index = i; if (a[index] > a[j]) { index = j; } // 将a[i]和最小值交换 a[i] = (a[i] + a[index]) - (a[index] = a[i]); } } System.out.println(Arrays.toString(a)); }
时间复杂度O(n^2)，不稳定
5、冒泡排序
每次冒泡操作都会对相邻的两个元素进行比较，不满足大小关系就交换，一次冒泡能让一个元素移动到它应该在的位置，n次冒泡排序完成。
public static void main(String[] args) { int[] a = {3, 43, 32, 2, 4, 6, 23, 9, 8, 2, 6, 7, 43}; int n = a.length; for (int i = 0; i < n - 1; i++) { for (int j = i + 1; j < n; j++) { if (a[i] > a[j]) { a[i] = (a[i] + a[j]) - (a[j] = a[i]); } } } System.out.println(Arrays.toString(a)); }
冒泡的排序时间复杂度是O(n^2)，交换和比较的次数是比较多的，是稳定的
6、快速排序
快排的思路是找一个基准数，从后往前找比之小的交换，从前往后找比之大的交换，这样循环处理之后比它小的都在左边，比它大的都在右边，对左右分别递归，完成排序。
public static void qSort(int[] a, int left, int right) { // 定义基准数为第一个数 int base = a[left]; // 左指针，从左往右找比之大的数 int p1 = left; // 右指针，从右往左找比之小的数 int p2 = right; // 终止条件，已经找到了同一个位置 while (p1 < p2) { // 左右指针还未指向同一个位置且基准数比右边的小 while (p1 < p2 && base <= a[p2]) { p2--; } // 左右指针仍未指向同一个位置，说明上面循环退出的条件是：从右到左找到了比base小的数，进行交换 if (p1 < p2) { a[p1] = (a[p1] + a[p2]) - (a[p2] = a[p1]); p1++; } // 和上面类似，这边是从左向右找比基准数大的数进行交换 while (p1 < p2 && base >= a[p1]) { p1++; } if (p1 < p2) { a[p1] = (a[p1] + a[p2]) - (a[p2] = a[p1]); p2--; } } // 左半部分递归 if (left < p1) { qSort(a, left, p1 - 1); } // 右半部分递归 if (p2 < right) { qSort(a, p2 + 1, right); } }
快排的时间复杂度是O(nlogn)，最坏的情况是O(n^2)。优化快排性能主要从优化基准数方向考虑，比如取三个数计算出合适的基准数。
快排和归并有些相似处，都会对数据进行拆分，不同的是归并排序从上到下处理，先处理子问题，然后再合并。而快排就是从上到下分区再处理子问题，不用合并，类似于尾递归。
这么多排序算法，如何选择，首先要看场景，需不需要稳定排序，然后看数据量，小的话直接选插入也没什么问题（虽然它是O(n^2)），然后还要分析空间，归并排序就需要额外开辟部分空间。所有没有说一定适用的排序算法，视情况而定，如果不好分析，选归并或者快排，基本能解决问题。
