数据结构排序2-希尔，快速，归并排序

希尔排序

希尔排序是对插入排序的改进。增加了分组

分组插入排序降低元素个数，然后对每组分别进行插入排序
利用分组增量遍历，因为最后必须全部排序一次，然后分别对每组插入排序。把每组的第一个数作为有序序列，
要比较的第一个基准数就是第二个

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<random>
#include<time.h>
#include<sys/timeb.h>
using namespace std;
#define MAX 50000long getSystemTime()
{struct timeb tb;ftime(&tb);return tb.time * 1000 + tb.millitm;  //毫秒
}void printArr(int arr[], int length)
{for (int i = 0; i < length; i++){printf("%d ", arr[i]);}printf("\n");
}
//插入排序
void insertSort(int arr[], int length)
{int j;for (int i = 1; i < length; i++)  //从第二个数开始是无序队列。第一个数为有序队列{if (arr[i]<arr[i - 1]){int temp = arr[i];  //将满足条件的元素缓冲到temp中for (j = i - 1; j >= 0 && temp < arr[j]; j--)  //将有序数列分别遍历{arr[j + 1] = arr[j];}arr[j + 1] = temp;  //填补坑}}
}
//错误
void shellSortme(int arr[], int length)
{int increasement = length;//确定分组的增量increasement = increasement /3+1;int i, j, k;for (i = 0; i < increasement; i++)  //外层分组循环，最后等于1时全部再一起排列一次{for (j = i + increasement; j < length; j += increasement)  //从i+creasement是无序的第一个数{if (arr[i + increasement] < arr[i]){int temp=arr[i];for (k = i + increasement; k < j && arr[k] < temp; k -= increasement){arr[k] = arr[k + 1];}arr[k + 1] = temp;}}}
}void shellSort(int arr[], int length)
{int increasement = length;int i, j, k;do {//确定分组的增量increasement = increasement / 3 + 1;//外层分组循环，最后等于1时全部再一起排列一次for (i = 0; i < increasement; i++)  {//从i+creasement是无序的第一个数for (j = i + increasement; j < length; j += increasement)  {if (arr[j] < arr[j - increasement]){int temp = arr[j];//temp如果大于arr[k]的话，就不需要移动元素。//只有temp小于arr[k]即有序数组的其中一个数，才需要继续往前移动for (k = j - increasement; k >= 0 && temp<arr[k]; k -= increasement){arr[k + increasement] = arr[k];  //将满足条件有序的元素往后移动}arr[k + increasement] = temp;}}}} while (increasement > 1);
}int main()
{int arr[MAX];srand((unsigned int)time(NULL));  //种子for (int i = 0; i < MAX; i++){arr[i] = rand() % MAX;}//printf("未排序数组为：");//printArr(arr, MAX);long t_start = getSystemTime();shellSort(arr, MAX);long t_end = getSystemTime();//printf("希尔排序后数组为：");//printArr(arr, MAX);printf("希尔排序%d个元素，所需时间：%1d\n", MAX, t_end - t_start);system("pause");return 0;
}

运行结果：

快速排序

分治法加挖坑填数
找一个基准，小于放左边，大于放右边。一直遍历。填坑。
一般将第一数作为基准数。第一个数下标为i.挖坑。最后一个下标为j，从右边找一个数填坑。找到小于基准数的然后填坑。则此时j的位置就是坑了，此时从左往右找比基准数大的然后填坑。。。。此时i的地方为坑，继续一直循环下去，直到i==j时，把基准数填i位置的坑。然后此时i的位置是正确的，然后将i的左边和右边分别进行相同的操作。所以用到了递归i<j就是递归结束条件>

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<random>
#include<time.h>
#include<sys/timeb.h>
using namespace std;
#define MAX 50000long getSystemTime()
{struct timeb tb;ftime(&tb);return tb.time * 1000 + tb.millitm;  //毫秒
}void printArr(int arr[], int length)
{for (int i = 0; i < length; i++){printf("%d ", arr[i]);}printf("\n");
}void quickSortme(int arr[], int start, int end)
{int mid = (start + end) / 2;int temp = arr[start];int i = start;int j = end;if (i >= j){//从后往前比较，找一个比基准数小的数，放前面if (arr[j] < temp){arr[i] = arr[j];arr[j] = temp;j--;}//从前往后比较，找一个比基准数大的数，放后面if (arr[i] > temp){arr[i] = arr[j];arr[i] = temp;i++;}}
}
//快速排序，从小到大
void quickSort(int arr[], int start, int end)
{   int i = start;int j = end;int temp = arr[start];  //作为基准数if (i < j){while (i<j){//从右向左比较，找一个比基准数小的元素，放左边while (i < j && arr[j] >= temp)  //从右往左遍历，寻找满足小于基准数的元素{j--;}if (i<j) {arr[i] = arr[j];  //填左边坑i++;}//从左往右比较，找一个比基准数大的数，放右边while (i < j && arr[i] <= temp)  //从左往右遍历，寻找满足大于基准数的元素{i++;}if (i<j){arr[j] = arr[i];  //填右边坑j--;}}//把基准数放到i位置arr[i] = temp;//对左半部分进行快速排序quickSort(arr,start, i - 1);//对右半部分进行快速排序quickSort(arr, i+1, end);}
}int main()
{int arr[MAX];srand((unsigned int)time(NULL));  //种子for (int i = 0; i < MAX; i++){arr[i] = rand() % MAX;}//printf("未排序数组为：");//printArr(arr, MAX);long t_start = getSystemTime();quickSort(arr, 0,MAX-1);long t_end = getSystemTime();//printf("冒希尔排序后数组为：");//printArr(arr, MAX);printf("快速排序%d个元素，所需时间：%1d\n", MAX, t_end - t_start);system("pause");return 0;
}

结果：

归并排序

分组，然后排序，然后存到数组，然后覆盖原来

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<random>
#include<time.h>
#include<sys/timeb.h>
using namespace std;
#define MAX 50000long getSystemTime()
{struct timeb tb;ftime(&tb);return tb.time * 1000 + tb.millitm;  //毫秒
}void printArr(int arr[], int length)
{for (int i = 0; i < length; i++){printf("%d ", arr[i]);}printf("\n");
}int* CreateArr()
{srand((unsigned int)time(NULL));  //种子int* arr =(int *)malloc(sizeof(int)*MAX);for (int i = 0; i < MAX; i++){arr[i] = rand() % MAX;}return arr;
}
//合并算法  从小到大
void merge(int arr[], int start, int end, int mid, int *temp)
{int i_start = start;int i_end = mid;int j_start = mid + 1;int j_end = end;//表示辅助空间有多少个元素int length = 0;//合并两个有序序列while (i_start <= i_end && j_start <= j_end){if (arr[i_start] < arr[j_start]){temp[length] = arr[i_start];length++;i_start++;}else{temp[length] = arr[j_start];length++;j_start++;}}//i这个序列while (i_start <= i_end){temp[length] = arr[i_start];length++;i_start++;}//j这个序列while (j_start <= j_end){temp[length] = arr[j_start];length++;j_start++;}//将辅助空间数据覆盖原空间for (int i = 0; i < length; i++){arr[start+i]=temp[i];}
}//归并排序，将两个有序序列合并成一个有序序列   不会写
void mergeSort(int arr[], int start,int end,int *temp)
{if (start >= end){return;}int mid = (start + end) / 2;//左半边mergeSort(arr, start, mid, temp);//右半边mergeSort(arr, mid+1, end, temp);//合并merge(arr, start, end, mid, temp);}int main()
{int *arr = CreateArr();long t_start = getSystemTime();//申请辅助空间int* temp = (int *)malloc(sizeof(int)*MAX);mergeSort(arr, 0, MAX - 1,temp);long t_end = getSystemTime();printf("归并排序%d个元素，所需时间：%1d\n", MAX, t_end - t_start);/*free(temp);free(arr);*/system("pause");return 0;
}

运行结果：

归并排序示意图：

思路：

因为题目要求复杂度为O(nlogn),故可以考虑归并排序的思想。

归并排序的一般步骤为：

1）将待排序数组（链表）取中点并一分为二；

2）递归地对左半部分进行归并排序；

3）递归地对右半部分进行归并排序；

4）将两个半部分进行合并（merge）,得到结果。

参考自https://blog.csdn.net/boguesfei/article/details/80413365