排序算法--从入门到入门

简单介绍下排序的几种算法，首先来O（n^2）：（均以从小到大排序为例）

两两比较，每一轮能确定一个位置（第 i 个），
比较 i 轮  ， 总的来说O（n^2）

1.冒泡排序

I.
第一次比较：取 a[1] = max(a[0],a[1])	（大的后移）
第二次比较: 取 a[2] = max(a[1],a[2])
......
第n-1次比较：取 [n] = max(a[n-2],a[n-1])
//第一轮确定 a[n-1] 

II.
第一次比较：取a[1] = max(a[0],a[1])
......
第n-2次比较：取a[n-3] = a[n-2]
//第二轮确定 a[n-2]
...
...
//第n-1轮确定a[1]，数组排序完成

用 i 表示轮次， j 表示比较的

	for (int i = 0; i < n - 1; ++i)
		for (int j = 1; j < n; ++j) 
			if (a[j-1] > a[j]) 
				swap(a[j-1], a[j]);

2.选择排序

for (int i = 0; i < n - 1; ++i) {
		int k = i;
		for (int j = i + 1; j < n; ++j) 
			if (a[k] > a[j])
				k = j;
		if (k != i)
			swap(a[i], a[k]);
	}

3.插入排序

for (int i = 0; i < n - 1; ++i)
	{
		for (int j = i + 1 ; j > 0; --j) 
			if (a[j] < a[j - 1])
				swap(a[j], a[j - 1]);
			else
				break;
	}

O（nlogn）类

1.二分归并

void merge(int a[],int s,int m ,int e, int tmp[])

分治思想
进行递归：
	1.对前半排序
	2.对后半排序
	3.归并
边界条件: 仅当 start < end 时 作用

进行归并：
例
	0 2 7 8		5 6  ==> 0
	2 7 8 		5 6  ==> 0 2
	7 8 		5 6  ==> 0 2 5
	7 8 		6	 ==> 0 2 5 6
	7 8    		     ==> 0 2 5 6 7
	8				 ==> 0 2 5 6 7 8

void Binary_sort(int* , int , int , int*);
void merge(int* , int ,int ,int ,int *);
//
void Binary_sort(int a[],int s,int e,int tmp[])
{
	if(s < e){
		int m = s + (e - s) / 2;
		Binary_sort(a,s,m,tmp);
		Binary_sort(a,m+1,e,tmp);
		//归并
		merge(a,s,m,e,tmp);		
	}
}
//
void merge(int a[],int s,int m ,int e, int tmp[])
{
	int pb = 0;
	int p1 = s, p2 = m + 1;
	while(p1 <= m && p2 <= e){
		if(a[p1]<a[p2])
			tmp[pb++] = a[p1++];
		else
			tmp[pb++] = a[p2++];
	}
	//
	while(p1<=m)
		tmp[pb++] = a[p1++];
	while(p2<=e)
		tmp[pb++] = a[p2++];
	//
	for(int i = 0; i < e - s + 1; ++i)
		a[s+i] = tmp[i];
}

//调用
Binary_sort(数组名,start,end,足够大的临时数组);

时间复杂度:
T(n) = 2 * T(n/2) + a * n  (a为常数)
// 对 两个数组排序  与  归并
 = 2 * (2 * T(n/4)) + a * n
 = 4 * T(n/4) + 2a * n
 = 8 * T(n/8) + 3a * n
 ...
 = 2^k * T(n/(2^k)) + ka * n
==>直到 n/2^k = 1 ,则 k = log2(n)
==> n * T(1) + log2(n)* a * n
==> n + log2(n)* a * n
==> 当n->∞,
		T(n)-> (1 + log2(n) * a) * n
	所以 T(n) 为 nlog2(n)

2.快速排序

void quick_sort(int a[],int s,int e);

分治思想：
进行递归：
	1.随机选择 k = a[s] 作 分界点，小的左边放，大的右边放
	（希望左右数目相差不大）
	2.对左侧快排
	3.对右侧快排
边界：仅当 s < e 时排序

