在年头怎么都需要这个程序啊
哎！！！
快快————————高手的都来显露一手
[em7]

各位高手帮忙搞搞吧，我也要做同样的设计题目，
怎么在机上子上上比较每种算法所用的时间？

[em1]救命啊，我都是同样的题目啊，救救我吧！！！就要交作业拉！！！ [em10]

这个任务请斑竹来完成  斑竹快来看看

//只有计算交换和比较次数的程序

#include <iostream.h>
#include <malloc.h>
#include <stdlib.h>
#define LS(a,b) ((a)<(b))
#define LL(a,b) ((a)>(b))
#define MAXSIZE 1000
typedef int KeyType;
typedef struct 
{
    int key;
}RedType;
typedef struct
{
    RedType r[MAXSIZE+1];
    int length;
}SqList;
typedef SqList HeapType;
int compare=0;
int change=0;
int Create_Sq(SqList &L)
{
    int i,k;
    cout<<"请输入产生随机数的个数:";
    cin>>k;
    L.length=k;
    for(i=1;i<=k;++i)
    {
        
        L.r[i].key=rand();
    }
    return 1;
}
void Bubble_sort(SqList &L)
{//冒泡排序
    int i,j,l,k=L.length;
    for(i=1;i<=L.length-1;++i)
    {
          for(j=1;j<=k-1;++j)
          {
               ++compare;
               if(LL(L.r[j].key,L.r[j+1].key))
               {
                    l=L.r[j].key;
                    L.r[j].key=L.r[j+1].key;
                    L.r[j+1].key=l;
                    ++change;
                }
          }
          --k;
    }
    cout<<endl<<"-----冒泡排序后的序列-----"<<endl;
    for(i=1;i<=L.length;i++)
      cout<<" "<<L.r[i].key;
    cout<<endl;
    cout<<"冒泡排序的比较次数:";
    cout<<compare<<endl;
    cout<<"冒泡排序的交换次数:";
    cout<<change<<endl;
        compare=0;
    change=0; 
} 
void InsertSort(SqList &L)
{//直接插入排序
    int i,j;
    cout<<endl;
    for(i=2;i<=L.length;++i)
      if(LS(L.r[i].key,L.r[i-1].key))
      {
           ++compare;
           ++change;
           L.r[0]=L.r[i];
           L.r[i]=L.r[i-1];
           for(j=i-2;LS(L.r[0].key,L.r[j].key);--j)
           {
                ++compare;
                L.r[j+1]=L.r[j];
           }
           L.r[j+1]=L.r[0];
      }
    cout<<"-----直接插入排序后的序列-----"<<endl;
    for(i=1;i<=L.length;i++)
      cout<<" "<<L.r[i].key;
    cout<<endl;
    cout<<"直接插入排序的比较次数:";
    cout<<compare<<endl;
    cout<<"直接插入排序的交换次数:";
    cout<<change<<endl;
    compare=0;
    change=0; 
} 
void SelectSort(SqList &L)
{//简单选择排序
    int l,i,j;
    cout<<endl;
    for(i=1;i<L.length;++i)
    {
          L.r[0]=L.r[i];
          j=i+1;
          l=i;
          for(j;j<=L.length;++j)
          {
               ++compare;
               if(LL(L.r[0].key,L.r[j].key))
               {
                    l=j;
                    L.r[0]=L.r[j];
               }
          }
           if(l!=i)
          {
                ++change;
                L.r[l]=L.r[i];
                L.r[i]=L.r[0];
          }
    }

cout<<"-----简单选择排序后的序列-----"<<endl;
    for(i=1;i<=L.length;i++)
    cout<<" "<<L.r[i].key;
    cout<<endl;
    cout<<"简单选择排序的比较次数:";
    cout<<compare<<endl;
    cout<<"简单选择排序的交换次数:";
    cout<<change<<endl;
    compare=0;
    change=0; 
} 
int Partition(SqList &L,int low,int high)
{
    int pivotkey;
    L.r[0]=L.r[low];
    pivotkey=L.r[low].key;
    while(low<high)
    {
          while(low<high&&L.r[high].key>=pivotkey)
          {
               ++compare;
               --high;
          }
          ++change;
          L.r[low]=L.r[high];
          while(low<high&&L.r[low].key<=pivotkey)
          {
               ++compare;
               ++low;
          }
          ++change;
          L.r[high]=L.r[low];
    }
    L.r[low]=L.r[0];
    return low;
} 
void QSort(SqList &L,int low,int high)
{//递归形式的快速排序算法
    int pivotloc;
    if(low<high)
    {
          pivotloc=Partition(L,low,high);
          QSort(L,low,pivotloc-1);
          QSort(L,pivotloc+1,high);
    }
} 
void QuickSort(SqList &L)
{
    int i;
    QSort(L,1,L.length);
    cout<<"-----快速排序后的序列为-----"<<endl;
    for(i=1;i<=L.length;i++)
    cout<<" "<<L.r[i].key;
    cout<<endl;
    cout<<"快速排序的比较次数:";
    cout<<compare<<endl;
    cout<<"快速排序的交换次数:";
    cout<<change<<endl;
    compare=0;
    change=0;
} 
void ShellInsert(SqList &L,int dk)
{//希尔排序
    int i;
    int j;
    for(i=dk+1;i<=L.length;++i)
      if(LS(L.r[i].key,L.r[i-dk].key))
      {
           ++compare;
           L.r[0]=L.r[i];
          for(j=i-dk;j>0&&LS(L.r[0].key,L.r[j].key);j-=dk)
          {
               ++compare;
               ++change;
               L.r[j+dk]=L.r[j];
          }
          L.r[j+dk]=L.r[0];
      }
} 
void ShellSort(SqList &L,int dlta[])
{//希尔排序
    int k,j=L.length/2,t=0;
    while(j>=0)
    {
          ++t;
          j-=2;
    }
    j=L.length/2;
    for(k=0;k<t;++k)
    {//计算每次的增量值
          if(j==0) 
           j=1;//定义最后一趟排序的增量
          dlta[k]=j;
          j-=2;
    }
    for(k=0;k<t;++k)
      ShellInsert(L,dlta[k]);
    cout<<"-----希尔排序后的序列为-----"<<endl;
    for(k=1;k<=L.length;k++)
      cout<<" "<<L.r[k].key;
    cout<<endl;
    cout<<"希尔排序的比较次数:";
    cout<<compare<<endl;
    cout<<"希尔排序的交换次数:";
    cout<<change<<endl;
    compare=0;
    change=0; 
}

