冒泡排序算法的两种优化

>冒泡排序（三种实现，两种优化）

/*
首先，我们先介绍BubbleSort； 就是冒泡排序，冒泡排序大家应该最熟悉不过了；

冒泡排序算法的运作如下：（从后往前）
1.
比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2.
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3.
针对所有的元素重复以上的步骤，除了最后一个。

4.
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。[

我们以排序整形为例，代码中的例子：6，5，4，3，2，1；

*/

@BubbleSort1 :

void BubbleSort1(int arr[],int len)
{
	int i = 0;
	int j = 0;

	for(i = 0; i < len - 1; i++)
	{
		for(j = 0; j < len - i - 1; j++)
		{
			int tmp  = 0;
			if(arr[j] > arr[j+1])
			{
				tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
			}
		}
	}
}//没有优化的方法，比较常规；

@BubbleSort2:

/*
略微的优化方案BubbleSort2: 如果原数组就是有序的 比如： 1，2，3，4；

如果我们继续按照BubbleSort1的方法，那还是要跑n-1趟，是不是有点浪费时间，

于是，我们就想到了一个方法，没跑完一趟就判断一次原数组现在是否有序，如果有序；

直接return 掉；于是这里就有了一个标志位flag去帮助我们判断！
*/

@分析图：

@代码：

void BubbleSort2(int arr[],int len)
{
	int i = 0;
	int j = 0;

	for(i = 0; i < len - 1; i++)
	{
		int flag = 1;//假定每次进入都是有序的 flag为1；
		for(j = 0; j < len - i - 1; j++)
		{
			int tmp  = 0;
			if(arr[j] > arr[j+1])
			{
				tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
				flag = 0;//如果发生交换，则flag 置为0；
			}
		}
		if(flag == 1)//如果这趟走完，没有发生交换，则原数组有序；
			break;
	}
}//加入标志位优化；

@BubbleSort3:

/*

有了上面的一个优化，大家肯定认为肯定不能再优化了吧，答案是否定的；

下面介绍第二部优化 BubbleSort3: 减少内部循环比较的次数；

*/

@分析图：

@coad:

void BubbleSort3(int arr[],int len)
{
	int i = 0;
	int j = 0;
	int k = len - 1;//控制内部比较循环
	int n = 0;

	for(i = 0; i < len -1 ; i++)
	{
		int flag  = 1;
		n = 0;
		//假定每次进入都是有序的 flag为1；
		for(j = 0; j < k; j++)
		{	
			int tmp  = 0;
			if(arr[j] > arr[j+1])
			{
				tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
				flag = 0;//如果发生交换，则flag 置为0；
				n = j;//保存最后一次交换的下标；
			}
		}
		
		if(flag == 1)//如果这趟走完，没有发生交换，则原数组有序；
			break;
		k = n;//最后一次交换的位置给k，减少比较的次数；
	}
}//最终优化

@ 主函数

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int arr[] = {6,5,4,3,2,1};
	int i = 0;
	int len  = sizeof(arr)/sizeof(arr[0]);

	BubbleSort3(arr,len);

	for(i = 0;i < len; i++)
		printf("%d ",arr[i]);

	system("pause");
	return 0;
}

写的比较粗浅，希望可以帮助大家！