C++数据结构X篇_20_选择排序

「 选择排序 」虽然在实际应用中没有「 插入排序 」广泛，但它也是我们学习排序算法中必不可少的一种。「 冒泡排序 」和「 插入排序 」都是在两层嵌套循环中慢慢比较元素，不停的调整元素的位置。而「 选择排序 」就比较直接了，属于不出手则已，一出手，相应的元素就必须要到位，元素的位置就不会再变了。

1. 选择排序原理

选择排序 也是一种很简单的排序算法，它的思路也是将一组待排序的数据，分成2段，一段是“已排序”了的数据，另一段是“未排序”的数据。当然，在最开始的时候，“已排序”区段里是没有数据的。排序开始后，每次都从“未排序”的数据中取出一个最小的元素（注意，这里是取最小的元素，这一点与「 插入排序 」是不同的），然后将这个最小的元素插入到“已排序”数据中末尾元素的后面（这里其实是将这个最小元素与“已排序”数据的末尾紧邻的下一位元素进行交换），这样保持了“已排序”中的数据永远是有序的。一直这么循环的去处理，直到所有的“未排序”的数据都已交换完，则整个排序全部完成。

下面用图示例讲解一下：

形象的动态图如下：

2. 选择排序原理核心代码

以下的代码虽然可以实现有序排序，但是在某些情况下是不能实现的，这里只实现了第i个元素与最后一个与其相比小的元素的交换，但是不能保证其为最小元素，因此需要增加一个数组来存储比第i个元素小的元素，再在数组中比较得到最小的元素，最后再进行交换。网上很多使用的就是以下的源代码，稳定性还是存在问题，在稳定性部分我将进行讨论。

//选择排序
void select_sort(int arr[], int length)
{
	int min = 0;
	//每一次大循环都能找出剩余元素的最小值
	for (int i = 0; i < length; i++)
	{
	    //min变量是用于存放最小值的下标的，在刚开始的时候，假设位置i是最小值，初始时将i赋值给min
		int min = i;
		//子循环是用于比较大小，从i的后面一位开始遍历，遍历后面所有元素
		for (int j = i + 1; j < length; j++)
		{
		//如果有元素小于min位的值，则将此元素的下标赋值给min
			if (arr[j] < arr[i])
			{
				min = j;
				//...相比较小的元素的存储及求最小值，最后再进行交换
			}
		}
		if (min != i)
		{
			swap(&arr[i], &arr[min]);
		}
	}
}
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

3. 选择排序时间消耗

整体代码：

#include 
#include 
#include 

using namespace std;

#define MAX 10000

//获取系统当前时间,ms为单位
long getSystemTime()
{
	struct timeb tb;
	ftime(&tb);
	return tb.time * 1000 + tb.millitm;
}

void swap(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

//打印数组
void printArr(int arr[])
{
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
}

//选择排序
void select_sort(int arr[], int length)
{
	int min = 0;
	for (int i = 0; i < length; i++)
	{
		int min = i;
		for (int j = i + 1; j < length; j++)
		{
			if (arr[j] < arr[i])
			{
				min = j;
			}
		}
		if (min != i)
		{
			swap(&arr[i], &arr[min]);
		}
	}
}

int main()
{
	int arr[MAX];
	//生成随机数
	srand((unsigned int)time(NULL));
	for (int i=0;i<MAX;i++)
	{
		arr[i] = rand() % MAX;
	}
	long tStart = getSystemTime();
	select_sort(arr, MAX);
	long tEnd = getSystemTime();
	cout << tEnd - tStart << endl;
	system("pause");
	return 0;
}

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

运行结果：时间消耗424ms，比冒泡排序改进版的时间消耗也少了很多

4. 选择排序的稳定性

网上很多提到选择排序算法不是稳定性排序算法。以下为摘抄：
这里再解释一下稳定性排序是指：2个相等的元素，在排序前的相对前后位置和排序完成后的，相对前后位置保持一致。

选择排序为啥不是稳定性排序呢，举个例子：数组 6、7、6、2、8，在对其进行第一遍循环的时候，会将第一个位置的6与后面的2进行交换。此时，就已经将两个6的相对前后位置改变了。因此选择排序不是稳定性排序算法。

除了上面提到的情况，我在实际使用时发现，当核心代码为：

//选择排序
void select_sort(int arr[], int length)
{
	int min = 0;
	//每一次大循环都能找出剩余元素的最小值
	for (int i = 0; i < length; i++)
	{
	    //min变量是用于存放最小值的下标的，在刚开始的时候，假设位置i是最小值，初始时将i赋值给min
		int min = i;
		//子循环是用于比较大小，从i的后面一位开始遍历，遍历后面所有元素
		for (int j = i + 1; j < length; j++)
		{
		//如果有元素小于min位的值，则将此元素的下标赋值给min
			if (arr[j] < arr[i])
			{
				min = j;
			}
		}
		if (min != i)
		{
			swap(&arr[i], &arr[min]);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

代码演示：
如果初始数组为int arr[] = {10,9,8,7,6,5,4,3,2,1};，运行之后结果是正确的

但是当数组变为：int arr[] = { 8,2,3,9,6,4,7,1,5,10 };，运行结果就是错误的

上面的代码存在优化的空间，后边有时间了我再进行修改！

5.视频： 选择排序；博文：常见的几种排序（C++）