void HeapAdjust(HeapType &H,int s,int m)
{//堆排序
    int j;
    RedType rc;
    rc=H.r[s];
    for(j=2*s;j<=m;j*=2)
    {
        if(j<m&&LS(H.r[j].key,H.r[j+1].key))
        {
            ++compare;
            ++j;
        }
        if(!LS(rc.key,H.r[j].key))
        {
            ++compare;
            break;
        }
        H.r[s]=H.r[j];
        s=j;
    }
    H.r[s]=rc;
} 
void HeapSort(HeapType &H)
{
    int i;
    for(i=H.length/2;i>0;--i)
        HeapAdjust(H,i,H.length);
    for(i=H.length;i>1;--i)
    {
        ++change;
        H.r[0]=H.r[1];
        H.r[1]=H.r[i];
        H.r[i]=H.r[0];
        HeapAdjust(H,1,i-1);
    }
    cout<<"-----堆排序后的序列为-----"<<endl;
    for(i=1;i<=H.length;i++)
        cout<<" "<<H.r[i].key;
    cout<<endl;
    cout<<"堆排序的比较次数:";
    cout<<compare<<endl;
    cout<<"堆排序的交换次数:";
    cout<<change<<endl;
    compare=0;
    change=0; 
}  
 
void main()
{
    int i;
    int dlta[MAXSIZE];
    SqList L;
    Create_Sq(L);

    cout<<"-----待排序序列为-----"<<endl;
    for(i=1;i<=L.length;i++)
    cout<<" "<<L.r[i].key;
    
    
        
//冒泡排v序
    SqList L1=L; 
    Bubble_sort(L1);
//直接插入排序
    SqList L2=L;
    InsertSort(L2);
//简单选择排序
    SqList L3=L;
    SelectSort(L3);
//快速排序
    SqList L4=L;
    QuickSort(L4);
//希尔排序
    SqList L5=L;
    ShellSort(L5,dlta);
//堆排序
    SqList L6=L;
    HeapSort(L6);
}

