选择排序详解及递归实现

---

一、概念及原理

选择排序：每一趟从待排序的记录中选出关键字最小的记录，按顺序放在已排序的记录序列的最后，知道全部排完为止。

二、适用说明

1.时间复杂度

简单的选择排序的时间复杂度是O(n^2)。

2.空间复杂度

只有在两个记录交换时需要一个辅助空间，所以空间复杂度为O(1)。

3.算法特点

1. 就选择排序方法本身来讲，它是一种稳定的排序方法。稳不稳定是看算所采用“交换记录”的策略，根据这个来判断自己所写的选择排序是不是稳定的。
2. 可用于链式存储结构
3. 移动记录次数越少，当每一种记录占用的空间较多时，此方法比直接插入排序快。

4.动画演示

三、双循环实现代码演示

1.未优化的代码实现

#include <stdio.h>
#include <stdlib.h>

void selectSort(int *array, int len)
{
	int i = 0, j = 0;
	for (i = 0; i < len - 1; ++i)     //也就是排序的次数，需要排多少次就能排好
	{
		int temp=i;                       //刚开始会把第一个元素默认为时最小的元素
		for (j = i+1; j < len; ++j)   //比较的次数   注意和谁进行比较
		{
			if (array[j] < array[temp])       //这个条件里面是在数组中找到比默认最小元素更小的数，并记录位置
			{
				temp = j;
			}
		}
		if (temp != i)
		{
			int ptemp1 = array[temp];          //此时经过上面循环已经找到了比默认更小的数，并执行交换操作
			array[temp] = array[i];
			array[i] = ptemp1;
		}
	}
}

void printArray(int *array,int len)
{
	for (int i = 0; i < len; ++i)
	{
		printf("%4d", array[i]);
	}
}

int main(void)
{
	int array[10] = { 78,15,99,53,84,27,39,1,41,67 };
	int len = sizeof(array) / sizeof(int);

	//输出排序前的数组
	printf("排序前的数组\n");
	printArray(array, len);
	putchar('\n');

	//调用选择排序函数排序
	selectSort(array, len);

	//输出排序后的数组
	printf("排序后的数组\n");
	printArray(array, len);
	putchar('\n');

	system("pause > 0");
	return 0;
}

代码运行结果如下：

2.优化后的代码实现

优化双层循环的选择排序
通过一次循环找出最大的数和最小的数，并且把最大的数放在右边，最小的数放在左边
注意：此时有一个特殊情况，那就是我要交换的最大数刚好被交换最小数时，被交换走了，此时我们就需要加一个判断。优化后只直接提高一半效率

#include <stdio.h>
#include <stdlib.h>

void optimizeSelectSort(int* array, int len)
{
	int i = 0, j = 0;				//定义循环因子
	int iLeft = 0;					//记录最左端的元素
	int iRight = len - 1;			//记录最右边的元素
	int iMax = 0, iMin = 0;

	while (iLeft < iRight)
	{
		iMax = iMin = iLeft;
		for (i = iLeft; i <= iRight; ++i)
		{
			//找出最小的数
			if (array[i] < array[iMin])
				iMin = i;               //记住最小的数位置
			//找出最大的数
			if (array[i] > array[iMax])
				iMax = i;             //记住最大数的位置
		}
		//此时需要执行交换操作
		//将最小的数放到左边
		if (iMin != iLeft)
		{
			int ptemp = array[iLeft];
			array[iLeft] = array[iMin];
			array[iMin] = ptemp;
		}
		//此处需要判断如果最大的数刚好在交换最小数的时候被交换走了
		if (iMax==iLeft)
		{
			iMax = iMin;
		}
		//将最大的数放到右边
		if (iMax != iRight)
		{
			int ptemp = array[iRight];
			array[iRight] = array[iMax];
			array[iMax] = ptemp;
		}
		iLeft++;
		iRight--;
	}
}

void printArray(int* array, int len)
{
	for (int i = 0; i < len; ++i)
	{
		printf("%4d", array[i]);
	}
}

