参考链接：
https://blog.csdn.net/hellozhxy/article/details/79911867
https://blog.csdn.net/mwj327720862/article/details/80498455
https://www.cnblogs.com/onepixel/articles/7674659.html
稳定排序：
相等的元素排序后元素相对位置不变
不稳定排序：
相等的元素排序后元素相对位置可能变
本文排序由小到大
1、插入排序
第一个元素已排序好
下一个元素i和前一个i-1比较，如果下一个元素i大于i-1，不动
下一个元素i和前一个i-1比较，如果下一个元素i小于i-1，将这个元素存到temp中，已排序元素都向后移动，i-1前面的元素依次和temp比较，知道找到小于或等于temp的元素，将temp放到这个元素后面。
void InsertSort(int *arr,int size){
int i,j,temp;
for(i=1;i<size;i++){
if(arr[i]<arr[i-1]){
temp=arr[i];
for(j=i-1;j>0=&&a[j]>temp;j--){
arr[j+1]=arr[j];
}
arr[j+1]=temp;
}
}
}
2、冒泡排序
每相邻两个对比，大的放到前面
每一轮将最大的放到最后一个位置，经过len1轮之后就达到了排序
排序好的数字不需要参与下一轮对比。
void BubbleSort(int *arr,int size){
int temp;
for(int i=0;i<size-1;i++){
for(int j=0;j<size-i-1;j++)
{
if(arr[j]>arr[j+1]){
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
3、归并排序
时间复杂度为nlogn
分治法，每个子序列有序
原来的数组为arr0，新建一个新数组arr1，arr序列分成两个，这两个分别是left和right，分别left和right中各取一个数字比较，小的放到arr1中，同时下标都移动位置
将arr0无限分下去，直到每组有序的序列只有一个数字。
void Merge(int *SR, int *TR, int i, int middle, int rightend)
{
int j, k, l;
for (k = i, j = middle + 1; i <= middle && j <= rightend; k++) {
if (SR[i] < SR[j]) {
TR[k] = SR[i++];
} else {
TR[k] = SR[j++];
}
}
if (i <= middle) {
for (l = 0; l <= middle - i; l++) {
TR[k + l] = SR[i + l];
}
}
if (j <= rightend) {
for (l = 0; l <= rightend - j; l++) {
TR[k + l] = SR[j + l];
}
}
}
void MergeSort(int *SR, int *TR1, int s, int t)
{
int middle;
int TR2[MAXSIZE + 1];
if (s == t) {
TR1[s] = SR[s];
} else {
middle = (s + t) / 2;
MergeSort(SR, TR2, s, middle);
MergeSort(SR, TR2, middle + 1, t);
Merge(TR2, TR1, s, middle, t);
}
}
4、快速排序
选取一个基准，大于基准的放一边，小于放一边。递归。
void QuickSort(int *arr,int maxlen,int begin,int end){
int low,high;
if(begin<end){
low=begin+1;
high=end;
while (low<high){//基准值每次和low比较
if(arr[begin]<arr[low])//low大于基准值，交换low和high，并让high前移动
{ swap(&arr[high],&arr[low]);
high--;
} else{//low小于基准值，不动，low向前移动
low++;
}
}//循环结束后low和high指向同一个位置
if(arr[low]>=arr[begin]){
low--;//找到一个小于基准的值，基准值与low指向的位置交换
}
swap(&arr[begin],&arr[low]);
//递归
QuickSort(arr,maxlen,begin,low);
QuickSort(arr,maxlen,high,end);
}
}
各种算法的特点
额外的空间消耗
平均时间复杂度和最差时间复杂度
重点为快速排序
