快速排序与堆排序

快速排序：

稳定的排序，总是将首元素当作枢轴元素，将数组进行划分，然后递归调用，时间复杂度
为nlogn;

#include 
using namespace std;

template
void quickSort(T *array, int n)
{
	if(n<=1)
		return;
	
	T *minArray = new T[n];
	T *maxArray= new T[n];
	T *equalArray = new T[n];
	int mi=0,ma=0,me=0;
	for(int i=0; i1)
		quickSort(minArray,mi);
	if(ma>1)
		quickSort(maxArray,ma);
	
	int j=0;
	for(int i=0; i
#include 
int main()
{
	int n;
	while(cin>>n)
	{
		double *array = new double[n];
		srand(time(NULL));
		for(int i=0; i>array[i];
			array[i] = rand() % 100;
			cout << array[i] << " ";
		}
		quickSort(array,n);
		
		cout << endl;
		for(int i=0; i

堆排序：

不是稳定的排序，不适合小样本集，时间复杂度是nlogn;

#include 
#include 
#include 

using namespace std;
template
void swapM(T &a, T &b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

template
void heapify(T *A, int i, int n)
{
	int l = 2*i;   // 左儿子
	int r = 2*i+1; // 右儿子
	int largest;
	if (l <= n && A[l] > A[i] )
		largest = l;
	else
		largest = i;

	if(r <= n && A[r] > A[largest])
		largest = r;
	if( largest != i)
	{
		swapM(A[i],A[largest]);
		heapify(A,largest,n);
	}
	
}

// construct a minimum heap
template
void buildHeap(T *A, int n)
{
	for(int i=n/2; i>=1; i--)  // i>n/2 是叶子节点，不需要调整
		heapify(A,i,n);
}

template
void heapSort(T *A, int n)
{
	buildHeap(A,n);  // <----> buildHeap(A,n);
	int size = n;
	for(int i=n; i>=2; i--)
	{
		swapM(A[1],A[i]);   // 总数将根部元素与尾部元素交换
		size -= 1;
		heapify(A,1,size);  // 从剩余元素中获取最大值到根部
	}
}

int main()
{
	int n;
	while(cin>>n)
	{
		srand(time(NULL));
		double *heap = new double[n+1];
		for(int i=1; i<=n; i++)
			heap[i] = rand()%100;
		for(int i=1; i<=n; i++)
			cout << heap[i] << " ";
		cout << endl;
		
		heapSort(heap,n);
		for(int i=1; i<=n; i++)
			cout << heap[i] << " ";
		cout << endl;
	}
	return 0;
}