【C语言】冒泡排序

最新推荐文章于 2025-04-28 19:29:01 发布

原创最新推荐文章于 2025-04-28 19:29:01 发布 · 666 阅读

CC 4.0 BY-SA版权

冒泡排序是一种简单的排序算法，通过重复遍历数列并交换错误位置的元素实现排序。文章介绍了冒泡排序的基本操作，包括数组下标访问和指针访问法，并讨论了其时间复杂度和优化策略，如设置旗标和双向穿梭。虽然冒泡排序在已排序数列上的效率较低，但其简单实现使其成为理解排序算法的起点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

冒泡排序（英语：Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

冒泡排序算法的运作如下：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

这是数组下标访问：

<span style="font-size:18px;">#include <stdio.h>
int main()
{
	int arr[8] = {9,2,7,8,3,6,4,1};
	int i = 0;
	int j = 0;
    int tmp;
	int len=sizeof (arr)/sizeof(arr[0]);
    for(j=0;j<len-1;j++)
	{
		for(i=1;i<len-1-j;i++)
		{
			if(arr[i]<arr[i+1])
			{
				tmp=arr[i];
				arr[i]=arr[i+1];
				arr[i+1]=tmp;
			}
		}
}
	for(i=0;i<8;i++)
    printf("%d ",arr[i]);
    return 0;
	}
	</span>

封装成函数：

<span style="font-size:18px;">#include<stdio.h>
void fun(int arr[], int len)
{
	int i;
	int j;
	int tmp;
	for(i=0;i<len-1;i++)
		for(j=0;j<len-i-1;j++)
		{
			if(arr[j]<arr[j+1])
			{
				tmp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=tmp;
			}
		}
}
int main()
{
	int arr[] = {9,2,7,8,3,6,4,1};
	int len= (int) sizeof(arr) / sizeof(*arr);
	int i=0;
	fun(arr,len);
	for(i=0;i<len;i++)
	{
		printf(" %d",arr[i]);
	}
	return 0;
}
</span>

还有指针访问法：

<span style="font-size:18px;">#include<stdio.h>
void fun(int *arr, int len)
{
	int i;
	int j;
	int tmp;
	for(i=0;i<len-1;i++)
		for(j=0;j<len-i-1;j++)
		{
			if(*(arr +j)<*(arr+j+1))
			{
				tmp=*(arr+j);
			*(arr+j)=*(arr+j+1);
			*(arr+j+1)=tmp;
			}
		}
}
int main()
{
	int arr[] = {9,2,7,8,3,6,4,1};
	int len= (int) sizeof(arr) / sizeof(*arr);
	int i=0;
	fun(arr,len);
	for(i=0;i<len;i++)
	{
		printf(" %d",arr[i]);
	}
	return 0;
}</span>

当然，运行结果都是下图：

冒泡排序对 $n$ 个项目需要O( $n^2$ )的比较次数，且可以原地排序。尽管这个算法是最简单了解和实现的排序算法之一，但它对于少数元素之外的数列排序是很没有效率的。

冒泡排序是与插入排序拥有相等的运行时间，但是两种算法在需要的交换次数却很大地不同。在最好的情况，冒泡排序需要 $O(n^2)$ 次交换，而插入排序只要最多 $O(n)$ 交换。冒泡排序的实现（类似下面）通常会对已经排序好的数列拙劣地运行（ $O(n^2)$ ），而插入排序在这个例子只需要 $O(n)$ 个运算。因此很多现代的算法教科书避免使用冒泡排序，而用插入排序取代之。冒泡排序如果能在内部循环第一次运行时，使用一个旗标来表示有无需要交换的可能，也可以把最好的复杂度降低到 $O(n)$ 。在这个情况，已经排序好的数列就无交换的需要。若在每次走访数列时，把走访顺序反过来，也可以稍微地改进效率。有时候称为鸡尾酒排序，因为算法会从数列的一端到另一端之间穿梭往返。