一些排序算法

 

头文件

/*************************

        交换排序

**************************/

//冒泡排序

void BubbleSort(vector<int> &v,int begin,int end);

//快速排序

void QuickSort(vector<int> & v,int begin,int end);







/************************

        插入排序

*************************/

//直接插入排序

void InsertionSort(vector<int> &v,int begin,int end);

//折半插入排序

void BinaryInsertSort(vector<int> &v,int begin,int end);

//希尔排序

void ShellSort(vector<int> & v,int begin,int end);







/************************

        选择排序

*************************/

//直接选择排序

void SelectSort(vector<int> & v,int begin,int end);

//锦标赛排序

void ChamptionSort(vector<int> & v,int begin,int end);

//堆排序

void HeapSort(vector<int> &v,int begin,int end);





/************************

        归并排序

*************************/

//递归的两路归并

void MergeSort(vector<int> & v,int begin,int end);



/***********************

        基数排序

***********************/

void RadixSort(vector<int> & v,int begin,int end);

实现源文件

#include "StdAfx.h"

#include "Sorts.h"

#include <MATH.H>





int getpositionvalue(list<int> & ilist,int pos){

    list<int>::iterator it = ilist.begin();

    while(pos-- >0)

        ++it;

    

    return *it;

}



void setpositionvalue(list<int> & ilist,int pos,int value){

    list<int>::iterator it = ilist.begin();

    while(pos-- >0)

        ++it;

    ilist.insert(it,value);

}

//冒泡排序

void BubbleSort(vector<int> &v,int begin,int end){

    

    int i = 0;

    int j = 0;

    int sorted = 0;  //后面的已经排好的位数，接下来就不用再比较了

    for(i = begin;i < end;i++){

        for(j = begin;j < end-sorted;j++){

            if(v[j] > v[j+1]){

                int temp = v[j+1];

                v[j+1] = v[j];

                v[j] = temp;

            }

        }

        sorted++;

    }    

}





//快速排序



int Partition(vector<int> & v,int begin,int end){

    int i = begin;

    int j = end;

    int key = v[begin];

    while(i<j){

        while(v[j] >= key && i<j)      //从后往前找到第一个比key小的

            j--;

        v[i] = v[j];

        

        while(v[i] < key && i<j)       //从前往后找到比key大的

            i++;

        v[j] = v[i];

    }

    v[i] = key;

    return i;

}



void QuickSort(vector<int> & v,int begin,int end){

    if(begin < end){

        int tempindex = Partition(v,begin,end);

        QuickSort(v,begin,tempindex);

        QuickSort(v,tempindex+1,end);

    }

}



//直接插入排序

void InsertionSort(vector<int> &v,int begin,int end){

    list<int> ilist;

    ilist.push_back(v[begin]);

    

    int i = begin+1;

    list<int>::iterator it = ilist.begin();

    for( ;i<=end;i++){

        int flag = 0;

        for(it = ilist.begin();it!=ilist.end();it++){

            if(v[i] < *it){

                ilist.insert(it,v[i]);

                flag = 1;         // 代表已在前面插入，否则需要在后面push_back

                break;            // 插入之后就得退出了

            }

        }

        if(flag == 0)

            ilist.push_back(v[i]);

    }

    for( it = ilist.begin();it!=ilist.end();it++,begin++){

        v[begin] = *it;

    }

}



//折半插入排序 (插入比较时，用二分查找法)

void BinaryInsertSort(vector<int> &v,int begin,int end){

    list<int> ilist;

    ilist.push_back(v[begin]);

    

    int i = begin+1;

    list<int>::iterator it = ilist.begin();

    for( ;i<=end;i++){

        

        int tempbegin = 0;

        int tempend = ilist.size()-1;

        while(tempbegin <= tempend){

            int mid = (tempbegin+tempend)/2 ;

            if(getpositionvalue(ilist,mid) > v[i]){

                tempend = mid-1;

            }

            else

                tempbegin = mid+1;

        }

        if(tempbegin <= ilist.size()-1){         //说明比v[i]大的元素还在list中，在内部插入

            setpositionvalue(ilist,tempbegin,v[i]);

        }

        else                                    //否则push_back,在最后面插入

            ilist.push_back(v[i]);

    }

    for( it = ilist.begin();it!=ilist.end();it++,begin++){

        v[begin] = *it;

    }

}

