数据结构：快速排序、基数排序、堆排序、归并排序

#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;
void QuickSort(int x[],int n);
void RadixSort(int x[],int n);
void HeapSort(int x[],int n);
void MergeSort(int x[], int low, int high, int * temp);
int cmp = 0;
int main()
{
    srand((unsigned int)time(0));
    clock_t cstart,cends;
    const int n=100;
    int data[n];
    int i;
    for(i = 0; i < n; i++)
    {
       data[i] = rand() % 801 + 200;
    }
    //●使用随机函数为data赋初值，随机函数的用法见文件”C++

    //输出排序前的数据序列
    cout<<"排序前："<<endl;
    for(i=0;i<n;++i) cout<<data[i]<<',';
    cout<<endl;

    //●调用排序函数,使用相应的排序名替换

    int b[n];  //归并排序辅助空间

    cstart=clock();
    QuickSort(data, n);
    cends=clock();

    //输出排序后的数据序列
    cout<<"排序后："<<endl;
    for(i=0;i<n;++i) cout<<data[i]<<',';
    cout<<endl;
    cout << " 数据交换次数：" << cmp << endl;
    cout << "排序耗时" << cends-cstart << "毫秒" << endl;
    return 0;
}

void QuickSort(int x[], int n)
{
    int value, start, end;
    if (n <= 1)
        return;
    value = x[0];
    start = 0;
    end = n - 1;
    while (start < end) {
        for (; start < end; --end)
        {
            if (x[end] < value)
            {
                x[start++] = x[end];
                cmp++;
                break;
            }
        }
        for (; start < end; ++start)
        {
            if (x[start] > value)
            {
                x[end--] = x[start];
                cmp++;
                break;
            }
        }
    }
    x[start] = value;
    cmp++;
    QuickSort(x, start);
    QuickSort(x + start + 1, n - start - 1);
}

void RadixSort(int x[],int n)
{
    int d =4;
    int tmp[n];
    int count[10];
    int i, j, k;
    int radix = 1;
    for(i = 1; i <= d; i++)
    {
        for(j = 0; j < 10; j++)
            count[j] = 0;
        for(j = 0; j < n; j++)
        {
            k = (x[j] / radix) % 10;
            count[k]++;
        }
        for(j = 1; j < 10; j++)
            count[j] = count[j - 1] + count[j];
        for(j = n - 1; j >= 0; j--)
        {
            k = (x[j] / radix) % 10;
            tmp[count[k] - 1] = x[j];
            count[k]--;
        }
        for(j = 0; j < n; j++)
            x[j] = tmp[j];
        radix = radix * 10;
    }
}

void buildHeap(int x[], int size, int pos)
{
    int value = x[pos];
    while(pos <= size)
    {
        int childpos = pos * 2;
        if(childpos <= size)
        {
            if((childpos + 1 <= size) && x[childpos + 1] > x[childpos])
                childpos += 1;
            if(value > x[childpos])
            {
                x[pos] = value;
                cmp++;
                return;
            }
            else
            {
                x[pos] = x[childpos];
                cmp++;
                pos = childpos;
            }
        }
        else
        {
            x[pos] = value;
            cmp++;
            return;
        }
    }
}

void Heapfying(int x[], int size)
{
    int lastPos = size;
    int rootPos = lastPos / 2;
    while(rootPos >= 1)
    {
        buildHeap(x, size, rootPos);
        rootPos--;
    }
}

void HeapSort(int x[],int n)
{
    int t[n + 1];
    for(int i = 0; i < n; i++)
    {
        t[i + 1] = x[i];
    }
    Heapfying(t, n);
    for(int i = n; i >= 2; i--)
    {
        int temp = t[i];
        t[i] = t[1];
        t[1] = temp;
        cmp++;
        buildHeap(t, i-1, 1);
    }
    for(int i = 1; i < n + 1; i++)
    {
        x[i - 1] = t[i];
    }
}

void Merge(int * a, int low, int mid, int high, int * temp)
{
    int i,j,k;
    i = low;
    j = mid + 1;
    k = 0;
    while (i <= mid && j <= high)
    {
        if(a[i] <= a[j])
            temp[k++] = a[i++];
        else
            temp[k++] = a[j++];
        cmp++;
    }
    while(i <= mid)
    {
        temp[k++] = a[i++];
        cmp++;
    }
    while(j <= high)
    {
        temp[k++] = a[j++];
        cmp++;
    }
    for (i = 0; i < k; i++)
    {
        a[low+i] = temp[i];
        cmp++;
    }
}

void MergeSort(int x[], int low, int high, int * temp)
{
    if (low < high)
    {
        int mid = (low + high)/2;
        MergeSort(x,low,mid,temp);
        MergeSort(x,mid+1,high,temp);
        Merge(x,low,mid,high,temp);
    }
}