排序算法

/*
冒泡排序
稳定排序
最好时间复杂度 : O(n)
最坏时间复杂度 : O(n^2)
空间复杂度 : O(1)
*/
void _sort(std::vector<int>& arr)
{
	for (int i = 0; i < arr.size() - 1; i++)
		for (int j = 0; j < arr.size() - i - 1; j++)
			if (arr[j] > arr[j + 1])
				std::swap(arr[j], arr[j + 1]);
}

/*
选择排序
不稳定排序
最好时间复杂度 : O(n^2)
最坏时间复杂度 : O(n^2)
空间复杂度 : O(1)
*/
void _sort(std::vector<int>& arr)
{
	for (int i = 0; i < arr.size() - 1; i++)
	{
		//查找后边的最小的那一个值
		int val = i;
		for (int j = i + 1; j < arr.size(); j++)
			if (arr[j] < arr[val]) val = j;

		//需要的时候再进行交换操作
		if (val != i) std::swap(arr[i], arr[val]);
	}
}

/*
插入排序
稳定排序
最好时间复杂度 : O(n)
最坏时间复杂度 : O(n^2)
空间复杂度 : O(1)
*/
void _sort(std::vector<int>& arr)
{
	for (int i = 1; i < arr.size(); i++)
	{
		int key = arr[i], j = i - 1;

		//从右到左 查找合适的位置
		while (j >= 0 && key < arr[j])
		{
			arr[j + 1] = arr[j];
			j--;
		}

		arr[j + 1] = key;
	}
}

/*
希尔排序
不稳定排序
最好时间复杂度 : O(nlog^2n)
最坏时间复杂度 : O(nlog^2n)
空间复杂度 : O(1)
*/
void _sort(std::vector<int>& arr)
{
	for (int g = arr.size() / 2; g > 0; g /= 2)
		for (int i = g; i < arr.size(); i++)
			for (int j = i; j - g >= 0 && arr[j - g] > arr[j]; j -= g)
				std::swap(arr[j - g], arr[j]);
}

/*
桶排序
稳定排序
最好时间复杂度 : O(n + k)
最坏时间复杂度 : O(n^2)
空间复杂度 : O(n + k)
*/
void _sort(std::vector<int>& arr)
{
	//查找出最大的那一个数值
	int max_val = arr[0];
	for (const auto& it : arr) if (it > max_val) max_val = it;

	//要一个足够大小的数组
	std::vector<std::vector<int>> bucket(max_val / 10 + 1, std::vector<int>{});

	//把不同大小的数值放到不同的桶中
	for (const auto& it : arr)
		bucket[it / 10].push_back(it);

	//对每一个桶中的数据进行排序
	for (auto& it : bucket)
		std::sort(it.begin(), it.end());

	//将排序的的数据赋值
	int index = 0;
	for (int i = 0; i < bucket.size(); i++)
		for (int j = 0; j < bucket[i].size(); j++)
			arr[index++] = bucket[i][j];
}