数据结构与算法每日一练---排序算法---0x0000

#pragma once

#include <vector>

using namespace std;

class SortFunction
{
public:
	static void CreatRandom(vector<int>& vecData, int nNumber);

	static void BubbleSort(vector<int>& vecData);			// 冒泡排序

	static void SelectionSort(vector<int>& vecData);		// 选择排序

	static void InsertSort(vector<int>& vecData);			// 插入排序

	static void ShellSort(vector<int>& vecData);			// 希尔排序（内部使用了插入排序的方式）

	static void QuikSort(vector<int>& vecData);				// 快速排序

	static void HeapSort(vector<int>& vecData);				// 堆排序

	static void MergeSort(vector<int>& vecData);			// 合并排序

private:
	/**
	 *@brief 快速排序
	 */
	static void QuikSort(vector<int>& vecData, int nStart, int nEnd);

	static int PartSort(vector<int>& vecData, int nStart, int nEnd);

	/**
	 *@brief 堆排序  
	 */
	static void BuildHeap(vector<int>& vecData, int nEndIndex);

	static void BuildNodeHeap(vector<int>& vecData, int nIndex, int nEndIndex);

	/**
	 *@brief 合并排序
	 */
	static void MergeStep(vector<int>& vecSrcData, vector<int>& vecDesData, int nStart, int nMiddle, int nEnd);
	
	static void MergePass(vector<int>& vecSrcData, vector<int>& vecDesData, int nSpace);

	/**
	 *@brief 通用的部分
	 */
	static void Swap(vector<int>& vecData, int nIndexA, int nIndexB);

	static bool IsValueExist(const vector<int>& vecData, int nValue);
};

源文件

#include "SortFunction.h"
#include <ctime>

void SortFunction::CreatRandom(vector<int>& vecData, int nNumber)
{
	srand(static_cast<int>(time(nullptr)));

	vecData.clear();

	int nValue = 0;

	for (int i = 0; i != nNumber; ++i)
	{
		nValue = rand() % 100;
		
		if (IsValueExist(vecData, nValue))
		{
			i--;
		}
		else
		{
			vecData.push_back(nValue);
		}
	}
}

void SortFunction::BubbleSort(vector<int>& vecData)
{
	if (vecData.empty())
		return;

	int nSize = static_cast<int>(vecData.size());

	for (int i = 0; i != nSize - 1; ++i)
	{
		for (int nIndex = nSize - 1; nIndex != i; --nIndex)
		{
			if (vecData[nIndex] < vecData[nIndex - 1])
				Swap(vecData, nIndex - 1, nIndex);
		}
	}
}

void SortFunction::SelectionSort(vector<int>& vecData)
{
	if (vecData.empty())
		return;

	int nSize = static_cast<int>(vecData.size());

	for (int i = 0; i != nSize - 1; ++i)
	{
		int nMinIndex = i;

		for (int nIndex = i; nIndex != nSize; ++nIndex)
		{
			if (vecData[nIndex] < vecData[nMinIndex])
				nMinIndex = nIndex;
		}

		Swap(vecData, i, nMinIndex);
	}
}

void SortFunction::InsertSort(vector<int>& vecData)
{
	if (vecData.empty())
		return;

	int nSize = static_cast<int>(vecData.size());

	for (int i = 1; i != nSize; ++i)
	{
		int nValue = vecData[i];
		int nIndex = i - 1;

		while (nIndex >= 0 && vecData[nIndex] > nValue)
		{
			vecData[nIndex + 1] = vecData[nIndex];
			nIndex--;
		}

		vecData[nIndex + 1] = nValue;
	}
}

void SortFunction::ShellSort(vector<int>& vecData)
{
	if (vecData.empty())
		return;

	int nSize = static_cast<int>(vecData.size());
	int nSpace = nSize / 2;

	while (nSpace >= 1)
	{
		for (int i = nSpace; i != nSize; ++i)
		{
			int nValue = vecData[i];
			int nIndex = i - nSpace;

			while (nIndex >= 0 && vecData[nIndex] > nValue)
			{
				vecData[nIndex + nSpace] = vecData[nIndex];
				nIndex -= nSpace;
			}

			vecData[nIndex + nSpace] = nValue;
		}

		nSpace /= 2;
	}
}

