主流排序算法（C++实现）

这里包含了很多排序算法：冒泡、二分插入排序、快排、归并、堆排

#include <iostream>

template<typename T>
void Sort_Bubble(T * pData, int b, int e)
{
	if(b >= e)
		return;
	int n = e - b + 1;
	pData += b;
	for(int i = n - 1; i > 0; --i)
	{
		for(int j = 0; j < i; ++j)
		{
			if(pData[j] > pData[j + 1])
			{
				pData[j] = pData[j] + pData[j + 1];
				pData[j + 1] = pData[j] - pData[j + 1];
				pData[j] = pData[j] - pData[j + 1];
			}
		}
	}
}

template<typename T>
void Sort_Insert(T * pData, int b, int e)
{
	if(b >= e)
		return;
	int n = e - b + 1;
	pData += b;
	for(int i = 0; i < n; ++i)
	{
		int begin = 0;
		int end = i - 1;
		bool isFind = false;
		while(begin <= end)
		{
			int half = (begin + end) / 2;
			if(pData[half] < pData[i])
				begin = half + 1;
			else if(pData[half] > pData[i])
				end = half - 1;
			else
				isFind = true;
		}
		if(!isFind)
		{
			T temp = pData[i];
			for(int j = i; j > begin; --j)
				pData[j] = pData[j - 1];
			pData[begin] = temp;
		}
	}
}


//快排（选择一个位置上的数，比这个大的放在右边，小的放在左边）
template<typename T>
void Sort_Quick(T * pData, int b, int e)
{	
	if(b >= e)
		return;
	int pos = b;
	for(int i = b + 1; i <= e; ++i)
	{
		if(pData[i] < pData[b])
		{
			++pos;
			//不定义中间变量容易出错，需要加以判断pos是否=i
			if(i != pos)
			{
				pData[pos] = pData[pos] + pData[i];
				pData[i] = pData[pos] - pData[i];
				pData[pos] = pData[pos] - pData[i];
			}
		}
	}
	if(pos != b)
	{
		pData[pos] = pData[pos] + pData[b];
		pData[b] = pData[pos] - pData[b];
		pData[pos] = pData[pos] - pData[b];
	}
	
	Sort_Quick(pData, b, pos - 1);
	Sort_Quick(pData, pos + 1, e);
}

template<typename T>
//void Sort_MergeIn(T * pData, int b, int e)
//{
//	Sort_Merge( pData,  b,  e);
//}
void Sort_Merge(T * pData, int b, int e)
{
	if(b >= e )
		return;
	int half = (b + e) / 2;
	Sort_Merge(pData, b, half);
	Sort_Merge(pData, half + 1, e);
	int n = e - b + 1;
	T * Help = new T[n];
	int pos1 = b;
	int pos2 = half + 1;
	int i = 0;
	for( ; pos1 <= half && pos2 <= e; ++i)
	{
		if(pData[pos1] < pData[pos2])
			Help[i] = pData[pos1++];
		else if(pData[pos1] > pData[pos2])
			Help[i] = pData[pos2++];
		else
		{
			Help[i] = Help[i + 1] = pData[pos1++];
			++pos2;
			++i;
		}
	}
	for( ; pos1 <= half; ++i)
	{
		Help[i] = pData[pos1++];
	}
	for( ; pos2 <= e; ++i)
	{
		Help[i] = pData[pos2++];
	}
	for(int j = 0; j < n; ++j)
	{
		pData[b++] = Help[j];
	}
	delete [] Help;
}

//堆排序
template<typename T>
void HeapAdjust(T * a,int i,int size)  //调整堆 
{
    int lchild = 2 * i;       
    int rchild = 2 * i + 1;     
    int max = i;      
    //如果i是叶节点就不用进行调整 
    if(i <= size/2)          
    {
        if(lchild <= size && a[lchild] > a[max])
        {
            max = lchild;
        }    
        if(rchild <= size && a[rchild] > a[max])
        {
            max = rchild;
        }
        if(max != i)
        {
            T temp = a[max];
			a[max] = a[i];
			a[i] = temp;
            HeapAdjust(a, max, size); 
        }
    }        
}
template<typename T> 
void Sort_Heap(T * pData,int realsize) 
{
	int size = realsize + 1;
	T * a = new T[size];
	a[0] = 0;
	for(int i = 0; i < realsize; ++i)
	{
		a[i + 1] = pData[i];
	}
	
    for(int i = size/2; i >= 1; --i)    
    {
        HeapAdjust<T>(a, i, size);    
    }    
    for(int i = size - 1; i >= 1; --i)
    {
		//交换堆顶和最后一个元素
		T temp = a[1];
		a[1] = a[i];
		a[i] = temp;
		//将余下元素重新建立为大顶堆 
		HeapAdjust<T>(a, 1, i-1); 
    }

	for(int i = 0; i < realsize; ++i)
	{
		pData[i] = a[i + 1];
	}

	delete [] a;
}

void main()
{
	int Array[5] = {3, 2, 7, 6, 4};

	//Sort_Bubble<int>(Array, 2, 4);

	//Sort_Insert<int>(Array, 1, 4);

	//Sort_Quick<int>(Array, 1, 4);

	//Sort_Merge<int>(Array, 1, 4);

	Sort_Heap<int>(Array, 6);
	system("pause");
}