常用排序算法

#include <iostream>
#include <cassert>

using namespace std;

template <typename T>
void printArray(T array[],int arrayLen)
{
    if (arrayLen > 1)
    {
        cout<<endl<<"		";
        for (int i=0;i<arrayLen;i++)
        {
            cout<<array[i]<<" ";
        }
        cout<<endl;
    }
    return;
}

template <typename T>
void randomPerm(T array[],int arrayLen)
{
    if (arrayLen > 1)
    {
        T ex;
        int rand1,rand2;
        for (int i=0;i<arrayLen; i++)
        {
            rand1=rand()%arrayLen;
            rand2=rand()%arrayLen;
            if (rand2!=rand1)
            {
                ex=array[rand1];
                array[rand1]=array[rand2];
                array[rand2]=ex;        
            }
        }
    }
    return;
}

template <typename T>
void selectSort(T array[],int arrayLen)
{
    if (arrayLen > 1)
    {
        T ex;
        int t;
        for (int i=1;i<arrayLen-1;i++)
        {
            t=i-1;
            for (int j=i;j<arrayLen;j++)
            {
                if (array[j]<array[t])
                {
                    t=j;
                }
            }
            if (t==i-1)
            {
                continue;
            }
            ex=array[t];
            array[t]=array[i-1];
            array[i-1]=ex;            
            
        }
    }
    return;
}

template <typename T>
void bubbleSort(T array[],int arrayLen)
{
    if (arrayLen > 1)
    {
        bool flag=true;
        T ex;
        for (int i=0;i<arrayLen-1 && flag;i++)
        {
            flag=false;
            for (int j=0;j<arrayLen-i-1;j++)
            {
                if (array[j]>array[j+1])
                {
                    ex=array[j];
                    array[j]=array[j+1];
                    array[j+1]=ex;    
                    flag=true;
                }
            }
        }
    }
    return;
}

template <typename T>
void insertSort(T array[],int arrayLen)
{
    if (arrayLen > 1)
    {
        T ex;
        bool flag=true;
        for (int i=0;i<arrayLen-1&&flag;i++)
        {
            flag=false;
            for (int j=i+1;j>0;j--)
            {
                if (array[j]<array[j-1])
                {
                    ex=array[j];
                    array[j]=array[j-1];
                    array[j-1]=ex;    
                    flag=true;
                }
            }
        }
    }
    return;
}

template <typename T>
void heapSort(T array[],int arrayLen,bool max)
{
    if (arrayLen > 1)
    {
        T ex;
        void (*heap)(T array[],int arrayLen);
        heap=minHeap;
        if (max)
        {
            heap=maxHeap;
        }
        heap(array,arrayLen);
        for (int i=0;i<arrayLen-1;i++)
        {
            ex=array[arrayLen-i-1];
            array[arrayLen-i-1]=array[0];
            array[0]=ex;
            heap(array,arrayLen-i-1);
        }
    }
    return;
}

template <typename T>
void  minHeap(T array[],int arrayLen)
{
    if (arrayLen > 1)
    {    
        T ex;
        for (int i=arrayLen/2-1;i>=0;i--)
        {
            if ((2*i+1)<arrayLen)
            {
                if (array[i]>array[2*i+1])
                {
                    ex=array[i];
                    array[i]=array[2*i+1];
                    array[2*i+1]=ex;
                }
            }
            if ((2*i+2)<arrayLen)
            {
                if (array[i]>array[2*i+2])
                {
                    ex=array[i];
                    array[i]=array[2*i+2];
                    array[2*i+2]=ex;
                }
            }
        }
    }
    return;
}

