几种排序方法总结

最新推荐文章于 2023-10-12 15:48:24 发布

幼、稚%

最新推荐文章于 2023-10-12 15:48:24 发布

阅读量329

点赞数 5

分类专栏：数据结构和算法

本文链接：https://blog.csdn.net/Immaturecld/article/details/105840532

版权

数据结构和算法专栏收录该内容

19 篇文章 0 订阅

订阅专栏

交换函数

//交换函数
void Swap(int* array, int i,int j) {
 int tmp = 0;
 tmp = array[i];
 array[i] = array[j];
 array[j] = tmp;
}

冒泡排序

时间复杂度：最坏O(n^2) 平均O(n^2) 最好O(n)
空间复杂度：O(1)
稳定性：稳定
数据敏感：敏感

void bubbleSort(int* array, int n) {
 while (n) {
  //对于已经有序的序列，通过标签提前结束排序过程
  int flag = 1;
  for (int i = 0; i < n - 1; i++) {
   if (array[i] > array[i + 1]) {
    Swap(array, i, i + 1);
    flag = 0;
   }
  }
  //flag=1，说明一轮冒泡的过程中没有反升数据交换，数据已经有序
  if (flag == 1) {
   break;
  }
  n--;
 }
}

插入排序

时间复杂度：最坏O(n^2) 平均O(n^2) 最好O(n)
空间复杂度：O(1)
稳定性：稳定
数据敏感：敏感

void insertSort(int* array, int n) {
 for (int i = 0; i < n - 1; i++) {
  //有序数列的最后一个位置end
  int end = i;
  //待排序的第一个数据key
  int key = array[end + 1];
  while (end >= 0 && array[end] > key) {
   array[end + 1] = array[end];
   end--;
  }
  //这里的end+1的目的是把end拉回到有序数列的最后一个位置
  //若没有进行while里面的end--，则array[end + 1]值不变
  array[end + 1] = key;
 }
}

希尔排序

时间复杂度：最坏O(n^1.3) 平均O(n^1.3) 最好O(n)
空间复杂度：O(1)
稳定性：不稳定 —> 分组时相同值的元素不一定可以分到同一组，预排序是可能导致相对位置发生变化
数据敏感：敏感

void shellSort(int* array, int n) {
 //gap表示步长，分组进行多组插入排序
 int gap = n;
 while (gap > 1) {
  //保证最后一次的步长为1
  gap = gap / 2;
  for (int i = 0; i < n - gap; i++) {
   //通过步长gap进行逻辑分组
   //组内进行插入排序
   //不同组的元素交替进行排序
   int end = i;
   int key = array[end + gap];
   while (end >= 0 && array[end] > key) {
    array[end + gap] = array[end];
    end = end - gap;
   }
   //这里的end+gap的目的是把end拉回到每一组当前有序数列的最后一个位置
      //若没有进行while里面的end = end - gap，则array[end + gap]值不变
   array[end + gap] = key;
  }
 }
}

选择排序

时间复杂度：最坏O(n^2) 平均O(n^2) 最好O(n^2)
空间复杂度：O(1)
稳定性：稳定
数据敏感：不敏感

void selectSort(int* array, int n) {
 for (int i = 0; i < n; i++) {
  //start表示未排序的最左边
  int start = i;
  //min表示未排序的数据中最小值的位置
  int min = start;
  //每次从未排序的数据中选择最小的数据，放到未排序的最左边（成为已排序的最后一个位置）
  for (int j = start + 1; j < n; j++) {
   if (array[j] < array[min]) {
    min = j;
   }
  }
  Swap(array, start, min);
 }
}

//选择排序第二个版本
void selectSort2(int* array, int n) {
 int begin = 0;
 int end = n - 1;
 while (begin < end) {
  //每次选择未排序中的最大值和最小值
  //把选择出来的最大值放到未排序的最右边，最小值放到未排序的最左边
  int max = begin, min = begin;
  for (int i = begin + 1; i <= end; i++) {
   //这里加个=，是为了保证最大值有相同数据时，优先获取位置靠后的数据，保证数据稳定性
   if (array[i] >= array[max]) {
    max = i;
   }
   if (array[i] < array[min]) {
    min = i;
   }
  }
  Swap(array, min, begin);
  //如果最大值位置发生了变化，需要更新
  if (max == begin) {
   max = min;
  }
  Swap(array, max, end);
  begin++;
  end--;
 }
}

堆排序

时间复杂度：O(nlogn)
空间复杂度：O(1)
稳定性：不稳定 --> 调整的过程中相对位置可能会发生变化
数据敏感：不敏感

//向下调整建大堆
void shiftDown(int* array, int n, int parent) {
 int child = 2 * parent + 1;
 while (child < n) {
  if (child + 1 < n&&array[child + 1] > array[child]) {
   child++;
  }
  if (array[child] > array[parent]) {
   Swap(array, child, parent);
   parent = child;
   child = 2 * parent + 1;
  }
  else {
   break;
  }
 }
}

