八大排序方法汇总（选择排序，插入排序-简单插入排序、shell排序，交换排序-冒泡排序、快速排序、堆排序，归并排序，计数排序）

2013-08-22 14:55:33

八大排序方法汇总（选择排序-简单选择排序、堆排序，插入排序-简单插入排序、shell排序，交换排序-冒泡排序、快速排序，归并排序，计数排序）。

插入排序还可以和折半查找相结合，提高查找插入位置的速度，也就是折半插入排序，此处没有给出这种方法的相应代码。

对排序算法，可从以下几个方面评价：

1. 时间复杂度；
2. 空间复杂度；
3. 稳定性。

代码（测试暂未发现问题，欢迎交流指正！）：

#include <iostream>
#include <cassert>
#include <ctime>
#include <bitset>
using namespace std;

typedef int DataType;
const int MaxSize = 1000000;
const int SortCutOff = 50;

//产生在[lowBound,upperBound - 1]区间的随机数
int RandomIntGenerate(int lowBound, int upperBound)
{    
    return (lowBound + (RAND_MAX * rand() + rand()) % (upperBound - lowBound + 1) );
}


//数组显示
void DisplayArray(DataType array[],int len)
{
    assert(NULL != array && len > 0);

    for (int i = 0;i < len;++i)
    {
        cout<<array[i]<<"	";
    }
    cout<<endl;
}

//简单选择排序
void SelectSort(DataType *unStorted,size_t n)
{
    assert(NULL != unStorted && n > 0);

    size_t i;
    size_t j;
    size_t minIndex = 0;

    for (i= 0;i < n - 1;++i)
    {
        minIndex = i;
        for (j = i + 1;j < n;++j)
        {
            minIndex = unStorted[minIndex] < unStorted[j] ? minIndex : j;
        }

        swap(unStorted[i],unStorted[minIndex]);  //没有判断i与minIndex是否相等
    }
}

//简单插入排序
void InsertSort(DataType *unStorted,size_t n)
{
    assert(NULL != unStorted && n > 0);

    size_t i;
    int j;   //不能定义为size_t,因为for循环的结束条件需要将j减为-1作为结束条件
    DataType dataToInsert = 0;

    for (i= 0;i < n - 1;++i)
    {
        dataToInsert = unStorted[i + 1];
        for (j = i;j >= 0;--j)
        {
            if (unStorted[j] > dataToInsert)
            {
                unStorted[j + 1] = unStorted[j];
            }
            else
            {
                break;
            }
        }
        unStorted[j + 1] = dataToInsert;   //注意此处为j + 1，而非j
    }
}

//插入排序-shell排序
//简单插入排序在输入为基本有序的情况下，性能最好，
//shell排序每次大步长下的排序，相当于通过分组对数组预处理，使其基本有序
void ShellSort(DataType *unStorted,size_t n)
{
    assert(NULL != unStorted && n > 0);

    size_t step = n / 2;
    size_t k;
    size_t i;
    int j;   //不能定义为size_t,因为for循环的结束条件需要将j减为-1作为结束条件
    DataType dataToInsert = 0;

    while (step >= 1)  //n为1时，step为0，不进入while循环就返回；
    {
        for (k = 0;k < step;++k )
        {
            for (i= 0;i < n - step;i += step)
            {
                dataToInsert = unStorted[i + step];
                for (j = i;j >= 0;j -= step)
                {
                    if (unStorted[j] > dataToInsert)
                    {
                        unStorted[j + step] = unStorted[j];
                    }
                    else
                    {
                        break;
                    }
                }
                unStorted[j + step] = dataToInsert;   //注意此处为j + 1，而非j
            }
        }
        step /= 2; 
    }
}

//交换排序-冒泡排序
void BubbleSort(DataType *unStorted,size_t n)
{
    assert(NULL != unStorted && n > 0);

    size_t i;
    size_t j;    

    for (i = n - 1;i >= 1;--i)
    {
        for (j = 0;j < i;++j)
        {
            if (unStorted[j] > unStorted[j + 1])
            {
                swap(unStorted[j],unStorted[j + 1]);
            }
        }
    }
}

//快速排序的划分函数
size_t Partion(DataType *unStorted,size_t begin,size_t end)
{
    assert(begin <= end); //begin end都是定义为size_t的，因此不需要检查
    
    size_t i = begin;
    size_t j = end;
    //size_t pivot = i;
    size_t pivot = RandomIntGenerate(begin,end);  //枢轴为随机的，使得快速排序的划分尽可能对称
    swap(unStorted[i],unStorted[pivot]);

    while (i < j)
    {
        while (j > i && unStorted[j] > unStorted[i])
        {
            --j;
        }
        
        if (j > i)
        {
            swap(unStorted[i],unStorted[j]);
            pivot = j;
            ++i;
        }

        while (i < j && unStorted[i] < unStorted[j])
        {
            ++i;
        }

        if (j > i)
        {
            swap(unStorted[i],unStorted[j]);
            pivot = i;
            --j;
        }
    }
    //return i;
    //return j;
    return pivot;
}

