网站导航
> 技术文档 > 数据结构 排序

数据结构 排序

网友: 技术文档 2025-07-30 12:36:35

文章目录

    • 📕1. 直接插入排序
    • 📕2. 希尔排序
    • 📕3. 冒泡排序
    • 📕4. 选择排序
    • 📕5. 堆排序
    • 📕6. 归并排序
    • 📕7. 快速排序

📕1. 直接插入排序

稳定性 : 稳定

时间复杂度 : 最好情况O(N) 最坏情况O(N^2) 平均情况O(N ^2)

空间复杂度 : O(1)

算法思路 :

  1. 从第一个元素开始，该元素可以认为已经被排序；
  2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
  3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
  4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  5. 将新元素插入到该位置后；
  6. 重复步骤2~5。
 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; } }

📕2. 希尔排序

稳定性 : 不稳定

空间复杂度 : O(1)

算法思路 :

  1. 选择一个步长序列，建议初始步长 n/2，每次减半直到步长为1
  2. 对每个步长，对数组进行分组，对应位置相隔为步长的元素视为一组
  3. 对每一组使用插入排序进行排序
  4. 减小步长，重复步骤2和3，直到步长减少到1
  5. 当步长为1时，相当于对整个数组做一次插入排序，此时数组已基本有序，所需的比较和移动次数大大减少
public static void shellsort(int[] array){ int gap = array.length/2; while (gap>0){ for (int i = gap; i < array.length; i++) { int tmp = array[i]; int j = i - gap; for (; j >=0 ; j-=gap) {  if (array[j]>tmp){ array[j+gap] = array[j];  }else{ break;  } } array[j+gap] = tmp; } gap/=2; } }

📕3. 冒泡排序

稳定性 : 稳定

时间复杂度 : 最好情况O(N) 最坏情况O(N^2) 平均情况O(N ^2)

空间复杂度 : O(1)

算法思路 :

  1. 比较相邻的元素。如果第一个比第二个大，就交换它们
  2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对
  3. 这步做完后，最后的元素会是最大的数
  4. 针对所有的元素重复以上的步骤，除了已经是最大数的最后一个
  5. 持续每次对越来越少(每次重复都会少一个最大数)的元素重复上面的步骤，直到没有任何一对数字需要比较
public static void bubbleSort(int[] array){ for (int i = 0; i < array.length-1; i++) { for (int j = 0; j < array.length-1-i; j++) { if (array[j]>array[j+1]){  int tmp = array[j];  array[j] = array[j+1];  array[j+1] = tmp; } } } }

📕4. 选择排序

稳定性 : 不稳定

时间复杂度 : 最好情况O(N^2) 最坏情况O(N ^2) 平均情况O(N ^2)

空间复杂度 : O(1)

算法思路 :

  1. 从下标0开始遍历数组 , 首先把0下标认为是最小元素的下标
  2. 如果有比0下标元素更小的元素则调换下标 , 然后交换值
  3. 不断重复上述过程 , 直到遍历完数组
public static void selectSort(int[] array){ for (int i = 0; i < array.length-1; i++) { int midIndex = i; for (int j = i+1; j < array.length; j++) { if (array[j] < array[midIndex]){  midIndex = j; } } int tmp = array[midIndex]; array[midIndex] = array[i]; array[i] = tmp; } }

📕5. 堆排序

稳定性 : 不稳定

时间复杂度 : 最好情况O(nlogn) 最坏情况O(nlogn) 平均情况O(n*logn)

空间复杂度 : O(1)

算法思路 :

  1. 将无序序列构建成一个最大堆
  2. 将堆顶元素（最大值）与堆的最后一个元素交换
  3. 剔除最后一个元素（已排序），将剩余元素重新构建为最大堆
  4. 重复步骤2和3，直到堆中只剩下一个元素
 public static void heapSort(int[] array){ for (int parent = (array.length-1-1)/2; parent>=0 ; parent--) { siftDown(array,parent,array.length); } int end = array.length-1; while(end>0){ int key = array[0]; array[0] = array[end]; array[end] = key; siftDown(array,0,end); end--; } } 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]){ int tmp = array[child]; array[child] = array[parent]; array[parent] = tmp; parent = child; child = parent*2+1; }else{ break; } } }

📕6. 归并排序

稳定性 : 稳定

时间复杂度 : O(nlogn)

空间复杂度 : O(n)

算法思路:

  1. 划分 : 将待排序数组从中间划分为两个子序列
  2. 求解子问题 : 分别对这两个子序列进行排序 , 得到两个有序的子序列
  3. 合并 : 将这两个子序列合并为一个有序数列
public static void mergeSort(int[] array) { mergeSortChild(array,0,array.length-1); } private static void mergeSortChild(int[] array,int left,int right) { //防御性编程 if(left >= right) { return; } int mid = (left + right) / 2; mergeSortChild(array,left,mid); mergeSortChild(array,mid+1,right); //开始合并 merge(array,left,mid,right); } private static void merge(int[] array, int left, int mid, int right) { //临时数组 int[] tmpArr = new int[right-left+1]; //tmpArr数组下标 int k = 0; int s1 = left; int e1 = mid; int s2 = mid+1; int e2 = right; //当2个段都有数据的时候 while (s1 <= e1 && s2 <= e2) { if(array[s1] <= array[s2]) { tmpArr[k++] = array[s1++]; }else { tmpArr[k++] = array[s2++]; } } //一个段走完了 把另一个段的数据 拷贝到临时数组 while (s1 <= e1) { tmpArr[k++] = array[s1++]; } while (s2 <= e2) { tmpArr[k++] = array[s2++]; } //临时数组当中存储的是有序的数据 -> 拷贝数据到原始数组当中 for (int i = 0; i < k; i++) { array[i+left] = tmpArr[i]; } }

📕7. 快速排序

稳定性 : 不稳定

时间复杂度 : 最好情况O(nlogn) 最坏情况O(n^2) 平均情况O(nlogn)

空间复杂度 : 最好情况O(logn) 最坏情况O(n) 平均情况O(logn)

算法思路(挖坑法):

  1. 选择基准元素：从列表中选择一个元素作为基准（pivot）。选择方式可以是第一个元素、最后一个元素、中间元素或随机元素。

  2. 分区：将列表重新排列，使得所有小于基准元素的元素都在基准的左侧，所有大于基准元素的元素都在基准的右侧。基准元素的位置在分区完成后确定。

  3. 递归排序：对基准元素左侧和右侧的子列表分别递归地进行快速排序。

  4. 合并：由于分区操作是原地进行的，递归结束后整个列表已经有序。

 public static void quickSort(int[] array){ quick(array,0,array.length-1); } private static void quick(int[] array, int startindex, int endindex) { if (startindex>=endindex){ return; } int par = getpartition(array,startindex,endindex); quick(array,startindex,par-1); quick(array,par+1,endindex); } private static int getpartition(int[] array, int startindex, int endindex) { int index = startindex; int left = startindex; int right = endindex; int pivot = array[index]; while (left<right){ while (left<right){ if (array[right]<pivot){  array[index] = array[right];  left++;  index = right;  break; }else {  right--; } } while (left<right){ if (array[left]>pivot){  array[index] = array[left];  index = left;  right--;  break; }else {  left++; } } } array[index] = pivot; return index; }
网络标签：

相关问题