//堆排序
void heapSort(int* array, int n) {
 for (int parent = (n - 2) / 2; parent >= 0; parent--) {
  shiftDown(array, n, parent);
 }
 int size = n;
 while (size) {
  //循环尾删
  Swap(array, 0, size - 1);
  size--;
  shiftDown(array, size, 0);
 }
}

快速排序

时间复杂度：O(nlogn)
空间复杂度：O(1)
稳定性：不稳定 --> 调整的过程中相对位置可能会发生变化
数据敏感：不敏感

选取基准值优化
三数取中法

int getMid(int* array, int begin, int end) {
 //每次从开头、中间、结尾选择三数之中大小处于中间位置的数字，作为快速排序的基准值
 int mid = begin + (end - begin) / 2;
 if (array[begin] < array[mid]) {
  if (array[mid] < array[end]) {
   return mid;
  }
  //array[mid]>=array[end]
  else {
   return end;
  }
 }
 else if (array[begin] >= array[mid]) {
  if (array[mid] > array[end]) {
   return mid;
  }
  else {
   //array[begin]大小处在中间
   if (array[begin] < array[end]) {
    return begin;
   }
   //array[end]大小处在中间
   else {
    return end;
   }
  }
 }
}

快速排序的三种划分子区间方法

//方法一：hora划分法
int partion(int* array, int begin, int end) {
 //选择一个基准值
 //用三数取中法
 int mid = getMid(array, begin, end);
 //交换起始位置和取中法取得的值
 Swap(array, begin, mid);
 int key = array[begin];
 int start = begin;
 //划分
 //基准值在首，则先从后向前找
 //基准值在尾，则先从前向后找
 while (begin < end) {
  //从后向前找第一个小于基准值的位置
  while (begin < end && array[end] >= key) {
   end--;
  }
  //从前向后找第一个大于基准值的位置
  while (begin < end && array[begin] <= key) {
   begin++;
  }
  Swap(array, end, begin);
 }
 //当begin和end相遇时，让基准值和相遇位置交换
 Swap(array, begin, start);
 //最后返回基准值位置
 return begin;
}

//方法二：挖坑法
int partion2(int* array, int begin, int end) {
 //选择一个基准值
 //用三数取中法
 int mid = getMid(array, begin, end);
 //交换起始位置和取中法取得的值
 Swap(array, begin, mid);
 int key = array[begin];
 while (begin < end) {
  //从后向前找第一个小于基准值的数据
  while (begin < end && array[end] >= key) {
   end--;
  }
  //拿小于基准值的数据填前面的坑
  array[begin] = array[end];
  while (begin < end && array[begin] <= key) {
   begin++;
  }
  //拿大于基准值的数据填后面的坑
  array[end] = array[begin];
 }
 //当begin和end相遇时，坑中填基准值
 array[begin] = key;
 //最后返回基准值位置
 return begin;
}

//方法三：前后指针法
int partion3(int *array, int begin, int end) {
 //用三数取中法
 int mid = getMid(array, begin, end);
 //交换起始位置和取中法取得的值
 Swap(array, begin, mid);
 //最后一个小于基准值的位置
 int prev = begin;
 //新发现的下一个小于基准值的位置
 int cur = prev + 1;
 //选择一个基准值
 int key = array[begin];
 while (cur <= end) {
  //新发现的小数据和尾指针指向的位置不连续，则中间含有大于基准值的数据，故进行交换
  //大数据向后移动，小数据向前移动
  if (array[cur] < key && ++prev != cur) {
   Swap(array, prev, cur);
  }
  cur++;
 }
 Swap(array, prev, begin);
 return prev;
}

递归实现快速排序

void quickSort(int* array, int begin, int end) {
 if (begin >= end) {
  return;
  }
 //划分第一次区间
 //int keyPos = partion(array, begin, end);
 //int keyPos = partion2(array, begin, end);
 int keyPos = partion3(array, begin, end);
 //递归划分接下来的子区间
 quickSort(array, begin, keyPos - 1);
 quickSort(array, keyPos + 1, end);
}

非递归实现快速排序
栈实现

void quickSortNoR(int* array, int n){
 Stack st;
 stackInit(&st, 10);
 //起始区间入栈: 先右后左
 if (n > 1){
  stackPush(&st, n - 1);
  stackPush(&st, 0);
 }
 //遍历栈，划分栈中的每一个区间
 while (stackEmpty(&st) != 1){
  //获取栈顶区间
  int begin = stackTop(&st);
  stackPop(&st);
  int end = stackTop(&st);
  stackPop(&st);
  //划分
  int keyPos = partion3(array, begin, end);
  //子区间入栈： 先入右区间
  // 右： keyPos + 1, end
  if (keyPos + 1 < end){
   stackPush(&st, end);
   stackPush(&st, keyPos + 1);
  }
  //左： begin ,  keyPos - 1
  if (begin < keyPos - 1){
   stackPush(&st, keyPos - 1);
   stackPush(&st, begin);
  }
 }
}

