选择、插入、冒泡排序

选择、插入、冒泡三种算是最典型的排序算法了，空间复杂度都为O(1)

选择排序时间复杂度跟初始数据顺序无关，O(n2)，而且还不稳定;

插入排序时间复杂度跟初始数据顺序有关最好O(n),最坏O(n2)，稳定

冒泡排序时间复杂度跟初始数据顺序有关最好O(n),最坏O(n2)，稳定

三种算法中对于大量随机数，所需时间插入<选择<冒泡。

// MySort.h: interface for the MySort class.
#include "iostream.h"

template<class T>
void swap(T &a,T &b)
{
    T c=a;
    a=b;
    b=c;
}

template<class T>
void print(T a[], int n ,int i){
    cout<<"第"<<i+1 <<"趟 : ";
    for(int j= 0; j<10; j++){
        cout<<a[j] <<"  ";
    }
    cout<<endl;
}  

template<class T>
void selectSort(T a[],int n)  //选择排序
{
    int i,j,k;
    for(i=0;i<n-1;++i)
    {
        k=i;
        for(j=i+1;j<n;++j)
        {
            if(a[j]<a[k])
                k=j;
        }
        if(k!=i)
            swap(a[i],a[k]);
    }
}

template<class T>
void selectSort2(T a[],int n)  //二元选择排序
{
    int i,j,min,max;

    for (i=1;i <= n/2;++i)    // 做不超过n/2趟选择排序
    {
        min = i; max = i ; //分别记录最大和最小关键字记录位置
        for (j= i; j<=n-i; ++j)
        {
            if (a[j] > a[max]) {
                max = j ;
                continue ;
            }
            if (a[j]< a[min])
                min = j ;   

        }
        //该交换操作还可分情况讨论以提高效率
        swap(a[i-1],a[min]);
        if(max!=i)
            swap(a[n-i],a[max]);

#ifdef _DEBUG
        print(a,n,i-1);
#endif

    }
}

template<class T>
void insertSort(T a[],int n)  //插入排序
{
    int i;
    for(i=1;i<n;++i)
    {
        if(a[i]<a[i-1])
        {
            int j= i-1;
            T x = a[i];         //复制为哨兵，即存储待排序元素
            a[i] = a[i-1];      //先后移一个元素
            while(j>=0 && x<a[j])     //查找在有序表的插入位置
            {
                a[j+1] = a[j];  //元素后移
                j--;
            }
            a[j+1] = x;        //插入到正确位置
        }
    }

}
template<class T>
void bubbleSort(T a[],int n)  //冒泡排序
{
/*
int i,j;
for(i=0; i<n-1; ++i) {
for(j=0; j<n-i-1; ++j) {
if(a[j] > a[j+1])
{
swap(a[j],a[j+1]);
}
}
#ifdef _DEBUG
print(a,n,i);
#endif
}
    */

    bool bSwaped = true;

    int i,j;
    int lastSwapPos, lastSwapPos_temp = 0;
    for(i=0; i<n-1; ++i)
    {
        bSwaped = false;
        lastSwapPos = lastSwapPos_temp; 

        for(j=n-1; j>lastSwapPos; j--)
        {
            if(a[j-1] > a[j])
            {
                swap(a[j],a[j-1]); 

                bSwaped = true;  

                lastSwapPos_temp = j - 1;
            }
        }
        // 如果上一次扫描没有发生交换，则说明数组已经全部有序，退出循环
        if(!bSwaped)
            break;
    } 

}