排序

Element.h

template<typename Type>
class Element{
private:
	Type key;
public:
	Type GetKey(){return key;}
	void SetKey(Type item){key = item;}
public:
	Element<Type>& operator =(Element<Type> copy)
	{
		key = copy.key;
		return *this;
	}
	bool operator ==(Element<Type> item){
		return this->key == item.key;
	}
	bool operator !=(Element<Type> item){
		return this->key != item.key;
	}
	bool operator <(Element<Type> item){
		return this->key < item.key;
	}
	bool operator >(Element<Type> item){
		return this->key > item.key;
	}
	bool operator <=(Element<Type> item){
		return this->key <= item.key;
	}
	bool operator >=(Element<Type> item){
		return this->key >= item.key;
	}
};

DataList.h

template<typename Type> class Sort;
template<typename Type> class DataList{
public:
	friend class Sort<Type>;
	DataList(int size = m_nDefaultSize):m_nMaxSize(size),m_ncurrentsize(0){
		m_pvector = new Element<Type>[size];
	}
	DataList(Type *data, int size);
	DataList(Element<Type> *data, int size);
	bool Insert(Type item);
	~DataList(){
		delete[] m_pvector;
	}
	int Size(){
		return this->m_ncurrentsize;
	}
	void Swap(Element<Type> &left, Element<Type> &right){
		Element<Type> temp = left;
		left = right;
		right = temp;
	}
	void Print();
private:
	static const int m_nDefaultSize = 10;
	Element<Type> *m_pvector;
	const int m_nMaxSize;
	int m_ncurrentsize;
};

DataList.cpp

template<typename Type> DataList<Type>::DataList(Type *data, int size)
		:m_nMaxSize(size>m_nDefaultSize?size:m_nDefaultSize),m_ncurrentsize(0){
	m_pvector = new Element<Type>[size];
	for(int i = 0; i < size; i++)
		m_pvector[i].SetKey(data[i]);
	m_ncurrentsize += size;
}

template<typename Type> DataList<Type>::DataList(Element<Type> *data, int size)
		:m_nMaxSize(size>m_nDefaultSize?size:m_nDefaultSize),m_ncurrentsize(0){
	m_pvector = new Element<Type>[size];
	for(int i = 0; i < size; i++)
		m_pvector[i].SetKey(data[i].GetKey());
	m_ncurrentsize += size;
}

template<typename Type> bool DataList<Type>::Insert(Type item){
	if(m_ncurrentsize >= m_nMaxSize){
        cerr << "The list is full!" <<endl;
        return 0;
    }
	m_pvector[m_ncurrentsize++]->Setkey(item);
}

template<typename Type> void DataList<Type>::Print(){
	for(int i = 0; i < m_ncurrentsize; i++)
	{
		cout<<m_pvector[i].GetKey()<<' ';
	}
	cout<<endl;
}

Sort.h

#include "Data.h"
#include "LinkQueue.h"

template<typename Type> class Sort{
public:
	void InsertSort(DataList<Type> &list, int n = -1);
	void BinaryInsertSort(DataList<Type> &list, int n = -1);
	void ShellSort(DataList<Type> &list, int n = -1);
	void BubbleSort(DataList<Type> &list);
	void QuickSort(DataList<Type> &list, int left=0, int right=-1);
	void SelectSort(DataList<Type> &list);
	void HeapSort(DataList<Type> &list);
	void MergeSort(DataList<Type> &list);
	void RadixSort(DataList<int> &list, int m, int d);
private:
    void BubbleSwap(DataList<Type> &list, const int n, int &flag);
    void SelectChange(DataList<Type> &list, const int n);
    void HeapAdjust(DataList<Type> &list, const int start, const int end);
    void Merge(DataList<Type> &list, DataList<Type> &mergedlist, int start, int end);
    void MergeDouble(DataList<Type> &list, DataList<Type> &mergedlist, const int start, const int part, const int end);
};

Sort.cpp

template<typename Type> void Sort<Type>::InsertSort(DataList<Type> &list, int n){
	if (-1 == n){
		for (int i=1; i<list.Size(); i++){
            InsertSort(list, i);
        }
        return;
    }
	Element<Type> temp = list.m_pvector[n];
	int i;
	for(i =n; i >0 ; i--)
	{
		if(temp > list.m_pvector[i-1])
			break;
		else
			list.m_pvector[i] = list.m_pvector[i-1];
	}
	list.m_pvector[i] = temp;
}

template<typename Type> void Sort<Type>::BinaryInsertSort(DataList<Type> &list, int n){
	if(-1 == n)
	{
		for(int i = 1; i < list.Size(); i++)
			BinaryInsertSort(list ,i);
		return ;
	}
	Element<Type> temp = list.m_pvector[n];
	int left = 0, right = n-1;
	while(left <= right)
	{
		int middle = (left + right) / 2;
		if(temp < list.m_pvector[middle])
			right = middle - 1;
		else left = middle + 1;
	}
	for (int i=n-1; i>=left; i--)
        list.m_pvector[i+1] = list.m_pvector[i];
	list.m_pvector[left] = temp;
}

template<typename Type> void Sort<Type>::ShellSort(DataList<Type> &list, const int gap){
	if(-1 == gap){
		int gap = list.Size() / 2;
		while(gap){
			ShellSort(list,gap);
			gap = gap / 2;
		}
		return ;
	}
	int i,j;
	for(i = gap; i < list.Size(); i++)
	{
		Element<Type> temp = list.m_pvector[i];
		if(temp < list.m_pvector[i-gap])
		{
			for(j = i - gap; j >=0 && temp < list.m_pvector[j]; j-=gap)
				list.m_pvector[j+gap] = list.m_pvector[j];
			list.m_pvector[j+gap] = temp;
		}
	}
}

