（C语言)冒泡排序的优化

我只愿面朝大海

已于 2024-09-16 00:13:20 修改

阅读量414

点赞数

文章标签： c语言排序算法数据结构

于 2021-12-03 13:36:46 首次发布

本文链接：https://blog.csdn.net/weixin_53112343/article/details/121696456

版权

本文探讨了冒泡排序算法的优化方法，通过在每轮比较后检查是否发生交换来判断数组是否已有序。优化后，对于大部分有序的数据，排序效率显著提升。通过对100个元素数组的随机和顺序初始化测试，展示了优化前后的比较次数差异，尤其在数据已有序的情况下，优化版冒泡排序大大减少了比较次数。

摘要由CSDN通过智能技术生成

优化的原理是，在优化的某一轮如果发现没有发生相邻两个元素的交换，那么说明整个数组已经是有序的了。如果能加入一个判断，如果某轮比较后没有发生元素的交换，那么就说明数组已经有序了，可以停止比较了。

这种优化做出后能够显著提升那种大部分数据已经是有序的，只有很少部分的数据是在不正确的位置上的数据排序。

以下我使用100个元素的数组，分别用随机赋值的方式初始化和顺序初始化，再比较两种情况下，相邻两个元素比较次数的多少。

1.随机值初始化+未做优化：

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

int count = 0;
bubble_sort(int arr[],int len)
{
	for (int i = 0; i < len-1; i++)
	{
		//int flag = 1;
		for (int j = 0; j < len - 1 - i; j++)
		{
			count++;
			if (arr[j] > arr[j + 1])//如果一整轮下来都没有发生交换，那就说明整个数组已经有序了
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			//	flag = 0;
			
			}
		}
		//if (flag == 1)//如果flag==0的话，说明没有进入交换
		//{
		//	break;
		//}
	}
}

void order_init(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		arr[i] = i;
	}
}

void rand_init(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		arr[i] = 1+rand() % 100;
	}
}

void print_arr(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%-3d ", arr[i]);
		if ((i + 1) % 10 == 0)
		{
			printf("\n");
		}
	}
	printf("\n");
}

int main()
{
	srand((unsigned int)time(NULL));

	int arr[100] = { 0 };
	int len = sizeof(arr) / sizeof(arr[0]);
	rand_init(arr,len);
	//order_init(arr, len);
	print_arr(arr,len);
	bubble_sort(arr,len);
	print_arr(arr, len);
	
	printf("比较次数:%d\n", count);
	system("pause");
	return 0;
}

2.顺序初始化+未作优化：

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

int count = 0;
bubble_sort(int arr[],int len)
{
	for (int i = 0; i < len-1; i++)
	{
		//int flag = 1;
		for (int j = 0; j < len - 1 - i; j++)
		{
			count++;
			if (arr[j] > arr[j + 1])//如果一整轮下来都没有发生交换，那就说明整个数组已经有序了
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			//	flag = 0;
			
			}
		}
		//if (flag == 1)//如果flag==0的话，说明没有进入交换
		//{
		//	break;
		//}
	}
}

void order_init(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		arr[i] = i;
	}
}

void rand_init(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		arr[i] = 1+rand() % 100;
	}
}

void print_arr(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%-3d ", arr[i]);
		if ((i + 1) % 10 == 0)
		{
			printf("\n");
		}
	}
	printf("\n");
}

int main()
{
	srand((unsigned int)time(NULL));

	int arr[100] = { 0 };
	int len = sizeof(arr) / sizeof(arr[0]);
	//rand_init(arr,len);
	order_init(arr, len);
	print_arr(arr,len);
	bubble_sort(arr,len);
	print_arr(arr, len);
	
	printf("比较次数:%d\n", count);
	system("pause");
	return 0;
}

可见，如果是未优化的版本，相邻两个元素之间比较次数是固定的，在100个元素时，固定为4950次。也就是说，无论你整个数组是不是有序的，他都要傻傻的去比较比较。

以下时优化后的版本：

优化其实很简单，读者可以自行对比bubble_sort()这个函数内的不同之处。主要是设置了一个flag变量，每次进去之前都将它赋值为1，一旦进入了元素交换就将它重新赋值为0，每一轮循环结束后都判断flag的值，如果还是1，就说明没有交换，那就可以break跳出循环了。

3.随机值初始化+优化后：

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

int count = 0;
bubble_sort(int arr[],int len)
{
	for (int i = 0; i < len-1; i++)
	{
		int flag = 1;
		for (int j = 0; j < len - 1 - i; j++)
		{
			count++;
			if (arr[j] > arr[j + 1])//如果一整轮下来都没有发生交换，那就说明整个数组已经有序了
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				flag = 0;
			
			}
		}
		if (flag == 1)//如果flag==0的话，说明没有进入交换
		{
			break;
		}
	}
}

void order_init(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		arr[i] = i;
	}
}

void rand_init(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		arr[i] = 1+rand() % 100;
	}
}

void print_arr(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%-3d ", arr[i]);
		if ((i + 1) % 10 == 0)
		{
			printf("\n");
		}
	}
	printf("\n");
}

int main()
{
	srand((unsigned int)time(NULL));

	int arr[100] = { 0 };
	int len = sizeof(arr) / sizeof(arr[0]);
	rand_init(arr,len);
	//order_init(arr, len);
	print_arr(arr,len);
	bubble_sort(arr,len);
	print_arr(arr, len);
	
	printf("比较次数:%d\n", count);
	system("pause");
	return 0;
}

比较次数由固定的4950次减少到4572次，其实对于完全随机排列的数据来说优化并不明显。

4.顺序排序+优化后：

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

int count = 0;
bubble_sort(int arr[],int len)
{
	for (int i = 0; i < len-1; i++)
	{
		int flag = 1;
		for (int j = 0; j < len - 1 - i; j++)
		{
			count++;
			if (arr[j] > arr[j + 1])//如果一整轮下来都没有发生交换，那就说明整个数组已经有序了
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				flag = 0;
			
			}
		}
		if (flag == 1)//如果flag==0的话，说明没有进入交换
		{
			break;
		}
	}
}

void order_init(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		arr[i] = i;
	}
}

void rand_init(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		arr[i] = 1+rand() % 100;
	}
}

void print_arr(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%-3d ", arr[i]);
		if ((i + 1) % 10 == 0)
		{
			printf("\n");
		}
	}
	printf("\n");
}

int main()
{
	srand((unsigned int)time(NULL));

	int arr[100] = { 0 };
	int len = sizeof(arr) / sizeof(arr[0]);
	//rand_init(arr,len);
	order_init(arr, len);
	print_arr(arr,len);
	bubble_sort(arr,len);
	print_arr(arr, len);
	
	printf("比较次数:%d\n", count);
	system("pause");
	return 0;
}