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;
}