template<typename Type> void Sort<Type>::BubbleSwap(DataList<Type> &list, const int n, int &flag){
	flag = 0;
	for(int i = list.Size() - 1; i >= n; i--)
	{
		if(list.m_pvector[i-1] > list.m_pvector[i])
		{
			list.Swap(list.m_pvector[i-1], list.m_pvector[i]);
			flag = 1;
		}
	}
}

template<typename Type> void Sort<Type>::BubbleSort(DataList<Type> &list){
	int flag = 1, n = 0;
	while(++n < list.Size() && flag)
		BubbleSwap(list, n, flag);
}

template<typename Type> void Sort<Type>::QuickSort(DataList<Type> &list, int left=0, int right=-1){
	if(-1 == right)
		right = list.Size() -1 ;
	int a = left, b = right;
	if(left < right)
	{
		int pos = left;
		Element<Type>temp = list.m_pvector[left];
		while(left < right)
		{
			while(left < right && list.m_pvector[right] >= temp)
				--right;
			list.m_pvector[left] = list.m_pvector[right];
			while(left < right && list.m_pvector[left] <= temp)
				++left;
			list.m_pvector[right] = list.m_pvector[left];
		}
		list.m_pvector[left] = temp;
		QuickSort(list, a, left - 1);
		QuickSort(list, left + 1, b);
	}
}

template<typename Type> void Sort<Type>::SelectChange(DataList<Type> &list, const int n){
	int j = n;
	for(int i = n + 1; i < list.Size(); i++)
	{
		if(list.m_pvector[i] < list.m_pvector[j])
			j = i;
	}
	if(j != n)
		list.Swap(list.m_pvector[n], list.m_pvector[j]);
}

template<typename Type> void Sort<Type>::SelectSort(DataList<Type> &list){
	for(int i = 0; i < list.Size()-1; i++)
		SelectChange(list, i);
}

template<typename Type> void Sort<Type>::HeapAdjust(DataList<Type> &list, const int start, const int end){
	int current = start, child = 2 * current + 1;
	Element<Type> temp = list.m_pvector[start];
	while(child <= end)
	{
		if(child < end && list.m_pvector[child] < list.m_pvector[child+1])
			child++;
		if(temp >= list.m_pvector[child])
			break;
		else
		{
			list.m_pvector[current] = list.m_pvector[child];
			current = child;
			child = 2 * current + 1;
		}
	}
	list.m_pvector[current] = temp;
}

template<typename Type> void Sort<Type>::HeapSort(DataList<Type> &list){
	for(int i = (list.Size()-2)/2; i >= 0; i--)
		HeapAdjust(list, i, list.Size() - 1);
	for(int i = list.Size() - 1; i >= 1; i--)
	{
		list.Swap(list.m_pvector[0], list.m_pvector[i]);
		HeapAdjust(list, 0, i-1);
	}
}

template<typename Type> void Sort<Type>::MergeDouble(DataList<Type> &list, DataList<Type> &mergedlist, int start, int part, int end){
	int j, k;
	for(j = part+1,k=start; start <= part&&j<=end; ++k)
	{
		if(list.m_pvector[start] < list.m_pvector[j])
			mergedlist.m_pvector[k] = list.m_pvector[start++];
		else
			mergedlist.m_pvector[k] = list.m_pvector[j++];
	}
	if(start <= part)
	{
		int i1,i2;
		for(i1=k,i2=start; i1<=end,i2<=part; i1++,i2++)
			mergedlist.m_pvector[i1] = list.m_pvector[i2];
	}
	if(j <= end)
	{
		int i1,i2;
		for(i1=k,i2=j; i1<=end,i2<=end; i1++,i2++)
			mergedlist.m_pvector[i1] = list.m_pvector[i2];
	}
}

template<typename Type> void Sort<Type>::Merge(DataList<Type> &list, DataList<Type> &mergedlist, int start, int end){
	if(start == end)
		mergedlist.m_pvector[start] = list.m_pvector[start];
	else{
		DataList<Type> temp(list.m_pvector,list.m_nMaxSize);
		int m = (start + end) / 2;
		Merge(list, temp, start, m);
		Merge(list, temp, m + 1, end);
		MergeDouble(temp, mergedlist, start, m, end);
	}
}

template<typename Type> void Sort<Type>::MergeSort(DataList<Type> &list){
	Merge(list, list, 0, list.Size() - 1);
}

template<typename Type> void Sort<Type>::RadixSort(DataList<int> &list, int m, int d){
	LinkQueue<int> *queue = new LinkQueue<int>[d];
    int power = 1;
    for (int i=0; i<m; i++){
        if (i){
            power = power * d;
        }
        for (int j=0; j<list.m_ncurrentsize; j++){
            int k = (list.m_pvector[j].GetKey() / power) % d;
            queue[k].Append(list.m_pvector[j].GetKey());
        }

        for (int j=0,k=0; j<d; j++){
            while (!queue[j].IsEmpty()){
                list.m_pvector[k++].SetKey(queue[j].Delete());
            }
        }
    }
}

Test.cpp

#include <iostream>
using namespace std;
#include "Sort.h"

int main(){
    int init[15]={1,3,5,7,4,2,8,0,6,9,29,13,25,11,32};
    DataList<int> data(init, 15);
    Sort<int> sort;
    data.Print();
    cout << endl << endl <<endl;
    sort.InsertSort(data);
    sort.BinaryInsertSort(data);
    sort.ShellSort(data);
    sort.BubbleSort(data);
    sort.QuickSort(data);
    sort.SelectSort(data);
    sort.HeapSort(data);
    sort.MergeSort(data);
    sort.RadixSort(data, 2, 10);
	data.Print();
	
    return 0;
}