int main(void)
{
	int array[10] = { 78,15,99,53,84,27,39,1,41,67 };
	int len = sizeof(array) / sizeof(int);

	//输出排序前的数组
	printf("排序前的数组\n");
	printArray(array, len);
	putchar('\n');

	//调用选择排序函数排序
	optimizeSelectSort(array, len);

	//输出排序后的数组
	printf("排序后的数组\n");
	printArray(array, len);
	putchar('\n');

	system("pause > 0");
	return 0;
}

代码运行结果如下：

四、递归实现代码演示

1.未优化的代码实现

#include <stdio.h>
#include <stdlib.h>

void recursionSelectSort(int *array, int len)
{
	if (len < 2)                      //递归出口   
		return;

	int i = 0;
	int temp = 0;
	for (i = 1; i < len; ++i)        //递归和双层循环不一样，判断交换的条件不一样
	{
		if (array[i] < array[temp])       //这个条件里面是在数组中找到比默认最小元素更小的数，并记录位置
			temp = i;
	}
	if (temp != 0)                          //此时交换和非递归不一样，需要将找出来的数和第一个位置的数交换
	{
		int ptemp1 = array[temp];          //此时经过上面循环已经找到了比默认更小的数，并执行交换操作
		array[temp] = array[0];
		array[0] = ptemp1;
	}
	recursionSelectSort(array + 1, --len);
}

void printArray(int *array,int len)
{
	for (int i = 0; i < len; ++i)
	{
		printf("%4d", array[i]);
	}
}

int main(void)
{
	int array[10] = { 78,15,99,53,84,27,39,1,41,67 };
	int len = sizeof(array) / sizeof(int);

	//输出排序前的数组
	printf("排序前的数组\n");
	printArray(array, len);
	putchar('\n');

	//调用递归选择排序函数排序
	recursionSelectSort(array, len);

	//输出排序后的数组
	printf("排序后的数组\n");
	printArray(array, len);
	putchar('\n');

	system("pause > 0");
	return 0;
}

代码运行结果如下：

2.优化后的代码实现

优化递归循环的选择排序
通过一次循环找出最大的数和最小的数，并且把最大的数放在右边，最小的数放在左边
注意：此时有一个特殊情况，那就是我要交换的最大数刚好被交换最小数时，被交换走了，此时我们就需要加一个判断。优化后只直接提高一半效率

#include <stdio.h>
#include <stdlib.h>

void optimizeRecursionSelectSort(int* array, int len)
{
	if (len < 2)                      //递归出口   数组中两个元素一下不用排序
	{
		return;
	}
	int i = 0;
	int iLeft = 0;
	int iRight = len - 1;
	int iMax = 0, iMin = 0;
	for (i = iLeft; i <= iRight; i++)
	{
		if (array[i] < array[iMin])
		{
			iMin = i;
		}
		if (array[i] > array[iMax])
		{
			iMax = i;
		}
	}
	//此时需要执行交换操作
	//将最小的数放到左边
	if (iMin != iLeft)
	{
		int ptemp = array[iLeft];
		array[iLeft] = array[iMin];
		array[iMin] = ptemp;
	}
	//此处需要判断如果最大的数刚好在交换最小数的时候被交换走了
	if (iMax == iLeft)
	{
		iMax = iMin;
	}
	//将最大的数放到右边
	if (iMax != iRight)
	{
		int ptemp = array[iRight];
		array[iRight] = array[iMax];
		array[iMax] = ptemp;
	}
	len = len - 2;

	optimizeRecursionSelectSort(array + 1, len);
}

void printArray(int* array, int len)
{
	for (int i = 0; i < len; ++i)
	{
		printf("%4d", array[i]);
	}
}

int main(void)
{
	int array[10] = { 78,15,99,53,84,27,39,1,41,67 };
	int len = sizeof(array) / sizeof(int);

	//输出排序前的数组
	printf("排序前的数组\n");
	printArray(array, len);
	putchar('\n');

	//调用递归选择排序函数排序
	optimizeRecursionSelectSort(array, len);

	//输出排序后的数组
	printf("排序后的数组\n");
	printArray(array, len);
	putchar('\n');

	system("pause > 0");
	return 0;
}

代码运行结果如下：

---