插入排序，希尔排序，堆排序，选择排序，快排，归并，实现和优化

1.插入排序：从头开始遍历，当前的和前面的数去比较，如果小的话，插到前面，时间复杂度o(n^2)；

2.希尔排序：它是对插入排序的优化，经测得他 的效率是插入排序的100倍左右。

思想：主要是把它分为几组grep，先对它几组几组的来个伪排序，grep越小越接近排好的序列，最后用插入排序

 只需要把i++ 变为 i += grep,start +=grep,每次grep= grep/3即可

3.选择排序

思想：每次选一个最小的放在最前面，下面是优化的版本，在选最小的时候，选出一个最大的放在最后面

4.快速排序：每次随机产生一个值，把小的放在它左边，大的放在它右边

5.堆排序：先以完全二叉树创建一个大堆，然后每次把第一个最大值放到最后，在重新向上调整堆，

6,归并：归并的思想和二分查找类似，先把它分成一半然后在各自再分成一半，一直到它们只剩一个值得时候，合并两个数组。

优点：归并是稳定的算法，时间复杂度为O（log2n）

缺点：浪费了O（n）的空间、

 

7.下面的代码都是在牛客网上严格测试过的，质量还是可以保证的

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

//冒泡排序
void maopaosort(vector<int> &v , int size)   //稳定 时间复杂度o(n^2);
{                                                                   //优化：加一个flag变量，判断是不是有序
    for(int i = size-1 ; i > 0; i--)
    {
        int flag = 1;
        
        for(int j = 1; j <= i; j++)
        {
            
            if(v[j] < v[j-1])
            {
                swap(v[j],v[j-1]);
                flag = 0;
            }
        }
        if(flag)
            break;
    }
}
//选择排序
void selectsort(vector<int> &v,int size)  //不稳定 时间复杂度o(n^2);
{                                                        //优化：两边选择,max,min 都是下标
    for(int i = 0; i < size ; i++)
        {
        int max = i;
        int min = i;
            for(int j = i; j < size; j++)
            {
                if(v[min] > v[j])
                   min = j;
                if(v[max] < v[j])
                    max = j;
            }
           if(max == i)
           {
               max = min;
           }
            swap(v[i],v[min]);
            swap(v[size-1],v[max]);
            size--;
        }
}
//插入排序
void insertsort(vector<int> &v,int size)  //稳定，时间复杂度o(n^2);
{                                       //优化：当前值比前一个大的话，直接往后走
    for(int i = 1; i < size; i++)
    {
        if(v[i] < v[i-1])
        {
        for(int j = i; j > 0; j--)
        {
            if(v[j] < v[j-1])
                swap(v[j],v[j-1]);
        }
        }
    }
}
//希尔排序
void xiersort(vector<int> &v,int size)  //稳定，时间复杂度o(小于n^2，最坏n^2);
{                                        //优化：让组每次减小
                                         //不稳定
    int grep = 5;
    while(grep > 1)
    {
       grep = grep/3 +1;
    for(int i = grep; i < size; i+=grep)
    {
        
        for(int j = i; j > 0; j -= grep )
        {
            if(v[j] < v[j-grep])
                swap(v[j],v[j-grep]);
        }
    }  
   
    }
}
//堆排序
void adjustdown(vector<int> &v,int i,int size)   //堆排序 时间复杂度o(n*logn)
{                                                //不稳定，建个大堆，向下调整
    int root = i;
    int child = root*2+1;
    while(child <= size)
    {
        if(child+1 <= size && v[child] < v[child+1])
            child++;
        if(v[child] > v[root]){
              swap(v[child],v[root]);
            root = child;
            child = root*2+1;
        }
        else{
            break;
        }
          
    }
}
void duisort(vector<int> &v,int size)
{
     size = size-1;
    for(int i = (size-1)/2; i >= 0; i--)
    {
        adjustdown(v,i,size);
    }
    for(int i = size; i >=0 ;i--)
    {
        swap(v[i],v[0]);
         size--;
        adjustdown(v,0,size);
       
    }
}
//归并排序
void merge(vector<int> &v,int start1,int end1 ,int start2,int end2) //合并
{
    vector<int> tmp;
    int ret = start1;
    while(start1 <= end1 && start2 <= end2)
    {
        if(v[start1] < v[start2])
        {
            tmp.push_back(v[start1]);
            start1++;
        }
        else{
            tmp.push_back(v[start2]);
            start2++;
        }
    }
    while(start1 <= end1)
    {
        tmp.push_back(v[start1]);
        start1++;
    }
    while(start2 <= end2)
    {
        tmp.push_back(v[start2]);
        start2++;
    }
    //合并
    for(int i = 0; i < tmp.size(); i++)
    {
        v[ret] = tmp[i];
        ret++;
    }
}
void mergesort(vector<int> &v,int start,int end)   //归并排序 稳定时间复杂度o(n*logn)
{                                                  //适合用于大文件外部排序
    if(start == end)
       return;
        int mid = (start+end)/2;
        mergesort(v,start,mid);
        mergesort(v,mid+1,end);
        merge(v,start,mid,mid+1,end);
}
//快速排序
int Partition(vector<int> &v,int start,int end)    //一次快速排序
{
    int small = start-1;
    for(int i = start; i < end;i++)
    {
        if(v[i] < v[end])
        {
            ++small;
            swap(v[small],v[i]);
        }
    }
    ++small;
    swap(v[small],v[end]);
    return small;
}
void quicksort(vector<int> &v,int start,int end)  //多次排序
{
    int index;
    if(start == end)
        return;
        index = Partition(v,start,end);
    if(index > start)
        quicksort(v,start,index-1);
    if(index < end)
        quicksort(v,index+1,end);
    
}
void Print(vector<int> &v ,int size)
{
    for(int i = 0; i < size; i++)
    {
        cout << v[i] << " ";
    }
}

int main()
{
    int size;
     while(cin >> size)
     {
        vector <int> v(100);
         for(int i = 0; i < v.size(); i++)
         {
             cin >> v[i];
         }
        //maopaosort(v,size);
        //selectsort(v,size);
        //insertsort(v,size);
         //xiersort(v,size);
         //duisort(v,size);
         //mergesort(v,0,size-1);
         //quicksort(v,0,size-1);
         Print(v,size);
     }
    return 0;
}