排序算法
一、时间复杂度
1，概念
时间复杂度:算法的时间复杂度是一个函数，他定性描述了该算法的运行时间。
大O记法:是算法的时间复杂度表达公式。简单的说大O记法可以告诉你一个算法耗费的时间长度同算法所处理的数据量大小的关系。大O记法只是一个概念性的或定性的记号，不能通过它来真正计算一个算法所耗费的精确时长。
2，常见的时间复杂度
- 常数阶O(1)
- 对数阶O(log2n)
- 线性阶O(n)
- 线性对数阶O(nlog2n)
- 平方阶O(n2)
- 立方阶O(n3)
- k次方阶O(nk)
- 指数阶O(2n)
3，算法复杂度
- 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
- 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。如：选择排序(5,6,5,7,-1,8)会将第一个5与-1交换，这样就导致第二个5排在第一个5前面。
- 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
- 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。
二、冒泡排序(Bubble Sort)
源码：冒泡排序
1，算法描述
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
2，动图演示
3，代码实现
public static void bubbleSort(int[] arr) { if (arr == null) { return; } boolean flag = false; //是否有交换 for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr.length - i - 1; j++) { if (arr[j] > arr[j + 1]) { //如果发现顺序不对就交换 flag = true; //有交换就置为true int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } if (flag) { //重置flag flag = false; } else { //如果没有交换直接退出 return; } } }
三、选择排序
源码：选择排序
1，算法描述
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
- 初始状态：无序区为R[1..n]，有序区为空；
- 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
- n-1趟结束，数组有序化了
2，动图演示
3，代码演示
public static void selectSort(int[] arr) { if (arr == null) { return; } for (int i = 0; i < arr.length; i++) { int index = i; for (int j = i + 1; j < arr.length; j++) { if (arr[index] > arr[j] ) { index = j; } } if (index != i) { int temp = arr[i]; arr[i] = arr[index]; arr[index] = temp; } } }
四、插入排序
源码：插入排序
1，算法描述
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
2，动图演示
3，代码实现
public static void insertionSort(int[] arr) { if (arr == null) { return; } int insertval;//需要插入的数据 int insertIndex;//被插入数组的索引 for (int i = 0; i < arr.length-1; i++) { insertval = arr[i +1]; insertIndex = i ; //如果需要插入的数值小于 while (insertIndex > 0 && insertval < arr[insertIndex]) { arr[insertIndex + 1] = arr[insertIndex]; insertIndex--; } if (insertIndex != i) { arr[insertIndex + 1] = insertval; } } }
五、希尔排序
源码：希尔排序
1，算法描述
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列个数k，对序列进行k 趟排序；
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
2，动图演示
3，代码实现
public static void shellSort(int[] arr) { if (arr == null) { return; } //gap表示步长，每次都会缩短步长 for (int gap = arr.length / 2; gap > 0; gap /= 2) { for (int i = gap; i < arr.length; i++) { int j = i; int temp = arr[j]; //添加while循环，当移动完成之后(11...32...1) => (11...1...32)接着与前一个进行比较 => (1...11...32) while (j - gap >= 0 && arr[j] < arr[j-gap]) { arr[j] = arr[j - gap]; j -= gap; } //如果发现两个值不相等 前面判断已经交换过了 此时将temp值赋给arr[j] if (temp != arr[j]) { arr[j] = temp; } } } }
六、快速排序
源码：快速排序
1，算法描述
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
- 从数列中挑出一个元素，称为 “基准”（pivot）；
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
2，动图演示
3，代码实现
public static void quickSort(int[] arr,int left,int right){ //获取第一個值 作为基准 if (left < right) { int temp = arr[left]; int l = left; int r = right; while (l < r) { //当右边的值小于基准值时退出循环 while (l < r && arr[r] >= temp) { r--; } //当左边的值大于基准值时退出循环 while (l < r && arr[l] <= temp) { l++; } //将左右两边的数进行交换 if (l < r) { int t = arr[l]; arr[l] = arr[r]; arr[r] = t; } } //再将此时的arr[l]与基准节点进行交换 arr[left] = arr[l]; arr[l] = temp; //最后将左边和右边分别进行对应的递归调用 quickSort(arr,left,l-1); quickSort(arr,l+1,right); } }
七、归并排序
源码：归并排序
1，算法排序
归并排序就是递归得将原始数组递归对半分隔，直到不能再分（只剩下一个元素）后，开始从最小的数组向上归并排序
- 向上归并排序的时候，需要一个暂存数组用来排序，
- 将待合并的两个数组，从第一位开始比较，小的放到暂存数组，指针向后移，
- 直到一个数组空，这时，不用判断哪个数组空了，直接将两个数组剩下的元素追加到暂存数组里，
- 再将暂存数组排序后的元素放到原数组里，两个数组合成一个，这一趟结束。
2，动图演示
3，代码实现
/** * 递归分割 */ public static void sort(int[] arr, int left, int right) { int mid = (left + right) / 2; if (left < right) { sort(arr, left, mid); sort(arr, mid + 1, right); merge(arr, left, right); } } /** * 合并排序 */ public static void merge(int[] arr, int left, int right) { int mid = (left + right) / 2; int i = left; int j = mid + 1; int k = 0; //用于临时存储有序的数据 int[] temp = new int[right - left + 1]; while (i <= mid && j <= right) { //如果左边的数大于右边的数 存放右边的数 if (arr[i] > arr[j]) { temp[k++] = arr[j++]; } else { //如果左边的数小于右边的数 存放左边的数 temp[k++] = arr[i++]; } } //剩余的左边的数据全部加入到temp数组中 while (i <= mid) { temp[k++] = arr[i++]; } //剩余的右边的数据全部加入到temp中 while (j <= right) { temp[k++] = arr[j++]; } //将原始arr数组中对应的这一段数据进行替换 System.arraycopy(temp, 0, arr, left, temp.length); }
八、基数排序
源码：基数排序
1，算法描述
- 取得数组中的最大数，并取得位数；
- arr为原始数组，从最低位开始取每个位组成radix数组；
- 对radix进行计数排序（利用计数排序适用于小范围数的特点）。
2，动图演示
3，代码实现
/** * 基数排序 */ public static void radixSort(int[] arr) { if (arr == null) { return; } int maxLength = getMaxLength(arr); //定义二维数组表示10个桶 每个桶中转入的数值最多为arr.length int[][] bucket = new int[10][arr.length]; //定义一维数组 用于记录每个余数上一共有多少个数据 int[] indexs = new int[10]; //第一层循环每次需要基数为i for (int i = 0, u = 1; i < maxLength; i++, u *= 10) { //第二层循环在指定的bucket中存储数据 for (int j = 0; j < arr.length; j++) { //获取当前数字的余数 int mod = (arr[j] / u) % 10; //将每条数据填充到二维数组中 bucket[mod][indexs[mod]] = arr[j]; //同时对应的桶上的数量 +1 indexs[mod] += 1; } int d = 0; //获取每个桶上的元素数量 for (int k = 0; k < indexs.length; k++) { //如果当前桶上有数据 if (indexs[k] != 0) { for (int j = 0; j < indexs[k]; j++) { //将当前桶上的绑定数据赋值给arr 进行一次arr的排序 arr[d] = bucket[k][j]; d++; } } //将索引清空，防止索引越界 indexs[k] = 0; } // System.out.println("第" + (i + 1) + "次数据为: " + Arrays.toString(arr)); } } /** * 获取数组中最大值得长度 */ private static int getMaxLength(int[] arr) { if (arr == null) { return 0; } //首先求出最大数 int max = arr[0]; for (int num : arr) { if (num > max) { max = num; } } //获取最大数的长度 int maxLength = (max + "").length(); return maxLength; }
九、堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
1，算法描述
- 将待排序序列构造成一个大顶堆，此时， 整个序列的最大值就是堆顶的根节点
- 将其堆顶的根节点与末尾元素进行交换， 此时末尾就为最大值
- 然后将剩余 n-1 个元素重新构造成一个堆， 这样会得到 n 个元素的次小值。 如此反复执行， 便能得到一个有序序列了
- 可以看到在构建大顶堆的过程中， 元素的个数逐渐减少， 最后就得到一个有序序列了
2，动态演示
3，代码实现
/** * 堆排序 */ public static void heapSort(int[] arr) { for (int i = arr.length / 2 - 1; i >= 0; i--) { adjustHeap(arr, i, arr.length); } for (int j = arr.length - 1; j > 0; j--) { //堆顶与最后一个元素进行交换 int end = arr[j]; arr[j] = arr[0]; arr[0] = end; adjustHeap(arr, 0, j); } } /** * 构建大顶堆 * 功能： 完成 将 以 i 对应的非叶子结点的树调整成大顶堆 * int arr[] = {4, 6, 8, 5, 9}; => i = 1 => adjustHeap => 得到 {4, 9, 8, 5, 6} * @param arr 数组 * @param i 非叶子结点的最后一个结点 * @param length 需要构建的长度 */ private static void adjustHeap(int[] arr, int i, int length) { int temp = arr[i]; //k指针，指向左子节点 for (int k = 2 * i + 1; k < length; k = 2 * k + 1) { //如果当前右子节点的值在检索范围内，并且右子节点的值大于左子节点 将k指向右子节点 if (k + 1 < length && arr[k] < arr[k + 1]) { k++; } //当前指针值大于非叶子结点值 if (arr[k] > temp) { //将当前的非叶子结点赋值为其子节点中的最大值 arr[i] = arr[k]; //使用i记录当前交换的k的索引 i = k; } else { break; } } //当 for 循环结束后，我们已经将以 i 为父结点的树的最大值，放在了 最顶(局部) //此时将temp赋值给调整后的位置上 arr[i] = temp; }