//交换排序-快速排序
void QuickSort(DataType *unStorted,size_t begin,size_t end)
{
    assert(NULL != unStorted);

    //assert(begin >= 0 && end >= 0);  //begin end都是定义为size_t的，因此不需要检查

    if (begin >= end)
    {
        return;
    }

    int mid = Partion(unStorted,begin,end);    

    if (begin < mid)
    {
        QuickSort(unStorted,begin,mid - 1);
    }

    //QuickSort(unStorted,begin,mid - 1);  //若mid为0，size_t类型的mid减1会出问题，因此用begin < mid判断
    QuickSort(unStorted,mid + 1,end);
}

//归并两个数组
void Merge(DataType *unStorted,size_t begin,size_t mid,size_t end)
{
    assert(NULL != unStorted);
    assert(begin <= mid && mid <=end);

    DataType *resArray = new DataType[end - begin + 1];
    DataType *res = resArray;

    size_t lowIndex = begin;
    size_t highIndex = mid + 1;

    while (lowIndex <= mid && highIndex <= end)
    {
        if (unStorted[lowIndex] <= unStorted[highIndex])
        {
            *res++ = unStorted[lowIndex++];
        }
        else
        {
            *res++ = unStorted[highIndex++];
        }
    }

    while (lowIndex <= mid)
    {
        *res++ = unStorted[lowIndex++];
    }

    while (highIndex <= end)
    {
        *res++ = unStorted[highIndex++];
    }

    res = resArray;

    for (size_t index = begin;index <= end;++index)
    {
        unStorted[index] = *res++;
    }

    delete [] resArray;
}

//归并排序的非递归实现，自底向上归并
void MergeSortNonRecursive(DataType *unStorted,size_t n)
{
    assert(NULL != unStorted);

    size_t begin = 0;
    size_t mid = 0;
    size_t end = 0;

    size_t step = 1;

    while (step < n)
    {
        begin = 0;
        mid = begin + step - 1;
        end = begin+ 2 * step - 1;

        while (mid < n)
        {
            end = end > (n - 1) ? (n - 1) : end;  //防止end越界

            Merge(unStorted,begin,mid,end);

            begin = end + 1;    //不是begin = begin + step + 1;
            mid = begin + step - 1;
            end = begin+ 2 * step - 1;
        }
        step *= 2;
    }
}

//归并排序的非递归实现，自顶向下归并，分治法
void MergeSort(DataType *unStorted,size_t begin,size_t end)
{
    assert(NULL != unStorted);

    if (begin >= end)
    {
        return;
    }

    size_t mid = begin + (end - begin) / 2;
    MergeSort(unStorted,begin,mid);
    MergeSort(unStorted,mid + 1,end);  //若mid为size_t类型最大值，mid + 1就会越界，此时end已经越界
    Merge(unStorted,begin,mid,end);
}

//堆调整
//参数n为数组中最大小标，如数组有n+1个元素，最大下标为n
//posToAdjust为需要调整的位置的下标
void HeapAdjust(DataType *unStorted,size_t n,size_t posToAdjust)
{
    assert(NULL != unStorted);  //在调用的函数中已经有，可以删去

    size_t lchildIndex = 2 * posToAdjust + 1;
    size_t rchildIndex = 2 * posToAdjust + 2;

    size_t maxPosition = posToAdjust;

    //while (lchildIndex <= n || rchildIndex <= n)
    while (lchildIndex <= n)  //此处只要lchildIndex <= n ，即可进入循环
    {
        if (lchildIndex <= n && unStorted[lchildIndex] > unStorted[maxPosition])
        {
            maxPosition = lchildIndex;
        }
        //else if (rchildIndex <= n && unStorted[rchildIndex] > unStorted[maxPosition])
        if (rchildIndex <= n && unStorted[rchildIndex] > unStorted[maxPosition])  //不是else if 
        {
            maxPosition = rchildIndex;
        }

        if (maxPosition != posToAdjust)
        {
            swap(unStorted[posToAdjust],unStorted[maxPosition]);
            
            posToAdjust = maxPosition;      //更新posToAdjust，可以用递归，即HeapAdjust(unStorted,n,maxPosition);
            lchildIndex = 2 * maxPosition + 1;
            rchildIndex = 2 * maxPosition + 2;
        }
        else
        {
            break;
        }
    }
}

//堆排序
//参数n为数组中最大小标，如数组有n+1个元素，最大下标为n
void HeapSort(DataType *unStorted,size_t n)
{
    assert(NULL != unStorted);

    int index;

    for (index = (n - 1) / 2;index >= 0;--index)  //index需要减到0，因此不能定义为size_t
    {
        HeapAdjust(unStorted,n,index);
    }

    for (index = n;index >= 1;--index)
    {
        swap(unStorted[0],unStorted[index]);
        HeapAdjust(unStorted,index - 1,0);  //不是HeapAdjust(unStorted,index,0);
    }
}

