排序算法数据结构 Compositor.h

///////////////////////////
//    //
//  排序算法数据结构 Compositor.h     //
//    //
//////////////////////////


#include<iostream.h>


template<class Type>
class Compositor
{
public:
Compositor():sort(NULL){}
void Creat();    //创建排序数组
void Bubble(); //冒泡排序   
void Insert(); //插入排序
//快速排序
void Quick();   
void QSort(int,int);
int Partition(int low,int high);
//归并排序
void Merge(Type SR[],Type TR[],int i,int m,int n);
void Msort(Type SR[],Type TR1[],int s,int t);
   void MergeSort();
//选择排序
void Select();
void Print();   //打印排序后的结果
protected:
Type *sort;
int leng;
};

template<class Type>
void Compositor<Type>::Creat()
{
cout<<"输入你需要排序的数据个数: ";
cin>>leng;
while(leng<=0)
{
cout<<"输入数据有误";
cin>>leng;
}
sort=new Type[leng];
cout<<"请输入各数据项：";
for(int i=0;i<leng;i++)
cin>>sort;
}   


template<class Type>
void Compositor<Type>::Insert()
{
Creat();
Type temp;
   for(int i=1;i<leng;i++)
{
  if(sort<sort[i-1])
  {
  temp=sort;
  for(int j=i-1;temp<sort[j]&&j>=0;j--)
  {
  sort[j+1]=sort[j];
  }
  sort[j+1]=temp;
  }
}
Print();

}

template<class Type>
void Compositor<Type>::Bubble()
{
  Creat();
Type temp;
for(int i=leng-1;i>=0;i--)
{
for(int j=0;j<leng-1;j++)
{
  if(sort[j]>sort[j+1])
  {
  temp=sort[j];
  sort[j]=sort[j+1];
  sort[j+1]=temp;
  }
}
}
Print();
}

template<class Type>
void Compositor<Type>::Quick()
{
Creat();
  QSort(0,leng-1);
Print();
}

template<class Type>
void Compositor<Type>::QSort(int s,int t)
{
if(s<t-1)
{
int pivotloc=Partition(s,t);
QSort(s,pivotloc-1);
QSort(pivotloc+1,t);
}
}

template<class Type>
int Compositor<Type>::Partition(int low,int high)
{
   Type pivotkey=sort[low];
while(low < high)
{
  while(low<high&&sort[high]>=pivotkey)
  --high;
  sort[low++]=sort[high];
  while(low<high&&sort[low]<=pivotkey)
  ++low;
  sort[high--]=sort[low];
}   
sort[low]=pivotkey;
return low;
}

template<class Type>
void Compositor<Type>::MergeSort()
{
Creat();
  Msort(sort,sort,0,leng-1);
Print();
}


template<class Type>
void Compositor<Type>::Msort(Type SR[],Type TR1[],int s,int t)
{
int m;
Type *TR2=new Type[t-s];
if(s==t) TR1[s]=SR[s];
else
{
m=(t+s)/2;
Msort(SR,TR2,s,m);
Msort(SR,TR2,m+1,t);
Merge(TR2,TR1,s,m,t);
}
}

template<class Type>
void Compositor<Type>::Merge(Type SR[],Type TR[],int i,int m,int n)
{
for(int j=m+1,k=i;i<=m&&j<=n;k++)
{
if(SR<=SR[j])
  TR[k]=SR[i++];
else
  TR[k]=SR[j++];
}
while(i<=m)
TR[k++]=SR[i++];
while(j<=n)
TR[k++]=SR[j++];
}


template<class Type>
void Compositor<Type>::Select()
{
Creat();
  Type temp;
int t;
for(int i=0;i<leng;i++)
{
t=i;
for(int j=i+1;j<leng;j++)
{
  if(sort[t]>sort[j])
  t=j;
}
if(t!=i)
{
  temp=sort[t];
  sort[t]=sort;
  sort=temp;
}
}
Print();
}

template<class Type>
void Compositor<Type>::Print()
{
cout<<"排序结果为: ";
for(int i=0;i<leng;i++)
cout<<sort<<" ";
cout<<endl;
}