排序算法之冒泡排序及优化--C++

先抛问题：冒泡排序大家都很熟悉！
问题1：
一个数列：【 6,5,4,3,2】我们按照从大到小排序，即使本来是有序的，排序算法也会兢兢业业执行5×4+4×3+3×2+2轮，那么我们有没有办法提前知道它到哪里为止有序，进而停止执行呢？

举个例子：【 6,5,4,3,2】我们知道它有序，时间复杂度直接降为一轮循环
【 5,6,4,3,2】只要在第一轮将5和6交换后，我们即停止循环
加标志位！
show me the Code

//初版
void Sortpp(int *array,int length)
{
	for (int i=0;i<length -1;i++)
	{
		for (int j=0;j<length -i-1;j++)
		{
			int tmp = 0;
			if (array[j]<array[j+1])
			{
				tmp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = tmp;
			}
		}
	}
}

//优化1
void SortppEx1(int *array, int length)
{
	for (int i = 0; i < length - 1; i++)
	{
		//有序标记 ，每轮的初始值都为true
		bool isSort = true;
		for (int j = 0; j < length - i - 1; j++)
		{
			int tmp = 0;
			if (array[j] < array[j + 1])
			{
				tmp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = tmp;
				//因为有元素进行交换，因此不是有序的，置为false
				isSort = false;
			}
			//如果标记值位改变，则说明本轮排序后的数列已经有序，节省后续时间
			if (isSort)
			{
				break;
			}
		}
	}
}

我们来看下优化后的耗时差别 11 VS 8 ！！！

void main()
{
	int array[6] = { 6,5,4,3,2 };
	int length = sizeof(array) / sizeof(array[0]);
	size_t beginTime1 = clock();
	for (int i=0;i<100000;i++)
	{
		Sortpp(array, length);
	}
	size_t endTime1= clock();
	std::cout << "第一版排序循环100000次耗时为："<<endTime1 - beginTime1 << endl;

	size_t beginTime2 = clock();
	for (int i = 0; i < 100000; i++)
	{
		SortppEx1(array, length);
	}
	size_t endTime2 = clock();
	std::cout << "第二版排序循环100000次耗时为：" << endTime2 - beginTime2 << endl;
	}

问题2：这就引出了第二个问题：假如这个数列为【6, 7，8，9, 3，2,1，0】,6、7、8、9排序完之后，我们发现后面的3、2、1、0是有序的！我不想再继续执行浪费资源了，那怎么办呢？基于此，我们加边界值进行二次优化
OK！show me the Code！！！

//优化2
void SortppEx2(int *array, int length)
{
	//记录最后一次交换的位置
	int LastExchangeIndex = 0;
	//每次需要比较的边界，需要比较到这里为止，再往后就是有序的了
	int Sortborder = length - 1;
	for (int i = 0; i < Sortborder; i++)
	{
		//有序标记 ，每轮的初始值都为true
		bool isSort = true;
		for (int j = 0; j < Sortborder-i; j++)
		{
			int tmp = 0;
			if (array[j] < array[j + 1])
			{
				tmp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = tmp;
				//因为有元素进行交换，因此不是有序的，置为false
				isSort = false;
				//更新为最后一次元素交换的位置
				Sortborder = j;
			}
			//每一轮的最后一次交换后，后续的已经有序无需比较
			Sortborder = LastExchangeIndex;
			//如果标记值位改变，则说明本轮排序后的数列已经有序，节省后续时间
			if (isSort)
			{
				break;
			}
		}
	}
}

OK！一起来见证下第三版的耗时！10 VS 4

void main()
{
	int array1[8] = {6,7,8,9,3,2,1,0 };
	int length1 = sizeof(array) / sizeof(array[0]);
	size_t beginTime3 = clock();
	for (int i = 0; i < 100000; i++)
	{
		Sortpp(array1, length1);
	}
	size_t endTime3 = clock();
	std::cout << "第一版排序循环100000次耗时为：" << endTime3 - beginTime3 << endl;


	size_t beginTime4 = clock();
	for (int i = 0; i < 100000; i++)
	{
		SortppEx2(array1, length1);
	}
	size_t endTime4 = clock();
	std::cout << "第三版排序循环100000次耗时为：" << endTime4 - beginTime4 << endl;
}

别问我怎么数列越多排序越执行越快了，问就是很多因素的影响，我可以给您列一篇八百字的作文
我们针对优化算法部分做分析哦~

还有一种鸡尾酒排序，由于我饿了，明天再更~嘿嘿