队列实现

void quickSortNoR2(int* array, int n){
 Queue q;
 queueInit(&q);
 if (n > 1){
  //先左后右
  queuePush(&q, 0);
  queuePush(&q, n - 1);
 }
 while (queueEmpty(&q) != 1){
  //获取队头区间
  int begin = queueFront(&q);
  queuePop(&q);
  int end = queueFront(&q);
  queuePop(&q);
  //划分
  int keyPos = partion3(array, begin, end);
  //子区间入队
  if (begin < keyPos - 1){
   queuePush(&q, begin);
   queuePush(&q, keyPos - 1);
  }
  if (keyPos + 1 < end){
   queuePush(&q, keyPos + 1);
   queuePush(&q, end);
  }
 }
}

归并排序

时间复杂度：O(nlogn)
空间复杂度：O(n)
稳定：稳定
数据敏感：不敏感

合并:需要知道两个有序子序列的区间: [begin, mid] [mid + 1, end]

void merge(int* array, int begin, int mid, int end, int* tmp) {
 int begin1 = begin, end1 = mid, begin2 = mid + 1, end2 = end;
 int idx = begin;
 //合并
 while (begin1 <= end1 && begin2 <= end2) {
  if (array[begin1] <= array[begin2]) {
   tmp[idx] = array[begin1];
   idx++;
   begin1++;
  }
  else {
   tmp[idx] = array[begin2];
   idx++;
   begin2++;
  }
 }
 //查看是否有剩余元素
 if (begin1 <= end1)
  memcpy(tmp + idx, array + begin1, sizeof(int)* (end1 - begin1 + 1));
 if (begin2 <= end2)
  memcpy(tmp + idx, array + begin2, sizeof(int)* (end2 - begin2 + 1));
 //拷贝到原始空间
 memcpy(array + begin, tmp + begin, sizeof(int)* (end - begin + 1));
}

递归实现归并排序

void mergeSortR(int* array, int begin, int end, int* tmp) {
 if (begin >= end) {
  return;
 }
 int mid = begin + (end - begin) / 2;
 //首先保证子区间有序，首先子区间的排序
 mergeSortR(array, begin, mid, tmp);
 mergeSortR(array, mid + 1, end, tmp);
 //最后合并子区间
 merge(array, begin, mid, end, tmp);
}

void mergeSort(int* array, int n) {
 int* tmp = (int*)malloc(sizeof(int)* n);
 mergeSortR(array, 0, n - 1, tmp);
 free(tmp);
}

非递归实现归并排序

void mergeSortNoR(int* array, int n){
 int* tmp = (int*)malloc(sizeof(int)* n);
 //待合并区间的元素个数
 int k = 1;
 //多轮的归并
 while (k < n){
  //一轮归并
  for (int i = 0; i < n; i += 2 * k){
   //[begin, mid]  [mid + 1, end]
   int begin = i;
   int mid = i + k - 1;
   //判断mid是否越界
   if (mid >= n - 1)
    continue;
   int end = i + 2 * k - 1;
   //判断end是否越界
   if (end >= n)
    end = n - 1;
   merge(array, begin, mid, end, tmp);
  }
  k *= 2;
 }
}

计数排序（只适合小范围数据，如果范围大，空间复杂度较高）

时间复杂度：O(max(n,范围))
空间复杂度：O(范围)
稳定：一般教材认为是稳定的(欠妥)
数据敏感：不敏感

void countSort(int* array, int n){
 // 1, 2, 3,   1000000
 //统计范围
 int min = array[0], max = array[0];
 for (int i = 1; i < n; ++i){
  if (array[i] > max)
   max = array[i];
  if (array[i] < min)
   min = array[i];
 }
 int range = max - min + 1;
 //开辅助空间，进行计数
 int* countArr = (int*)malloc(sizeof(int)* range);
 //初始化为0
 memset(countArr, 0, sizeof(int)* range);
 //统计次数
 for (int i = 0; i < n; ++i){
  countArr[array[i] - min]++;
 }
 //恢复数据， 遍历计数数组
 int idx = 0;
 for (int i = 0; i < range; ++i){
  while (countArr[i]--){
   array[idx++] = i + min;
  }
 }
 free(countArr);
}

幼、稚%

关注

5
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
几种排序方法总结

交换函数//交换函数void Swap(int* array, int i,int j) { int tmp = 0; tmp = array[i]; array[i] = array[j]; array[j] = tmp;}冒泡排序时间复杂度：最坏O(n^2) 平均O(n^2) 最好O(n)空间复杂度：O(1)稳定性：稳定数据敏感：敏感void bubbleSort(...
复制链接

扫一扫