老师给我门提供的 我看都没看 你看看 不知道是不是对的
#include"stdio.h"
#include"stdlib.h"
#define Max 100         //假设文件长度
typedef struct{         //定义记录类型
    int key;            //关键字项
}RecType;
typedef RecType SeqList[Max+1]; //SeqList为顺序表，表中第0个元素作为哨兵
int n;                 //顺序表实际的长度
//==========直接插入排序法======
void InsertSort(SeqList R) {  //对顺序表R中的记录R[1‥n]按递增序进行插入排序
    int i,j;
    for(i=2;i<=n;i++)         //依次插入R[2]，……，R[n]
      if(R[i].key<R[i-1].key){ //若R[i].key大于等于有序区中所有的keys，则R[i]留在原位         R[0]=R[i];j=i-1;      //R[0]是R[i]的副本         do {                  //从右向左在有序区R[1‥i-1]中查找R[i]    的位置             R[j+1]=R[j];      //将关键字大于R[i].key的记录后移             j--;         }while(R[0].key<R[j].key);  //当R[i].key≥R[j].key 是终止
        R[j+1]=R[0];                //R[i]插入到正确的位置上
    }//endif }
//==========冒泡排序======= typedef enum{FALSE,TRUE} Boolean;  //FALSE为0，TRUE为1
void BubbleSort(SeqList R) {  //自下向上扫描对R做冒泡排序
    int i,j;     Boolean exchange;     //交换标志     for(i=1;i<n;i++) {    //最多做n-1趟排序
      exchange=FALSE;     //本趟排序开始前，交换标志应为假
      for(j=n-1;j>=i;j--)           //对当前无序区R[i‥n] 自下向上扫描
        if(R[j+1].key<R[j].key){    //两两比较，满足条件交换记录
          R[0]=R[j+1];              //R[0]不是哨兵，仅做暂存单元
          R[j+1]=R[j];
          R[j]=R[0];
          exchange=TRUE;            //发生了交换，故将交换标志置为真
      }
      if(! exchange) return;        //本趟排序未发生交换，提前终止算法
    }//    endfor（为循环）
}
//==========快速排序=======
//1.========一次划分函数=====
int Partition(SeqList R,int i,int j) {
    // 对R[i‥j]做一次划分，并返回基准记录的位置
    RecType pivot=R[i];       //用第一个记录作为基准
    while(i<j) {              //从区间两端交替向中间扫描，直到i=j
         while(i<j &&R[j].key>=pivot.key)   //基准记录pivot相当与在位置i上
            j--;      //从右向左扫描，查找第一个关键字小于pivot.key的记录R[j]
        if(i<j)       //若找到的R[j].key < pivot.key，则
                R[i++]=R[j];                   //交换R[i]和R[j]，交换后i指针加1
        while(i<j &&R[i].key<=pivot.key)   //基准记录pivot相当与在位置j上
                i++;     //从左向右扫描，查找第一个关键字小于pivot.key的记录R[i]
        if(i<j)      //若找到的R[i].key > pivot.key，则
                R[j--]=R[i];                  //交换R[i]和R[j]，交换后j指针减1
    }
    R[i]=pivot;      //此时，i=j，基准记录已被最后定位
    return i;        //返回基准记录的位置
}
//2.=====快速排序===========
void QuickSort(SeqList R,int low,int high) { //R[low..high]快速排序
    int pivotpos;            //划分后基准记录的位置
    if(low<high) {           //仅当区间长度大于1时才排序
      pivotpos=Partition(R,low,high);  //对R[low..high]做一次划分，得到基准记录的位置
      QuickSort(R,low,pivotpos-1);     //对左区间递归排序
      QuickSort(R,pivotpos+1,high);    //对右区间递归排序
    }
}
//======直接选择排序========
void SelectSort(SeqList R) {
    int i,j,k;
    for(i=1;i<n;i++){         //做第i趟排序（1≤i≤n-1）
    k=i;
        for(j=i+1;j<=n;j++)  //在当前无序区R[i‥n]中选key最小的记录R[k]
               if(R[j].key<R[k].key)
                k=j;         //k记下目前找到的最小关键字所在的位置
        if(k!=i) {           //交换R[i]和R[k]
               R[0]=R[i];R[i]=R[k];R[k]=R[0];
        } //endif
    } //endfor
}
//======堆排序========
//==========大根堆调整函数=======
void Heapify(SeqList R,int low,int high) { 
   // 将R[low..high]调整为大根堆，除R[low]外，其余结点均满足堆性质
    int large;            //large指向调整结点的左、右孩子结点中关键字较大者
    RecType temp=R[low];  //暂存调整结点
    for(large=2*low; large<=high;large*=2){  //R[low]是当前调整结点
      //若large>high,则表示R[low]是叶子，调整结束；否则先令large指向R[low]的左孩子
        if(large<high && R[large].key<R[large+1].key)
                large++; //若R[low]的右孩子存在且关键字大于左兄弟，则令large指向它
        //现在R[large]是调整结点R[low]的左右孩子结点中关键字较大者
    if(temp.key>=R[large].key)  //temp始终对应R[low]
            break;  //当前调整结点不小于其孩子结点的关键字，结束调整
        R[low]=R[large];  //相当于交换了R[low]和R[large]
        low=large;  //令low指向新的调整结点，相当于temp已筛下到large的位置
   }
   R[low]=temp;   //将被调整结点放入最终位置上
}
//==========构造大根堆==========
void BuildHeap(SeqList R) { //将初始文件R[1..n]构造为堆
    int i;
    for(i=n/2;i>0;i--)
    Heapify(R,i,n);      //将R[i..n]调整为大根堆
}

