快速排序与堆排序

快速排序：

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

#include <iostream>
using namespace std;

template<typename T>
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; i<n; i++)
	{
		if(array[i]<array[0])
			minArray[mi++] = array[i];
		else if(array[i]==array[0])
			equalArray[me++] = array[i];
		else
			maxArray[ma++] = array[i];
	}
	if(mi>1)
		quickSort<T>(minArray,mi);
	if(ma>1)
		quickSort<T>(maxArray,ma);
	
	int j=0;
	for(int i=0; i<mi; i++)
	{
		array[j++] = minArray[i];
	}
	for(int i=0; i<me; i++)
	{
		array[j++] = equalArray[i];
	}
	for(int i=0; i<ma; i++)
	{
		array[j++] = maxArray[i];
	}

	delete[] minArray;
	delete[] equalArray;
	delete[] maxArray;
}

#include <cstdlib>
#include <ctime>
int main()
{
	int n;
	while(cin>>n)
	{
		double *array = new double[n];
		srand(time(NULL));
		for(int i=0; i<n; i++)
		{
			//cin>>array[i];
			array[i] = rand() % 100;
			cout << array[i] << " ";
		}
		quickSort<double>(array,n);
		
		cout << endl;
		for(int i=0; i<n; i++)
			cout << array[i] << " ";
		
		cout << endl;
		
		delete[] array;
	}
	
	return 0;
}

堆排序：

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

#include <iostream>
#include <cstdlib>
#include <ctime>

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

template<typename T>
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<T>(A[i],A[largest]);
		heapify<T>(A,largest,n);
	}
	
}

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

template<typename T>
void heapSort(T *A, int n)
{
	buildHeap(A,n);  // <----> buildHeap<T>(A,n);
	int size = n;
	for(int i=n; i>=2; i--)
	{
		swapM<T>(A[1],A[i]);   // 总数将根部元素与尾部元素交换
		size -= 1;
		heapify<T>(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<double>(heap,n);
		for(int i=1; i<=n; i++)
			cout << heap[i] << " ";
		cout << endl;
	}
	return 0;
}