几种排序，希尔排序，快速排序，堆排序，归并排序

因为最近看了一点stl，所以用vector代替了数组，从别的地方借鉴了很多，只是简单的实现，也没有做什么优化，其实也不会

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

void print(vector<int> v)
{
    for(int i=0; i<(int)v.size(); ++i)
        cout<<v[i]<<"  ";
    cout<<endl;
}
void shell_sort(vector<int> &v) //希尔排序
{
    int len = v.size();
    int step=0;
    while(step<len/3)
        step=step*3+1;
    while(step)
    {
        cout<<step<<endl;
        for(int i=step; i<len; ++i)
        {
            int t=v[i];
            int j = i-step;
            for(j=i-step; j>=0&&t<v[j]; j-=step)
                v[j+step]=v[j];
            v[j+step]=t;
        }
        step/=3;
    }
}
void quick_sort1(vector<int> &v,int low,int high) //交换的方法
{
    if(high<=low)
        return ;
    int key=v[high];
    int left=low;
    int right=high-1;
    while(left<right)
    {
        while(left<right && v[left]<key)//左边找比目标大的
            left++;
        while(left<right && v[right]>key)//右边找比目标小的
            right--;
        swap(v[left],v[right]);
    }
    swap(v[left],v[high]);
    quick_sort1(v,low,left-1);//左边
    quick_sort1(v,left+1,high);//右边
}
void quick_sort2(vector<int> &v,int low,int high) //不交换的方法
{
    if(high<=low)
        return ;
    int key=v[high];
    int left=low;
    int right=high;
    while(left<right)
    {
        while(left<right && v[left]<key)//左边找比目标大的
            left++;
        v[right]=v[left];
        while(left<right && v[right]>key)//右边找比目标小的
            right--;
        v[left]=v[right];
    }
    v[left]=key;
    quick_sort2(v,low,left-1);//左边
    quick_sort2(v,left+1,high);//右边
}
void merge(vector<int> &v,int low,int mid,int high)
{
    vector<int> a(v);
    int l = low; //左边
    int r = mid+1; //右边
    for(int k=low;k<=high;++k)
    {
        if(l>mid)
        {
            v[k]=a[r];
            r++;
        }
        else if(r>high)
        {
            v[k]=a[l];
            l++;
        }
        else if(a[l]<=a[r])
        {
            v[k]=a[l];
            l++;
        }
        else
        {
            v[k]=a[r];
            r++;
        }
    }
}
void merge_sort(vector<int> &v,int low,int high) //归并排序
{
    if(high<=low)
        return ;
    int mid=(low + high )/2;
    merge_sort(v,low,mid);
    merge_sort(v,mid+1,high);
    merge(v,low,mid,high); //合并
}

void max_heap(vector<int> &v,int begin,int end)
{
    int dad = begin;
    int son = dad*2+1;
    while(son<=end)
    {
        if(son+1<=end && v[son] < v[son+1])
            son++;
        if(v[dad] < v[son])
            return ;
        else
        {
            swap(v[dad],v[son]);
            dad=son;
            son=son*2+1;
        }
    }
}
void heap_sort(vector<int> &v)
{
    int len=v.size();//节点个数
    //堆，叶子节点个数一定是n/2+1
    //n/2-1 第一个非叶子节点
    //子节点 x*2+1 x*2+2
    for(int i=len/2-1;i>=0;--i) //调整每一个非叶子节点
        max_heap(v,i,len-1);
    for(int i=len-1;i>=1;--i)
    {
        swap(v[i],v[0]);
        max_heap(v,0,i-1);
    }
}

int main()
{
    int a[16] = {13,14,94,33,82,25,59,95,65,23,45,27,73,26,39,10};
    vector<int> v(a,a+16);
    bucket_sort(v);
    print(v);
    return 0;
}