常见排序算法

冒泡排序：

template <typename T>
void bubbleSort(T array[],int size){
	int flag = 0;
	for(int i=0; i<size; ++i){
		flag = 0;
		for(int j=0; j<size-i; ++j){
			if(array[j] > array[j+1]){
				T tmp = array[j];
				array[j] = array[j+1];
				array[j+1] = tmp;
				flag = 1;
			}
			if(flag == 0)
				break;
		}
	}
}

简单选择排序：

template <typename T>
void selectSort(T array[], int size){
	for(int i=0; i<size; ++i){
		int k = i;
		for(int j=i; j<size; ++j){
			if(array[k] < array[j]){
				k = j;
			}		
		}
			T tmp = array[i];
			array[i] = array[k];
			array[k] = tmp;
	}
}

快速排序：

template<typename T>
void qsort(T array[],int beg,int end){
	if(beg < end){
         int mid = partition(array,beg,end);
		 qsort(array,beg,mid);
		 qsort(array,mid+1,end);
	}
}

template<typename T>
int partition(T array[],int left,int right){
    int tmpLeft = left,tmpRight = right;
	T keyValue = array[left];
    while(tmpLeft < tmpRight){
		while(tmpLeft < tmpRight && array[tmpRight] >= keyValue) --tmpRight;
		array[tmpLeft] = array[tmpRight];
		while(tmpLeft < tmpRight && array[tmpLeft] <= keyValue) ++tmpLeft;
		array[tmpRight] = array[tmpLeft];
    }
	array[tmpLeft] = keyValue;
	return tmpLeft;
}

归并排序：

template<typename T>
void d_mergeSort(T array[],int beg,int end){
	int mid;
	if(beg < end){
		mid = (beg+end)/2;
		d_mergeSort(array,beg,mid);
		d_mergeSort(array,mid+1,end);
		merge(array,beg,mid,end);
	}
}
template<typename T>
void merge(T array[],int beg,int mid,int end){
    int leftLen = mid - beg+1;
	int rightLen = end - mid;
	int i,j,k;
	T *left = new T[leftLen];
	T *right = new T[rightLen];
	for(i=0; i < leftLen; ++i){
         left[i] = array[beg+i];
	}
	for(j=0; j < rightLen; ++j){
         right[j] = array[mid+j+1];
	}
    i = j = 0;
	k = beg;
	while(i<leftLen && j<rightLen){
		if(left[i] < right[j]){
			array[k++] = left[i++];
		}else {
			array[k++] = right[j++];
		}
	}
    while(i < leftLen){
		array[k++] = left[i++];
    }
	while(j < rightLen){
		array[k++] = right[j++];
	}
	delete left;
	delete right;
}