void SortFunction::QuikSort(vector<int>& vecData)
{
	if (vecData.empty())
		return;

	int nSize = static_cast<int>(vecData.size());

	QuikSort(vecData, 0, nSize - 1);
}

void SortFunction::QuikSort(vector<int>& vecData, int nStart, int nEnd)
{
	if (nStart < nEnd)
	{
		int nMiddle = PartSort(vecData, nStart, nEnd);

		QuikSort(vecData, nStart, nMiddle - 1);
		QuikSort(vecData, nMiddle + 1, nEnd);
	}
}

void SortFunction::HeapSort(vector<int>& vecData)
{
	if (vecData.empty())
		return;

	int nSize = static_cast<int>(vecData.size());

	for (int i = 0; i != nSize - 1; ++i)
	{
		BuildHeap(vecData, nSize - i - 1);
		Swap(vecData, 0, nSize - i - 1);
	}
}

int SortFunction::PartSort(vector<int>& vecData, int nStart, int nEnd)
{
	int nValue = vecData[nEnd];
	int nIndex = nStart;

	for (int i = nStart; i != nEnd; ++i)
	{
		if (vecData[i] < nValue)
		{
			Swap(vecData, nIndex, i);
			nIndex++;
		}
	}

	Swap(vecData, nIndex, nEnd);

	return nIndex;
}

void SortFunction::BuildHeap(vector<int>& vecData, int nEndIndex)
{
	for (int i = (nEndIndex - 1) / 2; i >= 0; --i)
		BuildNodeHeap(vecData, i, nEndIndex);
}

void SortFunction::BuildNodeHeap(vector<int>& vecData, int nIndex, int nEndIndex)
{
	int nLeft = (nIndex << 1) + 1;
	int nRight = ((nIndex + 1) << 1);

	int nMaxIndex = nIndex;

	if (nLeft <= nEndIndex && vecData[nLeft] > vecData[nMaxIndex])
		nMaxIndex = nLeft;

	if (nRight <= nEndIndex && vecData[nRight] > vecData[nMaxIndex])
		nMaxIndex = nRight;

	if (nMaxIndex != nIndex)
	{
		Swap(vecData, nIndex, nMaxIndex);
		BuildNodeHeap(vecData, nMaxIndex, nEndIndex);
	}
}

void SortFunction::MergeStep(vector<int>& vecSrcData, vector<int>& vecDesData, int nStart, int nMiddle, int nEnd)
{
	int nIndex = nStart;
	int nSrcFontIndex = nStart;
	int nSrcBackIndex = nMiddle + 1;

	while (nSrcFontIndex <= nMiddle && nSrcBackIndex <= nEnd)
	{
		if (vecSrcData[nSrcFontIndex] < vecSrcData[nSrcBackIndex])
		{
			vecDesData[nIndex++] = vecSrcData[nSrcFontIndex++];
		}
		else
		{
			vecDesData[nIndex++] = vecSrcData[nSrcBackIndex++];
		}
	}

	while (nSrcFontIndex <= nMiddle)
		vecDesData[nIndex++] = vecSrcData[nSrcFontIndex++];

	while (nSrcBackIndex <= nEnd)
		vecDesData[nIndex++] = vecSrcData[nSrcBackIndex++];
}

void SortFunction::MergePass(vector<int>& vecSrcData, vector<int>& vecDesData, int nSpace)
{
	int nSize = static_cast<int>(vecSrcData.size());

	int nStart = 0;
	int nMiddle = 
}

void SortFunction::Swap(vector<int>& vecData, int nIndexA, int nIndexB)
{
	if (nIndexA == nIndexB)
		return;

	int nTemp = vecData[nIndexA];
	vecData[nIndexA] = vecData[nIndexB];
	vecData[nIndexB] = nTemp;
}

bool SortFunction::IsValueExist(const vector<int>& vecData, int nValue)
{
	for (int nTemp : vecData)
	{
		if (nValue == nTemp)
			return true;
	}

	return false;
}