排序（快排， 计数排序）

1. 快排：原址排序，不需要合并操作，只用分解解决，属于比较排序。时间复杂度分三种情况，最好情况时为O(n lgn), 最差情况是O(n*n), 平衡情况为O(n lgn)

#include<iostream>

using namespace std;

void swap(int *p, int *q)
{
	int temp = *p;
	*p = *q;
	*q = temp;
}

int PARTITION(int A[], int p, int q)
{
	int i=p-1;
	int r = A[q];  //这里选取最后一个元素为主元，当然可以随机选取主元
	for(int j = p; j <= q-1;j++)
	{
		if(A[j]<=r)
		{
			i = i+1;
			swap(A[i],A[j]);
			
		}
	}

	swap(A[i+1],A[q]);   //调试了很久一直得到错误结果，才发现自己SB到swap的时候为swap(A[i+1], r),这能把数传到A中么，SBSBSBSB

	return i+1;
}

void mySort(int A[], int p, int q)
{
	int r = 0;
	if(p<q)  //由于这判断了p<q，所以在后面递归调用mySort前不用再加判断了
	{
		r = PARTITION(A, p, q);
		mySort(A, p, r-1);	
		mySort(A, r+1, q);
	}
}

int main()
{
	int B[] = {13, 19, 9, 5, 12, 8, 7, 4, 21, 2, 6, 11};
	//int B[] = {1,1,1,0,1,1,1,1,1,1,1,0};
	mySort(B, 0, 11);
	for(int i=0; i<12; ++i)
	{
		cout << B[i] << " ";
	}
	cout << endl;
	system("pause");
	return 0;
}

2、计数排序，时间复杂度为O(n)，这种方法进行排序是比较稳定的。

#include<iostream>

using namespace std;

//A为输入，R为输出，k为A数组中最大值
void COUNTING_SORT(int A[], int* R, int k, int length)
{
	int* C = new int[k+1]();
	for(int i=0; i<=k; ++i)   //显然啊，数组A的最大值为k的话，C的长度就是k+1，必须要记得数组从0开始，SB
		C[i] = 0;

	for(int i=0; i<length; ++i)
		C[A[i]] = C[A[i]]+1;

	for(int i=1; i<=k; ++i)
		C[i]+=C[i-1];

	for(int i = length-1; i>=0; --i)
	{
		R[C[A[i]]-1] = A[i];   //这个地方要注意，一直好奇C[A[i]]会不会为0，但是C经过上一个累加循环了，那么最有可能为0的情况是C[0],但是这里取到C[0]的情况是在A[i]==0
		//这时矛盾出现了，既然A[i]==0了，那么C是对A为C相应位置值个数计数，所以C[A[i]]!=0，所以这个是合理存在的。
		C[A[i]] = C[A[i]]-1;
	}
}

int main()
{
	int B[] = {13, 19, 9, 5, 12, 8, 7, 4, 21, 2, 0, 11};
	
	int length = sizeof(B)/sizeof(int);
	int* R = new int[length](); //注意，定义动态数组时可以用变量length来直接表明大小，但是  int D[length] = {}; 是错误的
	//动态数组可以在后面加括号表示将数组初始化默认值，但是不能人为指定为任意初始值
	
	COUNTING_SORT(B, R, 21, length);
	for(int i=0; i<length; ++i)
	{
		cout << R[i] << " ";
	}
	cout << endl;

	system("pause");
	return 0;
}