10种排序算法笔记总结（三）快速排序、归并排序、计数排序和基数排序

⑦快速排序：

该算法采用了一种分治策略，基本思想是取待排序对象序列中某个对象为基准（比如第一个对象），按照该关键码的大小，将整个对象序列划分成左右两个部分：左侧子序列中所有元素关键码值都小于或等于基准元素关键码值，右侧子序列中所有元素关键码值均大于基准元素关键码值，基准对象排在这两个子序列的中间，然后分别对两个子序列重复上述方法，直到完成为止。

可以归为4个步骤：假设有一个待排序数组array

（1）如果数组的大小是0或者1，那么返回这个数组；

（2）从数组中选择一项作为基准项；

（3）创建两个子数组：将原数组中的所有小于基准元素的元素都放入第一个子数组中，相应的，将原数组中所有大于基准元素关键码值的都放入第二个子数组中；

（4）返回一个数组，这个数组有3部分构成，他们分别是应用快速排序方案排序后的第一个子数组，基准以及应用快速排序方案后的第二个子数组

#include<iostream>
using namespace std;
void QuickSort(int*A, int first,int last)
{
	if (first < last)
	{
		int mid = first + (last - first) / 2;
		swap(A[mid], A[last]);
		int j = first;
		for (int i = first; i < last; i++)
		{
			if (A[i] < A[last])
			{
				swap(A[i], A[j++]);
			}
		}
		swap(A[j], A[last]);
		QuickSort(A, first, j - 1);
		QuickSort(A, j + 1, last);
	}
}
int main()
{
	int n;
	while (cin >> n)
	{
		int * arr = new int[n];
		for (int i = 0; i < n; i++)
			arr[i] = rand()%100;
		QuickSort(arr,0, n-1);
		for (int i = 0; i < n; i++)
			cout << arr[i] << " ";
		cout << endl;
	}
	system("pause");
	return 0;
}

⑧归并排序：

使用分治策略实现，算法可以递归实现。所谓归并南区陈将两个或两个以上的有序序列合并成一个新的有序序列。

归并：有序序列的线性归并方法，基本归并算法接收两个两个输入数组A和B，并输出数组C。在这个过程中有3个计数器A counter 、B counter 和 C counter，它们分别对应归并过程中序列A、B和C下标。在算法开始的时候，他们都位于各自序列的起始端。实施过程是将A[counter]和B[counter]中的元素进行比较，把小的那一个元素填到C中，并使元素小的所在序列counter和C的counter自增1.一旦A或B中任意一个中的元素被耗尽，则把另一个序列中所有元素全部填到数组C中。归并排序通过不断的将序列划分（第一次分成两半，第二次4半......），直到得到仅有一个元素序列的时候，可以认为一个元素是有序的，那么就能把两个相邻序列归并到一个序列中，如此反复，直到所有有序序列最终合并成一个序列为止。

#include<iostream>
using namespace std;
void Merge(int* A, int first, int mid, int last, int*tmp)
{
	int i = first;
	int j = first;
	int k = mid + 1;
	while (i <= mid && k <= last)
	{
		if (A[i] < A[k])
			tmp[j++] = A[i++];
		else
			tmp[j++] = A[k++];
	}
	while (i <= mid)
		tmp[j++] = A[i++];
	while (k <= last)
		tmp[j++] = A[k++];
	for (int i = 0; i <= last; i++)
		A[i] = tmp[i];
}

void MergeSort(int* A, int first, int last, int *tmp)
{
	if (first < last)
	{
		int mid = first + (last - first) / 2;
		MergeSort(A, first, mid, tmp);
		MergeSort(A, mid + 1, last, tmp);
		Merge(A, first, mid, last, tmp);
	}
}

int main()
{
	int n;
	while (cin >> n)
	{
		int * arr = new int[n];
		for (int i = 0; i < n; i++)
			arr[i] = rand()%100;
		int *tmp = new int[n];
		MergeSort(arr,0, n-1,tmp);
		for (int i = 0; i < n; i++)
			cout << arr[i] << " ";
		cout << endl;
	}
	system("pause");
	return 0;
}

⑨计数排序：

适合所需排列的元素取值范围不大的情况（并且不能有负数），否则会造成空间上的消耗。将待排序数对应到一个有序表中，并以此有序输出。

#include<iostream>
#include<vector>
using namespace std;
void CountingSort(int*A, int n)
{
	int maxVal = -1;
	for (int i = 0; i < n; i++)
	{
		if (A[i] > maxVal)
			maxVal = A[i];
	}
	vector<int> arr(maxVal + 1, 0);
	for (int i = 0; i < n; i++)
		++arr[A[i]];
	int top = 0;
	for (int i = 0; i <= maxVal; i++)
	{
		while (arr[i]--)
			A[top++] = i;
	}
	return ;
}
int main()
{
	int n;
	while (cin >> n)
	{
		int * arr = new int[n];
		for (int i = 0; i < n; i++)
			arr[i] = rand()%100;
		CountingSort(arr, n);
		for (int i = 0; i < n; i++)
			cout << arr[i] << " ";
		cout << endl;
	}
	system("pause");
	return 0;
}

⑩基数排序：

以十进制数为例：首先建立10个桶，根据待排序元素个位数一次进桶（个位数是几就进几号桶），然后从0到9号桶依次倒出；再根据十位数一次进桶，之后再倒出，如此反复，到最高位依次进桶之后，从0到9号桶依次导出的顺序就是排好序的。

#include<iostream>
#include<queue>
using namespace std;
int* RadixSort(int* A, int n)
{
	int i, j, k, factor;
	int radix = 10, digit = 10;
	queue<int> queues[10];
	for (int i = 0, factor = 1; i < digit; factor *= radix, i++)
	{
		for (j = 0; j < n; j++)
			queues[(A[j] / factor) % radix].push(A[j]);
		for (j = k = 0; j < radix; j++)
		{
			while (!queues[j].empty())
			{
				A[k++] = queues[j].front();
				queues[j].pop();
			}
		}		
	}
	return A;
}
int main()
{
	int n;
	while (cin >> n)
	{
		int * arr = new int[n];
		for (int i = 0; i < n; i++)
			arr[i] = rand()%100;
		RadixSort(arr, n);
		for (int i = 0; i < n; i++)
			cout << arr[i] << " ";
		cout << endl;
	}
	system("pause");
	return 0;
}