常用的一些排序方法

//选择排序
template<class T>
void SelectSort(T *pData,size_t size,bool IsUp=true)
{
	T swap;
	if (IsUp)
	{
		for (size_t i = 0; i < size - 1; ++i)
		{
			for (size_t j = i + 1; j < size; ++j)
			{
				if (pData[i]>pData[j])
				{
					swap = pData[i];
					pData[i] = pData[j];
					pData[j] = swap;
				}
			}
		}
	}
	else
	{
		for (size_t i = 0; i < size - 1; ++i)
		{
			for (size_t j = i + 1; j < size; ++j)
			{
				if (pData[i]<pData[j])
				{
					swap = pData[i];
					pData[i] = pData[j];
					pData[j] = swap;
				}
			}
		}
	}

}

//冒泡法排序
template<class T>
void PopSort(T *pData, size_t size, bool IsUp = true)
{
	T swap;
	if (IsUp)
	{
		for (size_t i = size-1; i >=1; --i)
		{
			for (size_t j = 0; j < i; ++j)
			{
				if (pData[j] > pData[j+1])
				{
					swap = pData[j];
					pData[j] = pData[j+1];
					pData[j+1] = swap;
				}
			}
		}
	}
	else
	{
		for (size_t i = size - 1; i >= 1; --i)
		{
			for (size_t j = 0; j < i; ++j)
			{
				if (pData[j] < pData[j + 1])
				{
					swap = pData[j];
					pData[j] = pData[j + 1];
					pData[j + 1] = swap;
				}
			}
		}
	}

}

//插入排序
template<class T>
void InsertSort(T *pData, size_t size, bool IsUp = true)
{
	T swap;
	if (IsUp)
	{
		for (size_t i = 1; i < size;++i)
		{
			for (size_t j = i; j >0; --j)
			{
				if (pData[j] < pData[j - 1])
				{
					swap = pData[j];
					pData[j] = pData[j - 1];
					pData[j - 1] = swap;
				}
				else
				{
					break;
				}
			}
		}
	}
	else
	{
		for (size_t i = 1; i < size; ++i)
		{
			for (size_t j = i; j >0; --j)
			{
				if (pData[j] > pData[j - 1])
				{
					swap = pData[j];
					pData[j] = pData[j - 1];
					pData[j - 1] = swap;
				}
				else
				{
					break;
				}
			}
		}
	}

}

//希尔排序
template<class T>
void ShellSort(T *pData, size_t count, bool IsUp = true)
{
	int step = count / 2;
	T temp;
	if (IsUp)
	{
		while (step)
		{
			for (int i = step; i < count; ++i)
			{
				temp = pData[i];
				int j = i;
				for (; j >= step; j -= step)
				{
					if (temp < pData[j - step])
					{
						pData[j] = pData[j - step];
					}
					else
					{
						break;
					}
				}
				pData[j] = temp;
			}
			step /= 2;
		}
	}
	else
	{
		while (step)
		{
			for (int i = step; i < count; ++i)
			{
				temp = pData[i];
				int j = i;
				for (; j >= step; j -= step)
				{
					if (temp > pData[j - step])
					{
						pData[j] = pData[j - step];
					}
					else
					{
						break;
					}
				}
				pData[j] = temp;
			}
			step /= 2;
		}
	}
}

//快速排序
void _QuickSort(T *pData, int low, int high, bool IsUp = true)
{
	if (low >=high)
	{
		return;
	}
	int first = low;
	int last = high;
	T Key = pData[first];
	if (IsUp)
	{
		while (first < last)
		{
			while (first < last)
			{
				if (pData[last] < Key)
				{
					pData[first] = pData[last];
					break;
				}
				else
				{
					--last;
				}
			}
			while (first < last)
			{
				if (pData[first] > Key)
				{
					pData[last] = pData[first];
					break;
				}
				else
				{
					++first;
				}
			}
		}
	}
	else
	{
		while (first < last)
		{
			while (first < last)
			{
				if (pData[last] > Key)
				{
					pData[first] = pData[last];
					break;
				}
				else
				{
					--last;
				}
			}
			while (first < last)
			{
				if (pData[first] < Key)
				{
					pData[last] = pData[first];
					break;
				}
				else
				{
					++first;
				}
			}
		}
	}

	pData[first] = Key;
	_QuickSort(pData, low, first - 1,IsUp);
	_QuickSort(pData, first + 1, high,IsUp);
}
void QuickSort(T *pData, size_t count, bool IsUp = true)
{
	_QuickSort(pData, 0, count - 1, IsUp);
}

