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

//冒泡排序
void BubbleSort1(int* arr, int len)
{
	int tmp;
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j + 1 < len - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
// 冒泡排序的优化
void BubbleSort(int* arr, int len)
{
	int tmp;
	bool flg;//标记是否有交换数据

	for (int i = 0; i < len - 1; i++)
	{
		flg = false;
		for (int j = 0; j + 1 < len - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flg = true;
			}
		}
		if (!flg)//没有交换数据则排序已经完成
		{
			return;
		}
	}
}
void Show(const int* arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int n;
	printf("请输入要排序的随机数个数\n");
	scanf_s("%d", &n);

	int* p = (int*)malloc(n * sizeof(int));
	assert(p != NULL);
	srand((unsigned)time(NULL));
	for (int i = 0; i < n; i++)
	{
		p[i] = rand()%100;
	}

	clock_t start = clock();
	BubbleSort(p,n);
	clock_t end = clock();
	printf("使用冒泡排序花费了 %d  ms.\n", end - start);


	clock_t start2 = clock();
	BubbleSort1(p,n);
	clock_t end2 = clock();
	printf("使用优化后的冒泡花费了 %d ms.\n", end2 - start2);
	free(p);
	return 0;
}

对比了10组50000个随机数的排序有如下结果

第一组
使用冒泡排序花费了 6488  ms.
使用优化后的冒泡花费了 3169 ms.
第二组
使用冒泡排序花费了 6401  ms.
使用优化后的冒泡花费了 3160 ms.
第三组
使用冒泡排序花费了 6371  ms.
使用优化后的冒泡花费了 3172 ms.
第四组
使用冒泡排序花费了 6398  ms.
使用优化后的冒泡花费了 3140 ms.
第五组
使用冒泡排序花费了 6404  ms.
使用优化后的冒泡花费了 3136 ms.
第六组
使用冒泡排序花费了 6416  ms.
使用优化后的冒泡花费了 3168 ms.
第七组
使用冒泡排序花费了 6401  ms.
使用优化后的冒泡花费了 3165 ms.
第八组
使用冒泡排序花费了 6392  ms.
使用优化后的冒泡花费了 3153 ms.
第九组
使用冒泡排序花费了 6402  ms.
使用优化后的冒泡花费了 3166 ms.
第十组
使用冒泡排序花费了 6432  ms.
使用优化后的冒泡花费了 3172 ms.

由此可知 优化后的冒泡排序大大提升了效率