//==========堆排序===========
void HeapSort(SeqList R) {  //对R[1..n]进行堆排序，不妨用R[0]做暂存单元
    int i;
    BuildHeap(R);          //将R[1..n]构造为初始大根堆
    for(i=n;i>1;i--){      //对当前无序区R[1..i]进行堆排序，共做n-1趟。
    R[0]=R[1]; R[1]=R[i];R[i]=R[0];     //将堆顶和堆中最后一个记录交换
        Heapify(R,1,i-1);   //将R[1..i-1]重新调整为堆，仅有R[1]可能违反堆性质。
    }
}
//==========二路归并排序===========
//===将两个有序的子序列R[low..m]和R[m+1..high]归并成有序的序列R[low..high]===
void Merge(SeqList R,int low,int m,int high) { 
    int i=low,j=m+1,p=0; //置初始值
    RecType *R1;         //R1为局部量
    R1=(RecType *)malloc((high-low+1)*sizeof(RecType)); //申请空间
    while(i<=m && j<=high)      //两个子序列非空时取其小者输出到R1[p]上
    R1[p++]=(R[i].key<=R[j].key)? R[i++]:R[j++];
    while(i<=m)                 //若第一个子序列非空，则复制剩余记录到R1
        R1[p++]=R[i++];
    while(j<=high)              //若第二个子序列非空，则复制剩余记录到R1中
    R1[p++]=R[j++];
    for(p=0,i=low;i<=high;p++,i++)
    R[i]=R1[p];             //归并完成后将结果复制回R[low..high]
}
//=========对R[1..n]做一趟归并排序========
void MergePass(SeqList R,int length) { 
    int i;
    for(i=1;i+2*length-1<=n;i=i+2*length)
        Merge(R,i,i+length-1,i+2*length-1); //归并长度为length的两个相邻的子序列
    if(i+length-1<n)              //尚有一个子序列，其中后一个长度小于length
        Merge(R,i,i+length-1,n);  //归并最后两个子序列
        //注意：若i≤n且i+length-1≥n时，则剩余一个子序列轮空，无须归并
}
//========== 自底向上对R[1..n]做二路归并排序===============
void MergeSort(SeqList R) {
    int length;
    for(length=1;length<n;length*=2)     //做[lgn]趟排序
    MergePass(R,length);             //有序长度≥n时终止
}
//==========输入顺序表========
void input_int(SeqList R) {  
    int i;
    printf("Please input num(int):");
    scanf("%d",&n);
    printf("Plase input %d integer:",n);
    for(i=1;i<=n;i++)
    scanf("%d",&R[i].key);
}
//==========输出顺序表========
void output_int(SeqList R) {
    int i;
    for(i=1;i<=n;i++)
    printf("%4d",R[i].key);
}
//==========主函数======
void main() {
    int i;
    SeqList R;
    input_int(R);
    printf("\t******** Select **********\n");
    printf("\t1: Insert Sort\n");
    printf("\t2: Bubble Sort\n");
    printf("\t3: Quick Sort\n");
    printf("\t4: Straight Selection Sort\n");
    printf("\t5: Heap Sort\n");
    printf("\t6: Merge Sort\n");
    printf("\t7: Exit\n");
    printf("\t***************************\n");
    scanf("%d",&i);   //输入整数1-7，选择排序方式
    switch (i){
    case 1: InsertSort(R); break;       //值为1，直接插入排序
        case 2: BubbleSort(R); break;       //值为2，冒泡法排序
    case 3: QuickSort(R,1,n); break;    //值为3，快速排序
        case 4: SelectSort(R); break;       //值为4，直接选择排序
    case 5: HeapSort(R); break;         //值为5，堆排序
        case 6: MergeSort(R); break;        //值为6，归并排序
    case 7: exit(0);                    //值为7，结束程序
    }
    printf("Sort reult:");
    output_int(R);
}

