排序（用java实现）

排序

  • 排序的概念及引用
    • 排序的概念
    • 常见的排序算法
  • 常见排序算法的实现
    • 插入排序
      • 基本思想：
      • 直接插入排序
      • 希尔排序(缩小增量排序)
    • 选择排序
      • 基本思想：
      • 直接选择排序
      • 堆排序
    • 交换排序
      • 冒泡排序
      • 快速排序
      • 快速排序的优化
      • 快速排序非递归
    • 归并排序
      • 基本思想
      • 归并排序
      • 归并排序的非递归
      • 海量数据的排序问题
  • 排序算法复杂度及稳定性分析
  • 其他非基于比较排序
  • 选择题

排序的概念及引用

排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i] = r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
在这里插入图片描述
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求在内外存之间移动数据的排序。

常见的排序算法

在这里插入图片描述

常见排序算法的实现

插入排序

基本思想：

直接插入排序是一种简单的插入排序算法，其基本思想是：
把待排序的记录按照其关键码值的大小逐个插入到有个已经排好序的有序序列中，直到所有的记录插入完为止，得到新的有序序列。实际中玩扑克牌，就用了插入排序的思想。

直接插入排序

当插入第 i (i>=1) 个元素时，前面的array[0],array[1],…,array[i-1] 已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移
在这里插入图片描述

    /*** 时间复杂度为：O(N^2)*      最坏情况下：逆序的   5 4 3 2 1*      最好情况下：本身就是有序的  1 2 3 4 5 O(n)*              如果数据越有序，直接插入排序越快* 空间复杂度：O(1)* 稳定性：稳定的排序*      本身如果是一个稳定的排序，那么可以实现为不稳定的*      但是 如果一个 排序 本身就是不稳定，能实现为稳定的排序吗？* @param array*/
public static void insertSort(int[] array){for (int i = 1; i < array.length; i++) {int tmp = array[i];int j = i - 1;for (; j >= 0; j--) {if(array[j] > tmp){array[j+1] = array[j];}else {break;}}array[j+1] = tmp;}
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.insertSort(array);System.out.println("排序后："+ Arrays.toString(array));
}

public static void main(String[] args) {testSimple();
}

时间复杂度为：1+2+3+4+…+N-1 = ( 1 + ( N − 1 ) ∗ ( N − 1 ) ) 2 \frac{(1+(N-1)*(N-1))}{2} 2(1+(N−1)∗(N−1))​ = N 2 − N 2 \frac{N^2-N}{2} 2N2−N​ ，所以为O( N 2 N^2 N2)
在这里插入图片描述
直接插入排序的特性总结：

  1. 元素集合越接近越有序，直接插入排序算法的时间效率越高
  2. 时间复杂度： O ( N 2 ) O(N^2) O(N2)
  3. 空间复杂度： O ( 1 ) O(1) O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定

希尔排序(缩小增量排序)

希尔排序又称缩小增量法。希尔排序法的基本思想：先选定一个整数，把待排序文件中所有记录分成多个组，所有距离为这个整数的记录在同一组内，并对每一组内的记录进行排序。然后再取，重复上述分组和排序的工作。当这个数=1时，所有记录在同一组内排好序。
在这里插入图片描述
在这里插入图片描述

/*** 不稳定的* 时间复杂度：n^1.3 - n^1.5* 空间复杂度：O(1)* @param array*/
public static void shellSort(int[] array){int gap = array.length;while(gap > 1){gap /= 2;for (int i = gap; i < array.length; i++) {int tmp = array[i];int j = i - gap;for (; j >= 0; j = j - gap) {if(array[j] >= tmp){array[j+gap] = array[j];}else {break;}}array[j+gap] = tmp;}}
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.shellSort(array);System.out.println("排序后："+ Arrays.toString(array));
}

