c++实现冒泡，选择，插入，快速排序

template<class T>
class Csort{
Csort(int nArraySize);
virtual ~Csort();


void Bubble(T array[]);
void Insertion(T array[]);
void Quick(T array[] , int nLeftLimit , int nRightLimit);
void Selection(T array[]);




private:
int m_nArraySize;
};




template<class T>
Csort<T>::Csort(int nArraySize){
if (nArraySize < 0){
m_nArraySize = 0;
}
else{
m_nArraySize = nArraySize;
}
}


template<class T>
Csort<T>::~Csort(){


}




template<class T>
void Csort<T>::Bubble(T array[])  //冒泡排序
{
T  temp;
int nLast = m_nArraySize - 1;


bool bSorted = true;


do{
bSorted = true;
for (int i = 0; i < nLast; i++){
if (array[i] < array[i + 1]){
temp = array[i];
array[i] = array[i + 1];
array[i + 1] = temp;
bSorted = false;
}
}
nLast--;


} while (!bSorted);


}




template<class T>
void Csort<T>::Insertion(T array[]) //插入排序函数模板
{
T cVal;
for (int i = 1; i < m_nArraySize; i++){
cVal = array[i];
for (int n = i - 1; n >= 0 && cVal < array[n]; n--){
array[n + 1] = array[n];
}
array[n + 1] = cVal;
}
}




template<class T>
void  Csort<T>::Quick(T array[], int llimit, int rlimit){  //快速排序
T temp;
int nLeft = llimit;
int nRight = rlimit;
int pivot = (nLeft + nRight) / 2;


T nMedian = array[pivot];
do{
while ((array[nLeft] < nMedian) && (nLeft < rlimit)){
nLeft++;
}


while ((nMedian < array[nRight]) && (nRight > llimit)){
nRight--;
}


if (nLeft <= nRight){
temp = array[nLeft];
array[nLeft] = array[nRight];
array[nRight] = temp;
nLeft++;
nRight--;
}
} while (nLeft <= nRight)


if (llimit < nRight){
Csort<T>::Quick(array, llimit, nRight);
}


if (nLeft < rlimit){
Csort<T>::Quick(array, nLeft, rlimit);
}
}




template<class T>
void Csort<T>::Selection(T array[]){  //选择排序
T temp;
int min;
for (int i = 0; i < m_nArraySize - 1; i++){
min = 1; 
for (int n = i + 1; n < m_nArraySize; n++){
if (array[n] < array[min]){
min = n;
}
}
temp = array[min];
array[min] = array[i];
array[i] = temp;
}
}