谢谢各位了，我这也有一个，但是好像也还是不行的～～[em14]
// sort.cpp : Defines the entry point for the console application.
//

#include "sort2.h"
# include <stdio.h>
# include <time.h>
#include <stdlib.h>
# define MAXSIZE 2000

typedef struct{
    int key[MAXSIZE];
    int length; 
}list;


long int  compCount;
long int  shiftCount;


void menu(int *m)/*retun m*/
{
    int i;
    char menu[6][15]={"1 CREATE ","2 IMPORT ","3 SORT","4 SHOW RESULT",
                           "5 SAVE RESULT","6 EXIT"};

//    clrscr();
    printf("SORT COMPARE SYSTEM\n");
    for (i=0;i<6;i++) printf("%s\n",menu[i]);
    printf("\n Please Select (1-6):\n");
    
    scanf("%d",m);

}



void menusort(int *m)/*retun m*/
{
    int i;
    char menusort[5][15]={"1 SHELL SORT","2 QUICK SORT","3 HEAP SORT",
                            "4 MERGE SORT","5 ALL SORT"};
    
//    clrscr();
    printf("SORT\n");
    for(i=0;i<5;i++) printf("%s\n",menusort[i]);
    printf("\n Please Select (1-5):\n");
    
    scanf("%d",m);

}


void menushow(int *m)/*retun m*/
{
    int i;
    char menushow[4][20]={"1 SHELL SORT RESULT","2 QUICK SORT RESULT",
                            "3 HEAP SORT RESULT","4 MERGE SORT RESULT"};
    
//    clrscr();
    printf("SHOW SORT RESULT\n");
    for(i=0;i<4;i++) printf("%s\n",menushow[i]);
    printf("\n Please Select (1-4):\n");
    
    scanf("%d",m);

}

