选择、插入、冒泡排序

选择、插入、冒泡三种算是最典型的排序算法了，空间复杂度都为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;
    } 
    
}