//希尔排序

//选取步长分组，对分组的进行直接插入排序，一直到步长为0，因为经过之前的处理已经是大概有序了，在进行直接插入排序很快

//受之前插入代码的影响，有很多对象的构造析构成本消耗，但是思路很清晰！！！

void ShellSort(vector<int> & v,int begin,int end){

    int d = (end-begin+1)/2;

    while(d){

        //    cout<<d<<endl;

        int tempd = d;

        int i = 0,j = 0;

        int tempbegin = begin;

        while(tempd--){

            vector<int> tempivec;

            for(i = tempbegin ; i <= end ; i+=d){     //以d为步长

                tempivec.push_back(v[i]);

            }

            

            InsertionSort(tempivec,0,tempivec.size()-1); //插入排序

            

            

            for(i = tempbegin,j =0 ; i <= end ; i+=d,j++){   //排序后将排序好的部分返回到原vector，第一步 取值分组的逆操作

                //    tempivec.push_back(v[i]);

                v[i] = tempivec[j];

            }

            tempbegin++;

        }

        

        d = d/2;

    }

}



//直接选择排序

void SelectSort(vector<int> & v,int begin,int end){

    int i = 0;

    int k = 0;

    for( ; begin <= end ; begin++){

        int min = v[begin];

        k = begin;              //k记录默认最小位置

        for(i = begin+1;i<=end;i++){

            if(v[i] < min){

                min = v[i];

                k = i;             // k记录最小值的位置，若后面有最小的，更新k的值

            }

        }

        

        if(k != end){

            v[k] = v[begin];

            v[begin] = min;

        }

    }

}

//锦标赛排序



void MakeChamption(vector<int> &v,int begin,int end); //构造一个类似最大堆，选出冠军

void GetChamption(vector<int> &v,int begin,int end);  //将已完成的锦标赛的第一个元素与最后一个元素互换



void ChamptionSort(vector<int> & v,int begin,int end){

    // 堆排序是用来改正锦标赛的缺点的

    //    cout<<"ChampionSort"<<endl;

    while(end > begin){

        GetChamption(v,begin,end);

        //    cout<<v[end]<<endl;

        end--;

    }

}



void GetChamption(vector<int> &v,int begin,int end){

    if(begin >= end)

        return;

    MakeChamption(v,begin,end);

    int temp = v[end];

    v[end] = v[begin];

    v[begin] = temp;

}



void MakeChamption(vector<int> &v,int begin,int end){

    int size = end - begin;

    if(size < 1 )

        return ;                       //如果有1个元素，就不需要再操作了

    

    int parentindex = (end-begin-1)/2+begin;    //index of parent

    while(true){

        //        cout<<"parentindex"<<parentindex<<endl;

        if(parentindex == begin-1)

            return;

        

        int lchildindex = (parentindex - begin) * 2 + 1 + begin;  //index of parent's lchild

        int rchildindex = (parentindex - begin) * 2 + 1 + begin + 1; //index of parent's rchild

        

        int maxchildindex = 0;

        if(rchildindex > end)              //maxchildindex两种情况，若左右孩子存在选较大值得，若右孩子不存在，选左孩子为maxchildindex

            maxchildindex = lchildindex;

        else

            maxchildindex = v[lchildindex] > v[rchildindex] ? lchildindex:rchildindex;

        if(v[maxchildindex] > v[parentindex]){

            int temp = v[parentindex];

            v[parentindex] = v[maxchildindex];

            v[maxchildindex] = temp;

        }

        

        parentindex--;

    }

}



//堆排序

//可以参考《STL源码剖析》 heap部分，172~180,将过程再细分为pop，push部分