void menusave(int *m)
{
    int i;
    char menusave[4][20]={"1 SHELL SORT RESULT","2 QUICK SORT RESULT",
                           "3 HEAP SORT RESULT","4 MERGE SORT RESULT"};
    
//    clrscr();
    printf("SAVE:\n");
    for (i=0;i<4;i++) printf("%s\n",menusave[i]);
    printf("\n Please Select (1-4):\n");
    
    scanf("%d",m);
}

void create(list *L)
{
    int i;
    
    printf("HOW MANY DATA?\n");
    scanf("%d",&((*L).length));
    
    for(i=1;i<=(*L).length;i++)
    {
        printf("\nPLEASE INPUT THE %dth DATA:\n",i);
        scanf("%d",&(*L).key[i]);
    }
    printf("\nCREATE COMPLETE !\n");
        
}


int listopen(list *L,char *filename)
{
    int k=1;
    FILE *data;
    
    data=NULL;


    data=fopen(filename,"rb");
    
    while (! feof(data))
        {
            fscanf(data,"%d",&(*L).key[k]);
            k++;
        }
        (*L).length=k-1;
        return 0;
}

void import(list *L)/*fix L*/
{
    char filename[255];
    int i;

    printf("\nPLEASE INPUT THE FILE PATH AND NAME:\n");
    scanf("%s",filename);

//    clrscr();
    listopen(L,filename);
    for(i=1;i<(*L).length;i++) printf("%d ",(*L).key[i]);
    printf("\nPRESS ANYKEY RETURN TO MAINMENU...\n");
    getchar();
}

void save(list L)
{
    FILE *data;
    char filename[255];
    int r;

    printf("\nPLEASE INPUT THE FILE PATH AND NAME:\n");
    scanf("%s",filename);

    data=fopen(filename,"wb");
    for(r=1;r<=L.length;r++) fprintf(data,"%d\n",L.key[r]);
    fclose(data);
    printf("SAVE OK! \n PRESS ANY KEY TO RETURN THE MAINMENU... ");
    getchar();
        
}


list shellsort(list L)/*retun L_SHELL*/
{
    int i,j,gap,x,n;
    
    compCount=shiftCount=0;
    n=L.length;
    gap=n/2;
    while (gap>0)
    {
        compCount++;
        for(i=gap+1;i<=n;i++)
        {
            compCount++;
            j=i-gap;
            while(j>0)
            {
                compCount++;
                if(L.key[j]>L.key[j+gap])
                {
                    compCount++;
                    x=L.key[j];shiftCount++;
                    L.key[j]=L.key[j+gap];shiftCount++;
                    L.key[j+gap]=x;shiftCount++;
                    j=j-gap;
                }
                else j=0;
            }
                
        }
        gap=gap/2;
    }
    return L;
}

void shell(list L,list *LS,float *timeshell)/*return LS,timeshell.
                                               MUST add an "getch"!!*/
{
    clock_t start,end;
    
        
    start=clock();
    (*LS)=shellsort(L);
    end=clock();
    
    *timeshell=(end-start);//CLK_TCK;
    
    printf("\nSHELLSORT COST TIME :%f SECONDS.",*timeshell);
    printf("Compare %d times.Shfit %d times.\n",compCount,shiftCount); 
}



 


int Partition(list * pL,int low,int high)
{
    int pivotkey;
    pL->key[0]=pL->key[low];shiftCount++;
    pivotkey=pL->key[low];shiftCount++;
    while(low<high)
    {
        compCount++;
        while(low<high && pivotkey<=(pL->key[high])) 
             {compCount++;compCount++; --high;}
        pL->key[low]=pL->key[high];shiftCount++;
        while(low<high && (pL->key[low])<=pivotkey) 
             {compCount++;compCount++; ++low;}
        pL->key[high]=pL->key[low];shiftCount++;
    }
    pL->key[low]=pL->key[0];shiftCount++;
    return low;
}/*Partition*/

void QSort(list * pL,int low,int high)
{
    int pivotloc;
    if(low<high)
    {
        compCount++;
        pivotloc=Partition(pL,low,high);
        QSort(pL,low,pivotloc-1);
    QSort(pL,pivotloc+1,high);
    }
}/*QSort*/

