插入排序，选择排序，递归排序和冒泡排序的实现

最新推荐文章于 2021-02-21 15:29:50 发布

majunyangyang

最新推荐文章于 2021-02-21 15:29:50 发布

阅读量383

点赞数

分类专栏： Leetcode 文章标签： windows 编程算法导论插入排序递归

本文链接：https://blog.csdn.net/majunyangyang/article/details/41171385

版权

Leetcode 专栏收录该内容

49 篇文章 0 订阅

订阅专栏

以下是根据算法导论中伪码实现的几种排序方式，包括插入排序，选择排序，递归排序和冒泡排序。

<pre name="code" class="cpp">#include <iostream>
using std::cout;
// the insertion sort
void Insertion_sort(double* t_dpSeq,unsigned long t_ulSeqLen)
{
	double dKey;
	long lIndex;
	for (unsigned long ulTemp = 1; ulTemp < t_ulSeqLen; ulTemp++)
	{
		dKey = t_dpSeq[ulTemp];
		lIndex = ulTemp - 1;
		while (lIndex >= 0 && t_dpSeq[lIndex] > dKey)
		{
			t_dpSeq[lIndex + 1] = t_dpSeq[lIndex];
			lIndex--;
		}
		t_dpSeq[lIndex + 1] = dKey;
	}
}

// the choose sort
void Choose_sort(double* t_dpSeq, unsigned long t_ulSeqLen)
{
	double dMin;
	long lPos;
	for (unsigned long ulTemp = 0; ulTemp < t_ulSeqLen - 1; ulTemp++)
	{
		dMin = t_dpSeq[ulTemp];
		lPos = ulTemp;
		for (unsigned long ulIndex = ulTemp + 1; ulIndex < t_ulSeqLen; ulIndex++)
		{
			if (t_dpSeq[ulIndex] < dMin)
			{
				dMin = t_dpSeq[ulIndex];
				lPos = ulIndex;
			}	
		}
		t_dpSeq[lPos] = t_dpSeq[ulTemp];
		t_dpSeq[ulTemp] = dMin;
	}
}

// the merge sort
void Merge(double* t_dpSeq, unsigned long t_ulBegin, unsigned long t_ulMiddle, unsigned long t_ulEnd)
{
	unsigned long ulLen1, ulLen2, ulIndex1, ulIndex2;
	ulLen1 = t_ulMiddle - t_ulBegin + 1;
	ulLen2 = t_ulEnd - t_ulMiddle;
	double* dpUpSeq = new double[(ulLen1 + 1)*sizeof(double)];
	double* dpDownSeq = new double[(ulLen2 + 1)*sizeof(double)];
	for (unsigned long ulTemp = 0; ulTemp < ulLen1; ulTemp++)
	{
		dpUpSeq[ulTemp] = t_dpSeq[t_ulBegin + ulTemp];
	}
	for (unsigned long ulTemp = 0; ulTemp < ulLen2; ulTemp++)
	{
		dpDownSeq[ulTemp] = t_dpSeq[t_ulMiddle + ulTemp + 1];
	}
	dpUpSeq[ulLen1] = 1e10;
	dpDownSeq[ulLen2] = 1e10;
	ulIndex1 = 0;
	ulIndex2 = 0;
	for (unsigned long ulIndex = t_ulBegin; ulIndex <= t_ulEnd; ulIndex++)
	{
		if (dpUpSeq[ulIndex1] <= dpDownSeq[ulIndex2])
		{
			t_dpSeq[ulIndex] = dpUpSeq[ulIndex1];
			ulIndex1++;
		}
		else
		{
			t_dpSeq[ulIndex] = dpDownSeq[ulIndex2];
			ulIndex2++;
		}
	}
	delete[]dpUpSeq;
	delete[]dpDownSeq;
}
void Merge_inner(double* t_dpSeq, unsigned long t_ulBegin, unsigned long t_ulEnd)
{
	unsigned long ulMiddle;
	if (t_ulBegin < t_ulEnd)
	{
		ulMiddle = (t_ulBegin + t_ulEnd) / 2;
		Merge_inner(t_dpSeq, t_ulBegin, ulMiddle);
		Merge_inner(t_dpSeq, ulMiddle + 1, t_ulEnd);
		Merge(t_dpSeq, t_ulBegin, ulMiddle, t_ulEnd);
	}
}
void Merge_sort(double* t_dpSeq, unsigned long t_ulSeqLen)
{
	unsigned long ulBegin = 0, ulEnd = t_ulSeqLen - 1;
	Merge_inner(t_dpSeq, ulBegin, ulEnd);
}

// the bubble sort
void Bubble_sort(double* t_dpSeq, unsigned long t_ulSeqLen)
{
	double dTemp;
	for (unsigned long ulTemp = 0; ulTemp < t_ulSeqLen - 1; ulTemp++)
	{
		for (unsigned long ulIndex = t_ulSeqLen - 1; ulIndex > ulTemp; ulIndex--)
		{
			if (t_dpSeq[ulIndex] < t_dpSeq[ulIndex - 1])
			{
				dTemp = t_dpSeq[ulIndex];
				t_dpSeq[ulIndex] = t_dpSeq[ulIndex - 1];
				t_dpSeq[ulIndex - 1] = dTemp;
			}
		}
	}
}
int main()
{
	double dSeq[10] = { 11, 33, 20, 9, 80, 22, 31, 49, 78, 96 };
	unsigned long ulSeqLen = 10;
	//Insertion_sort(dSeq, ulSeqLen);
	//Choose_sort(dSeq, ulSeqLen);
	//Merge_sort(dSeq, ulSeqLen);
	Bubble_sort(dSeq, ulSeqLen);
	for (unsigned long ulTemp = 0; ulTemp < ulSeqLen; ulTemp++)
	{
		cout << dSeq[ulTemp] << " ";
	}
	system("pause");
}