两种排序-快排与冒泡

快速排序

算法描述：
先定义左边i=L 与最右边的 j=R
取中间的数 mid 作为判断 mid = a[(R+l)/2]
一趟快速排序：
先从左边开始 逐渐递增i的值直到找到第一个a[i] > mid 此时跳出循环
然后从右边开始 逐渐递减j的值直到找到第一个a[j] < mid 此时跳出循环
此时这两者是应该满足 i < j的 也就是保持 i在左边而j在右边 才符合一部分小的数据在左边，大的数据在右边
满足上面条件的话互相交换值
并顺便递增i递减j看是否满足i<j
满足 则继续循环
否则 使用递归，对小序列进行再排序

void qSort(int a[],int l,int r)
{
	if (l > r) 
	{
		return;    //参数不对  退出
	}
	int i, j, mid, p;
	i = l;
	j = r;
	mid = a[(l + r) / 2];                  
	do
	{
		while (a[i] < mid) i++;     //如果左边第一个大于mid的数找到了 就退出循环 等待交换     
		while (a[j] > mid) j--;   //如果右边第一个小于mid的数找到了  就退出循环  
		if (i < j)  //判断  j的数是否是在i的右边
		{                                
			p = a[i];
			a[i] = a[j];
			a[j] = p;
			i++; //一定要对数据进行更新
			j--;                          
		}
		else if (i == j) 
		{
			i++;  //对序列的数据进行更新
			j--;
		
		}

	} while (i < j);                                 
	if (l < j)  qSort(a,l, j);      //再分别对子序列进行排序         
	if (i < r)  qSort(a,i, r);
}

冒泡排序

描述：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
1 8 5 36 9 10 i=1
8 1 5 36 9 10
8 5 1 36 9 10
8 5 36 1 9 10
8 5 36 9 1 10
8 5 36 9 10 1 执行了 5次
i = 2
8 5 36 9 10 1
8 36 5 9 10 1
8 36 9 5 10 1
8 36 9 10 5 1
执行了 4 次
i = 3
36 8 9 10 5 1
36 9 8 10 5 1
36 9 10 8 5 1 执行 3次

i = 4
36 9 10 8 5 1
36 10 9 8 5 1
执行了2次
…（再后面就不需要比较了 所以需要进行优化，就是再比较一次，如果没有发生交换就break 说明已经排好了）
可见每趟的比较次数是 n-i

void bSort(int a[], int n)  //n的值应该是元素的个数
{
	bool bo;
	int i = 1,temp;
	do
	{
		bo = true;    //优化做法  当下面没有发生交换的时候就退出循环  并且已经排序好了
		for (int j = 0; j < n - i; ++j) 
		{
			if (a[j] > a[j + 1]) 
			{
				temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
				bo = false;
			}
		}
		++i;
	} while (!bo);
}