各种排序

都是准备找工作的时候写的，放了这，可以随时来复习。

头文件：

#ifndef SORT_H_INCLUDED
#define SORT_H_INCLUDED
/*
insertion sorting
*/
void InsertionSort(vector<int>& vec);
void BinaryInsert(vector<int>& vec);//binary insertiong
void ShellSort(vector<int>& vec);//shell sorting

/*
exchange sorting
*/
void BubbleSort(vector<int>& vec);
//quick sorting
void QuickSort(vector<int>& vec,const int left,const int right);
int Part(vector<int>& vec,int low,int high);

/*
selection sorting
*/
void SelectSort(vector<int>& vec);
//tournament sorting
class DataNode{
    public:
        int data;
        int index;
        int active;
        DataNode():data(0),index(0),active(0){ }
};
void Updateintree(vector<DataNode>& v,int i);
void intournamentSort(vector<int>& vec);
//heap sorting
void FilterDown(vector<int>&vec,int m,int n);
void HeapSort(vector<int> &vec);

/*
merge sorting
*/
void merge(vector<int>& vec,vector<int>& tmp,const int l,
            const int m,const int n);
void MergePass(vector<int>& vec,vector<int>& tmp,const int len);
void MergeSort(vector<int>& vec);
//recurve MergeSort
struct Node{
    int d;
    int next;
};
int ListMerge(vector<Node>&vec,int s1,int s2);
int rMergeSort(vector<Node>&vec,const int l,const int r);

/*
counting sorting
*/
void CountingSort(vector<int>& vec);
#endif // SORT_H_INCLUDED

算法：

#include <iostream>
#include <vector>
#include <deque>
#include <iterator>
#include <cstdlib>
using namespace std;
#include <sort.h>
/*
insertion sorting
*/

void InsertionSort(vector<int>& vec){
    for(int i=1;i<vec.size();++i){
        int temp=vec[i];
        int j=i-1;
        while(j>=0&&temp<vec[j]){
            vec[j+1]=vec[j];
            --j;
        }
        vec[j+1]=temp;
    }
}

//binary insertiong
void BinaryInsert(vector<int>& vec){
    for(int i=1;i<vec.size();++i){
        int temp=vec[i];
        int Left=0,Right=i-1;
        while(Left<=Right){
            int mid=(Left+Right)/2;
            if(temp<vec[mid]) Right=mid-1;
            else Left=mid+1;
        }
        for(int j=i-1;j>=Left;--j)
            vec[j+1]=vec[j];
        vec[Left]=temp;
    }
}
//shell sorting
void ShellSort(vector<int>& vec){
    int gap=vec.size();
    while(gap){
        for(int i=gap;i<vec.size();++i){
            int temp=vec[i];
            int j=i-gap;
            while(j>=0&&temp<vec[j]){
                vec[j+gap]=vec[j];
                j-=gap;
            }
            vec[j+gap]=temp;
        }
        gap=gap==2?1:(int)gap/2;
    }
}

/*
exchange sorting
*/
void BubbleSort(vector<int>& vec){
    for(int i=0;i<vec.size()-2;++i)
        for(int j=vec.size()-1;j>i;--j)
           if(vec[j]<vec[j-1])
               swap(vec[j],vec[j-1]);
}


//quick sorting
void QuickSort(vector<int>& vec,const int left,const int right){
    if(left<right){
        int pivotpos=Part(vec,left,right);
        QuickSort(vec,left,pivotpos-1);
        QuickSort(vec,pivotpos+1,right);
    }
}

int Part(vector<int>& vec,int low,int high){
    int pivotpos=low-1;
    int temp;
    for(int i=low;i<high;++i)
        if(vec[i]<vec[high]&&++pivotpos!=i)
            swap(vec[pivotpos],vec[i]);
    ++pivotpos;
    swap(vec[pivotpos],vec[high]);
    return pivotpos;
}

/*
selection sorting
*/
void SelectSort(vector<int>& vec){
    int k=0;
    for(int i=0;i<vec.size()-1;++i){
        k=i;
        for(int j=i+1;j<vec.size();++j)
            if(vec[j]<vec[k])
                k=j;
        if(k!=i) swap(vec[i],vec[k]);
    }
}

//tournament sorting
void Updateintree(vector<DataNode>& v,int i){
    int j=0;
    while(i){
        if(i%2==0) j=i-1;
        else j=i+1;
        if(v[i].active&&v[j].active){
            if(v[i].data<=v[j].data)
                v[(i-1)/2]=v[i];
            else v[(i-1)/2]=v[j];
        }
        else if(!v[i].active||!v[j].active){
            if(v[i].active) v[(i-1)/2]=v[i];
            else v[(i-1)/2]=v[j];
        }
        else v[(i-1)/2]=v[i];
        i=(i-1)/2;
    }
}

