简单选择排序与堆排序

Posted on Edited on In Views: Word count in article: 1.8k Reading time ≈ 18 mins.
前言：简单选择排序与堆排序都属于选择排序，它们排序的思想是：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置。然后再从剩余的未排序元素中寻找到最小（大）元素，放到已排序的序列的末尾，直到全部待排序的数据元素排完

注意：下文中所有排序都是升序

一、简单选择排序

 简单选择排序思想：在待排序序列中选择关键码最小(大)的数据元素，若它不是序列中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换，重复上面步骤，直到序列只有1个元素为止。

在这里插入图片描述

1.1 简单选择排序

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
void swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}

void SelectSort(int* arr, int n)
{
	assert(arr);
	int begin = 0;
	int end = n - 1;

	while (begin < end) // 待排序序列元素个数小于等于1时退出循环
	{
		int max = 0; // 存放待排序序列最大值元素的下标
		for (int i = begin; i <= end; i++) // 单趟排序
		{
			if (arr[max] < arr[i])
			{
				max = i;
			}
		}
		if(max != end) // 当最大值元素不是待排序序列最后一个元素时，将最大值元素与序列最后一个元素交换
			swap(&arr[max], &arr[end]); 
		end--; 
	}
}

1.2 简单选择排序优化

 1.1 中每次排序找到序列中值最大的元素并与序列中最后一个元素交换。我们可以每次排序找到序列中值最小的元素和值最大的元素，分别与序列第一个元素和序列中最后一个元素交换,需要注意如果最大值元素是序列第一个元素时，需要特殊处理，因为最大值元素与序列最后一个元素交换前，最小值元素与序列第一个元素已经交换了，此时最大值元素位置存放的是最小值了
在这里插入图片描述

下面是错误代码

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
void swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}

void SelectSort(int* arr, int n)
{
	assert(arr);
	int begin = 0; 
	int end = n - 1;
	while (begin < end)
	{
		int max = begin; // 存放待排序序列最大值元素的下标
		int min = begin; // 存放待排序序列最小值元素的下标
		for (int i = begin; i <= end; i++)
		{
			if (arr[i] > arr[max])
				max = i;
			if (arr[i] < arr[min])
				min = i;
		}
		if (min != begin) // 当最小值元素不是待排序序列第一个元素时,将最小值元素与序列第一个元素交换
			swap(&arr[min], &arr[begin]);
			
		if (max != end) // 当最大值元素不是待排序序列最后一个元素时，将最大值元素与序列最后一个元素交换
			swap(&arr[max], &arr[end]);

		begin++;
		end--;
	}
}

正确代码：

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
void swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}

void SelectSort(int* arr, int n)
{
	assert(arr);
	int begin = 0; 
	int end = n - 1;
	while (begin < end)
	{
		int max = begin; // 存放待排序序列最大值元素的下标
		int min = begin;// 存放待排序序列最小值元素的下标
		for (int i = begin; i <= end; i++)
		{
			if (arr[i] > arr[max])
				max = i;
			if (arr[i] < arr[min])
				min = i;
		}
		if (min != begin) // 当最小值元素不是待排序序列第一个元素时,将最小值元素与序列第一个元素交换
			swap(&arr[min], &arr[begin]);

		if (max == begin) // 当max等于begin，上面操作将最大值换走了，需要调整最大值下标位置
			max = min;
			
		if (max != end) // 当最大值元素不是待排序序列最后一个元素时，将最大值元素与序列最后一个元素交换
			swap(&arr[max], &arr[end]);

		begin++;
		end--;
	}
}

1.3 时间复杂度与空间复杂度

无论是最好还是最坏情况下简单选择排序时间复杂度都是：O(N^2)。简单选择排序只用了常数个辅助变量空间，空间复杂度：O(1)

说明：
 ●简单选择排序思想与代码实现比较简单，但是效率很低，一般很少使用
 ●简单选择排序是一个不稳定的排序算法

二、堆排序

堆排序排升序一般构造大根堆，降序一般构造小根堆

 堆排序思想：利用堆的性质，将待排序的序列构造成一个大根堆，此时，整个序列的最大值就是堆顶的根节点。将它与堆数组的末尾元素交换，此时末尾元素就是最大值，然后将剩余的n-1个元素重新构造成一个大根堆，这样就会得到n个元素中的次大值。如此反复执行，便能得到一个有序序列

2.1 向下调整构建大根堆

在这里插入图片描述

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

void swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}

void AdjustDown(int* data, int size, int parent) // 向下调整算法前提，左右子树必须为堆
{
	/*
		data为数组首元素地址,size为数组元素个数,parent为当前节点
	*/
	int child = parent * 2 + 1; // 左孩子
	while (child < size) // 循环结束条件：1 调整到叶子节点（节点没有左孩子） 2. 孩子节点小于等于父节点
	{
		// 选出左右孩子中较大的一个 
		if (child + 1 < size && data[child + 1] > data[child])
		{
			child++;
		}
		if (data[child] > data[parent]) // 交换元素值，继续向下调整
		{
			swap(&data[child], &data[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

2.2 堆排序

在这里插入图片描述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void HeapSort(int* arr, int n)
{
	assert(arr);
	for (int parent = (n - 1 - 1) / 2; parent >= 0; parent--) // 建立大堆
	{
		AdjustDown(arr, n ,parent);
	}

	int end = n - 1; // 堆中最后一个元素下标
	for (end; end > 0; end--)
	{
		swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);
	}
}

2.3 测试堆排序

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
#include <stdio.h>
#include <assert.h>

void PrintArray(const int* arr, int n)
{
	assert(arr);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

void swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}

void AdjustDown(int* data, int size, int parent) // 向下调整算法前提，左右子树必须为堆
{
	int child = parent * 2 + 1;
	while (child < size) // 循环结束条件：1 调整到叶子节点（节点没有左孩子） 2. 孩子节点大于等于（小于等于）父节点
	{
		// 选出左右孩子中较小（较大）的一个 
		if (child + 1 < size && data[child + 1] > data[child])
		{
			child++;
		}
		if (data[child] > data[parent]) // 交换元素值，继续向下调整
		{
			swap(&data[child], &data[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* arr, int n)
{
	assert(arr);
	for (int parent = (n - 1 - 1) / 2; parent >= 0; parent--) // 建立大堆
	{
		AdjustDown(arr, n ,parent);
	}

	int end = n - 1; // 堆中最后一个元素下标
	for (end; end > 0; end--)
	{
		swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);
	}
}

int main()
{
	int arr[10] = {2,5,1,9,7,4,7,3,6,10};
	PrintArray(arr, 10);
	HeapSort(arr,10);
	PrintArray(arr, 10);
	return 0;
}

输出

1
2
2 5 1 9 7 4 7 3 6 10
1 2 3 4 5 6 7 7 9 10

2.4 时间复杂度

堆排序主要消耗时间在建堆和排序上，使用向下调整建堆时间复杂度：O(N),排序时间复杂度：O(Nlog₂N)，所以堆排序时间复杂度：O(Nlog₂N)，堆排序只用了常数个辅助变量空间，空间复杂度：O(1)

说明：
 ●堆排序是一个不稳定的排序算法
 ●堆排序前需要建堆