8-4交换排序-冒泡排序

一.基本思想和代码

以下按从小到大排序
基本思想：从后往前两两对比元素

（一）第一轮
1.对比最后两个元素。如果右边的小，二者交换。此处不动

2.对比5、6两个元素
不动

3.对比4、5两个元素
76>13，交换位置
代码角度：if (a[j - 1] > a[j]) swap(a[j - 1], a[j]);
其中swap为交换函数

void swap(int &a, int &b)
{
	int t;
	t = a;
	a = b;
	b = t;
}
1
2
3
4
5
6
7

变为

4.对比3、4两个元素
交换13和97

以此类推
直到0和1号位的元素比较（交换）

此时第一轮完成，最小的元素13放到了0号位（第一轮使得关键字最小的元素放到了正确的位置）

（二）第二轮
从最后两个开始比较，直到1、2完成比较（交换）

循环条件为：

for (j = n - 1; j > 1; j--)//按数组下标，最后一个元素下标是n-1
		{
			if (a[j - 1] > a[j])//相等时不交换，保证稳定性 
			//当j=2时，最后一次1和2的比较：if (a[1] > a[2]) 
				swap(a[j - 1], a[j]);
		}
1
2
3
4
5
6

此时将第二个最小的元素放到了1号位（正确位置）

第二轮结束

以此类推，通过五轮的处理，全部有序

注：如果某轮没有发生任何元素的交换，说明整体已经有序

完整代码

#include
#include
using namespace std;
void swap(int &a, int &b)
{
	int t;
	t = a;
	a = b;
	b = t;
}
void BubbleSort(int a[], int n)
{
	for (int i = 0; i < n; i++)
	{
		bool flag = false;//每轮重置flag，判断是否提前结束
		for (int j = n - 1; j > i; j--)
		{
			if (a[j - 1] > a[j]) { 
				swap(a[j - 1], a[j]); 
				flag = true; //本轮进行了元素交换，不能提前结束
			}
		}
		if (flag == false) //某轮没有元素交换，提前结束
			return;
	}
}
int main()
{
	int a[5] = {34,23,12,87,45 };
	BubbleSort(a, 5);
	for (int i = 0; i < 5; i++)
	{
		cout << a[i] << " ";
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

二.效率分析
1.空间复杂度：O(1)
2.时间复杂度
（1）最好：原本有序。根据flag可以提前结束，对比关键字n-1次，复杂度O(n)
（2）最坏：原本逆序。
第一轮：对比n-1次，交换n-1次（交换次数≠移动次数，每一个交换swap函数会移动3次）
第二轮：对比n-2次，交换n-2次
…
第n-1轮：对比1次，交换1次
第n轮：无需操作
故O(2×(n-1+n-2+…+1)) =O(n²)
（3）平均：O(n²)
3.稳定性：由比较时的判断条件if (a[j - 1] > a[j])//相等时不交换，保证稳定性。可知，算法是稳定的

三.应用于链表
如由小到大
49和38比，小的在前，交换

继续比较第二个和第三个元素，以此类推

每轮结束都使得最大的元素放到了后面位置（正确位置）

同样第二轮只需要从头开始，到第n-2和n-1个元素的比较结束

因此对于顺序表也可以选择每次将最大的元素冒到后面

总结