template <typename T>
void  maxHeap(T array[],int arrayLen)
{
    if (arrayLen > 1)
    {
        T ex;
        for (int i=arrayLen/2-1;i>=0;i--)
        {
            if ((2*i+1)<arrayLen)
            {
                if (array[i]<array[2*i+1])
                {
                    ex=array[i];
                    array[i]=array[2*i+1];
                    array[2*i+1]=ex;
                }
            }
            if ((2*i+2)<arrayLen)
            {
                if (array[i]<array[2*i+2])
                {
                    ex=array[i];
                    array[i]=array[2*i+2];
                    array[2*i+2]=ex;
                }
            }
        }
    }
    return;
}

template <typename T>
void quikSort(T array[],int start,int end)
{
    if (start < end)
    {    
        T key=array[end];
        int i=start-1,j=start;
        T ex;
        while (j<=end-1)
        {
            if (array[j]<key)
            {
                i++;
                ex=array[i];
                array[i]=array[j];
                array[j]=ex;
            }
            j++;
        }
        ex=array[i+1];
        array[i+1]=array[end];
        array[end]=ex;
        quikSort(array,start,i);
        quikSort(array,i+2,end);
        }
    return;
}

template <typename T>
void mergeSort(T array[],int start,int end)
{
    if (start < end)
    {
        int mid=(start+end)/2;
        mergeSort(array,start,mid);
        mergeSort(array,mid+1,end);
        insertSort(&array[start],end-start+1);
        //selectSort(&array[start],end-start+1);
        //printArray(array,10);
    }    
}

template <typename T>
void shellSort(T array[],int arrayLen,int seed)
{
    if (seed && arrayLen > 1)
    {
        T ex;
        bool flag=true;
        for (int i=0;i<arrayLen-seed && flag;i++)
        {
            flag=false;
            for (int j=i+seed;j>0;j-=seed)
            {
                if (array[j]<array[j-seed])
                {
                    ex=array[j];
                    array[j]=array[j-seed];
                    array[j-seed]=ex;
                    flag=true;
                }
            }
        }
        seed/=2;
        //printArray(array,10);
        shellSort(array,arrayLen,seed);
    }
}
void main(void)
{
    double array[10]={0.3,3.2,5.7,2.1,4.5,1.9,8.6,7.3,9.4,6.1};
    
    cout<<"Select Sort"<<endl;
    randomPerm(array,10);
    cout<<"Original array: ";
    printArray(array,10);
    selectSort(array,10);
    cout<<"Sorted array: ";
    printArray(array,10);
    cout<<endl;
    
    cout<<"Bubble Sort"<<endl;
    randomPerm(array,10);
    cout<<"Original array: ";
    printArray(array,10);
    bubbleSort(array,10);
    cout<<"Sorted array: ";
    printArray(array,10);
    cout<<endl;

    cout<<"Insert Sort"<<endl;
    randomPerm(array,10);
    cout<<"Original array: ";
    printArray(array,10);
    //insertSort(array,10);
    shellSort(array,10,1);
    cout<<"Sorted array: ";
    printArray(array,10);
    cout<<endl;

    cout<<"Heap Sort"<<endl;
    randomPerm(array,10);
    cout<<"Original array: ";
    printArray(array,10);
    heapSort(array,10,true);
    cout<<"Sorted array: ";
    printArray(array,10);
    cout<<endl;

    cout<<"Quik Sort"<<endl;
    randomPerm(array,10);
    cout<<"Original array: ";
    printArray(array,10);
    quikSort(array,0,9);
    cout<<"Sorted array: ";
    printArray(array,10);
    cout<<endl;

    cout<<"Merge Sort"<<endl;
    randomPerm(array,10);
    cout<<"Original array: ";
    printArray(array,10);
    mergeSort(array,0,9);
    cout<<"Sorted array: ";
    printArray(array,10);
    cout<<endl;

    cout<<"Shell Sort"<<endl;
    randomPerm(array,10);
    cout<<"Original array: ";
    printArray(array,10);
    shellSort(array,10,5);
    cout<<"Sorted array: ";
    printArray(array,10);
    cout<<endl;

    printf("%d", sizeof(unsigned short int));
    system("pause");
    return;
}