排序加测试

</pre><pre name="code" class="cpp">#include<stdio.h>
#include<iostream>
#include<stack>
#include<math.h>
#include<string.h>
using namespace std;

void insert_sort(int a[], int n)
{
    int i,j,temp;
    for ( i=1; i<n; i++)
    {
        temp = a[i];
        for (j=i-1; j>=0&&temp<a[j];j--)
        {
            a[j+1] = a[j];
        }
        a[j+1] = temp;
    }
}
/*================================================*/
void shell_sort(int a[],int len)
{

    int h,i,j,temp;

    for (h=len/2; h>0; h=h/2)
    {
        for (i=h; i<len; i++)
        {
            temp = a[i];
            for (j=i-h; (j>=0 && temp<a[j]); j-=h)
            {
                a[j+h] = a[j];
            }
            a[j+h] = temp;
        }
    }
}
/*================================================*/
void bubble_sort(int a[],int len)
{
    int i = 0;
    int j = 0;
    int temp = 0;
    int exchange = 0;

    for(i=0; i<len-1; i++)
    {
        exchange = 0;
        for(j=len-1; j>=i;j--)
        {
            if(a[j+1] < a[j])
            {
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
                exchange = 1;
            }
        }
        if(exchange !=1)
            return;
    }
}
/*================================================*/
int quick_sort_mid(int a[],int low,int high)
{
    int i,j,pivot;
    if(low < high)
    {
        pivot = a[low];
        i = low;
        j = high;
        while(i<j)
        {
            while (i<j && a[j]>=pivot)
                j--;
            if(i<j)
                a[i++] = a[j];

            while (i<j && a[i]<=pivot)
                i++;
            if(i<j)
                a[j--] = a[i];
        }
        a[i] = pivot;
    }
    return i;
}

//递归
void quick_sort_recur(int a[],int low,int high)
{
    if(low<high)
    {
        int p = quick_sort_mid(a,low,high);
        quick_sort_recur(a,low,p-1);
        quick_sort_recur(a,p+1,high);
    }

}

//非递归

void quick_sort_unrecur(int a[],int low,int high)
{
    stack <int> s;
    int p,q;

    if(low<high)
    {
        int mid = quick_sort_mid(a,low,high);
        if(low<mid-1)
        {
            s.push(low);
            s.push(mid-1);
        }
        if(high>mid+1)
        {
            s.push(mid+1);
            s.push(high);
        }
        while(!s.empty())
        {
            q = s.top();
            s.pop();
            p = s.top();
            s.pop();
            mid = quick_sort_mid(a,p,q);
            if(p<mid-1)
            {
                s.push(p);
                s.push(mid-1);
            }
            if(q>mid+1)
            {
                s.push(mid+1);
                s.push(q);
            }
        }
    }
}
/*================================================*/
void select_sort(int a[],int len)
{
    int i,j,mmin,mmin_pos;

    for(i=0; i<len; i++)
    {
        mmin = a[i];
        mmin_pos = i;
        for(j=i; j<len; j++)
        {
            if(a[j] < mmin)
            {
                mmin = a[j];
                mmin_pos = j;
            }
        }
        a[mmin_pos] = a[i];
        a[i] = mmin;
    }
}
/*================================================*/
int heapSize = 0;
#define LEFT(index) (((index<<1)+1))
#define RIGHT(index) (((index<<1)+2))
void swap(int* a,int* b){int temp = *a;*a = *b;*b = temp;}

void maxHeapify (int array[],int index)
{
    int largest = 0;
    int left = LEFT(index);
    int right = RIGHT(index);

    if((left <= heapSize) && (array[left] > array[index]))
        largest = left;
    else
        largest = index;

    if((right <= heapSize) && (array[right] > array[largest]))
        largest = right;

    if(largest != index)
    {
        swap(&array[index],&array[largest]);
        maxHeapify(array,largest);
    }
}

void buildMaxHeap(int array[],int length)
{
    int i;
    heapSize = length;
    for (i= length/2; i >= 0; i--)
        maxHeapify(array, i);
}

void heap_sort (int array[], int length)
{
    int i;

    buildMaxHeap(array,(length - 1));

    for(i = length-1;i >= 1; i--)
    {
        swap(&array[0],&array[i]);
        heapSize--;
        maxHeapify(array,0);
    }
}
/*================================================*/
void Merge(int a[],int tmp[],int lPos,int rPos,int rEnd)
{
    int i,lEnd,len,tmpPos;
    lEnd = rPos - 1;
    tmpPos = lPos;
    len = rEnd - lPos + 1;

    while( lPos <= lEnd && rPos <= rEnd)
    {
        if(a[lPos] <= a[rPos])
            tmp[tmpPos++] = a[lPos++];
        else
            tmp[tmpPos++] = a[rPos++];
    }
    while( lPos <= lEnd)
        tmp[tmpPos++] = a[lPos++];
    while( rPos <= rEnd)
        tmp[tmpPos++] = a[rPos++];

    for( i = 0; i<len; i++,rEnd--)
        a[rEnd] = tmp[rEnd];
}