list QuickSort(list pL)
{
    compCount=shiftCount=0;
    QSort(&pL,1,pL.length);
    return pL;
}/*QuickSort*/


void quick(list L,list *LQ,float *timequick)/*MUST add an "getch"!!*/
{
    clock_t start,end;


    start=clock();
    (*LQ)=QuickSort(L);
    end=clock();
    
    *timequick=(end-start);//CLK_TCK;
    
    printf("\nQUICKSORT COST TIME :%f SECONDS.",*timequick);
    printf("Compare %d times.Shfit %d times.\n",compCount,shiftCount); 
}


void sift(list L,int l,int m)
{
    int i,j,x;
    i=l;
    j=2*i;
    x=L.key[i];
    while (j<=m)
    {
        compCount++;
        if(j<m && L.key[j]<L.key[j+1]) {j++;compCount++;compCount++;}
        if(x<L.key[j])
        {
            compCount++;
            L.key[i]=L.key[j];shiftCount++;
            i=j;shiftCount++;
            j=2*i;
        }
        else j=m+1;
    }
    L.key[i]=x;shiftCount++;
}

list heapsort(list L)
{
    int i,w;
    
    compCount=shiftCount=0;
    for (i=L.length/2;i>=1;i--) {sift(L,i,L.length);compCount++;}
    for (i=L.length;i>=2;i--)
    {
        compCount++;
        w=L.key[i];shiftCount++;
        L.key[i]=L.key[1];shiftCount++;
        L.key[1]=w;shiftCount++;
        sift(L,i-1,1);
    }
    return L;
}


void heap(list L,list *LH,float *timeheap)
{
    clock_t start,end;
    
        
    start=clock();
    (*LH)=heapsort(L);
    end=clock();
    
    *timeheap=(end-start);//CLK_TCK;
    
    printf("\nHEAPSORT COST TIME :%f SECONDS.",*timeheap);
    printf("Compare %d times.Shfit %d times.\n",compCount,shiftCount); 
}


 

    
void Merge(int source[],int result[],int size,int n)
{
    int lb1,lb2,ub1,ub2,p,i,j;
    lb1=0;
    p=0;
    while((lb1+size)<n)
    {
        compCount++;
        lb2=lb1+size;
        ub1=lb2-1;
        if((lb2+size-1)>n)
           { ub2=n-1; compCount++; shiftCount++;}
        else
           {ub2=lb2+size-1; compCount++; shiftCount++;}
        i=lb1;
        j=lb2;
        while((i<=ub1)&&(j<=ub2))
            {
                compCount++;compCount++;
                if(source[i]<=source[j])
                    {result[p++]=source[i++]; shiftCount++; compCount++;}
                else
                    {result[p++]=source[j++]; shiftCount++; compCount++;}
            }
        while(i<=ub1)
            {result[p++]=source[i++]; shiftCount++; compCount++;}
        while(j<=ub2)
            {result[p++]=source[j++]; shiftCount++; compCount++;}
        lb1=ub2+1;
    }
    i=lb1;
    while(p<n)
       {compCount++; result[p++]=source[i++];shiftCount++;}
}

void Mergesort(list *L)
{
    int n=(*L).length;
    int s=1;
    int *temp=(int *)malloc(n*sizeof(int));
    compCount=shiftCount=0;
    
    if (temp==NULL)
    {
        printf("out of memory");
        return;
    }
    while(s<n)
    {
    compCount++;
    Merge((*L).key,temp,s,n);
        s*=2;
    Merge(temp,(*L).key,s,n);
        s*=2;
    }
    compCount++;
}


void domerge(list L,list *LM,float *timemerge)/*MUST add an "getch"!!*/
{
    clock_t start,end;


    start=clock();
    Mergesort(&L);
    
    end=clock();
    (*LM)=L;
    *timemerge=(end-start);//CLK_TCK;
    
    printf("\nMERGESORT COST TIME :%f SECONDS.",*timemerge);
    printf("Compare %d times.Shfit %d times.\n",compCount,shiftCount); 
}