八大排序之冒泡排序+选择排序

先给一个数组arr[]{5,2,9,1,5,6}通过这个数组讲解

一、冒泡排序（从小到大）

原理：相邻两个数比较，大的往后 "冒"，每一趟确定最后一个最大数。

数组：5 2 9 1 5 6一共 6 个数，需要 5 趟。

第 1 趟（确定最后一位：最大数 9）

从头两两比：

5 和 2 → 5>2，交换 → 2 5 9 1 5 6
5 和 9 → 不换
9 和 1 → 9>1，交换 → 2 5 1 9 5 6
9 和 5 → 9>5，交换 → 2 5 1 5 9 6
9 和 6 → 9>6，交换 → 2 5 1 5 6 9

第 1 趟结束：2 5 1 5 6 9

第 2 趟（确定倒数第二位：6）

只比前 5 个：2 5 1 5 6

2 和 5 → 不换
5 和 1 → 交换 → 2 1 5 5 6
5 和 5 → 不换
5 和 6 → 不换

第 2 趟结束：2 1 5 5 6 9

第 3 趟（确定倒数第三位：5）

只比前 4 个：2 1 5 5

2 和 1 → 交换 → 1 2 5 5
2 和 5 → 不换
5 和 5 → 不换

第 3 趟结束：1 2 5 5 6 9

第 4 趟

比前 3 个：1 2 5已经有序，无交换。结果不变：1 2 5 5 6 9

第 5 趟

比前 2 个：1 2有序，无交换。

最终排序：1 2 5 5 6 9

代码实现：

cpp 复制代码

void BubbleSort1(int* arr, int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				swap(arr[j], arr[j + 1]);
			}
		}
	}
}

冒泡优化：给一个tag 当一趟下来没有交换的时候，说明这时候的数组已经有序了，则直接return

cpp 复制代码

void BubbleSort2(int* arr, int len)
{
	
	for (int i = 0; i < len - 1; i++)
	{
		bool tag = true;
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				swap(arr[j], arr[j + 1]);
				tag = false;
			}
			
		}
		if (tag)return;
	}
}

二、选择排序（从小到大）

原理：每一趟在未排序部分找最小值，直接和未排序第一个位置交换。

数组：5 2 9 1 5 6同样 5 趟。

第 1 趟（确定第 1 位）

未排序：5 2 9 1 5 6找最小值：1（下标 3）和第 1 位交换：

第 1 趟结束：1 2 9 5 5 6

第 2 趟（确定第 2 位）

未排序从第 2 位开始：2 9 5 5 6最小值是 2，已经在位置上，不用交换。

第 2 趟结束：1 2 9 5 5 6

第 3 趟（确定第 3 位）

未排序从第 3 位开始：9 5 5 6最小值是 5（下标 3）和第 3 位交换：

第 3 趟结束：1 2 5 9 5 6

第 4 趟（确定第 4 位）

未排序从第 4 位开始：9 5 6最小值是 5（下标 4）和第 4 位交换：

第 4 趟结束：1 2 5 5 9 6

第 5 趟（确定第 5 位）

未排序从第 5 位开始：9 6最小值是 6（下标 5）和第 5 位交换：

第 5 趟结束：1 2 5 5 6 9

cpp 复制代码

void SelectSort(int* arr, int len)
{
	if (arr == nullptr || len <= 0) return;
	for (int i = 0; i < len - 1; i++)
	{
		int Index = i;
		for (int j = i + 1; j < len; j++)
		{
			if (arr[j] < arr[Index])
			{
				Index = j;
			}
		}
		swap(arr[Index], arr[i]);
	}
}