void msort(int a[],int tmp[],int low,int high)
{
    if(low>=high)
        return;
    int middle = (low + high)/2;
    msort(a,tmp,low,middle);
    msort(a,tmp,middle+1,high);
    Merge(a,tmp,low,middle+1,high);
}

void merge_sort(int a[],int len)
{
    int* tmp = NULL;
    tmp = new int[len];
    if(tmp != NULL)
    {
        msort(a,tmp,0,len-1);
        delete []tmp;
    }
}
/*================================================*/
int find_max(int a[],int len)
{
    int max = a[0];
    for(int i=1; i<len; i++)
    {
        if( max < a[i])
            max = a[i];
    }
    return max;
}

int digit_number(int number)
{
    int digit = 0;
    do
    {
        number = number/10;
        digit++;
    }while(number != 0);
    return digit;
}

int kth_digit(int number,int kth)
{
    number = number/pow(10,kth-1);
    return number%10;
}

void radix_sort(int a[],int len)
{
    int* temp[10];
    int cont[10] = {0};
    int max = find_max(a,len);
    int maxDigit = digit_number(max);
    int i,j,k;
    for(i=0;i<10;i++)
    {
        temp[i] = new int[len];
        memset(temp[i],0,sizeof(int)*len);
    }
    for(i=1; i<=maxDigit; i++)
    {
        memset(cont,0 , sizeof(int)*10);
        for(j=0; j<len; j++)
        {
            int xx = kth_digit(a[j],i);
            temp[xx][cont[xx]] = a[j];
            cont[xx]++;
        }
        int index = 0;
        for(j=0; j<10; j++)
        {
            for(k=0; k<cont[j]; k++)
            {
                a[index++] = temp[j][k];
            }
        }
    }
}
/*================================================*/

int main()
{
    int data1[9] = {54,38,96,23,15,72,60,45,83};
    insert_sort(data1,9);
    for(int i=0;i<9;i++)
        cout<< data1[i]<<" ";
    cout<<"insert_sort"<<endl;
/*================================================*/
    int data2[9] = {54,38,96,23,15,72,60,45,83};
    shell_sort(data2,9);
    for(int i=0;i<9;i++)
        cout<< data2[i]<<" ";
    cout<<"shell_sort"<<endl;
/*================================================*/
    int data3[9] = {54,38,96,23,15,72,60,45,83};
    bubble_sort(data3,9);
    for(int i=0;i<9;i++)
        cout<< data3[i]<<" ";
    cout<<"bubble_sort"<<endl;
/*================================================*/
    int data4[9] = {54,38,96,23,15,72,60,45,83};
    quick_sort_recur(data4,0,8);
    for(int i=0;i<9;i++)
        cout<< data4[i]<<" ";
    cout<<"quick_sort_recur"<<endl;
/*================================================*/
    int data5[9] = {54,38,96,23,15,72,60,45,83};
    quick_sort_unrecur(data5,0,8);
    for(int i=0;i<9;i++)
        cout<< data5[i]<<" ";
    cout<<"quick_sort_unrecur"<<endl;
/*================================================*/
    int data6[9] = {54,38,96,23,15,72,60,45,83};
    select_sort(data6,9);
    for(int i=0;i<9;i++)
        cout<< data6[i]<<" ";
    cout<<"select_sort"<<endl;
/*================================================*/
    int data7[9] = {54,38,96,23,15,72,60,45,83};
    heap_sort(data7,9);
    for(int i=0;i<9;i++)
        cout<< data7[i]<<" ";
    cout<<"heap_sort"<<endl;
/*================================================*/
    int data8[9] = {54,38,96,23,15,72,60,45,83};
    merge_sort(data8,9);
    for(int i=0;i<9;i++)
        cout<< data8[i]<<" ";
    cout<<"merge_sort"<<endl;
/*================================================*/
    int data9[9] = {54,38,96,23,15,72,60,45,83};
    radix_sort(data9,9);
    for(int i=0;i<9;i++)
        cout<< data9[i]<<" ";
    cout<<"radix_sort"<<endl;
    return 0;
}