C++ 实现几种排序

写几个常用的排序：

1）冒泡排序

2）选择排序

3）插入排序

4）归并排序

5）快速排序

6）希尔排序

具体实现：

1. 冒泡排序

//冒泡排序
//i: start -> end - 1
//每一次两两比较array[i]与array[i+1],大的上浮，小下沉
//比较次数来源于如果array[0]是最大值，则需要size - 1次才能放到正确的位置
template<class Type>
void BubbleSort(Type* array,int start,int end){
	for(int i = 0;i < end - start;i++)
		for(int j = 0;j < end - start;j++){
			if(array[j] > array[j + 1])
				swap(array[j],array[j + 1]);
		}
}

2. 选择排序

//选择排序
//每一次都从为选出值的数组中选取最小的放在当前排放的位置处
template<class Type>
void SelectionSort(Type* array,int start,int end){
	for(int i = 0;i < end - start;i++)
		for(int j = i + 1;j < end - start + 1;j++){
			if(array[i] > array[j])
				swap(array[i],array[j]);
		}
}

3. 插入排序

//插入排序
//从i: start -> end
//在i之前的有序的数组中找到正确的位置插入
template<class Type>
void InsertionSort(Type* array,int start,int end){
	for(int i = 1;i < end - start + 1;i++)
		for(int j = 0;j < i;j++){
			if(array[j] > array[i]){
				int temp = array[i];
				for(int k = i;k > j;k--)
					array[k] = array[k - 1];
				array[j] = temp;    //此时array[j]是最大的了
				break;
			}
		}
}

4. 归并排序

//归并排序
//每次Merge都是将start -> end 划分为start -> middle -1  && middle -> end两部分，吧两个部分中最小的
//一半放到新的start -> middle - 1中去，其余的未塞入的将start -> end 填满
//MergeSort 就是讲一长串数组划分为两半，用递归再划分两半的两半... 自底向上排序完成
//此外：Merge完成后，array: start -> middle -1 这前半部分的最大值 小于 array: middle -> end这后半部分的最小值
template<class Type>
void Merge(Type* a,int start,int middle,int end){
	Type *temp = new Type[end - start + 1]; //保留这轮排序后的数组
	int index = 0;
	bool *isChosen = new bool[end - start + 1]; //某个元素是否被选出
	for(int i = 0;i < end - start + 1;i++)
		isChosen[i] = false;
	int indexA = start; //前半段a[start] -->  a[middle]
	int indexB = middle; // 后半段 a[middle + 1] --> a[end - 1]
	while(indexA < middle && indexB <= end){
		if(a[indexA] < a[indexB]){
			temp[index++] = a[indexA];
			isChosen[indexA++ - start] = true;
		}else{
			temp[index++] = a[indexB];
			isChosen[indexB++ - start] = true;
		}
	}
	//剩余的都填满temp[]
	for(int i = 0;i < end - start + 1;i++)
		if(!isChosen[i])
			temp[index++] = a[start + i];
	for(int i = 0;i < end - start + 1;i++)
		a[start + i] = temp[i];

	delete []temp;
	delete []isChosen;
}
template<class Type>
void MergeSort(Type* array,int start,int end){
	if(end - start == 1){  //如果只剩两个元素了那就简单比一下
		if(array[start] > array[end])
			swap(array[start],array[end]);
	}
	else if(end - start >= 2){ //只剩余了少于三个元素，就不进行分割比较了
		int middle = (start + end) / 2;
		MergeSort(array,start,middle);
		MergeSort(array,middle + 1,end);
		Merge(array,start,middle + 1,end);
	}
}

5. 快速排序

//快速排序
//就是找第一位a[start]为基准为，一轮Partition之后，a[start]值的位置变为q
//q位置前都小于他，后面都大于他,然后就q所分割的两部分再进行快排
template<class Type>
int Partition(Type *a,int start,int end){
	Type x = a[start];
	int i = start;
	for(int j = start + 1;j <= end;j++){
		if(a[j] <= x){
			i++;
			swap(a[i],a[j]);
		}
	}
	swap(a[i],a[start]); //把基准的值放在中间，则左边都小于他，右边都大于他
	return i;
}
template<class Type>
void QuickSort(Type *array,int start,int end){
	if(start < end){
		int q = Partition(array,start,end); //分割成两部分
		QuickSort(array,start,q - 1);
		QuickSort(array,q + 1,end);
	}
}

6. 希尔排序

//希尔排序
//步长要小于数组元素数量,不然没意义跳过
//通过不同的步进，选取相隔一样步进的元素组成组，如步进为3时则a[0],a[3],a[6]...为一组
//由最初的步进长度，作为起始步进逐步减少到步进为一，变为普通的全数组的插入排序
template<class Type>
void ShellPass(Type* array,int start,int end,int d){
	for(int i = 0;i < d;i++){
		for(int j = start + i + d;j < end - start + 1;j += d){
			for(int k = start + i;k < j;k += d){
				if(array[k] > array[j]){
					Type temp = array[j];
					for(int l = j;l > k;l -= d)
						array[l] = array[l - d];
					array[k] = temp;
				}
			}
		}
	}
}
template<class Type>
void ShellSort(Type* array,int start,int end){
	int d = 10;
	while(d > 0){
		d = (d + 1) / 2;
		ShellPass(array,start,end,d);
		if(d == 1)
			break;
	}
}

测试代码：

int main()
{
	int a[] = {1,4,3,6,9,12,12,1,2,43,3,2,1,3,12};
	int size = 15;

        cout << "原数组： " << endl;
	for(int i = 0;i < size;i++)
		cout << a[i] << " ";
	cout << endl << endl;

	int *array = new int[size];

	for(int i = 0;i < size;i++)
		array[i] = a[i];
	cout << "BubbleSort: " << endl;
	BubbleSort(array,0,size - 1);
	for(int i = 0;i < size;i++)
		cout << array[i] << " ";
	cout << endl << endl;

	for(int i = 0;i < size;i++)
		array[i] = a[i];
	cout << "SelectionSort: " << endl;
	SelectionSort(array,0,size - 1);
	for(int i = 0;i < size;i++)
		cout << array[i] << " ";
	cout << endl << endl;

	for(int i = 0;i < size;i++)
		array[i] = a[i];
	cout << "InsertionSort: " << endl;
	InsertionSort(array,0,size - 1);
	for(int i = 0;i < size;i++)
		cout << array[i] << " ";
	cout << endl << endl;

	for(int i = 0;i < size;i++)
		array[i] = a[i];
	cout << "MergeSort: " << endl;
	MergeSort(array,0,size - 1);
	for(int i = 0;i < size;i++)
		cout << array[i] << " ";
	cout << endl << endl;

	for(int i = 0;i < size;i++)
		array[i] = a[i];
	cout << "QuickSort: " << endl;
	QuickSort(array,0,size - 1);
	for(int i = 0;i < size;i++)
		cout << array[i] << " ";
	cout << endl << endl;

	for(int i = 0;i < size;i++)
		array[i] = a[i];
	cout << "ShellSort: " << endl;
	ShellSort(array,0,size - 1);
	for(int i = 0;i < size;i++)
		cout << array[i] << " ";
	cout << endl << endl;

	return 0;
}

测试输出：