ExchangeSort(data,7);
    for (int i=0;i<7;i++)
        cout<<data[i]<<" ";
    cout<<"\n";
}   before_compare|one_turn|two_turn|three_turn|four_turn|five_turn|six_turn 
10         9         8         7         6           5     4                      9        10        10 
10       10           10    10          8         8         9         9         9           9     9 
7         7         7         8         8           8     8          6         6         6         6         7  
7     7          5         5         5         5      5        6   6          4         4         4         4  
4           4     5 从上面的算法来看，基本和冒泡法的效率一样。
倒序(最糟情况)
第一轮：10,9,8,7->9,10,8,7->8,10,9,7->7,10,9,8(交换 3 次)
第二轮：7,10,9,8->7,9,10,8->7,8,10,9(交换 2 次)
第一轮：7,8,10,9->7,8,9,10(交换 1 次)
循环次数：6 次
交换次数：6 次

其他：
第一轮：8,10,7,9->8,10,7,9->7,10,8,9->7,10,8,9(交换 1 次)
第二轮：7,10,8,9->7,8,10,9->7,8,10,9(交换 1 次)
第一轮：7,8,10,9->7,8,9,10(交换 1 次)
循环次数：6 次
交换次数：3 次

从运行的表格来看，交换几乎和冒泡一样糟。事实确实如此。循环次数和冒泡一样也是
1/2*(n-1)*n，所以算法的复杂度仍然是 O(n*n)。由于我们无法给出所有的情况，所以只
能直接告诉大家他们在交换上面也是一样的糟糕（在某些情况下稍好，在某些情况下稍
差）。3.选择法：
现在我们终于可以看到一点希望：选择法，这种方法提高了一点性能（某些情况下）这
种方法类似我们人为的排序习惯：从数据中选择最小的同第一个值交换，在从省下的部
分中选择最小的与第二个交换，这样往复下去。
#include <iostream.h>
void SelectSort(int* pData,int Count)
{
    int iTemp;
    int iPos;
    for(int i=0;i<Count-1;i++)
    {
        iTemp = pData[i];
        iPos = i;
        for(int j=i+1;j<Count;j++)
        {
            if(pData[j]<iTemp)
            {