void intournamentSort(vector<int>& vec){
    vector<DataNode> v;

    int n=vec.size();
    int s=2;
    while(s<n) s*=2;
    int intreeSize=s*2-1;
    v.resize(intreeSize);

    int cur=s-1;
    int j=0;
    for(int i=cur;i<intreeSize;++i){
       v[i].index=i;
       if(j<n){
           v[i].data=vec[j];
           v[i].active=1;
           ++j;
       }
    }
    cur=s-1;
    while(cur){
        j=cur;
        while(j<2*cur){
            if(v[j+1].active){
                if(v[j].data<=v[j+1].data) v[(j-1)/2]=v[j];
                else v[(j-1)/2]=v[j+1];
            }
            else if(!v[j+1].active)
                if(v[j].active) v[(j-1)/2]=v[j];
            j+=2;
        }
        cur=(cur-1)/2;
    }
    for(int i=0;i<n-1;++i){
        vec[i]=v[0].data;
        v[v[0].index].active=0;
        Updateintree(v,v[0].index);
    }
    vec[n-1]=v[0].data;
}

//heap sorting
void FilterDown(vector<int>&vec,int m,int n){
    int temp=vec[m];
    int i=m,j=2*i+1;
    while(j<=n){
        if(j<n&&vec[j]<vec[j+1]) ++j;
        if(temp>=vec[j]) break;
        else{
            vec[i]=vec[j];
            i=j;
            j=2*i+1;
        }
    }
    vec[i]=temp;
}

void HeapSort(vector<int> &vec){
    int n=vec.size();
    for(int i=(n-2)/2;i>=0;--i)
        FilterDown(vec,i,n-1);
    for(int i=n-1;i>=1;--i){
        swap(vec[0],vec[i]);
        FilterDown(vec,0,i-1);
    }
}

/*
merge sorting
*/
void merge(vector<int>& vec,vector<int>& tmp,const int l,
            const int m,const int n){
    int i=l,j=m+1,k=l;
    while(i<=m&&j<=n){
        if(vec[i]<vec[j])
            tmp[k++]=vec[i++];
        else
            tmp[k++]=vec[j++];
    }
    if(i<=m){
        while(i<=m&&k<=n)
            tmp[k++]=vec[i++];
    }
    else{
        while(j<=n&&k<=n)
            tmp[k++]=vec[j++];
    }
}

void MergePass(vector<int>& vec,vector<int>& tmp,const int len){
    int n=vec.size();
    int i=0;
    while(i+2*len-1<=n-1){
        merge(vec,tmp,i,i+len-1,i+2*len-1);
        i+=2*len;
    }
    if(i+len<=n-1)
        merge(vec,tmp,i,i+len-1,n-1);
    else
        while(i<=n-1){
            tmp[i]=vec[i];
            ++i;
        }
}

void MergeSort(vector<int>& vec){
    int n=vec.size();
    vector<int> tmp(n);
    int len=1;
    while(len<n){
        MergePass(vec,tmp,len);len*=2;
        MergePass(tmp,vec,len);len*=2;
    }
}
//recurve MergeSort
int ListMerge(vector<Node>&vec,int s1,int s2){
    int k=0;
    int i=s1,j=s2;
    while(i&&j){
        if(vec[i].d<=vec[j].d){
            vec[k].next=i;
            k=i;
            i=vec[i].next;
        }
        else{
           vec[k].next=j;
           k=j;
           j=vec[j].next;
        }
    }
    if(!i) vec[k].next=j;
    else vec[k].next=i;
    return vec[0].next;

}
int rMergeSort(vector<Node>&vec,const int l,const int r){
    if(l>=r) return l;
    int m=(l+r)/2;
    return ListMerge(vec,rMergeSort(vec,l,m),rMergeSort(vec,m+1,r));
}
/*
counting sorting
*/
void CountingSort(vector<int>& vec){
    int n=vec.size();
    vector<int> b(n);
    vector<int> c(100);
    for(int i=0;i<n;++i)
        ++c[vec[i]];
    for(int i=1;i<c.size();++i)
        c[i]+=c[i-1];
    for(int i=n-1;i>=0;--i){
        b[c[vec[i]]-1]=vec[i];
        --c[vec[i]];
    }
    copy(b.begin(),b.end(),vec.begin());
}