C++数据结构03--排序算法

#include "stdafx.h"
#include <iostream> 
#include <windows.h>
using namespace std;  
  
template <class T>  
void  BubbleSort(T& nData,int len)  
{  
    bool isOk = false;  
    for(int i = 0;i<len-1&&!isOk;++i){  
        isOk = true;  
        for(int j = len - 1;j > i;--j){  
            if(nData[j]<nData[j-1]){  
                int temp = nData[j];  
                nData[j] = nData[j-1];  
                nData[j-1] = temp;  
                isOk = false;  
Sleep(500);
            }  
        }  
    }  
}  
  
template <class T>  
void InsertSort(T& array, int length){  
    int i, j, key;  
  
    for (i = 1; i < length; i++){  
        key = array[i];  
        //把i之前大于array[i]的数据向后移动  
        for (j = i - 1; j >= 0 && array[j] > key; j--){  
            array[j + 1] = array[j];  
        }  
        //在合适位置安放当前元素  
        array[j + 1] = key;  
Sleep(500);
    }  
}  
   
  
  
  //基数排序
int RadixCountSort(int* npIndex, int nMax, int* npData, int nLen){    
//这里就不用说了，计数的排序。不过这里为了是排序稳定     
//在标准的方法上做了小修改。     
    int* pnCount  = (int*)malloc(sizeof(int)* nMax);            //保存计数的个数     
    int i = 0;    
    for (i = 0; i < nMax; ++i){    
       pnCount[i] = 0;    
    }    
    for (i = 0; i < nLen; ++i){                                  //初始化计数个数     
       ++pnCount[npIndex[i]];    
    }    
    
for (i = 1; i < 10; ++i){                                    //确定不大于该位置的个数。     
       pnCount[i] += pnCount[i - 1];    
    }    


   
    
    int * pnSort  = (int*)malloc(sizeof(int) * nLen);           //存放零时的排序结果。     
    //注意：这里i是从nLen-1到0的顺序排序的，是为了使排序稳定。     
    for (i = nLen - 1; i >= 0; --i){    
       // --pnCount[npIndex[i]];            
        pnSort[pnCount[npIndex[i]]] = npData[i];    
    }  
    for (i = 0; i < nLen; ++i){                                  //把排序结构输入到返回的数据中。       
        npData[i] = pnSort[i];    
    }    
    free(pnSort);                                               //记得释放资源。     
    free(pnCount);    
Sleep(500);
    return 1;    
}    
    
     
int RadixSort(int* nPData, int nLen){    
    //申请存放基数的空间     
    int* nDataRadix    = (int*)malloc(sizeof(int) * nLen);   
    int nRadixBase = 1;                                         //初始化倍数基数为1     
    int nIsOk = 0;                                              //设置完成排序为0     
    
    //循环，直到排序完成     
    while (!nIsOk){    
        nIsOk = 1;    
        nRadixBase *= 10;    
       int i = 0;     
        for (i = 0; i < nLen; ++i){    
            nDataRadix[i] = nPData[i] % nRadixBase;    
            nDataRadix[i] /= nRadixBase / 10;    
            if (nDataRadix[i] > 0){    
                nIsOk = 0;    
            }    
        }    
        if (nIsOk){                                             //如果所有的基数都为0，认为排序完成，就是已经判断到最高位了。     
            break;    
        }    
        RadixCountSort(nDataRadix, 10, nPData, nLen);    
    }    
    free(nDataRadix);  
    return 1;  
}  














//选择排序
template <class T> 
int Max(T a[],int n)
{
int pos=0;
for (int i = 1; i < n; i++)
{
if (a[pos]<a[i])
{
pos=i;
return pos;
}
}


}




template <class T> 
void Swap(T &a,T &b)
{


T temp=a;a=b;b=temp;
}


template <class T> 
void Selection(T a[],int n)
{
for (int size = n; size < 1; size--)
{
int j=Max(a,size);
Swap(a[j],a[size-1]);


}




}








//标准输出  
template <class T>   
void show(T arr,int n){  
    for(int i =0;i<n-1;i++){  
        cout<<arr[i]<<",";  
    }  
    cout<<arr[n-1]<<endl;  
}  
  
  
template <class T>  
void change(T arr,int n)  
{  
    arr[0]=2;  
    arr[1]=2;  
    show(arr,n);  
}  
  
 


int _tmain(int argc, _TCHAR* argv[])
{
int inputNumber[10];  
    int count = 0;  
    cout<<"Input"<<endl;  
    for(int i =0;i<10;i++){  
        int a;  
        cin>>a;  
        if(a==0){  
            break;  
        }  
        inputNumber[i]=a;  
        count++;  
    }  
    cout<<"1-冒泡排序、2-插入排序、3-基数排序、4-选择排序"<<endl;  
    cout<<"Output"<<endl;  
    int choice;  
    cin>>choice;  
    switch(choice){  
    case 1:  
        cout<<"冒泡排序"<<endl;  
        BubbleSort(inputNumber,count);  
        show(inputNumber,count);  
        break;  
    case 2:  
        cout<<"插入排序"<<endl;  
        InsertSort(inputNumber,count);  
        show(inputNumber,count);  
        break;  
    case 3:  
        cout<<"基数排序"<<endl;  
        RadixSort(inputNumber,count);  
        show(inputNumber,count);  
        break;  
case 4:  
        cout<<"选择排序"<<endl;  
Selection(inputNumber,count);  
        show(inputNumber,count);  
        break;  
    default:  
        break;  
    }  
    cout<<"End"<<endl;  
return 0;
}