排序算法:选择排序

原理:假设有n个数据,第一次从待排序的元素中选出最小/大的一个元素,放在所有元素的第一个位置/起始位置;接着,在剩下未排序的元素中选出最小/大元素,继续放在未排序元素的前面,直到未排序的元素个数剩余0个

具体实现:

1. 假设有一个数组需要排序，我们从第一个元素开始，将其标记为最小值。

2. 继续从第二个元素开始遍历数组，将其与当前最小值进行比较，如果找到更小的元素，则更新最小值的位置。

3. 遍历完成后，交换第一个元素与最小值，将最小值移至数组的开头。

4. 接着从第二个元素开始重复上述过程，直到整个数组排序完成。

简单来说，选择排序的原理就是依次选出最小的元素并放置在数组的最前面，不断缩小待排序的范围，直到整个数组排序完成。

在实现过程中，我们使用了一个minIndex变量来保存当前未排序数组中最小元素的下标，并通过循环遍历未排序的元素，选择最小的元素并交换到未排序的数组开头。通过不断地缩小未排序的范围，最后实现整个数组排序。

代码举例:

#include<iostream>
using namespace std;

template<class T>
void mySwap(T &a,T &b)
{
	T temp = a;
	a = b;
	b = temp;
}

//从小到大
template<class T,class Func>
void mySelectSort(T arr[], Func swap, int len)
{
	for (int i = 0; i < len; i++)
	{
		//确定最小值的下标
		//i=0时,把第一个元素当做最小的元素
		//接着和后面的所有元素做比较,寻找更小的元素(这个更小是指待排元素序列中最小的元素)
		int minIndex = i;
		for (int j = i + 1; j < len; j++)//找出最小的元素
		{
			if (arr[min] > arr[j])
				min = j;
		}
		if (min != i)//只要不等于,就说嘛找到了最小的元素
		{
			swap(arr[min], arr[i]);
		}
	}
}

template<class T>
void myPrint(T arr[], int len)
{
	for (int i = 0; i < len; i++)
		cout << arr[i] << " ";
	cout << endl;
}

int main()
{
	int a = 1, b = 2;
	cout << "brfore swap a =" << a<<endl
		<< "before swap b =" << b<<endl; 
	mySwap(a, b);
	cout << "after swap a = " << a<<endl
		<< "after swap b =" << b<<endl;

	int myArr[] = { 5,6,22,4,6,3,4 };
	int len = sizeof(myArr) / sizeof(int);
	cout << "默认的元素:";
	myPrint(myArr, len);
	mySelectSort(myArr, mySwap<int>, len);
	cout << "排序后:";
	myPrint<int>(myArr, len);//显示指定类型推导

	char myCharArr[] = { 'v','g','s','e','t' };
	int len2 = sizeof(myCharArr) / sizeof(char);
	cout << "默认的元素:";
	myPrint(myCharArr, len2);//自动类型推导
	mySelectSort(myCharArr, mySwap<char>, len2);
	cout << "排序后:";
	myPrint(myCharArr, len2);//自动类型推导

	return 0;
}

选择排序优化,在一趟遍历中,同时找出最小值和最大值,分别放在数组的两端,这样数组的遍历次数会少一半

代码优化:

template<class T, class Func>
void mySelectSort(T arr[], Func swap, int len)
{	
		int left = 0, right = len - 1;
		while (left < right)
		{
			int min = left;
			int max = right;
			for (int i = left; i <= right; i++)
			{
				if (arr[i] < arr[min])
					min = i;
				if (arr[i] > arr[max])
					max = i;
			}
			swap(arr[max], arr[right]);
			if (min == max)
				min = max;
			swap(arr[min], arr[left]);
			left++;
			right--;
		}
	
}

稳定性:在待排序的元素中若出现了相同的元素,那么稳定性就会被破坏

如在2,3(1),5,4,3(2)中排序后可能出现:2,3(2),3(1),4,5

时间复杂度:O(n^2);

使用场景:排序简单的数据结构或者相同元素顺序无关的场合