排序--归并排序

归并排序

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

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
//升序
//递归

void merge(int* array, int begin, int mid, int end, int* tmp) {
 int begin1 = begin;
 int end1 = mid;
 //分成两个子区间
 int begin2 = mid + 1;
 int end2 = end;
 int idx = begin;
 //保证子区间有元素
 while (begin1 <= end1 && begin2 <= end2) {
  if (array[begin1] <= array[begin2]) {
   tmp[idx++] = array[begin1++];
  }
  else {
   tmp[idx++] = array[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 merge_Sort(int* array, int begin, int end, int* tmp) {
 if (begin >= end) {
  return;
 }
 int mid = begin + (end - begin) / 2;//这样写不容易溢出

 //首先保证子区间是有序的，对子区间排序
 merge_Sort(array, begin, mid, tmp);
 merge_Sort(array, mid + 1, end, tmp);

 //合并有序子区间
 merge(array, begin, mid, end, tmp);
}

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

int main() {
 int array[10] = { 1,5,6,3,4,8,9,2 };
 mergeSort(array, 8);
 for (int i = 0; i < 8; i++) {
  printf("%d ", array[i]);
 }
 return 0;
}

下边是非递归的归并排序，替换上边的mergeSort函数的作用

//非递归
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;
 }
}