终于把数据结构课程设计搞定

终于把数据结构课程设计搞定了,也是第一次用MFC 做出了一个比较象样的咚咚,得到老师的充分肯定,心情不错!

赫赫!

贴上排序的类

template <class Elem, class Comp>
class SortClass
{
 public:
 ///**********插入排序**********/
 void inssort(Elem A[],int n)
 {
 for(int i=1;i<n;i++)//插入第i个数据
  for(int j=i;(j>0)&&(Comp::lt(A[j],A[j-1]));j--)
   swap(A,j,j-1);

 }
 ///**********冒泡排序**********/
 void bubsort(Elem A[], int n) { // 冒泡排序
   for (int i=0; i<n-1; i++)     // 起泡第i个记录
  for (int j=n-1; j>i; j--)
    if (Comp::lt(A[j], A[j-1]))
   swap(A, j, j-1);
 }
 ///**********选择排序**********/
 void selsort(Elem A[],int n)
 {
  int lowindex;
  for(int i=0;i<n-1;i++)//select the ith record
  {
   lowindex=i;
   for(int j=n-1;j>i;j--)
    if(Comp::lt(A[j],A[lowindex]))
     lowindex=j;
     if(lowindex!=i)
   swap(A,i,lowindex);
  }

 }
 ///**********希尔排序**********/
 void inssort2(Elem A[],int n,int incr)
 {
  for(int i=incr;i<n;i+=incr)
   for(int j=i;(j>=incr)&&(Comp::lt(A[j],A[j-incr]));j-=incr)
    swap(A,j,j-incr);

 }

 void shellsort(Elem A[],int n)
 {
  for(int i=n/2;i>=1;i/=2)//每个增量
   for(int j=0;j<i;j++)//每个分组冒泡
    inssort2(&A[j],n-j,i);
  
 }
 ///**********快速排序**********/
 int partition(Elem A[],int i,int j,Elem &pivot)
 {
  i--;
  do
  {
   while((i<j)&&Comp::lt(A[++i],pivot));
   while((j>i)&&Comp::gt(A[--j],pivot));
   swap(A,i,j);
  }while(i<j);
  return i;
 }
 void qsort(Elem A[],int i,int j)
 {
 if(j<=i) return;//递规结束
 int pivotindex=(i+j)/2;
 swap(A,pivotindex,j);//put pivot at end
 int k=partition(A,i,j,A[j]);
 swap(A,k,j);
 qsort(A,i,k-1);
 qsort(A,k+1,j);
 }
 ///**********归并排序**********/
 void mergesort(Elem A[],Elem temp[],int left,int right)
 {
  if(left==right)
   return;
  int mid=(left+right)/2;
  mergesort(A,temp,left,mid);
  mergesort(A,temp,mid+1,right);
  for(int i=left;i<=right;i++)
     temp[i]=A[i];
  int l=left,r=mid+1;
  for(int j=left;j<=right;j++)
  {
   if(l>mid)
    A[j]=temp[r++];
   else
   if(r>right)
    A[j]=temp[l++];
   else
   if(Comp::lt(temp[l],temp[r]))
    A[j]=temp[l++];
   else
    A[j]=temp[r++];
  }
   
 }
 ///**********堆 排 序**********/
 void heapsort(Elem A[], int n) {
 Elem mval;
 maxheap<Elem,Comp> H(A, n, n);
 for (int i=0; i<n; i++)      
    H.removemax(mval);
 }
 ///**********基数排序**********/
 void radix(Elem A[], Elem B[],
           int n, int k, int r, int cnt[]) {
 
   int j;
   for (int i=0, rtok=1; i<k; i++, rtok*=r) {
  for (j=0; j<r; j++) cnt[j] = 0;   

  for (j=0; j<n; j++) cnt[(A[j]/rtok)%r]++;

  for (j=1; j<r; j++) cnt[j] = cnt[j-1] + cnt[j];

  for (j=n-1; j>=0; j--) B[--cnt[(A[j]/rtok)%r]] = A[j];

  for (j=0; j<n; j++) A[j] = B[j];   
   }
 }
 ///**********end of sortclass**********/
};