算法之排序
算法之排序
八大排序
插入排序
插入排序是选择未排序部分首个元素，然后遍历已排过序的部分，插入对应的位置上。
直接插入排序
-
思想
将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。
要点：设立哨兵，作为临时存储和判断数组边界之用。
如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的
-
复杂度
- 时间复杂度
- 最好情况下时间复杂度为O（n）
- 最坏情况下时间复杂度为O（n2）
- 平均时间复杂度为O（n2）
- 空间复杂度
- 插入排序，只需要两个变量暂存当前数，以及下标，与n的大小无关，所以空间复杂度为：O（1）
- 时间复杂度
-
代码
public class InsertSort { public static void main(String[] args) { int[] n = Data.dataArray; int temp = 0, j; //默认位置0已经是有序序列，从位置1开始 for (int i = 1; i < n.length; i++) { temp = n[i]; for (j = i; j > 0; j--) { //如果当前数前面的数大于当前数，则把前面的数向后移一个位置 if (n[j - 1] > temp) { n[j] = n[j - 1]; //此时已经将，将当前数放到第一个位置，这一趟结束 if (j == 1) { n[j - 1] = temp; break; } } else {//如果不大于，将当前数放到j的位置，这一趟结束 n[j] = temp; break; } } System.out.println(Arrays.toString(n)); } System.out.println(Arrays.toString(n)); } }
希尔排序
-
思想
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
即：将待排序数组按照步长gap(初始gap=length/2)进行分组，然后将每组的元素利用直接插入排序的方法进行排序；每次将gap折半减小(gap = gap/2)，循环上述操作；当gap=1时，利用直接插入，完成排序。
希尔排序的总体实现应该由三个循环完成：第一层循环：将gap依次折半，对序列进行分组，直到gap=1、第二、三层循环：也即直接插入排序所需要的两次循环。
-
复杂度
- 时间复杂度
- 最好情况下的时间复杂度为O（n）
- 最坏情况下的时间复杂度为O（n2）
- 平均时间复杂度为O（n1.3）
- 空间复杂度
- 希尔排序，只需要一个变量用于两数交换，与n的大小无关，所以空间复杂度为：O（1）
- 时间复杂度
-
代码
public class ShellSort { public static void main(String[] args) { int[] arr = Data.dataArray; int temp; //数组长度减半遍历至1，此时为直接插入排序 for (int i = arr.length / 2; i > 0; i /= 2) { //从前往后，对多个增量序列进行排序 for (int j = i; j < arr.length; j++) { //从后往前，根据该比较序列的最后一个数的位置，依次向前执行插入排序 for (int k = j - i; k >= 0; k -= i) { if (arr[k] > arr[k + i]) { swap(arr, k, k + i); } } } System.out.println(Arrays.toString(arr)); } } private static void swap(int[] data, int i, int j) { data[i] = data[i] + data[j]; data[j] = data[i] - data[j]; data[i] = data[i] - data[j]; } }
选择排序
选择排序是遍历未排序部分，选出最大或者最小元素，直接插入已排序部分相应位置。
简单选择排序
-
思想
在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。
可以考虑改进为每趟循环确定两个元素（当前趟最大和最小记录）的位置,从而减少排序所需的循环次数。
-
复杂度
- 时间复杂度
- 不管原始数组是否有序，时间复杂度都是O（n2），因为每一个数都要与其他数比较一次
- 空间复杂度
- 因为只定义了两个辅助变量，与n的大小无关，所以空间复杂度为O（1）
- 时间复杂度
-
代码
public class SimpleSelectSort { public static void main(String[] args) { int[] a = Data.dataArray; for (int i = 0; i < a.length; i++) { //k存放最小值下标。每次循环最小值下标+1 int k = i; for (int j = i + 1; j < a.length; j++) { //找到最小值下标 if (a[k] > a[j]) { k = j; } } //把最小值放到它该放的位置上 swap(a, k, i); } System.out.println(Arrays.toString(a)); } private static void swap(int[] data, int i, int j) { if (i == j) { return; } data[i] = data[i] + data[j]; data[j] = data[i] - data[j]; data[i] = data[i] - data[j]; } }
堆排序
-
思想
堆排序是一种树形选择排序，是对直接选择排序的有效改进。
堆的定义如下：具有n个元素的序列（k1,k2,…,kn),当且仅当满足
时称之为堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。
若以一维数组存储一个堆，则堆对应一棵完全二叉树，且所有非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。【备注】：
- 用数组表达完全2叉树中，第i个元素的左右子节点是2i+1,2i+2；i节点的 父节点为：(i-1)/2；最后一个非叶子节点：n/2 - 1（上面元素中，i是从0开始的，n的计算是从1开始的）
- 输出堆顶元素就是：把堆顶元素与最后一个元素交换，然后把最后一个元素从堆中摘除,下次排数组下标为0到n-2的元素，即n-1位置第2次不参与排序
初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。
因此，实现堆排序需解决两个问题：
- 如何将n 个待排序的数建成堆；
- 建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。
- n 个结点的完全二叉树，则最后一个结点是第[n/2-1]个结点的子树。
- 筛选从第[n/2-1]个结点为根的子树开始，该子树成为堆。
- 之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。
- 建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。
- 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。
- 调整小顶堆的方法：
- 设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换,然后下次最后一个元素不参与交换了），堆被破坏，其原因仅是根结点不满足堆的性质。
- 将根结点与左、右子树中较小元素的进行交换。
- 若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法 2
- 若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法 2
- 继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。
- 调整小顶堆的方法：
-
复杂度
-
时间复杂度
-
初始化建堆过程时间：O（n）
-
更改堆元素后重建堆时间：O（nlogn）
-
堆排序的时间复杂度为：O（nlogn）
-
-
空间复杂度
- 因为堆排序是就地排序，空间复杂度为O（1）
-
-
代码
public class HeapSort { public static void main(String[] args) { int[] arr = Data.dataArray; //1.构建大顶堆 for (int i = arr.length / 2 - 1; i >= 0; i--) { //从第一个非叶子结点从下至上，从右至左调整结构 adjustHeap(arr, i, arr.length); } //2.调整堆结构+交换堆顶元素与末尾元素 for (int j = arr.length - 1; j > 0; j--) { //将堆顶元素与末尾元素进行交换 swap(arr, j); //重新对堆进行调整 adjustHeap(arr, 0, j); } System.out.println(Arrays.toString(arr)); } private static void swap(int[] data, int j) { data[0] = data[0] + data[j]; data[j] = data[0] - data[j]; data[0] = data[0] - data[j]; } private static void adjustHeap(int[] arr, int i, int length) { //先取出当前元素i int temp = arr[i]; //从i结点的左子结点开始，也就是2i+1处开始 for (int k = i * 2 + 1; k < length; k = k * 2 + 1) { //如果左子结点小于右子结点，k指向右子结点 if (k + 1 < length && arr[k] < arr[k + 1]) { k++; } //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换） if (arr[k] > temp) { arr[i] = arr[k]; i = k; } else { break; } } //将temp值放到最终的位置 arr[i] = temp; } }
交换排序
冒泡排序
-
思想
在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
-
复杂度
- 时间复杂度
- 不管原始数组是否有序，时间复杂度都是O（n2），因为每一个数都要与其他数比较一次
- 空间复杂度
- 空间复杂度是O（1）,因为只定义了一个辅助变量，与n的大小无关，所以空间复杂度为O（1）
- 时间复杂度
-
代码
public class BubbleSort { public static void main(String[] args) { int[] a = Data.dataArray; bubble(a, a.length); System.out.println(Arrays.toString(a)); } private static void bubble(int[] a, int n) { for (int i = 0; i < n - 1; ++i) { //每轮选出最大值，遍历长度由后向前缩短 for (int j = 0; j < n - i - 1; ++j) { if (a[j] > a[j + 1]) { swap(a, j, j + 1); } } } } /** * 设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可 * * @param r 数组 * @param n 数组长度 * @author 石一歌 * @date 2022/7/18 23:08 */ private static void bubble1(int[] r, int n) { //初始时,最后位置保持不变 int i = n - 1; while (i > 0) { //每趟开始时,无记录交换 int pos = 0; for (int j = 0; j < i; j++) { if (r[j] > r[j + 1]) { //记录交换的位置 pos = j; swap(r, j, j + 1); } } //为下一趟排序作准备 i = pos; } } /** * 传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半 * * @param r 数组 * @param n 数组长度 * @author 石一歌 * @date 2022/7/18 23:11 */ private static void bubble2(int[] r, int n) { int low = 0; //设置变量的初始值 int high = n - 1; int j; while (low < high) { //正向冒泡,找到最大者 for (j = low; j < high; ++j) { if (r[j] > r[j + 1]) { swap(r, j, j + 1); } } //修改high值, 前移一位 --high; //反向冒泡,找到最小者 for (j = high; j > low; --j) { if (r[j] < r[j - 1]) { swap(r, j, j - 1); } } //修改low值,后移一位 ++low; } } private static void swap(int[] data, int i, int j) { data[i] = data[i] + data[j]; data[j] = data[i] - data[j]; data[i] = data[i] - data[j]; } }
快速排序
-
思想
- 选择一个基准元素,通常选择第一个元素或者最后一个元素,
- 通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。
- 此时基准元素在其排好序后的正确位置
- 然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序
-
复杂度
- 时间复杂度
- 最坏情况就是每一次取到的元素就是数组中最小/最大的，这种情况其实就是冒泡排序，时间复杂度O(n2)
- 平均时间复杂度为O（nlog2n）
- 空间复杂度
- 最优的情况下空间复杂度为:O(log2n)；每一次都平分数组的情况
- 最差的情况下空间复杂度为：O(n)；退化为冒泡排序的情况
- 平均空间复杂度为O（log2n）
- 时间复杂度
-
代码
public class QuickSort { public static void main(String[] args) { int[] a = Data.dataArray; quickSort(a, 0, a.length - 1); System.out.println(Arrays.toString(a)); } private static void quickSort(int[] a, int low, int high) { //如果不加这个判断递归会无法退出导致堆栈溢出异常 if (low < high) { //取中间位置，然后分为两部分 int middle = getMiddle(a, low, high); quickSort(a, 0, middle - 1); quickSort(a, middle + 1, high); } } public static int getMiddle(int[] a, int low, int high) { //基准元素，排序中会空出来一个位置 int key = a[low]; while (low < high) { //从high开始找比基准小的，放在low空位上，high位置空出 while (low < high && a[high] >= key) { high--; } a[low] = a[high]; //从low开始找比基准大,放在high空位上，low位置空出 while (low < high && a[low] <= key) { low++; } a[high] = a[low]; } //此时low=high 是基准元素的位置，也是空出来的那个位置 a[low] = key; return low; } public static int partition(int[] array, int low, int high) { //三数取中 int mid = (high + low) / 2; if (array[mid] > array[high]) { swap(array, mid, high); } if (array[low] > array[high]) { swap(array, low, high); } ////枢纽值被放在序列开头 if (array[mid] > array[low]) { swap(array, mid, low); } int key = array[low]; while (low < high) { while (low < high && array[high] >= key) { high--; } array[low] = array[high]; while (low < high && array[low] <= key) { low++; } array[high] = array[low]; } array[high] = key; return high; } private static void swap(int[] data, int i, int j) { data[i] = data[i] + data[j]; data[j] = data[i] - data[j]; data[i] = data[i] - data[j]; } }
归并排序
-
思想
归并排序（Merge）是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
-
复杂度
- 时间复杂度
- 无论原始数组是否是有序的，都要递归分隔并向上归并排序，所以时间复杂度始终是O（nlog2n）
- 空间复杂度
- 每次两个数组进行归并排序的时候，都会利用一个长度为n的数组作为辅助数组用于保存合并序列，所以空间复杂度为O（n）
- 时间复杂度
-
代码
public class MergeSort { public static void main(String[] args) { int[] data = Data.dataArray; mergeSort(data, 0, data.length - 1); } public static void mergeSort(int[] data, int left, int right) { if (left >= right) { return; } // 找出中间索引 int center = (left + right) / 2; // 对左边数组进行递归 mergeSort(data, left, center); // 对右边数组进行递归 mergeSort(data, center + 1, right); // 合并 merge(data, left, center, right); System.out.println(Arrays.toString(data)); } /** * 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序 * * @param data 数组对象 * @param left 左数组的第一个元素的索引 * @param center 左数组的最后一个元素的索引，center+1是右数组第一个元素的索引 * @param right 右数组最后一个元素的索引 */ public static void merge(int[] data, int left, int center, int right) { // 临时数组 int[] tmpArr = new int[data.length]; // 右数组第一个元素索引 int mid = center + 1; // third 记录临时数组的索引 int third = left; // 缓存左数组第一个元素的索引 int tmp = left; while (left <= center && mid <= right) { // 从两个数组中取出最小的放入临时数组 if (data[left] <= data[mid]) { tmpArr[third++] = data[left++]; } else { tmpArr[third++] = data[mid++]; } } // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个） while (mid <= right) { tmpArr[third++] = data[mid++]; } while (left <= center) { tmpArr[third++] = data[left++]; } // 将临时数组中的内容拷贝回原数组中 // （原left-right范围的内容被复制回原数组） while (tmp <= right) { data[tmp] = tmpArr[tmp++]; } } }
桶排序
-
思想
是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。
简单来说，就是把数据分组，放在一个个的桶中，然后对每个桶里面的在进行排序。
基数排序
-
思路
不再是一种常规的排序方式，它更多地像一种排序方法的应用，基数排序必须依赖于另外的排序方法。基数排序的总体思路就是将待排序数据拆分成多个关键字进行排序，也就是说，基数排序的实质是多关键字排序。
多关键字排序的思路是将待排数据里德排序关键字拆分成多个排序关键字；第1个排序关键字，第2个排序关键字，第3个排序关键字……然后，根据子关键字对待排序数据进行排序。
多关键字排序时有两种解决方案：- 最高位优先法（MSD）(Most Significant Digit first)
- 最低位优先法（LSD）(Least Significant Digit first)
流程
- 设待排序的数据元素关键字是m位d进制整数（不足m位的关键字在高位补0）设置d个桶，令其编号分别为0,1,2.... d-1
- 首先，按关键字最低位的数值一次把各数据元素放到相应的桶中
- 然后，按照桶号从小到大和进入桶中数据元素的先后次序收集分配在各桶中的数据元素，这样就形成了数据元素集合的一个新的排列，此为一次基数排序。重复m次，就得到了排好序的数据元素序列
-
复杂度
-
时间复杂度
- 时间复杂度始终为O(d*n) 。其中，n是数组长度，d是最大位数。
-
空间复杂度
- 基数排序的空间复杂度为O(n+r)，其中r代表关键字的基数（即0-9，长度为10），需要分配n个数。
-
-
代码
public class MultiKeyRadixSort { public static void main(String[] args) { int[] array = Data.dataArray; radixSort(array, 10, 3); System.out.println(Arrays.toString(array)); } /** * 基于计数排序的基数排序算法 * * @param array 数组 * @param radix 进制 * @param distance 位数 * @author 石一歌 * @date 2022/7/19 13:55 */ private static void radixSort(int[] array, int radix, int distance) { //array为待排序数组，此处拿array当桶 //radix，代表基数 //distance，代表排序元素的位数 int length = array.length; //用于暂存元素 int[] temp = new int[length]; //用于计数排序 int[] count = new int[radix]; int divide = 1; //i表示第几位，0代表个位，1代表十位，2代表百位 for (int i = 0; i < distance; i++) { // 将array中的元素完全复制到temp数组中 System.arraycopy(array, 0, temp, 0, length); // 重置count数组，防止上次循环的数据影响,开始统计下一个关键字 Arrays.fill(count, 0); // 计算每个待排序数据的子关键字 // 分别统计第k位是0,1,2,3,4,5,6,7,8,9的数量, 此循环用来统计每个桶中的数据的数量 for (int j = 0; j < length; j++) { int tempKey = (temp[j] / divide) % radix; count[tempKey]++; } //利用count[i]来确定放置数据的位置 for (int j = 1; j < radix; j++) { count[j] = count[j] + count[j - 1]; } //执行完此循环之后的count[i]就是第i个桶右边界的位置 //个人觉的运用计数排序实现计数排序的重点在下面这个方法 // 按子关键字对指定的数据进行排序,利用循环把数据装入各个桶中，注意是从后往前装,这里是重点，一定要好好理解 for (int j = length - 1; j >= 0; j--) { int tempKey = (temp[j] / divide) % radix; count[tempKey]--; array[count[tempKey]] = temp[j]; } divide = divide * radix; } } }
复杂度