//归并排序
void MergeSort(T *pData, size_t count, bool IsUp = true)
{
	if (count > 1)
	{
		int fsize = count / 2;
		int bsize = count - fsize;

		T *pNewFData = new T[fsize];
		T *pNewBData = new T[bsize];

		memcpy(pNewFData, pData, sizeof(T)*fsize);
		memcpy(pNewBData, pData+fsize, sizeof(T)*bsize);

		MergeSort(pNewFData, fsize, IsUp);
		MergeSort(pNewBData, bsize, IsUp);

		int dataindex=0;
		int findex = 0;
		int bindex = 0;

		if (IsUp)
		{
			while ((findex < fsize) && (bindex <bsize))
			{
				if (pNewFData[findex] > pNewBData[bindex])
				{
					pData[dataindex++] = pNewBData[bindex++];
				}
				else
				{
					pData[dataindex++] = pNewFData[findex++];
				}
			}
		}
		else
		{
			while ((findex < fsize) && (bindex <bsize))
			{
				if (pNewFData[findex] < pNewBData[bindex])
				{
					pData[dataindex++] = pNewBData[bindex++];
				}
				else
				{
					pData[dataindex++] = pNewFData[findex++];
				}
			}
		}

		while ((findex < fsize))
		{
			pData[dataindex++] = pNewFData[findex++];
		}

		while ((bindex <bsize))
		{
			pData[dataindex++] = pNewBData[bindex++];
		}

		SAFE_DELARR(pNewFData);
		SAFE_DELARR(pNewBData);
	}
}

//非递归的归并排序
void MergeSort2(T *pData, size_t count, bool IsUp = true)
{
	T *pTempData = new T[count];
	int BigBlockSize = 2;

	while (BigBlockSize < count * 2)
	{
		int SmallBlockSize = BigBlockSize / 2;

		for (int i = 0; i < count;i += BigBlockSize)
		{
			int findex = i;
			int findeEnd = (i + SmallBlockSize < count) ? (i + SmallBlockSize) : count;
			int bindex = i + SmallBlockSize;
			int bindexEnd = (bindex + SmallBlockSize < count) ? bindex + SmallBlockSize : count;
			int dataindex = i;

			while ((findex < findeEnd) && (bindex < bindexEnd))
			{
				if (pData[findex]>pData[bindex])
				{
					pTempData[dataindex++] = pData[bindex++];
				}
				else
				{
					pTempData[dataindex++] = pData[findex++];
				}
			}

			while (findex<findeEnd)
			{
				pTempData[dataindex++] = pData[findex++];
			}

			while (bindex < bindexEnd)
			{
				pTempData[dataindex++] = pData[bindex++];
			}
		}
		memcpy(pData, pTempData, size_t(T)*pTempData);
		BigBlockSize *= 2;
	}
	SAFE_DELARR(pTempData);
}

//非递归的快速排序（用栈实现）
#include <vector>
using namespace std;
struct Range
{
	int first, last;
};
template<class T>
void QuickSort2(T *pData, size_t count, bool IsUp = true)
{
	vector<T> v;
	Range r,r1;
	r.first = 0;
	r.last = count - 1;
	v.push_back(r);
	int first, last;
	T Key;
	while (!v.empty())
	{
		r = v.back();
		v.pop_back();
		first = r.first;
		last = r.last;
		Key = pData[first];
		while (first < last)
		{
			while (first < last)
			{
				if (pData[last]<Key)
				{
					pData[first]=pData[last];
					break;
				}
				else
				{
					--last;
				}
			}
			while (first < last)
			{
				if (pData[first] > Key)
				{
					pData[last] = pData[first];
					break;
				}
				else
				{
					++first;
				}
			}
		}
		pData[first] = Key;

		if (first-1 > r1.first)
		{
			r1.first = r.first;
			r1.last = first-1;
			v.push_back(r1);
		}

		if (first +1 < r1.last)
		{
			r1.first = first+1;
			r1.last = r.last;
			v.push_back(r1);
		}
	}
}

//基数排序（桶排序）

#ifndef SAFE_DELARR
#define SAFE_DELARR(p){if(p){delete[] p;p=nullptr;}}
#endif

void RadixSort(T *pData, size_t count, size_t databit,bool IsUp = true)
{
	T *Tong[10];//指针数组
	int TongNum[10];
	int baserate = 1;
	int insertnum;
	int datongindex;
	for (int i = 0; i < 10;++i)
	{
		Tong[i]=new T[count];
	}
	for (int time = 0; time < databit;++time)
	{
		memset(TongNum, 0, sizeof(TongNum));//数组在sizeof里表示的是数组大小

		for (int i = 0; i < count;++i)
		{
			//先找到个位数是多少
			insertnum =(pData[i] / baserate) % 10;
			//把这个数放入对应的桶里
			Tong[insertnum][TongNum[insertnum]++]=pData[i];
		}

		datongindex = 0;

		if (IsUp)
		{
			for (int t = 0; t < 10; ++t)//从0号桶开始倒
			{
				for (int daonum = 0; daonum < TongNum[t]; ++daonum)
				{
					pData[datongindex] = Tong[t][daonum];
				}
			}
		}
		else
		{
			for (int t = 9; t >=0; --t)//从9号桶开始倒
			{
				for (int daonum = 0; daonum < TongNum[t]; ++daonum)
				{
					pData[datongindex] = Tong[t][daonum];
				}
			}
		}

		baserate *= 10;
	}
	for (int i = 0; i < 10; ++i)
	{
		SAFE_DELARR(Tong[i]);
	}
}