基础数据结构——冒泡排序和归并排序

冒泡排序

原理

冒泡排序(Bubble Sort)(也叫沉石排序) 是一种交换排序，思想是(按升序)：
两两相比较，大的向后挪，一轮走完后，最后一个元素就是最大的；依靠这一特性，每一轮找待排序序列的最大值，放到最后。

图示

C语言代码

void Bubble_Sort(int* arr, int len)
{
	assert(arr != NULL);

	for (int i = 0; i < len - 1; ++i)
	{
		for (int j = 0; j < len - 1 - i; ++j)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行示例

void Show(int* ar, int len)
{
	for (int i = 0; i < len; ++i)
	{
		printf("%d ", ar[i]);
	}
	printf("\n");
}
int main(void)
{
	int ar[] = { 3, 6, 14, 9, 11, 8, 5, 2, 13, 15, 1, 7, 4, 12, 10 };
	int len = sizeof(ar) / sizeof(ar[0]);

	Bubble_Sort(ar, len);
	Show(ar, len);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行结果：

小优化

如果在没走完之前数据已经有序了，那程序就不用再继续执行，想办法让他停下来。

void Bubble_Sort(int* arr, int len)
{
	assert(arr != NULL);

	bool flag = true;

	for (int i = 0; i < len - 1; ++i)
	{
		flag = true;
		for (int j = 0; j < len - 1 - i; ++j)
		{
			if (arr[j] > arr[j + 1])
			{
				flag = false;
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;	
			}
		}
		if (flag)
		{
			break;
		}
	}
}
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

当if判断中的flag为真时，说明内层循环的语句没有执行过，意思就是剩下的数据已经有序，可以直接跳出了。

评价

1. 时间复杂度：O(n^2)
2. 空间复杂度：O(1)
3. 稳定性：稳定的(不存在跳跃交换数据）。

归并排序(非递归形式)

原理

假设初始序列含有n子序列, 每个子序列的长度为1, 然后两两归并,得到 n / 2个长度为2或1的有序子序列; 再两两归并,……, 如此重复, 直至得到一个长度为n的有序序列为止, 这种排序方法称为2-路归并排序。

图示

先进行一一合并

划分出来的每一部分都保持有序了。

再接着合并

四四合并

是怎么合并的呢
当low1和low2对应的元素哪个小，就优先把它放下来，并给下标加一，当low1和low2等于high1或high2时，退出。退出时有一方的数据没有比较完，就把剩下的元素也依次放下来。

再次合并

这样就完全有序了

C语言代码

static void Merge(int* arr, int len, int gap)
{
	//申请额外空间，等长于原始数组
	int* brr = (int*)malloc(sizeof(int) * len);
	assert(brr != NULL);

	int i = 0; // 额外数组brr的下标

	//申请四个指针，用来表示合并两组的边界
	int low1 = 0;
	int high1 = low1 + gap - 1;
	int low2 = high1 + 1;
	int high2 = low2 + gap - 1 < len ? low2 + gap - 1 : len - 1;


	while (low2 < len) // 当low2满足小于len，则low1和high1肯定满足条件
	{
		//比较两组数据
		while (low1 <= high1 && low2 <= high2)
		{
			if (arr[low1] <= arr[low2])
			{
				brr[i++] = arr[low1++];
			}
			else
			{
				brr[i++] = arr[low2++];
			}
		}

		//上面的while循环跳出
		//要么因为右边组数据比较完了，那就把
		//左边组剩下的数据也放下来
		while (low1 <= high1)
		{
			brr[i++] = arr[low1++];
		}
		//要么因为左边组数据比较完了，那就把
		//右边组剩下的数据也放下来
		while (low2 <= high2)
		{
			brr[i++] = arr[low2++];
		}

		//更新指针
		low1 = high2 + 1;
		high1 = low1 + gap - 1;
		low2 = high1 + 1;
		high2 = low2 + gap - 1 < len ? low2 + gap - 1 : len - 1;
	}

	//上面的外层循环跳出，可能存在这种情况
	//即右边组没有数据了，左边还有，则把左边数据放下来
	while (low1 < len)
	{
		brr[i++] = arr[low1++];
	}

	//再把排好序后的数据放回原始数组
	for (int j = 0; j < len; ++j)
	{
		arr[j] = brr[j];
	}

	//再把额外空间释放掉
	free(brr);
	brr = NULL;
}

void Merge_Sort(int* arr, int len)
{
	assert(arr != NULL);

	for (int i = 1; i < len; i *= 2)
	{
		Merge(arr, len, 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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

指针的位置怎么找？
low1初始都为 0 ，更新位置在high2 + 1处；
high1为low1 + gap - 1;

low2 为 high1 + 1；

high2有两种情况：
当我要取的右边界小于len时，就把 low2 + gap - 1 赋给 high2；
当我要取的右边界大于len时，就把最后一个元素下标赋给 high2 ,
即 len - 1。。

运行示例

void Show(int* ar, int len)
{
	for (int i = 0; i < len; ++i)
	{
		printf("%d ", ar[i]);
	}
	printf("\n");
}
int main(void)
{
	int ar[] = { 3, 6, 14, 9, 11, 8, 5, 2, 13, 15, 1, 7, 4, 12, 10 };
	int len = sizeof(ar) / sizeof(ar[0]);

	Merge_Sort(ar, len);
	Show(ar, len);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行结果

评价

1. 时间复杂度： O(n log n)
2. 空间复杂度： O(n)
3. 稳定性： 稳定的。