排序的两种方法

 

归并：

归并排序：将待排序的数列分成若干个长度为1的子数列，然后将这些数列两两合并；得到若干个长度为2的有序数列，再将这些数列两两合并；得到若干个长度为4的有序数列，再将它们两两合并；直接合并成一个数列为止。这样就得到了我们想要的排序结果。（参考下面的图2．从上往下的归并排序：它与\"从下往上\"在排序上是反方向的。它基本包括3步：\n\n①分解﹣将当前区间一分为二，即求分裂点 mid =( low + high )/2;\n\n②求解﹣递归地对两个子区间 a [ low ... mid ] 和 a [ mid +1.. high ］进行归并排序。递归的终结条件是子区间长度为1。\n\n③合并﹣将已排序的两个子区间 a [ low .. mid]  和 a [ mid +1.. high ］归并为一个有序的区间 a [ low .. high ]。

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

#include <stdlib.h>

 

// 归并排序：将一个数组中两个相邻有序空间合并成一个

 

// 参数说明

// a -- 包含两个有序区间的数组

// start -- 第一个有序区间的起始地址

// mid -- 第一个有序区间的结束地址。也是第二个有序区间的起始地址

// end -- 第二个有序区间的结束地址

 

void merge(int a[], int start, int mid, int end) {

 int* tmp = (int*)malloc((end - start + 1) * sizeof(int));

 // tmp是汇总2个有序区间的临时区域。

 int i = start; // 第一个有序区的索引

 int j = mid + 1; // 第二个有序区的索引

 int k = 0; // 临时区域的索引

 while (i <= mid && j <= end) {

  if (a[i] <= a[j]) {

   tmp[k++] = a[i++];

  }

  else {

   tmp[k++] = a[j++];

  }

 }

 while (i <= mid) {

  tmp[k++] = a[i++];

 }

 while (j <= end) {

  tmp[k++] = a[j++]; // 将两个有序区间合并

 }

 // 排序后的元素，全部都整合到数组a中

 for (i = 0; i < k; i++) {

  a[start + i] = tmp[i];

 }

 free(tmp);

 tmp = NULL;

}

 

 

void merge_sort_up_to_down(int a[], int start, int end) {

 if (a == NULL || start >= end) {

  return;

 }

 int mid = (end + start) / 2;

 merge_sort_up_to_down(a, start, mid); // 递归排序a[start..mid]

 merge_sort_up_to_down(a, mid + 1, end); // 递归排序a[mid..end]

 // a[start..mid]和a[mid..end]是两个有序空间

 // 将它们排序成一个有序空间a[start..end]

 merge(a, start, mid, end);

}

 

int main() {

 int arr[] = { 9,5,1,6,2,3,0,4,8,7 };

 mergesortuptodown(arr, 0, 9);

 for (int i = 0; i < 10; i++) {

  printf("%d ", arr[i]);

 }

 printf("\n");

 

 return 0;

}

 

 

快速排序

（1）简单总结三步：\n\n第一步，从后往前找比基准小的数据，往前挪\n\n第二步，从前往后找比基准大的数据，往后挪\n\n第三步，重复第一步和第二步\n\n（2）eg: 34, 5, 6,22,56,88,11,2,4,0（一段非有序整数数据）\n\n定义一个下标low指向这一段数据的第一个，即34；定义一个下标high指向这段数据的最后一个，即0；\n\n\n\n找一个基准，一般找这一段数据的第一个就行，也就是low下标所指的值34；

（3）依次进行（1）中所说步骤，\n\n第一步，\n\n\n\n因为0\u003C34，将0往前挪，挪在基准空余的位置，因为有临时变量保存34，所以不怕数据丢失\n\n第二步，\n\n\n\n因为56>34，将56往后挪，挪在空位上，以此类推，当high=low时，快排中的一次完成，也就找到了基准34的位置，（如下图）那最终排好序要进行多少次呢，可以看到一次排序后34前后分为了两块，将这两块在进行如上操作，这就是第三步，当每部分只剩一个数时，快排结束。

 

#include <stdio.h>

int Partition(int* arr, int low, int high)

{

 //一次划分

 int tmp = arr[low];//基准

 while (low < high)

 {

  //（1）从后往前找比基准小的数字

  while (low<high && arr[high]>tmp)

  {

   high--;

  }

  if (low < high)

  {

   arr[low] = arr[high];

  }

  //（2）从前往后找比基准大的数字

  while (low < high && arr[low] <= tmp)

  {

   low++;

  }

  if (low < high)

  {

   arr[high] = arr[low];

  }

 }

 arr[low] = tmp;

 return low;

}

void Quick(int* arr, int low, int high)

{

 int par = Partition(arr,low, high);

 if (low < par - 1)//左边数据超过一个

 {

  Quick(arr, low, par - 1);

 }

 if (par + 1 < high)//右边数据超过一个

 {

  Quick(arr, par + 1, high);

 }

}

void QuickSort(int* arr, int len)

{

 Quick(arr, 0, len - 1);//参数一致

}

void Show(int* arr, int len)

{

 for (int i = 0; i < len; i++)

 {

  printf("%d ", arr[i]);

 }

 printf("\n");

}

int main()

{

 int arr[] = { 34, 5, 6,22,56,88,11,2,4,0 };

 QuickSort(arr, sizeof(arr) / sizeof(arr[0]));

 Show(arr, sizeof(arr) / sizeof(arr[0]));

 return 0;

}