void quick_sort(int a[],int s,int e)
{
	if(s < e){
		int i =s,j = e;
		int k =a[s];
		while(i != j){
			while(j > i && a[j] > k)
				--j;
			swap(a[i],a[j]);
			while(j > i && a[i] < k)
				++i;
			swap(a[i],a[j]);
		}
		//********【注释】********//
		quick_sort(a,s,i-1);
		quick_sort(a,i+1,e);
	}
}

需要说明的是在递归中的 区间为什么只能是 (s,i-1)和(i+1,e)
如果 (s,I) (I>=i)，那么就会 将 对应 i 下标的 这个 k 值被重复选择，
就回到了最初递归的情况，陷入死循环。
同理，这个 k 值不可重复，所以(I,e)不能包含 i

O（n）类:

1.计数排序

void count_sort(int* a,int n)

空间换时间
	用下标 表示 所存 数字，统计 该下标下 的个数 ， 在遍历中输出 元素
	//
	这稍微优化，将范围圈在 (min, max)
	用   a[i]  - min 作为下标存储  
	最后  a[i] = i + min 还原

代码如下：

void count_sort(int* a,int n)
{
	int min(a[0]),max(a[0]);
	for(int i = 0; i < n; ++i){
		if(a[i] > max) 		max = a[i];
		if(a[i] < min)		min = a[i];
	}
	//
	int range = max - min + 1;
	int* tmp = new int[range];
	memset(tmp,0,sizeof(int)*range);
	//
	for(int i = 0; i<n ; ++i)
		tmp[a[i] - min]++;
	//
	int index = 0;
	for(int i = 0;i < range;++i)
		while(tmp[i]--)
			a[index++] = i + min;
	delete[] tmp; 
}

计数排序显然，兼容性”不大好，也不太常用，但它的复杂度线性且稳定为O(n+k)，但是在最坏的情况下，（max - min过大），最坏复杂度为O(n^2)，这样一种思想，也为后面这种排序提供了思路；

2.基数排序

void radix_sort(int a[],int n);
原理：
	按低-->高位的顺序： 从小到大排：
		123 501 200
	
		个位：200 501 123
		十位：200 501 123
		百位：123 200 501

	以最大数位数为循环次数，统计k次

//#include <algorithm>
int maxbit(int a[],int n)
{	
	//int max = max_element(a,a+n);
	int max = a[0];
	for(int i = 0;i < n;++i)
		if(a[i]>max) max = a[i];
	//
	int d = 1;
	while(max>=10){
		d++;
		max/=10;
	}
	return d;
}
//
void radix_sort(int a[],int n)
{
	int d = maxbit(a,n）；
	int* tmp = new int[n];
	int* count = new int[10];
	//
	int radix = 1;
	for(int time = 0;times < d;++times){
		//每次计数器 重置
		memset(count,0,sizeof(int)*10);
		//计数
		for(int i =0;i<n;++i){
			int k = a[i]/radix%10;
			count[k]++;
		}
		//将每个桶在数组中对应好位置，以右侧为准
		for(int i = 1;i < 10;++i)
			count[i]+=count[i-1];
		//************【注释】*************//
		for(int i = n-1;i >= 0;--i){
			int k = a[i]/radix%10;
			tmp[count[k]-1] = a[i];
			--count[k];
		}
		//拷贝
		for(int i = 0;i < n;++i)
			a[i] = tmp[i];
		//
		radix *=10;
	}
}

注意：在 给临时 数组拷贝 的时候，需要逆序，
这是为了后面的排序，因为这里是 先读取 而 拷贝在后面
 tmp[count[k]-1] = a[i];
 --count[k];

基数排序采用了计数排序和桶排序结合，ta也是线性复杂度：

T(n) = maxbit + maxbit*(重置 + 计数 + 对应 + 赋值 + 拷贝)
	= n + k * ( n + n + n + n + n)
  	= n + 5k*n
  	= (5k + 1) * n = K * n

空间复杂度： O(k+n)

到这里，虽然还有很对排序算法，但应该对排序算法有大概掌握了，更优的排序算法正等待着去发掘0.0！