排序算法之三选择排序(C++版本)

最新推荐文章于 2024-06-25 21:35:54 发布

xupeng1644

最新推荐文章于 2024-06-25 21:35:54 发布

阅读量1.5k

点赞数

CC 4.0 BY-SA版权

分类专栏： Algorithm 文章标签：选择排序(C++版本) (C++版本) 选择排序

本文链接：https://blog.youkuaiyun.com/xp178171640/article/details/103119175

Algorithm 专栏收录该内容

39 篇文章

订阅专栏

本文深入探讨了选择排序算法的基本原理及其实现方式，通过对比初始版本与改进版本，详细解析了如何在每轮查找最小值的同时找到最大值，以此减少排序总轮数，提升排序效率。文章通过具体的代码示例和输出验证，展示了排序过程中的数据变化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一. 实现原理

选择排序的相关知识，参考漫画：什么是选择排序？

二. 具体实现

初始版本


void SelectSort_Init(int* pData, int size)
{
	if (nullptr == pData || size <= 0) return;

	for (int i = 0; i < size - 1; ++i) // i为每轮最小值的最终位置，总共进行size-1轮，最后一轮只有一个元素，无需处理
	{
		int minIdx = i;

		for (int j = i + 1; j < size; ++j)
		{
			if (pData[j] < pData[minIdx]) minIdx = j; // 更新这轮的最小值
		}

		if (minIdx != i) std::swap(pData[i], pData[minIdx]);// 这轮的最小值不在初始位置
	}
}

其实，每轮中找到最小值的同时，可以找到最大值，将最小值放在前面，最大值放在后面。这样可以减少总的进行轮数。

改进版本

void SelectSort_Advance(int* pData, int size)
{
	if (nullptr == pData || size <= 0) return;

	std::cout << "INIT DATA" << std::endl;
	Print(pData, size);

	for (int i = 0; i < size - 1; ++i) // i为每轮最小值的最终位置，总共进行size-1轮，最后一轮只有一个元素，无需处理
	{
		int minIdx = i;
		int maxIdx = size - 1 - i;
		if (minIdx >= maxIdx) break;

		for (int j = i; j <= size - 1 - i; ++j)
		{
			if (pData[j] < pData[minIdx]) minIdx = j; // 更新这轮的最小值
			if (pData[j] > pData[maxIdx]) maxIdx = j; // 更新这轮的最大值
		}

		if (minIdx != i) std::swap(pData[i], pData[minIdx]);
		if (maxIdx != size - 1 - i) std::swap(pData[size - 1 - i], pData[maxIdx]);
	}
}

三. 输出验证

加上相关的输出信息后再进行调用。

辅助函数：

void Print(int* pData, int size)
{
	for (int idx = 0; idx < size; ++idx) std::cout << pData[idx] << " ";
	std::cout << std::endl;
}

初始数据为：

int datas[6] = { 1, 2, 3, 2, 1, 6 };

初始版本

void SelectSort_Init_Output(int* pData, int size)
{
	if (nullptr == pData || size <= 0) return;

	std::cout << "INIT DATA" << std::endl;
	Print(pData, size);

	for (int idx = 0; idx < size - 1; ++idx) // idx为每轮的选择集合的起始位置，注意结束位置为size - 1
	{
		std::cout << std::endl << "MIN DEST IDX " << idx << std::endl;

		int minIdx = idx;

		for (int j = idx + 1; j < size; ++j)
		{
			if (pData[j] < pData[minIdx]) minIdx = j; // 更新这轮的最小值
		}

		std::cout << "MIN ACTUAL IDX " << minIdx << std::endl;

		if (minIdx != idx)
		{
			std::swap(pData[idx], pData[minIdx]); // 这轮的最小值不在初始位置
			std::cout << "NEED SWAP" << std::endl;
			Print(pData, size);
		}
	}

	std::cout << std::endl << "FINAL DATA" << std::endl;
	Print(pData, size);
}

调用输出

INIT DATA
1 2 3 2 1 6

MIN DEST IDX 0
MIN ACTUAL IDX 0

MIN DEST IDX 1
MIN ACTUAL IDX 4
NEED SWAP
1 1 3 2 2 6

MIN DEST IDX 2
MIN ACTUAL IDX 3
NEED SWAP
1 1 2 3 2 6

MIN DEST IDX 3
MIN ACTUAL IDX 4
NEED SWAP
1 1 2 2 3 6

MIN DEST IDX 4
MIN ACTUAL IDX 4

FINAL DATA
1 1 2 2 3 6

改进版本

void SelectSort_Advance_Output(int* pData, int size)
{
	if (nullptr == pData || size <= 0) return;

	std::cout << "INIT DATA" << std::endl;
	Print(pData, size);

	for (int i = 0; i < size; ++i) // idx为每轮的选择集合的起始位置，注意结束位置为size - 1
	{
		int minIdx = i;
		int maxIdx = size - 1 - i;
		if (minIdx >= maxIdx) break;

		std::cout << std::endl << "MIN DEST IDX " << minIdx << " MAX DEST IDX " << maxIdx << std::endl;

		for (int j = i; j <= size - 1 - i; ++j)
		{
			if (pData[j] < pData[minIdx]) minIdx = j; // 更新这轮的最小值
			if (pData[j] > pData[maxIdx]) maxIdx = j; // 更新这轮的最大值
		}

		if (minIdx != i) std::swap(pData[i], pData[minIdx]);
		if (maxIdx != size - 1 - i) std::swap(pData[size - 1 - i], pData[maxIdx]);

		std::cout << "MIN ACTUAL IDX " << minIdx << " MAX ACTUAL IDX " << maxIdx << std::endl;
		Print(pData, size);
	}

	std::cout << std::endl << "FINAL DATA" << std::endl;
	Print(pData, size);
}

调用输出

INIT DATA
1 2 3 2 1 6

MIN DEST IDX 0 MAX DEST IDX 5
MIN ACTUAL IDX 0 MAX ACTUAL IDX 5
1 2 3 2 1 6

MIN DEST IDX 1 MAX DEST IDX 4
MIN ACTUAL IDX 4 MAX ACTUAL IDX 2
1 1 2 2 3 6

MIN DEST IDX 2 MAX DEST IDX 3
MIN ACTUAL IDX 2 MAX ACTUAL IDX 3
1 1 2 2 3 6

FINAL DATA
1 1 2 2 3 6