冒泡排序详解及优化

排序的稳定性

对于一个排序算法，假设两个相同的元素Ai和Aj·
在排序前这两个元素满足条件i<j，即Ai在Aj之前·
在排序后Ai仍在Aj之前，则称为排序算法为稳定排序·
否则称这个算法为不稳定排序

稳定性的说明
排序的稳定性并不影响排序算法的效率，稳定性只对类/结构体类型数据有影响

冒泡排序

这里全部以从小到大(升序)为例讲解
冒泡排序介绍
基本思想:每轮不断将元素进行两两比较，并按“前小后大"规则交换实现思路:
比较相邻元素，若前者大于后者，两元素进行交换
对每组相邻元素，实现上述步骤，在第一轮结束后，最后一个元素即为最大值重复上述步骤，每次比较次数减1，直到无需比较，排序结束

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

void bubbleSort(int arr[], int len)
{
	//外层循环 len-1次
	for (int i = 0; i < len - 1; i++)
	{
		//内层循环len-i-1
		for (int j = 0; j < len - i - 1; j++)
		{
			//相邻元素，前者大于后者，进行交换
			if (arr[j]>arr[j+1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

//打印数组
void printArray(int arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << "";
	}
	cout << endl;
}

void test01()
{
	int arr[8] = { 2,5,4,5,7,1,3,6 };

	//数组中的元素个数
	int len = sizeof(arr) / sizeof(int);

	//调用冒泡排序
	bubbleSort(arr, len);

	//打印数组
	printArray(arr, len);
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

优化后的冒泡排序

我们先观察此冒泡排序的具体的步骤，用下面这段代码即可实现

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

//打印数组
void printArray(int arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << "";
	}
	cout << endl;
}

void bubbleSort(int arr[], int len)
{
	//外层循环 len-1次
	for (int i = 0; i < len - 1; i++)
	{
		//内层循环len-i-1
		for (int j = 0; j < len - i - 1; j++)
		{
			//相邻元素，前者大于后者，进行交换
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
		//打印数组
		printArray(arr, len);
	}
}

void test01()
{
	int arr[8] = { 2,5,4,5,7,1,3,6 };

	//数组中的元素个数
	int len = sizeof(arr) / sizeof(int);

	//调用冒泡排序
	bubbleSort(arr, len);
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

下面是优化后的冒泡排序

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

//打印数组
void printArray(int arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << "";
	}
	cout << endl;
}


void bubbleSort2(int arr[], int len)
{
	bool flag = true;//true 代表交换过  false代表还没交换
	//外层循环 len-1次
	for (int i = 0; i < len - 1; i++)
	{
		flag = false;//每轮初始化状态为真
		//内层循环len-i-1
		for (int j = 0; j < len - i - 1; j++)
		{
			//相邻元素，前者大于后者，进行交换
			if (arr[j]>arr[j+1])
			{
				flag = true;//发生交换  状态改为真
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
		if (flag==false)
		{
			break;
		}
		printArray(arr, len);
	}
}

void test02()
{
	int arr[8] = { 2,5,4,5,7,1,3,6 };

	//数组中的元素个数
	int len = sizeof(arr) / sizeof(int);

	//调用冒泡排序
	bubbleSort2(arr, len);
}

int main()
{
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

最终代码

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

//打印数组
void printArray(int arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << "";
	}
	cout << endl;
}


void bubbleSort2(int arr[], int len)
{
	bool flag = true;//true 代表交换过  false代表还没交换
	//外层循环 len-1次
	for (int i = 0; i < len - 1 && flag==true; i++)
	{
		flag = false;//每轮初始化状态为真
		//内层循环len-i-1
		for (int j = 0; j < len - i - 1; j++)
		{
			//相邻元素，前者大于后者，进行交换
			if (arr[j]>arr[j+1])
			{
				flag = true;//发生交换  状态改为真
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

void test02()
{
	int arr[8] = { 2,5,4,5,7,1,3,6 };

	//数组中的元素个数
	int len = sizeof(arr) / sizeof(int);

	//调用冒泡排序
	bubbleSort2(arr, len);

	//打印
	printArray(arr, len);

}

int main()
{
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

冒泡排序的复杂度