排序---（桶排序、冒泡排序、选择法排序、快速排序）

简单的桶排序(Simple Bucket Sort）

例题：将下列数据从小到大排序，第一行n为第二行需排序的数据个数。

Input：
10

8 100 50 22 15 6 1 1000 999 0

Output：
0 1 6 8 15 22 50 100 999 1000

代码:

#include <iostream> 
#include <cstring>   //memset头文件（也可用string.h) 
using namespace std;
int main()
{
	int a[1001],n,i,j,t;   //注意：数组开的一定要比最大的数大！！！ 
	cin>>n;
	memset(a,0,sizeof (a));   //将a数组内数据全部置为0 
	/*
	for (int i=0;i<1001;i++)
	a[i]=0;
	*/
	for (i=0;i<n;i++)   //注意此处为n 
	{
		cin>>t;
		a[t]++;   //对编号为t的桶数字加1，表示改编号出现了一次 
	}
	for (i=0;i<1001;i++)   //注意此处为10001，不能是n，此时i表示要遍历的编号数 
		for (j=0;j<a[i];j++)
		{
			cout<<i<<' ';  //编号出现了几次就打印几次 
		}
	return 0;
}

桶排序的时间复杂度为O（M+N）最快但最浪费空间

（代码第10行的循环一共循环了m次(m为桶的个数），第13行循环了n次（n为待排序的个数），第18和19行共循环了m+n次，故整个算法共执行了m+n+m+n次，故时间复杂度为O(2*(m+n))，说时间复杂度时可忽略较小常数，故最终桶排序时间复杂度为O(m+n)，通常用大写字母表示，即O(M+N)。  ）

桶排序缺点：

1、非常浪费空间！

    （如要排序的范围是0~2100000000，则要申请2100000001个变量，即 int a[2100000001] 。因为我们要2100000001个“桶”来存储0~2100000000每个数出现的次数。即便就给你五个数（Eg：1，15433，199999999，2100000000，54）你仍需要2100000001个桶，这样就非常浪费空间！！！）

2、如果需要排序的数有小数，就不能用桶排序。

桶排序应用

把这个字符串按照字典序排序（按 ASCII 码从小到大排序。大写字母的 ASCII 码小于小写字母的 ASCII 码）

https://blog.csdn.net/bbbbswbq/article/details/56676743

冒泡排序

冒泡排序的复杂度为O（N²）

冒泡排序核心：

int i,j,t;
for (i=0;i<n-1;i++)
    for (j=i+1;j<n;j++)
    {
    	if (a[j]<a[i])    //为从小到大排，从大到小排改为a[j]>a[i] 
    	{
    		t=a[i];a[i]=a[j];a[j]=t;
		}
	}

选择法排序

选择法排序的复杂度为O（N²）

选择法排序核心：

int i,j,k,t;
for (i=0;i<n-1;i++)
{
    k=i;
    for (j=i+1;j<n;j++)
    {
        if (a[j]<a[k]) k=j;   //为从小到大排，从大到小排改为a[j]>a[k] 
    }
    t=a[i];a[i]=a[k];a[k]=t;
}

快速排序

基本思想（基于“二分”思想）：

      每次排序的时候设置一个基准点，将小于基准点的数全部放到基准点的左边，将大与等于基准点的数全部放到基准点的右边。

例题：将下列数据从小到大排序，第一行n为第二行需排序的数据个数。

Input：
10

6 1 2 7 9 3 4 5 10 8

Output：
1 2 3 4 5 6 7 8 9 10

代码：

#include <iostream>
using namespace std;
void quicksort(int left,int right);
int a[101],n;//定义全局变量！因为在函数中要用到。 
int main()
{
	cin>>n;
	for (int i=1;i<=n;i++)
	{
		cin>>a[i];
	}
	quicksort(1,n);
	for (int i=1;i<=n;i++)
	{
		cout<<a[i]<<" ";
	}
	cout<<endl;
	return 0;
} 
void quicksort(int left,int right)
{
	int i,j,t,temp;
	i=left;
	j=right;
	temp=a[left];   //temp中存的是基准数
	if (i>j) return;
	while (i!=j)
	{
		// 顺序很重要，一定先要从右往左找！（因为此时设置的基准数是最左边的数） ;j的使命是找到小于基准数的数（直到i,j碰头为止,即i=j）
		while (a[j]>=temp && j>i)
		{
			j--;
		}
		//再从右往左找 ;i的使命是找到大于基准数的数（直到i,j碰头为止,即i=j）
		while (a[i]<=temp && i<j)
		{
			i++;	
		}	
		if (i<j)
		{
			t=a[i];a[i]=a[j];a[j]=t;
			/* 可做输出检查 
			for(int k=1;k<=n;k++)
			{
				cout<<a[k]<<" ";
			} 
			 cout<<endl;
			 */
		}
	}
	//将基准数归位 （i,j碰头时，将a[i]与基准数交换）
	a[left]=a[i];
	a[i]=temp;
	/* 可做输出检查 
	for(int k=1;k<=n;k++)
	{
		cout<<a[k]<<" ";
	} 
	 cout<<endl;
	 */
	quicksort(left,i-1);//继续处理左边的，递归 
	quicksort(i+1,right);//继续处理右边的，递归 
	return; 
} 

以下为程序执行过程中数组a的变化过程，带下划线的表示的是要交换的数（i，j），只有一根下划线，表示此时i=j，该数要与基准数交换。

10
6 1 2 7 9 3 4 5 10 8
6 1 2 5 9 3 4 7 10 8
6 1 2 5 4 3 9 7 10 8
3 1 2 5 4 6 9 7 10 8
2 1 3 5 4 6 9 7 10 8
1 2 3 5 4 6 9 7 10 8
1 2 3 5 4 6 9 7 10 8
1 2 3 4 5 6 9 7 10 8
1 2 3 4 5 6 9 7 10 8
1 2 3 4 5 6 9 7 8 10
1 2 3 4 5 6 8 7 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

（错误做法）若先从左往右找，数组a的变化过程：

10
6 1 2 7 9 3 4 5 10 8
6 1 2 5 9 3 4 7 10 8
6 1 2 5 4 3 9 7 10 8
9 1 2 5 4 3 6 7 10 8
3 1 2 5 4 9 6 7 10 8
5 1 2 3 4 9 6 7 10 8
2 1 5 3 4 9 6 7 10 8
1 2 5 3 4 9 6 7 10 8
1 2 5 3 4 9 6 7 10 8
1 2 5 3 4 9 6 7 10 8
1 2 5 3 4 9 6 10 7 8
1 2 5 3 4 9 6 10 7 8
1 2 5 3 4 9 6 10 7 8
1 2 5 3 4 9 6 10 7 8

快速排序的最差时间复杂度和冒泡排序是一样的，都为O（N²）

（快速排序之所以比较快，是因为相比冒泡排序，每次交换都是跳跃式的。每次排序的时候设置一个基准点，将小于基准点的数全部放到基准点的左边，将大与等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样只能在相邻的数之间进行交换，交换的距离变大了，总的比较和交换次数就变少了，速度即得到提高。但，最坏的情况，仍可能是相邻的两个数进行交换，则此时快排的时间复杂度与冒泡相同）

快速排序平均复杂度为O（NlogN）

ps：八大常用排序算法详细分析 包括复杂度，原理和实现
https://blog.csdn.net/yuxin6866/article/details/52771739