快速排序、堆排序、归并排序

#include <iostream>
#include <iterator>
#include <vector>
using namespace std;

// 不重复元素，递归，全排列

// 交换两个元素
inline void swap(char &c1, char &c2)
{
	char ch = c1;
	c1 = c2;
	c2 = ch;
}
// 全排列，考虑了重复元素，递归
void allpailie(char *a, char *p, int n)
{
	if (n == 1)
	{
		cout<<a<<endl;
		return;
	}
	int i;
	for (i=0; i<n; ++i)
	{
#if 1
		int j;
		for (j=0; j<i; ++j)
			if(p[i] == p[j])
				break;
		if (j<i)
			continue;
#endif
		swap(p[0], p[i]);
		allpailie(a,p+1,n-1);
		swap(p[0], p[i]);
	}
}

// 逆序
void reversec(char *p, int a, int b)
{
	int x=a, y =b;
	while(a<b)
	{
		swap(p[a++],p[b--]);
	}
}
// 下一个全排列，迭代版，考虑了重复元素
bool next_permutation(char *p, int n)
{
	if(n<=1)
		return true;

	int i; 
	for (i=n-1; i>0; ) 
	{
		if (p[i] <= p[i-1])
			--i;
		else
			break;
	}

	if (i == 0)
	{
		reversec(p,0,n-1);
		return false;
	}
	{
		int j = i-1;
		int k;
		for (k=n-1;k>j;--k)
			if (p[k]>p[j])
				break;

		swap(p[j], p[k]);
		reversec(p, j+1,n-1);
		
	}
	return true;
} 
int cmp(const void*p1, const void *p2)
{
	return *((char*)p1) > *((char*)p2);
}

template<class T>
void _swap(T&a, T &b)
{
	T tmp;
	tmp = a;
	a = b;
	b = tmp;
}

template<class T>
void _insert_sort(T *p, int a, int b)
{
	int i, j;
	b++;
	for (i=a+1; i<b; ++i)
	{
		T tmp = p[i];
		for (j=i-1; j>=a && tmp<p[j]; j-- )
			p[j+1]=p[j];
		p[j+1] = tmp;

	}
}

template<class T>
void _make_medium(T*p1, T*p2, T*p3)
{
	T*pma, *pmi;
	pma = *p1 > *p2 ? p1 : p2;
	pmi = *p1 < *p2 ? p1 : p2;
	
	pma = *pma > *p3 ? pma : p3;
	pmi = *pma < *p3 ? pma : p3;

	if (p1 == pma)
	{
		swap(*p1, *pma);
	}else if (p1 == pmi)
	{
		swap(*p1, *pmi);
	}
	
}

template<class T>
void _quick_sort(T *p, int a, int b)
{
	if (b-a<=1)
		return;
	if (b-a<8)
	{
		_insert_sort(p,a,b);
		return;
	}

	_make_medium(p,p+((b-a)>>1),p+b);

	size_t a1 = a+1;
	size_t b1 = b;
	T tmp = p[a];

	while(a1<b1)
	{
		while(p[a1] < tmp) ++a1;
		while(p[b1] > tmp) --b1;
		if (a1>=b1)
			break;
		swap(p[a1], p[b1]);
		++a1;
		--b1;
	}
	swap(p[a], p[b1]);
	_quick_sort(p, a, b1-1);
	_quick_sort(p, b1+1, b);

}
///
template<class T>
void adjust_heap(T*p, int b)
{
	size_t t = (b - 1) >> 1;
	while(1)
	{
		size_t t1 = 2*t + 2;
		T *tmp = p + t1 - 1;
		if (t1 <= b && p[t1] < p[t1-1]) 
			tmp = p + t1; 
		if (p[t] > *tmp) 
			swap(p[t], *tmp);
		if (t == 0)
			break;
		t = (t - 1)>>1;
	} 
} 

template<class T> 
void make_heap(T*p, int b) 
{ 
	int t; 
	for (t=b; t>0; t--)
		adjust_heap(p,t);
}

template<class T>
void push_heap(T*p, int b)
{
	int i = 0;
	int x = 2*i+2;
	while (x <= b)
	{
		
		if (p[x] > p[x-1])
			x--;
		if (p[x] < p[i])
		{
			swap(p[x], p[i]);
			i = x;
			x = 2*x + 2;
		}
		else
		{
			break; 
		}
	}
}


template<class T>
void pop_heap(T*p, int b)
{
	swap(p[0], p[b]);
}

template<class T>
void heap_sort(T*p, int b)
{
	int i;
	make_heap(p,b);
//	copy(p,p+b+1,ostream_iterator<int>(cout, " "));
//	cout<<endl;
	for (i=b; i>1;i--)
	{
		pop_heap(p,i);
//		copy(p,p+b+1,ostream_iterator<int>(cout, " "));
//		cout<<endl;
		push_heap(p,i-1);
//		copy(p,p+b+1,ostream_iterator<int>(cout, " "));
//		cout<<endl;
	}
}
template<class T>
void merge_array(T *p, int s, int mid, int e, T*tmp)
{
	T*p1 = p+s;
	T*p1e = p+mid;
	T*p2 = p+mid;
	T*end = p+e+1;
	T*t = tmp;
	while(p1 != p1e && p2 != end)
	{
		if(*p1 < *p2)
			*t++ = *p1++;
		else
			*t++ = *p2++;
	}
	while(p1 != p1e)
	{
		*t++ = *p1++;
	}
	while (p2 != end)
	{
		*t++ = *p2++;
	}
	t = tmp;
	p1 = p+s;
	while(p1 != end)
	{
		*p1++ = *t++;
	}
}

template<class T>
void merge_sort(T *p, int s, int e)
{
	if (e-s<1)
		return;
	if (e-s<=8)
	{
		_insert_sort(p,s,e);
		return;
	}
	T *tmp = new T[e-s+1]; 
	int mid = s+((e-s)>>1);
	merge_sort(p, s, mid-1);
	merge_sort(p, mid, e);
	merge_array(p, s,mid,e,tmp);

	delete []tmp; 
}

int main()
{
	int a[] = {4,12,5,3,2,2,2,123,21,2,24,27,3,45,45,6};
	int n = sizeof(a)/sizeof(a[0]);
	int *b = new int[n];
	copy(a,a+n,b);
	int *c = new int[n];
	copy(a,a+n,c);
	
	// quick
	copy(a,a+n,ostream_iterator<int>(cout, " "));
	cout<<endl;
	_quick_sort(a,0,n-1);
	copy(a,a+n,ostream_iterator<int>(cout, " "));
	cout<<endl;

	//heap
	copy(b,b+n,ostream_iterator<int>(cout, " "));
	cout<<endl;
	heap_sort(b,n-1);
	copy(b,b+n,ostream_iterator<int>(cout, " "));
	cout<<endl;

	//merge
	copy(c,c+n,ostream_iterator<int>(cout, " "));
	cout<<endl;
	merge_sort(c,0,n-1);
	copy(c,c+n,ostream_iterator<int>(cout, " "));
	cout<<endl;
	return 0;
}