void HeapifyIndex(vector<int> &v,int begin,int end,int parentindex); //对v[index]为根的堆进行调整适应

void BuildHeap(vector<int> &v,int begin,int end);

void HeapSort(vector<int> &v,int begin,int end){  //重新实现

    BuildHeap(v,begin,end);

    int tempend = end;

    for( ; tempend > begin;){

        int temp = v[tempend];

        v[tempend] = v[begin];

        v[begin] = temp;

        HeapifyIndex(v,begin,--tempend,begin);

    }

}



void HeapifyIndex(vector<int> &v,int begin,int end,int parentindex){

//     if(parentindex >= end)

//         return;

    int lchildindex = (parentindex - begin) * 2 + 1 + begin;  //index of parent's lchild

    int rchildindex = (parentindex - begin) * 2 + 1 + begin + 1; //index of parent's rchild

    int largeindex = 0;

    if(rchildindex <= end && v[rchildindex] > v[parentindex])

        largeindex = rchildindex;

    else

        largeindex = parentindex;



    if(lchildindex <= end && v[lchildindex] > v[largeindex])

        largeindex = lchildindex;



    if(largeindex != parentindex ){           

        //最大的那个元素如果不是parentindex值，

        //就需要与父节点进行交换，就有可能破坏其子的最大堆性质，因此需要进行递归

        //可参考《算法导论》 p86~90

        int temp = v[largeindex];

        v[largeindex] = v[parentindex];

        v[parentindex] = temp;



        HeapifyIndex(v,begin,end,largeindex);

    }





}

void BuildHeap(vector<int> &v,int begin,int end){           //从最后一个父节点(即end的父)开始往前调整

    int parentindex = (end-begin-1)/2+begin;    //index of parent

    for(;parentindex >= begin ;parentindex--){

        HeapifyIndex(v,begin,end,parentindex);

    }

}









//递归的两路归并

void Merge(vector<int> & v,int begin,int mid,int end){

    vector<int> temp;

    int index1 = begin;

    int index2 = mid+1;

    while(index1 <= mid && index2 <= end){

        if(v[index1] < v[index2]){

            temp.push_back(v[index1]);

            index1++;

        }

        else{

            temp.push_back(v[index2]);

            index2++;

        }

    }

    

    while(index1 <= mid)

        temp.push_back(v[index1++]);

    while(index2 <= end)

        temp.push_back(v[index2++]);

    

    for(int i = 0;i<temp.size();i++){

        v[begin++] = temp[i];

    }

    

}

void MergeSort(vector<int> & v,int begin,int end){

    if(begin < end){

        int mid = (begin+end)/2;

        MergeSort(v,begin,mid);

        MergeSort(v,mid+1,end);

        Merge(v,begin,mid,end);

    }

}



//基数排序

void RadixSort(vector<int> & v,int begin,int end){

    vector< list<int> > listvec;

    listvec.resize(10);

    list<int> resulttemp;

    int i = 0;

    for(i = begin;i<=end;i++)

        resulttemp.push_back(v[i]);

    

    int d = 3;        //d为分配回收的次数，即最大值的位数

    

    int index = 0;       //获取第几位的数，0 为个位，1为十位，2为百位

    list<int>::iterator itres;

    while(d-- > 0){

        itres = resulttemp.begin();

        for(; itres!= resulttemp.end();itres++){           //将所有数以从index的数值(上述规则)分配至相应的桶

            int radix = pow(10,index);

            int numofindex = ((*itres)/ radix)%10;

            listvec[numofindex].push_back(*itres);

        }

        index++;

        

        resulttemp.clear();

        for(i = 0;i<10;i++){                               //依次将桶中的数值回收至list中

            resulttemp.splice(resulttemp.end(),listvec[i]);

            listvec[i].clear();

        }

    }

    

    for(i = begin,itres = resulttemp.begin(); itres != resulttemp.end();itres++,i++){

        v[i] = *itres;

    }

}