//计数排序，基本实现
//此处的基数排序的使用场合：
//输入为正数；
//    输入不重复；
//输入的最大数与输入的个数基本相等时空间利用率最高，也就是输入为0~n内的n个不重复的正数
void CountSortBasic_1(DataType *unStorted,size_t n)
{
    assert(NULL != unStorted);

    size_t *hash = new size_t [n + 1];
    size_t cnt = 0;
    int index =  0;

    for (index = 0;index <= n;++index)
    {
        hash[index] = 0;
    }

    for (index = 0;index < n;++index)  //index < n而非index <= n，因为此处访问的是unStorted[index]，最大下标为n-1
    {
        ++hash[ unStorted[index] ];
    }

    for (index = 0;index <= n;++index)
    {
        if (hash[ index ] != 0)   //判断index是否出现
        {
            unStorted[cnt++ ] = index;  
        }
    }

    delete [] hash;
}

//计数排序，位图实现
void CountSort(DataType *unStorted,size_t n)
{
    assert(NULL != unStorted);

    bitset<MaxSize> hash;
    
    size_t cnt = 0;
    int index =  0;

    hash.reset();

    for (index = 0;index < n;++index)  //index < n而非index <= n，因为此处访问的是unStorted[index]，最大下标为n-1
    {
        hash.set(unStorted[index]);
    }

    for (index = 0;index <= n;++index)
    {
        if ( hash.test(index) )
        {
            unStorted[cnt++ ] = index;  
        }
    }
}

//测试“脚手架”
void TestSortDriver()
{    
    /*DataType *unsortedArray = new DataType[MaxSize];
    size_t lengthOfUnsortedArray;*/
    size_t programToTest;
    
    int MinRandomInt;
    int MaxRandomInt;
    size_t i;
    int timeStart = 0;
    double timeCostAverage = 0;

    //用于计数排序时的输入
    DataType  unsortedArray[10]= {2,0,9,8,4,5,3,7,1,6};
    size_t lengthOfUnsortedArray = 10;
    

    cout<<"please enter the length Of UnsortedArray,MinRandomInt and MaxRandomInt :"<<endl;
    cin>>lengthOfUnsortedArray>>MinRandomInt>>MaxRandomInt;
    cout<<"please enter the identifier of the program to test (end with ctrl+z): "<<endl;
    while (cin>>programToTest)
    {
        for (i = 0;i < lengthOfUnsortedArray;++i)  //准备待排序数组
        {
            unsortedArray[i] = RandomIntGenerate(MinRandomInt,MaxRandomInt);
        }

        cout<<"the unsorted array is :"<<endl;
        DisplayArray(unsortedArray,lengthOfUnsortedArray);

        timeStart = clock();
        switch (programToTest)
        {
            case 11: 
                cout<<"Test SelectSort..."<<endl;
                SelectSort(unsortedArray,lengthOfUnsortedArray);
                break;

            case 21: 
                cout<<"Test InsertSort..."<<endl;
                InsertSort(unsortedArray,lengthOfUnsortedArray);
                break;

            case 22: 
                cout<<"Test ShellSort..."<<endl;
                ShellSort(unsortedArray,lengthOfUnsortedArray);
                break;

            case 31: 
                cout<<"Test BubbleSort..."<<endl;
                BubbleSort(unsortedArray,lengthOfUnsortedArray);
                break;

            case 32: 
                cout<<"Test QuickSort..."<<endl;
                QuickSort(unsortedArray,0,lengthOfUnsortedArray - 1);
                break;

            case 33: 
                cout<<"Test HeapSort..."<<endl;
                HeapSort(unsortedArray,lengthOfUnsortedArray - 1);
                break;

            case 41: 
                cout<<"Test MergeSortNonRecursive..."<<endl;
                MergeSortNonRecursive(unsortedArray,lengthOfUnsortedArray);
                break;

            case 42: 
                cout<<"Test MergeSort..."<<endl;
                MergeSort(unsortedArray,0,lengthOfUnsortedArray - 1);
                break;


            case 51: 
                cout<<"Test CountSort..."<<endl;
                CountSort(unsortedArray,lengthOfUnsortedArray);
                break;
                
            default:
                break;
        }

        timeCostAverage = 1e9 * ( clock() - timeStart ) / ( CLOCKS_PER_SEC * lengthOfUnsortedArray );
        cout<<"the average time cost per data is : "<<timeCostAverage<<" ns"<<endl;

        for (i = 0;i < lengthOfUnsortedArray - 1;++i)
        {
            if (unsortedArray[i] > unsortedArray[i + 1])
            {
                cout<<"sort bug i = "<<i<<endl;
            }
        }

        cout<<"the sorted array is :"<<endl;
        DisplayArray(unsortedArray,lengthOfUnsortedArray);

        cout<<endl;
        cout<<"please enter the identifier of the program to test (end with ctrl+z): "<<endl;
    }

    //delete [] unsortedArray;
}

int main()
{
    TestSortDriver();

    return 0;
}