第四章 向量容器 --项目设计题--排序算法的性能比较

#include
#include
#include
#include

using namespace std;
/

template                                   //选择
void selectionSort(vector & v)
{
    // index of smallest item in each pass
    int smallIndex;
    // save the vector size in n
    int pass, j, n = v.size();
    T temp;
    // sort v[0]..v[n-2], and arr[n-1] is in place
    for (pass = 0; pass < n-1; pass++)
    {
        // start the scan at index pass; set smallIndex to pass
        smallIndex = pass;
        // j scans the sublist v[pass+1]..v[n-1]
        for (j = pass+1; j < n; j++)
            // update smallIndex if smaller element is found
            if (v[j] < v[smallIndex])
                smallIndex = j;
            // when finished, place smallest item in arr[pass]
            if (smallIndex != pass)
            {
                temp = v[pass];
                v[pass] = v[smallIndex];
                v[smallIndex] = temp;
            }
    }
}
//
template                                  //插入排序
void insertionSort(vector & v)
{
    int i, j, n = v.size();
    T target;
    // place v[i] into the sublist
    //   v[0] ... v[i-1], 1 <= i < n,
    // so it is in the correct position
    for (i = 1; i < n; i++)
    {
        // index j scans down list from v[i] looking for
        // correct position to locate target. assigns it to
        // v[j]
        j = i;
        target = v[i];
        // locate insertion point by scanning downward as long
        // as target < v[j-1] and we have not encountered the
        // beginning of the list
        while (j > 0 && target < v[j-1])
        {
            // shift elements up list to make room for insertion
            v[j] = v[j-1];
            j--;
        }
        // the location is found; insert target
        v[j] = target;
    }
}
//
template                                     //冒泡
void bubbleSort(vector & v )
{
    int n = v.size();
    int i,j;
    T temp;
    bool flag = true;
    for (i = 0;i
    {
        if (flag)
        {
            flag = false;
        }
        else
        {
            //break;
        }
        for(j = 0;j         {
            if (v[j]>v[j+1])
            {
                flag = true;
                temp = v[j];
                v[j] = v[j+1];
                v[j+1] = temp;
            }
        }
    }
}

//
template                           //交换
void switchSort(vector & v)
{
    int i , j ,n = v.size();
    T temp;
    for (i = 0 ; i < n-1; i++)
    {
        j = i;
        for (j;j
        {
            if (v[i]>v[j])
            {
                temp = v[i];
                v[i] = v[j];
                v[j] = temp;
            }
        }
    }
}

template
void shellSort(vector & v)                          //希尔排序
{
    int n = v.size();
    int i, j;  
    T key;  
    int h;  
    for (h = 1; h <= (n-1)/9; h = 3*h + 1)   
        ;  
    for (; h > 0; h /= 3)  
        for (i = h; i < n; i++)  
        {  
            key = v[i];  
            j = i;  
            while ((j >= h) && (v[j-h] > key))  
            {  
                v[j] = v[j-h];  
                j -= h;  
            }  
            v[j] = key;  
        } 
}
//

template
void writeVector(const vector & v)                    //output vector
{
    int i;
    for (i = 0; i
    {
        cout< <<"     ";
    }
    cout<
}

///
enum sortType {SelectionSort,InsertSort,BubbSort,ExchangeSort,ShellSort};
enum testType {randNum , Ascending , Descending}; //up,down

template
void generateNum(vector & v,testType tst,int n) //n is the size of the vector
{
    int i;
    randomNumber randInt;
    switch(tst)
    {
    case randNum :
        {
            for (i = 0;i
            {
                v.push_back(randInt.random(n)+1);
            }
            writeVector(v);
            break;
        }
    case Ascending:
        {
            for (i = 1;i<=n;i++)
            {
                v.push_back(i);
            }
            //writeVector(v);
            break;
        }
    case Descending:
        {
            for (i = n;i>0;i--)
            {
                v.push_back(i);   
            }
        //    writeVector(v);
        break;   
        }
    default:break;
    }
}
/

///
void timeSort(sortType stype, testType tst, int vecsize);

///
//enum sortType {SelectionSort,InsertSort,BubbSort,ExchangeSort,ShellSort};
//enum testType {randNum , Ascending , Descending}; //up,down
void main()
{
    sortType stype;
    testType tst;
    stype = ShellSort;
    tst = randNum;

    timeSort(stype,tst,10000);

}

void timeSort(sortType stype, testType tst, int vecsize)
{
    vector upVector;
    vector downVector;
    vector randVector;
    timer t;

    switch(stype)
    {
    case SelectionSort:
        {
            switch(tst)
            {
            case Ascending:
                {
                    generateNum(upVector,Ascending,vecsize);
                    t.start();
                    selectionSort(upVector);
                    t.stop();
                    writeVector(upVector);
                    cout<
                    cout<<"Selection Sort takes  "< <<"seconds"<
                    break;
                }
            case Descending:
                {
                    generateNum(downVector,Descending,vecsize);
                    t.start();
                    selectionSort(downVector);
                    t.stop();
                    writeVector(downVector);
                    cout<
                    cout<<"Selection Sort takes  "< <<"seconds"<
                    break;
                }
            case randNum:
                {
                    generateNum(randVector,randNum,vecsize);
                    t.start();
                    selectionSort(randVector);
                    t.stop();
                    writeVector(randVector);
                    cout<
                    cout<<"Selection Sort takes  "< <<"seconds"<
                    break;
                }
            default:break;
            }
            break;
        }
            //enum sortType {SelectionSort,InsertSort,BubbSort,ExchangeSort,ShellSort};
            case InsertSort:
                {
                    switch(tst)
                    {
                    case Ascending:
                        {
                            generateNum(upVector,Ascending,vecsize);
                            t.start();
                            insertionSort(upVector);
                            t.stop();
                            writeVector(upVector);
                            cout<
                            cout<<"insertion Sort takes  "< <<"seconds"<
                            break;
                        }
                    case Descending:
                        {
                            generateNum(downVector,Descending,vecsize);
                            t.start();
                            insertionSort(downVector);
                            t.stop();
                            writeVector(downVector);
                            cout<
                            cout<<"insertion Sort takes  "< <<"seconds"<
                            break;
                        }
                    case randNum:
                        {
                            generateNum(randVector,randNum,vecsize);
                            t.start();
                            insertionSort(randVector);
                            t.stop();
                            writeVector(randVector);
                            cout<
                            cout<<"insertion Sort takes  "< <<"seconds"<
                            break;
                        }
                    default:break;
                    }
                        break;
                }
            case BubbSort:
                {
                    switch(tst)
                    {
                    case Ascending:
                        {
                            generateNum(upVector,Ascending,vecsize);
                            t.start();
                            bubbleSort(upVector);
                            t.stop();
                            writeVector(upVector);
                            cout<
                            cout<<"BubbSort Sort takes  "< <<"seconds"<
                            break;
                        }
                    case Descending:
                        {
                            generateNum(downVector,Descending,vecsize);
                            t.start();
                            bubbleSort(downVector);
                            t.stop();
                            writeVector(downVector);
                            cout<
                            cout<<"BubbSort Sort takes  "< <<"seconds"<
                            break;
                        }
                    case randNum:
                        {
                            generateNum(randVector,randNum,vecsize);
                            t.start();
                            bubbleSort(randVector);
                            t.stop();
                            writeVector(randVector);
                            cout<
                            cout<<"BubbSort Sort takes  "< <<"seconds"<
                            break;
                        }
                    default:break;
                    }
                    break;
                }
            case ExchangeSort:
                {
                    switch(tst)
                    {
                    case Ascending:
                        {
                            generateNum(upVector,Ascending,vecsize);
                            t.start();
                            switchSort(upVector);
                            t.stop();
                            writeVector(upVector);
                            cout<
                            cout<<"switchSort Sort takes  "< <<"seconds"<
                            break;
                        }
                    case Descending:
                        {
                            generateNum(downVector,Descending,vecsize);
                            t.start();
                            switchSort(downVector);
                            t.stop();
                            writeVector(downVector);
                            cout<
                            cout<<"switchSort Sort takes  "< <<"seconds"<
                            break;
                        }
                    case randNum:
                        {
                            generateNum(randVector,randNum,vecsize);
                            t.start();
                            switchSort(randVector);
                            t.stop();
                            writeVector(randVector);
                            cout<
                            cout<<"switchSort Sort takes  "< <<"seconds"<
                            break;
                        }
                    default:break;
                    }
                    break;
                }
            case ShellSort:
                {
                    switch(tst)
                    {
                    case Ascending:
                        {
                            generateNum(upVector,Ascending,vecsize);
                            t.start();
                            shellSort(upVector);
                            t.stop();
                            writeVector(upVector);
                            cout<
                            cout<<"shellSort Sort takes  "< <<"seconds"<
                            break;
                        }
                    case Descending:
                        {
                            generateNum(downVector,Descending,vecsize);
                            t.start();
                            shellSort(downVector);
                            t.stop();
                            writeVector(downVector);
                            cout<
                            cout<<"shellSort Sort takes  "< <<"seconds"<
                            break;
                        }
                    case randNum:
                        {
                            generateNum(randVector,randNum,vecsize);
                            t.start();
                            shellSort(randVector);
                            t.stop();
                            writeVector(randVector);
                            cout<
                            cout<<"shellSort Sort takes  "< <<"seconds"<
                            break;
                        }
                    default:break;
                    }
                    break;
                }
            default:break;
    }

}