public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序，当gap == 1时，数组已经接近有序的了，这样就会很快，这样整体而言，可以达到优化的效果。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中的希尔排序的时间复杂度都不固定：
    《数据结构(C语言版)》— 严蔚敏
    在这里插入图片描述
    《数据结构-用面向对象方法与C++描述》— 殷人昆
    在这里插入图片描述
    因为我们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O(n1.25)到O(1.6*n1.25)来算
  4. 稳定性：不稳定

选择排序

基本思想：

每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

直接选择排序

  • 在元素集合array[i] ~ array[i-1]中选择关键码最小(或最大)的元素
  • 若它不是这组元素中最后一个元素(或第一个元素)，则将它与这组元素中的最后一个(第一个)元素交换
  • 在剩余的array[i] ~ array[n-2](array[i+1] ~ array[n-1])集合中，重复上述步骤，直到集合剩一个元素。

在这里插入图片描述

public static void selectSort(int[] array){for (int i = 0; i < array.length; i++) {int minIndex = i;for (int j = i+1; j < array.length; j++) {if(array[j] < array[minIndex]){minIndex = j;}}swap(array,i,minIndex);}
}private static void swap(int[] array, int j, int i) {int tmp = array[j];array[j] = array[i];array[i] = tmp;
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.selectSort(array);System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

可以继续改进：
在这里插入图片描述

/*** 选择排序：* 时间复杂度：O(N^2)*      和数据是否有序无关* 空间复杂度：O(1)* 稳定性：不稳定的排序* @param array*/
public static void selectSort(int[] array){int left = 0;int right = array.length - 1;while(left < right){int minIndex = left;int maxIndex = left;for (int i = left+1; i < right; i++) {if(array[minIndex] > array[i]){minIndex = i;}if(array[maxIndex] < array[i]){maxIndex = i;}}swap(array,left,minIndex);if(maxIndex == left){maxIndex = minIndex;}swap(array,right,maxIndex);left++;right--;}
}private static void swap(int[] array, int j, int i) {int tmp = array[j];array[j] = array[i];array[i] = tmp;
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.selectSort(array);System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

总结：

  1. 直接选择排序好理解，但是效率不是很好，实际中很少使用
  2. 时间复杂度：O(N2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

堆排序

堆排序(HeapSort)即利用堆的思想进行排序，是指利用堆积树(堆)这种数据结构所设计的一种排序算法，它是选择排序的一种，它是通过堆来进行选择数据。总共分为两个步骤：

  1. 建堆
    • 升序：建大堆
    • 降序：建小堆
  2. 利用堆删除思想来进行排序

建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。
在这里插入图片描述

在这里插入图片描述

/**
* 堆排序
* 时间复杂度：O(n * logN)
* 空间复杂度：O(1)
* 稳定性：不稳定
* @param array
*/
public static void heapSort(int[] array){int end = array.length - 1;createHeap(array);while(end >= 0){swap(array, end, 0);siftDown(array, 0, end);end--;}}public static void createHeap(int[] array) {for (int parent = (array.length - 2) / 2; parent >= 0; parent--) {siftDown(array, parent, array.length);}
}/**
*
* @param array
* @param parent   每棵子树调整的根节点
* @param length    每棵子树调整的结束结点
*/
public static void siftDown(int[] array,int parent, int length){int child = parent * 2 + 1;while(child < length){if(child + 1 < length && array[child + 1] > array[child]){child++;}if(array[child] > array[parent]){swap(array,parent,child);parent = child;child = parent * 2 + 1;}else{break;}}
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.heapSort(array);System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

时间复杂度为：排序之前需创建大根堆或小根堆，时间复杂度为O(N)，向下调整加每个结点的时间复杂度为：O(N * l o g 2 N log_2N log2​N)，所以堆排序的时间复杂度为：O(N) + O(N * l o g 2 N log_2N log2​N) = O(N * l o g 2 N log_2N log2​N) ，详见堆排序这篇文章
总结：

  1. 堆排序使用堆来选数，效率高了很多
  2. 时间复杂度：O(N * l o g 2 N log_2N log2​N)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

交换排序

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

冒泡排序

在这里插入图片描述

public static void  bubbleSort(int[] array){for (int i = 0; i < array.length - 1; i++) {for (int j = 0; j < array.length-1; j++) {if(array[j] > array[j+1]){swap(array,j,j+1);}}}
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.bubbleSort(array);System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

可以加以改进：

/*** 冒泡排序：* 时间复杂度：【讨论 没有优化的情况下，也就是 没有下方的boolean元素和 -i操作】*              O(N^2)*              优化以后 可能会达到O(N)* 空间复杂度：O(1)* 稳定性：稳定的排序* @param array*/
public static void  bubbleSort(int[] array){for (int i = 0; i < array.length - 1; i++) {boolean flag = false;for (int j = 0; j < array.length-1-i; j++) {if(array[j] > array[j+1]){swap(array,j,j+1);flag = true;}}if(!flag){break;}}
}

总结：

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任待取元素序列的某元素作为基准值，按照该序列将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后对左右子序列重复该过程，直到所有元素都排列在相应的位置上为止。

public static void quickSort(int[] array){quick(array,0,array.length - 1);
}//假设按照升序对array数组中[left, right]区间中的元素进行排序
public static void quick(int[] array, int left, int right){if(left >= right){return;}//按照基准值对array数组的[left, right]区间中的元素进行划分int div = partion(array, left, right);//划分成功后以div为边界形成了左右两部分[left, div-1]和[div+1, right]//递归排[left, div-1]quick(array, left, div-1);//递归排[div+1, right]quick(array,div+1, right);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，所以写递归框架可想想二叉树前序遍历规则即可快速写出来，后续只需分析如何按照基准值来对区间中数据进行划分的方式即可。
将区间按照基准值划分为左右两部分的常见方式有：

  1. Hoare版
    在这里插入图片描述
    在这里插入图片描述
private static void swap(int[] array, int j, int i) {int tmp = array[j];array[j] = array[i];array[i] = tmp;
}
/*** 时间复杂度：*          最坏情况：当数据指定的是1 2 3 4 ......有序的情况下，确实是O(n^2)*                                9 8 7 6 ......*          最好情况：O(n * logN)* 空间复杂度：*      最坏情况下：O(N)*      最好情况下：O(logN)* 稳定性：*      不稳定* @param array*/
public static void quickSort(int[] array){quick(array,0,array.length - 1);
}//假设按照升序对array数组中[left, right]区间中的元素进行排序
public static void quick(int[] array, int left, int right){if(left >= right){return;}//按照基准值对array数组的[left, right]区间中的元素进行划分int div = partition(array, left, right);//划分成功后以div为边界形成了左右两部分[left, div-1]和[div+1, right]//递归排[left, div-1]quick(array, left, div-1);//递归排[div+1, right]quick(array,div+1, right);
}public static int partition(int[] array, int left, int right){int tmp = array[left];int tmpLeft = left;while(left < right){while(left < right && array[right] >= tmp){right--;}while(left < right && array[left] <= tmp){left++;}swap(array,left,right);}swap(array,left,tmpLeft);return left;
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.quickSort(array);System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
2. 挖坑法
在这里插入图片描述

public static void quickSort(int[] array){quick(array,0,array.length - 1);
}//假设按照升序对array数组中[left, right]区间中的元素进行排序
public static void quick(int[] array, int left, int right){if(left >= right){return;}//按照基准值对array数组的[left, right]区间中的元素进行划分int div = partition(array, left, right);//划分成功后以div为边界形成了左右两部分[left, div-1]和[div+1, right]//递归排[left, div-1]quick(array, left, div-1);//递归排[div+1, right]quick(array,div+1, right);
}public static int partition(int[] array, int left, int right){int tmp = array[left];while(left < right){while(left < right && array[right] > tmp){right--;}array[left] = array[right];while(left < right && array[left] < tmp){left++;}array[right] = array[left];}array[left] = tmp;return left;
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.quickSort(array);System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]
  1. 前后指针
    在这里插入图片描述
public static void quickSort(int[] array){quick(array,0,array.length - 1);
}//假设按照升序对array数组中[left, right]区间中的元素进行排序
public static void quick(int[] array, int left, int right){if(left >= right){return;}//按照基准值对array数组的[left, right]区间中的元素进行划分int div = partition(array, left, right);//划分成功后以div为边界形成了左右两部分[left, div-1]和[div+1, right]//递归排[left, div-1]quick(array, left, div-1);//递归排[div+1, right]quick(array,div+1, right);
}public static int partition(int[] array, int left, int right){int prev = left;int cur = left+1;int key = left;while(cur <= right){if(array[cur] < array[key] && array[++prev] != array[cur]){swap(array,prev,cur);}cur++;}swap(array,prev,key);return left;
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.quickSort(array);System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

快速排序的优化

由于快排使用递归，若待排序列是有序的或无序的，所开辟的栈是需要很多的，空间复杂度达到O(N)，所以为了减少栈的开辟，提高空间的利用率和时间成本，对此进行了优化
在这里插入图片描述

  1. 三数取中选key
    在这里插入图片描述
    在这里插入图片描述
public static void quickSort(int[] array){quick(array,0,array.length - 1);
}public static void quick(int[] array, int left, int right){if(left >= right){return;}int midIndex = getMiddleNum(array,left,right);swap(array,midIndex,left);int div = partition(array, left, right);quick(array, left, div-1);quick(array,div+1, right);
}
public static int partition(int[] array, int left, int right){int tmp = array[left];while(left < right){while(left < right && array[right] > tmp){right--;}array[left] = array[right];while(left < right && array[left] < tmp){left++;}array[right] = array[left];}array[left] = tmp;return left;
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.quickSort(array);System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]
  1. 递归到小的子区间时，可以考虑使用插入排序
    对于排序，越排是越有序的，而且对于二叉树来讲，越到后面结点越集中，所需开辟的空间越多，但是更有序，对于有序的序列，直接插入排序是最快的。
public static void quickSort(int[] array){quick(array,0,array.length - 1);
}public static void quick(int[] array, int left, int right){if(left >= right){return;}if(right - left + 1 <= 7){insertSortRange(array,left,right);return;}int midIndex = getMiddleNum(array,left,right);swap(array,midIndex,left);int div = partition(array, left, right);quick(array, left, div-1);quick(array,div+1, right);
}private static void insertSortRange(int[] array, int left, int right) {for (int i = left+1; i < right; i++) {int tmp = array[i];int j = i-1;for (; j >= left; j--) {if(array[j] > array[j+1]){array[j+1] = array[j];}else{array[j+1] = tmp;break;}}array[j+1] = tmp;}
}public static int partition(int[] array, int left, int right){int tmp = array[left];while(left < right){while(left < right && array[right] > tmp){right--;}array[left] = array[right];while(left < right && array[left] < tmp){left++;}array[right] = array[left];}array[left] = tmp;return left;
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.quickSort(array);System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

快速排序非递归

在这里插入图片描述

public static void quickSort(int[] array){quickNor(array,0,array.length - 1);}
public static void quickNor(int[] array, int left, int right){Stack<Integer> stack = new Stack<>();int div = partition(array,left,right);if(div > left + 1){stack.push(left);stack.push(div-1);}if(div < right-1){stack.push(div+1);stack.push(right);}while(!stack.isEmpty()){right = stack.pop();left = stack.pop();div = partition(array,left,right);if(div > left + 1){stack.push(left);stack.push(div-1);}if(div < right-1){stack.push(div+1);stack.push(right);}}
}
public static int partition(int[] array, int left, int right){int tmp = array[left];while(left < right){while(left < right && array[right] > tmp){right--;}array[left] = array[right];while(left < right && array[left] < tmp){left++;}array[right] = array[left];}array[left] = tmp;return left;
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.quickSort(array);System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的
  2. 时间复杂度：O(N* l o g 2 N log_2N log2​N)
    在这里插入图片描述
  3. 空间复杂度：O( l o g 2 N log_2N log2​N)
  4. 稳定性：不稳定

归并排序

基本思想

归并排序(MEGRE-SORT)是建立在归并操作上的一种有效的排序算法，该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列：即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路合并。归并排序核心步骤：分解和合并
在这里插入图片描述

归并排序

在这里插入图片描述

public static void mergeSort(int[] array){merge(array,0,array.length-1);
}private static void merge(int[] array, int left, int right) {if(left >= right){return;}int mid = (left + right) / 2;merge(array,left,mid);merge(array,mid+1,right);}

在这里插入图片描述

/*** 归并排序：* 时间复杂度：O(N * logN)* 空间复杂度：O(N)* 稳定性：稳定* @param array*/
public static void mergeSort(int[] array){mergeSortTmp(array,0,array.length-1);
}private static void mergeSortTmp(int[] array, int left, int right) {if(left >= right){return;}int mid = (left + right) / 2;mergeSortTmp(array,left,mid);mergeSortTmp(array,mid+1,right);merge(array,left,right,mid);}private static void merge(int[] array, int left, int right, int mid) {int s1 = left;//int e1 = mid;int s2 = mid+1;//int e2 = right;int k = 0;int len = right - left + 1;int tmp[] = new int[len];while(s1 <= mid && s2 <= right){if(array[s1] > array[s2]){tmp[k++] = array[s2++];}else{tmp[k++] = array[s1++];}}while(s1 <= mid){tmp[k++] = array[s1++];}while(s2 <= right){tmp[k++] = array[s2++];}for (int i = 0; i < tmp.length; i++) {array[i+left] = tmp[i];}
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.mergeSort(array);System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

归并排序的非递归

在这里插入图片描述

public static void mergeSortNor(int[] array){int gap = 1;while(gap < array.length){gap = gap * 2;for (int i = 0; i < array.length; i = i+gap*2) {int left = i;int right = left + gap - 1;if(right >= array.length){right = array.length-1;}int mid = (left + right) / 2;if(mid >= array.length){mid = array.length-1;}merge(array,left,right,mid);}}
}private static void merge(int[] array, int left, int right, int mid) {int s1 = left;//int e1 = mid;int s2 = mid+1;//int e2 = right;int k = 0;int len = right - left + 1;int tmp[] = new int[len];while(s1 <= mid && s2 <= right){if(array[s1] > array[s2]){tmp[k++] = array[s2++];}else{tmp[k++] = array[s1++];}}while(s1 <= mid){tmp[k++] = array[s1++];}while(s2 <= right){tmp[k++] = array[s2++];}for (int i = 0; i < tmp.length; i++) {array[i+left] = tmp[i];}
}

public static void testSimple(){int[] array = {10,2,5,7,3};System.out.println("排序前："+ Arrays.toString(array));Sort.mergeSortNor(array);System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

总结：

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N* l o g 2 N log_2N log2​N)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定

海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序
前提：内存只有1G，需要排序的数据有100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

  1. 先把文件切分成200份，每个512M
  2. 分别对512M排序，因为内存已经可以放得下，所以任意排序方式都可以
  3. 进行2路归并，同时对200份有序文件做归并过程，最终结果就有序了

排序算法复杂度及稳定性分析

在这里插入图片描述

排序方法最好平均最坏空间复杂度稳定性
冒泡排序O(N)(优化以后)没有优化为O(N2)O(N2)O(N2)O(1)稳定
插入排序O(N)O(N2)O(N2)O(1)稳定
选择排序O(N2)O(N2)O(N2)O(1)不稳定
希尔排序O(N)O(N1.3~N1.5)O(N2)O(1)不稳定
堆排序O(N * l o g 2 N log_2N log2​N)O(N * l o g 2 N log_2N log2​N)O(N * l o g 2 N log_2N log2​N)O(1)不稳定
快速排序O(N * l o g 2 N log_2N log2​N)O(N * l o g 2 N log_2N log2​N)O(N2)O( l o g 2 N log_2N log2​N)~O(N)不稳定
归并排序O(N * l o g 2 N log_2N log2​N)O(N * l o g 2 N log_2N log2​N)O(N * l o g 2 N log_2N log2​N)O(N)稳定

其他非基于比较排序

  1. 计数排序
    思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。操作步骤：
    1. 统计相同元素出现次数
    2. 根据统计的结果将序列回收到原来的序列中

    在这里插入图片描述计数排序的特性总结：
    1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限
    2. 时间复杂度：O(Max(N,范围))
    3. 空间复杂度：O(范围)
    4. 稳定
  2. 基数排序
  3. 桶排序

选择题

1.快速排序算法是基于()的一个排序算法。
A：分治法 B：贪心法 C：递归法 D：动态规划法
答案：A
没有递归法这种说法
2.对记录（54,38,96,23,15,72,60,45,83）进行从小到大的直接插入排序时，当把第8个记录45插入到有序表时，为找到插入位置需比较()次？（采用从后往前比较）
A: 3 B: 4 C: 5 D: 6
在这里插入图片描述
答案：C
3.设一组初始记录关键字序列为(65,56,72,99,86,25,34,66)，则以第一个关键字65为基准而得到的一趟快速排序结果是（）
A: 34，56，25，65，86，99，72，66 B: 25，34，56，65，99，86，72，66
C: 34，56，25，65，66，99，86，72 D: 34，56，25，65，99，86，72，66
在这里插入图片描述
答案： A
4.以下排序方式中占用O(n)辅助存储空间的是()
A: 简单排序 B: 快速排序 C: 堆排序 D: 归并排序
答案：D
5.4.下列排序算法中稳定且时间复杂度为O(n^2)的是()
A: 快速排序 B: 冒泡排序 C: 直接选择排序 D: 归并排序
答案：B
6.关于排序，下面说法不正确的是()
A: 快排时间复杂度为O(N*logN)，空间复杂度为O(logN)
B: 归并排序是一种稳定的排序,堆排序和快排均不稳定
C: 序列基本有序时，快排退化成 “冒泡排序”，直接插入排序最快
D: 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)
答案：D

这篇文章先了解到这，希望对大家有帮助，多谢阅读！！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/59510.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

(C++回溯算法)微信小程序“开局托儿所”游戏

(C++回溯算法)微信小程序“开局托儿所”游戏

问题描述 给定一个矩阵 A ( a i j ) m n \bm A(a_{ij})_{m\times n} A(aij​)mn​&#xff0c;其中 a i j ∈ { 1 , 2 , ⋯ , 9 } a_{ij}\in\{1,2,\cdots,9\} aij​∈{1,2,⋯,9}&#xff0c;且满足 ∑ i 1 m ∑ j 1 n a i j \sum\limits_{i1}^m\sum\limits_{j1}^na_{ij} i…
阅读更多...
数字IC后端实现之Innovus Place跑完density爆涨案例分析

数字IC后端实现之Innovus Place跑完density爆涨案例分析

下图所示为咱们社区a7core后端训练营学员的floorplan。 数字IC后端实现 | Innovus各个阶段常用命令汇总 该学员跑placement前density是59.467%&#xff0c;但跑完place后density飙升到87.68%。 仔细查看place过程中的log就可以发现Density一路飙升&#xff01; 数字IC后端物…
阅读更多...
聊一聊Elasticsearch的索引的分片分配机制

聊一聊Elasticsearch的索引的分片分配机制

1、什么是分片分配 分片分配是由ES主节点将索引分片移动到ES集群中各个节点上的过程。 该过程尽量保证&#xff0c;同一个索引的分片尽量分配到更多的节点上&#xff0c;以此来达到读写索引的时候可以利用更多硬件资源的效果。 在分配过程当中&#xff0c;也不能将某个主分片…
阅读更多...
最详细【Elasticsearch】Elasticsearch Java API + Spring Boot集成 实战入门（基础篇）

最详细【Elasticsearch】Elasticsearch Java API + Spring Boot集成 实战入门（基础篇）

Elasticsearch Java API Spring Boot集成 实战入门&#xff08;基础篇&#xff09; 一、初始Elasticseach1、什么是Elasticseach2、Elasticsearch生态2、Elasticsearch结构3、Elasticsearch核心概念4、Elasticsearch 实现全文检索的原理 二、Elasticsearch入门1、入门-环境安装…
阅读更多...
文件操作：Xml转Excel

文件操作：Xml转Excel

1 添加依赖 Spire.Xls.jar <dependency><groupId>e-iceblue</groupId><artifactId>spire.xls</artifactId><version>5.3.3</version></dependency>2 代码使用 package cctd.controller;import com.spire.xls.FileFormat; im…
阅读更多...
物理验证Calibre LVS Debug案例之通过deleteEmptyModule解决LVS问题

物理验证Calibre LVS Debug案例之通过deleteEmptyModule解决LVS问题

上周帮助T12nm A55训练营学员debug一个Calibre LVS问题&#xff0c;小编觉得挺好的一个问题。这个问题之前没有遇到过&#xff0c;今天分享给大家。 数字IC后端先进工艺设计实现之TSMC 12nm 6Track工艺数字IC后端实现重点难点盘点 下图所示为Calibre LVS的报告。从报告中看到…
阅读更多...
深度解析阿里的Sentinel

深度解析阿里的Sentinel

1、前言 这是《Spring Cloud 进阶》专栏的第五篇文章&#xff0c;这篇文章介绍一下阿里开源的流量防卫兵Sentinel&#xff0c;一款非常优秀的开源项目&#xff0c;经过近10年的双十一的考验&#xff0c;非常成熟的一款产品。 文章目录如下&#xff1a; 2、什么是sentinel&…
阅读更多...
ReactPress系列—Next.js 的动态路由使用介绍

ReactPress系列—Next.js 的动态路由使用介绍

ReactPress Github项目地址&#xff1a;https://github.com/fecommunity/reactpress 欢迎提出宝贵的建议&#xff0c;感谢Star。 Next.js 的动态路由使用介绍 Next.js 是一个流行的 React 框架&#xff0c;支持服务端渲染、静态站点生成和动态路由等功能&#xff0c;极大地简化…
阅读更多...
软件压力测试有多重要?北京软件测试公司有哪些?

软件压力测试有多重要?北京软件测试公司有哪些?

软件压力测试是一种基本的质量保证行为&#xff0c;它是每个重要软件测试工作的一部分。压力测试是给软件不断加压&#xff0c;强制其在极限的情况下运行&#xff0c;观察它可以运行到何种程度&#xff0c;从而发现性能缺陷。 在数字化时代&#xff0c;用户对软件性能的要求越…
阅读更多...
学习方法该升级了，‌AI时代的弯道超车：【心流学习法】行动与意识合一的巅峰进化

学习方法该升级了，‌AI时代的弯道超车：【心流学习法】行动与意识合一的巅峰进化

你是否曾感到内心如荒漠般干涸&#xff0c;面对浩瀚的知识海洋&#xff0c;热情逐渐消磨殆尽&#xff1f; 你是否渴望忘却时间的流逝&#xff0c;心无旁骛&#xff0c;与知识展开一场纯粹而深邃的对话&#xff1f; ​在AI时代&#xff0c;智能体处理数据、知识迭代的速率让人…
阅读更多...
手边酒店多商户版V2源码独立部署_博纳软云

手边酒店多商户版V2源码独立部署_博纳软云

新版采用laraveluniapp开发&#xff0c;为更多平台小程序开发提供坚实可靠的底层架构基础。后台UI全部重写&#xff0c;兼容手机端管理。 全新架构、会员卡、钟点房、商城、点餐、商户独立管理
阅读更多...
机器学习（二）——线性回归模型、多分类学习（附核心思想和Python实现源码）

机器学习（二）——线性回归模型、多分类学习（附核心思想和Python实现源码）

目录 关于1. 基本形式2. 线性回归2.1 单变量线性回归2.2 多元线性回归2.2 对数线性回归 3. 对数几率回归4. 线性判别分析5. 多分类学习5.1 拆分策略 6. 类别不平衡问题X 案例代码X.1 源码X.2 数据集&#xff08;糖尿病数据集&#xff09;X.3 模型效果 关于 本文是基于西瓜书&a…
阅读更多...
跳表原理笔记

跳表原理笔记

课程地址 跳表是一种基于随机化的有序数据结构&#xff0c;它提出是为了赋予有序单链表以 O(logn) 的快速查找和插入的能力 创建 首先在头部创建一个 sentinel 节点&#xff0c;然后在 L1 层采用“抛硬币”的方式来决定 L0 层的指针是否增长到 L1 层 例如上图中&#xff0c;L…
阅读更多...
wpf 制作丝滑Flyout浮出侧边栏Demo (Mahapps UI框架)

wpf 制作丝滑Flyout浮出侧边栏Demo (Mahapps UI框架)

Flyout 属性 CloseButtonVisibility: 设置为 Collapsed&#xff0c;意味着关闭按钮不可见。TitleVisibility: 设置为 Collapsed&#xff0c;意味着标题不可见。IsPinned: 设置为 True&#xff0c;意味着这个 Flyout 会固定住&#xff0c;不会自动关闭。Opacity: 设置为 1&…
阅读更多...
MySQL记录锁、间隙锁、临键锁（Next-Key Locks）详解

MySQL记录锁、间隙锁、临键锁（Next-Key Locks）详解

行级锁&#xff0c;每次操作锁住对应的行数据。锁定粒度最小&#xff0c;发生锁冲突的概率最低&#xff0c;并发度最高。 应用在InnoDB存储引擎中。InnoDB的数据是基于索引组织的&#xff0c;行锁是通过对索引上的索引项加锁来实现的&#xff0c;而不是对记录加的锁。 对于行…
阅读更多...
GeoSever发布图层（保姆姬）

GeoSever发布图层（保姆姬）

发布服务的具体步骤。 1. 安装 GeoServer 下载 GeoServer 安装包&#xff1a;GeoServer 官网按照安装说明进行安装&#xff0c;可以选择 Windows、Linux 或其他平台。 2. 启动 GeoServer 启动 GeoServer 通常通过访问 http://localhost:8080/geoserver 进行。默认用户名和密…
阅读更多...
交易所开发：构建安全、高效、可靠的数字资产交易平台

交易所开发：构建安全、高效、可靠的数字资产交易平台

随着数字资产的不断发展&#xff0c;数字货币交易所作为连接数字资产与现实世界的重要桥梁&#xff0c;逐渐成为全球金融市场的核心组成部分。无论是比特币、以太坊等主流加密货币&#xff0c;还是各种基于区块链的资产&#xff0c;都需要通过交易所进行交换和流通。因此&#…
阅读更多...
了解分布式数据库系统中的CAP定理

了解分布式数据库系统中的CAP定理

在分布式数据库系统的设计和实现中&#xff0c;CAP定理是一个至关重要的概念。CAP定理&#xff0c;全称为一致性&#xff08;Consistency&#xff09;、可用性&#xff08;Availability&#xff09;和分区容忍性&#xff08;Partition tolerance&#xff09;定理&#xff0c;由…
阅读更多...
HTB：Sense[WriteUP]

HTB：Sense[WriteUP]

目录 连接至HTB服务器并启动靶机 1.What is the name of the webserver running on port 80 and 443 according to nmap? 使用nmap对靶机TCP端口进行开放扫描 2.What is the name of the application that presents a login screen on port 443? 使用浏览器访问靶机80端…
阅读更多...
【LeetCode每日一题】——802.找到最终的安全状态

【LeetCode每日一题】——802.找到最终的安全状态

文章目录 一【题目类别】二【题目难度】三【题目编号】四【题目描述】五【题目示例】六【题目提示】七【解题思路】八【时空频度】九【代码实现】十【提交结果】 一【题目类别】 图 二【题目难度】 中等 三【题目编号】 802.找到最终的安全状态 四【题目描述】 有一个有…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023