排序（快排， 计数排序）

#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;
}

#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;
}