数据结构试验报告各种内排序算法的实现及性能比较.docx
《数据结构试验报告各种内排序算法的实现及性能比较.docx》由会员分享,可在线阅读,更多相关《数据结构试验报告各种内排序算法的实现及性能比较.docx(25页珍藏版)》请在冰豆网上搜索。
数据结构试验报告各种内排序算法的实现及性能比较
实验报告
(2010/2011学年第2学期)
课程名称
数据结构——使用C++语言描述
实验名称
各种内排序算法的实现及性能比较
实验时间
2011
年
5
月
27
日
指导单位
计算机科学与技术系
指导教师
学生姓名
班级学号
学院(系)
专业
指导老师
实验类型
设计
实验学时
4
2011.5.27
一.实验目的和要求
内容:
验证教材的各种内排序算法。
分析各种排序算法的时间复杂度。
要求:
使用随机数产生器产生大数据集合,运行上述各种排序算法,使用系统时钟测量各算法所需的实际时间,并进行比较。
二.实验环境(实验设备)
VisualC++6.0
三.实验原理及内容
//selectsort.h
#include//简单选择排序
template
voidSelectSort(TA[],intn)
{
intsmall;
for(inti=0;ismall=i;for(intj=i+1;jif(A[j]Swap(A[i],A[small]);}}Insertsort.h#include//直接插入排序templatevoidInsertSort(TA[],intn){for(inti=1;iintj=i;Ttemp=A[i];while(j>0&&tempA[j]=A[j-1];j--;}A[j]=temp;}}/*ok!*/Bubblesort.h#includetemplatevoidBubbleSort(TA[],intn){inti,j,last;i=n-1;while(i>0){last=0;for(j=0;jif(A[j+1]Swap(A[j],A[j+1]);last=j;}i=last;}}Quicksort.h#include//改进的快速排序templatevoidquick(TA[],intn){int*a;//用数组保存待排序的子序列的上、下界inttop=0,right,left,j;//left和right为待排序a=newint[n];if(a==NULL)return;a[top++]=0;a[top++]=n-1;//以初始序列为待排序序列开始改进的快速排序//lcfor(j=0;a[j]!=NULL;j++)//循环到数组元素为空{left=a[j++];right=a[j];//每次按序从数组中取出两个元素作为待排序序列的上、下界if(left>right)Swap(left,right);//如果下界大于上界,交换上、下界if(right-left<15)InsertSortExt(A,left,right);//若元素较少调用插入排序else{a[top++]=left;a[top++]=QuickSort(A,left,right)-1;a[top++]=a[top-2]+2;a[top++]=right;//否则将低、高端序列上、下界依次保存到数组中}}}templateintQuickSort(TA[],intleft,intright)//用于改进的快速排序的原始快速排序方法{inti,j;if(lefti=left;j=right+1;do{doi++;while(A[i]doj--;while(A[j]>A[left]);if(i}while(iSwap(A[left],A[j]);returnj;}return0;}templatevoidInsertSortExt(TA[],intleft,intright)//用于快速排序的直接插入排序方法{for(inti=left+1;iintj=i;Ttemp=A[i];//待插入元素存入临时变量while(j>0&&tempA[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移}A[j]=temp;//待插入元素存入找到的插入位置}}Mergesort.h#include//两路合并的C++程序templatevoidMerge(TA[],inti1,intj1,inti2,intj2){//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针while(i<=j1&&j<=j2)if(A[i]<=A[j])Temp[k++]=A[i++];elseTemp[k++]=A[j++];while(i<=j1)Temp[k++]=A[i++];while(j<=j2)Temp[k++]=A[j++];for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
small=i;
for(intj=i+1;jif(A[j]Swap(A[i],A[small]);}}Insertsort.h#include//直接插入排序templatevoidInsertSort(TA[],intn){for(inti=1;iintj=i;Ttemp=A[i];while(j>0&&tempA[j]=A[j-1];j--;}A[j]=temp;}}/*ok!*/Bubblesort.h#includetemplatevoidBubbleSort(TA[],intn){inti,j,last;i=n-1;while(i>0){last=0;for(j=0;jif(A[j+1]Swap(A[j],A[j+1]);last=j;}i=last;}}Quicksort.h#include//改进的快速排序templatevoidquick(TA[],intn){int*a;//用数组保存待排序的子序列的上、下界inttop=0,right,left,j;//left和right为待排序a=newint[n];if(a==NULL)return;a[top++]=0;a[top++]=n-1;//以初始序列为待排序序列开始改进的快速排序//lcfor(j=0;a[j]!=NULL;j++)//循环到数组元素为空{left=a[j++];right=a[j];//每次按序从数组中取出两个元素作为待排序序列的上、下界if(left>right)Swap(left,right);//如果下界大于上界,交换上、下界if(right-left<15)InsertSortExt(A,left,right);//若元素较少调用插入排序else{a[top++]=left;a[top++]=QuickSort(A,left,right)-1;a[top++]=a[top-2]+2;a[top++]=right;//否则将低、高端序列上、下界依次保存到数组中}}}templateintQuickSort(TA[],intleft,intright)//用于改进的快速排序的原始快速排序方法{inti,j;if(lefti=left;j=right+1;do{doi++;while(A[i]doj--;while(A[j]>A[left]);if(i}while(iSwap(A[left],A[j]);returnj;}return0;}templatevoidInsertSortExt(TA[],intleft,intright)//用于快速排序的直接插入排序方法{for(inti=left+1;iintj=i;Ttemp=A[i];//待插入元素存入临时变量while(j>0&&tempA[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移}A[j]=temp;//待插入元素存入找到的插入位置}}Mergesort.h#include//两路合并的C++程序templatevoidMerge(TA[],inti1,intj1,inti2,intj2){//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针while(i<=j1&&j<=j2)if(A[i]<=A[j])Temp[k++]=A[i++];elseTemp[k++]=A[j++];while(i<=j1)Temp[k++]=A[i++];while(j<=j2)Temp[k++]=A[j++];for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
if(A[j]Swap(A[i],A[small]);}}Insertsort.h#include//直接插入排序templatevoidInsertSort(TA[],intn){for(inti=1;iintj=i;Ttemp=A[i];while(j>0&&tempA[j]=A[j-1];j--;}A[j]=temp;}}/*ok!*/Bubblesort.h#includetemplatevoidBubbleSort(TA[],intn){inti,j,last;i=n-1;while(i>0){last=0;for(j=0;jif(A[j+1]Swap(A[j],A[j+1]);last=j;}i=last;}}Quicksort.h#include//改进的快速排序templatevoidquick(TA[],intn){int*a;//用数组保存待排序的子序列的上、下界inttop=0,right,left,j;//left和right为待排序a=newint[n];if(a==NULL)return;a[top++]=0;a[top++]=n-1;//以初始序列为待排序序列开始改进的快速排序//lcfor(j=0;a[j]!=NULL;j++)//循环到数组元素为空{left=a[j++];right=a[j];//每次按序从数组中取出两个元素作为待排序序列的上、下界if(left>right)Swap(left,right);//如果下界大于上界,交换上、下界if(right-left<15)InsertSortExt(A,left,right);//若元素较少调用插入排序else{a[top++]=left;a[top++]=QuickSort(A,left,right)-1;a[top++]=a[top-2]+2;a[top++]=right;//否则将低、高端序列上、下界依次保存到数组中}}}templateintQuickSort(TA[],intleft,intright)//用于改进的快速排序的原始快速排序方法{inti,j;if(lefti=left;j=right+1;do{doi++;while(A[i]doj--;while(A[j]>A[left]);if(i}while(iSwap(A[left],A[j]);returnj;}return0;}templatevoidInsertSortExt(TA[],intleft,intright)//用于快速排序的直接插入排序方法{for(inti=left+1;iintj=i;Ttemp=A[i];//待插入元素存入临时变量while(j>0&&tempA[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移}A[j]=temp;//待插入元素存入找到的插入位置}}Mergesort.h#include//两路合并的C++程序templatevoidMerge(TA[],inti1,intj1,inti2,intj2){//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针while(i<=j1&&j<=j2)if(A[i]<=A[j])Temp[k++]=A[i++];elseTemp[k++]=A[j++];while(i<=j1)Temp[k++]=A[i++];while(j<=j2)Temp[k++]=A[j++];for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
Swap(A[i],A[small]);
}
Insertsort.h
#include//直接插入排序
voidInsertSort(TA[],intn)
for(inti=1;iintj=i;Ttemp=A[i];while(j>0&&tempA[j]=A[j-1];j--;}A[j]=temp;}}/*ok!*/Bubblesort.h#includetemplatevoidBubbleSort(TA[],intn){inti,j,last;i=n-1;while(i>0){last=0;for(j=0;jif(A[j+1]Swap(A[j],A[j+1]);last=j;}i=last;}}Quicksort.h#include//改进的快速排序templatevoidquick(TA[],intn){int*a;//用数组保存待排序的子序列的上、下界inttop=0,right,left,j;//left和right为待排序a=newint[n];if(a==NULL)return;a[top++]=0;a[top++]=n-1;//以初始序列为待排序序列开始改进的快速排序//lcfor(j=0;a[j]!=NULL;j++)//循环到数组元素为空{left=a[j++];right=a[j];//每次按序从数组中取出两个元素作为待排序序列的上、下界if(left>right)Swap(left,right);//如果下界大于上界,交换上、下界if(right-left<15)InsertSortExt(A,left,right);//若元素较少调用插入排序else{a[top++]=left;a[top++]=QuickSort(A,left,right)-1;a[top++]=a[top-2]+2;a[top++]=right;//否则将低、高端序列上、下界依次保存到数组中}}}templateintQuickSort(TA[],intleft,intright)//用于改进的快速排序的原始快速排序方法{inti,j;if(lefti=left;j=right+1;do{doi++;while(A[i]doj--;while(A[j]>A[left]);if(i}while(iSwap(A[left],A[j]);returnj;}return0;}templatevoidInsertSortExt(TA[],intleft,intright)//用于快速排序的直接插入排序方法{for(inti=left+1;iintj=i;Ttemp=A[i];//待插入元素存入临时变量while(j>0&&tempA[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移}A[j]=temp;//待插入元素存入找到的插入位置}}Mergesort.h#include//两路合并的C++程序templatevoidMerge(TA[],inti1,intj1,inti2,intj2){//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针while(i<=j1&&j<=j2)if(A[i]<=A[j])Temp[k++]=A[i++];elseTemp[k++]=A[j++];while(i<=j1)Temp[k++]=A[i++];while(j<=j2)Temp[k++]=A[j++];for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
intj=i;
Ttemp=A[i];
while(j>0&&tempA[j]=A[j-1];j--;}A[j]=temp;}}/*ok!*/Bubblesort.h#includetemplatevoidBubbleSort(TA[],intn){inti,j,last;i=n-1;while(i>0){last=0;for(j=0;jif(A[j+1]Swap(A[j],A[j+1]);last=j;}i=last;}}Quicksort.h#include//改进的快速排序templatevoidquick(TA[],intn){int*a;//用数组保存待排序的子序列的上、下界inttop=0,right,left,j;//left和right为待排序a=newint[n];if(a==NULL)return;a[top++]=0;a[top++]=n-1;//以初始序列为待排序序列开始改进的快速排序//lcfor(j=0;a[j]!=NULL;j++)//循环到数组元素为空{left=a[j++];right=a[j];//每次按序从数组中取出两个元素作为待排序序列的上、下界if(left>right)Swap(left,right);//如果下界大于上界,交换上、下界if(right-left<15)InsertSortExt(A,left,right);//若元素较少调用插入排序else{a[top++]=left;a[top++]=QuickSort(A,left,right)-1;a[top++]=a[top-2]+2;a[top++]=right;//否则将低、高端序列上、下界依次保存到数组中}}}templateintQuickSort(TA[],intleft,intright)//用于改进的快速排序的原始快速排序方法{inti,j;if(lefti=left;j=right+1;do{doi++;while(A[i]doj--;while(A[j]>A[left]);if(i}while(iSwap(A[left],A[j]);returnj;}return0;}templatevoidInsertSortExt(TA[],intleft,intright)//用于快速排序的直接插入排序方法{for(inti=left+1;iintj=i;Ttemp=A[i];//待插入元素存入临时变量while(j>0&&tempA[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移}A[j]=temp;//待插入元素存入找到的插入位置}}Mergesort.h#include//两路合并的C++程序templatevoidMerge(TA[],inti1,intj1,inti2,intj2){//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针while(i<=j1&&j<=j2)if(A[i]<=A[j])Temp[k++]=A[i++];elseTemp[k++]=A[j++];while(i<=j1)Temp[k++]=A[i++];while(j<=j2)Temp[k++]=A[j++];for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
A[j]=A[j-1];j--;
A[j]=temp;
}/*ok!
*/
Bubblesort.h
#include
voidBubbleSort(TA[],intn)
inti,j,last;
i=n-1;
while(i>0){
last=0;
for(j=0;j
if(A[j+1]Swap(A[j],A[j+1]);last=j;}i=last;}}Quicksort.h#include//改进的快速排序templatevoidquick(TA[],intn){int*a;//用数组保存待排序的子序列的上、下界inttop=0,right,left,j;//left和right为待排序a=newint[n];if(a==NULL)return;a[top++]=0;a[top++]=n-1;//以初始序列为待排序序列开始改进的快速排序//lcfor(j=0;a[j]!=NULL;j++)//循环到数组元素为空{left=a[j++];right=a[j];//每次按序从数组中取出两个元素作为待排序序列的上、下界if(left>right)Swap(left,right);//如果下界大于上界,交换上、下界if(right-left<15)InsertSortExt(A,left,right);//若元素较少调用插入排序else{a[top++]=left;a[top++]=QuickSort(A,left,right)-1;a[top++]=a[top-2]+2;a[top++]=right;//否则将低、高端序列上、下界依次保存到数组中}}}templateintQuickSort(TA[],intleft,intright)//用于改进的快速排序的原始快速排序方法{inti,j;if(lefti=left;j=right+1;do{doi++;while(A[i]doj--;while(A[j]>A[left]);if(i}while(iSwap(A[left],A[j]);returnj;}return0;}templatevoidInsertSortExt(TA[],intleft,intright)//用于快速排序的直接插入排序方法{for(inti=left+1;iintj=i;Ttemp=A[i];//待插入元素存入临时变量while(j>0&&tempA[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移}A[j]=temp;//待插入元素存入找到的插入位置}}Mergesort.h#include//两路合并的C++程序templatevoidMerge(TA[],inti1,intj1,inti2,intj2){//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针while(i<=j1&&j<=j2)if(A[i]<=A[j])Temp[k++]=A[i++];elseTemp[k++]=A[j++];while(i<=j1)Temp[k++]=A[i++];while(j<=j2)Temp[k++]=A[j++];for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
Swap(A[j],A[j+1]);
last=j;
i=last;
Quicksort.h
//改进的快速排序
voidquick(TA[],intn)
int*a;//用数组保存待排序的子序列的上、下界
inttop=0,right,left,j;//left和right为待排序
a=newint[n];
if(a==NULL)return;
a[top++]=0;
a[top++]=n-1;//以初始序列为待排序序列开始改进的快速排序
//lc
for(j=0;a[j]!
=NULL;j++)//循环到数组元素为空
left=a[j++];
right=a[j];//每次按序从数组中取出两个元素作为待排序序列的上、下界
if(left>right)
Swap(left,right);//如果下界大于上界,交换上、下界
if(right-left<15)
InsertSortExt(A,left,right);//若元素较少调用插入排序
else
a[top++]=left;
a[top++]=QuickSort(A,left,right)-1;
a[top++]=a[top-2]+2;
a[top++]=right;//否则将低、高端序列上、下界依次保存到数组中
intQuickSort(TA[],intleft,intright)//用于改进的快速排序的原始快速排序方法
inti,j;
if(lefti=left;j=right+1;do{doi++;while(A[i]doj--;while(A[j]>A[left]);if(i}while(iSwap(A[left],A[j]);returnj;}return0;}templatevoidInsertSortExt(TA[],intleft,intright)//用于快速排序的直接插入排序方法{for(inti=left+1;iintj=i;Ttemp=A[i];//待插入元素存入临时变量while(j>0&&tempA[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移}A[j]=temp;//待插入元素存入找到的插入位置}}Mergesort.h#include//两路合并的C++程序templatevoidMerge(TA[],inti1,intj1,inti2,intj2){//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针while(i<=j1&&j<=j2)if(A[i]<=A[j])Temp[k++]=A[i++];elseTemp[k++]=A[j++];while(i<=j1)Temp[k++]=A[i++];while(j<=j2)Temp[k++]=A[j++];for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
i=left;j=right+1;
do{
doi++;while(A[i]doj--;while(A[j]>A[left]);if(i}while(iSwap(A[left],A[j]);returnj;}return0;}templatevoidInsertSortExt(TA[],intleft,intright)//用于快速排序的直接插入排序方法{for(inti=left+1;iintj=i;Ttemp=A[i];//待插入元素存入临时变量while(j>0&&tempA[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移}A[j]=temp;//待插入元素存入找到的插入位置}}Mergesort.h#include//两路合并的C++程序templatevoidMerge(TA[],inti1,intj1,inti2,intj2){//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针while(i<=j1&&j<=j2)if(A[i]<=A[j])Temp[k++]=A[i++];elseTemp[k++]=A[j++];while(i<=j1)Temp[k++]=A[i++];while(j<=j2)Temp[k++]=A[j++];for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
doj--;while(A[j]>A[left]);
if(i}while(iSwap(A[left],A[j]);returnj;}return0;}templatevoidInsertSortExt(TA[],intleft,intright)//用于快速排序的直接插入排序方法{for(inti=left+1;iintj=i;Ttemp=A[i];//待插入元素存入临时变量while(j>0&&tempA[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移}A[j]=temp;//待插入元素存入找到的插入位置}}Mergesort.h#include//两路合并的C++程序templatevoidMerge(TA[],inti1,intj1,inti2,intj2){//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针while(i<=j1&&j<=j2)if(A[i]<=A[j])Temp[k++]=A[i++];elseTemp[k++]=A[j++];while(i<=j1)Temp[k++]=A[i++];while(j<=j2)Temp[k++]=A[j++];for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
}while(iSwap(A[left],A[j]);returnj;}return0;}templatevoidInsertSortExt(TA[],intleft,intright)//用于快速排序的直接插入排序方法{for(inti=left+1;iintj=i;Ttemp=A[i];//待插入元素存入临时变量while(j>0&&tempA[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移}A[j]=temp;//待插入元素存入找到的插入位置}}Mergesort.h#include//两路合并的C++程序templatevoidMerge(TA[],inti1,intj1,inti2,intj2){//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针while(i<=j1&&j<=j2)if(A[i]<=A[j])Temp[k++]=A[i++];elseTemp[k++]=A[j++];while(i<=j1)Temp[k++]=A[i++];while(j<=j2)Temp[k++]=A[j++];for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
Swap(A[left],A[j]);
returnj;
return0;
voidInsertSortExt(TA[],intleft,intright)//用于快速排序的直接插入排序方法
for(inti=left+1;iintj=i;Ttemp=A[i];//待插入元素存入临时变量while(j>0&&tempA[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移}A[j]=temp;//待插入元素存入找到的插入位置}}Mergesort.h#include//两路合并的C++程序templatevoidMerge(TA[],inti1,intj1,inti2,intj2){//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针while(i<=j1&&j<=j2)if(A[i]<=A[j])Temp[k++]=A[i++];elseTemp[k++]=A[j++];while(i<=j1)Temp[k++]=A[i++];while(j<=j2)Temp[k++]=A[j++];for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
Ttemp=A[i];//待插入元素存入临时变量
while(j>0&&tempA[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移}A[j]=temp;//待插入元素存入找到的插入位置}}Mergesort.h#include//两路合并的C++程序templatevoidMerge(TA[],inti1,intj1,inti2,intj2){//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针while(i<=j1&&j<=j2)if(A[i]<=A[j])Temp[k++]=A[i++];elseTemp[k++]=A[j++];while(i<=j1)Temp[k++]=A[i++];while(j<=j2)Temp[k++]=A[j++];for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
A[j]=A[j-1];j--;//A[j-1]元素后移,j指针前移
A[j]=temp;//待插入元素存入找到的插入位置
Mergesort.h
//两路合并的C++程序
voidMerge(TA[],inti1,intj1,inti2,intj2)
{//i1,j1是子序列1的下、上界,i1,j2是子序列2的下、上界
T*Temp=newT[j2-i1+1];//分配能存放两个子序列的临时数组
inti=i1,j=i2,k=0;//i,j是两个子序列的游动指针,k是Temp的游动指针
while(i<=j1&&j<=j2)
if(A[i]<=A[j])Temp[k++]=A[i++];
elseTemp[k++]=A[j++];
while(i<=j1)Temp[k++]=A[i++];
while(j<=j2)Temp[k++]=A[j++];
for(i=0;idelete[]Temp;} //合并排序的C++程序templatevoidMergeSort(TA[],intn){inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界intsize=1;//子序列中元素个数,初始化为1。while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
delete[]Temp;
//合并排序的C++程序
voidMergeSort(TA[],intn)
inti1,j1,i2,j2;//i1,j1是子序列1的下、上界,i2,j2是子序列2的下、上界
intsize=1;//子序列中元素个数,初始化为1。
while(sizei1=0;while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
i1=0;
while(i1+sizei2=i1+size;j1=i2-1;if(i2+size-1>n-1)j2=n-1;elsej2=i2+size-1;Merge(A,i1,j1,i2,j2);i1=j2+1;}size*=2;}}Heapsort.h#include//AdjustDown函数templatevoidAdjustDown(TA[],intr,intj){intchild=2*r+1;Ttemp=A[r];while(child<=j){if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
i2=i1+size;
j1=i2-1;
if(i2+size-1>n-1)
j2=n-1;
elsej2=i2+size-1;
Merge(A,i1,j1,i2,j2);
i1=j2+1;
size*=2;
Heapsort.h
//AdjustDown函数
voidAdjustDown(TA[],intr,intj)
intchild=2*r+1;Ttemp=A[r];
while(child<=j){
if((childif(temp>=A[child])break;A[(child-1)/2]=A[child];child=2*child+1;}A[(child-1)/2]=temp;}//堆排序的C++程序templatevoidHeapSort(TA[],intn){for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆for(i=n-1;i>0;i--){Swap(A[0],A[i]);AdjustDown(A,0,i-1);}}Meau.h#include#include#include#include#include"selectsort.h"#include"insertsort.h"#include"bubblesort.h"#include"quicksort.h"#include"mergesort.h"#include"heapsort.h"#defineSIZE400#defineTIMES1000templateclassMenu{public:voidprintmenu();voidselectsort();//简单选择排序voidinsertSort();//直接插入排序voidbubbleSort();//冒泡排序voidquickSort();//快速排序voidmergeSort();//两路合并排序voidheapSort();//堆排序voidchildmenu();//子菜单1voidchildmenu2();//子菜单2voidswitcha();private:inta,b,c;};templatevoidMenu::printmenu(){cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
if(temp>=A[child])break;
A[(child-1)/2]=A[child];
child=2*child+1;
A[(child-1)/2]=temp;
//堆排序的C++程序
voidHeapSort(TA[],intn)
for(inti=(n-2)/2;i>-1;i--)AdjustDown(A,i,n-1);//构造最大堆
for(i=n-1;i>0;i--){
Swap(A[0],A[i]);
AdjustDown(A,0,i-1);
Meau.h
#include"selectsort.h"
#include"insertsort.h"
#include"bubblesort.h"
#include"quicksort.h"
#include"mergesort.h"
#include"heapsort.h"
#defineSIZE400
#defineTIMES1000
classMenu
public:
voidprintmenu();
voidselectsort();//简单选择排序
voidinsertSort();//直接插入排序
voidbubbleSort();//冒泡排序
voidquickSort();//快速排序
voidmergeSort();//两路合并排序
voidheapSort();//堆排序
voidchildmenu();//子菜单1
voidchildmenu2();//子菜单2
voidswitcha();
private:
inta,b,c;
};
voidMenu:
:
printmenu()
cout<<"--------------------------------------------------------"<cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"内排序测试系统"<cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"--------------------------------------------------------"<cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"1.简单选择排序"<cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"2.直接插入排序"<cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"3.冒泡排序"<cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"4.快速排序"<cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"5.两路合并排序"<cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"6.堆排序"<cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"7.退出"<cout<<"PS:测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"PS:
测试用的数组元素为"<this->switcha();}templatevoidMenu::childmenu(){cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
this->switcha();
childmenu()
cout<<"--------------------------------------------------------"<cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"1.最好情况"<cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"2.最坏情况"<cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"3.平均情况"<cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"4.返回主菜单"<cin>>b;if(b==4)this->printmenu();}templatevoidMenu::childmenu2(){cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cin>>b;
if(b==4)this->printmenu();
childmenu2()
cout<<"--------------------------------------------------------"<cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"1.原始算法"<cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"2.改进算法"<cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"3.返回主菜单"<cin>>c;if(c==3)this->printmenu();}templatevoidMenu::switcha(){//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cin>>c;
if(c==3)this->printmenu();
switcha()
//cout<<"ok"<cin>>a;switch(a){case1:this->selectsort();break;//okcase2:this->insertSort();break;//okcase3:this->bubbleSort();break;//okcase4:this->quickSort();break;//okcase5:this->mergeSort();break;//okcase6:this->heapSort();break;//okcase7:exit(1);break;default:cout<<"error"<printmenu();break;}};templatevoidprintout(TA[],intn)//打印数组,测试时用{for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cin>>a;
switch(a)
case1:
this->selectsort();break;//ok
case2:
this->insertSort();break;//ok
case3:
this->bubbleSort();break;//ok
case4:
this->quickSort();break;//ok
case5:
this->mergeSort();break;//ok
case6:
this->heapSort();break;//ok
case7:
exit
(1);break;
default:
cout<<"error"<printmenu();break;
voidprintout(TA[],intn)//打印数组,测试时用
for(inti=0;icout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<}templateT*producedate(intx)//产生顺序,逆序,随机的数组{inti;T*A=newT[SIZE];switch(x){case1:for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
T*producedate(intx)//产生顺序,逆序,随机的数组
inti;
T*A=newT[SIZE];
switch(x)
for(i=0;ibreak;case2:for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序break;case3:srand(time(NULL));for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
break;
for(i=SIZE;i>0;i--)A[i-1]=SIZE-i;returnA;//逆序
srand(time(NULL));
for(i=0;ibreak;default:cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"error"<}}templatevoidSwap(T&a,T&b)//交换2个元素{Ttemp=a;a=b;b=temp;}templatevoidMenu::bubbleSort(){cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
voidSwap(T&a,T&b)//交换2个元素
Ttemp=a;
a=b;
b=temp;
bubbleSort()
cout<<"冒泡排序"<this->childmenu();T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
this->childmenu();
T*A;
doubleduration;
clock_tstart,finish;
start=clock();
cout<<"ok"<for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
for(inti=0;i{A=producedate(b);BubbleSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
A=producedate(b);
BubbleSort(A,SIZE);
delete[]A;
finish=clock();
duration=(double)(finish-start)/CLOCKS_PER_SEC;
//printout(A,SIZE);
cout<<"用时:
"<system("pause");//delete[]A;this->bubbleSort();}/*ok*/templatevoidMenu::heapSort(){cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
system("pause");
//delete[]A;
this->bubbleSort();
}/*ok*/
heapSort()
cout<<"堆排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"ok"<for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
for(inti=0;i{A=producedate(3);HeapSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
A=producedate(3);
HeapSort(A,SIZE);
"<system("pause");this->printmenu();}templatevoidMenu::insertSort(){cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
this->printmenu();
insertSort()
cout<<"直接插入排序"<this->childmenu();T*A;doubleduration;//A=producedate(b);//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}//printout(A,SIZE);clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
//A=producedate(b);
//if(A==NULL){cout<<"error";delete[]A;this->insertSort();}
cout<<"ok"<for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
for(inti=0;i{A=producedate(b);InsertSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
InsertSort(A,SIZE);
"<system("pause");//delete[]A;this->insertSort();}templatevoidMenu::mergeSort(){//this->childmenu();cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
this->insertSort();
mergeSort()
//this->childmenu();
cout<<"合并排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"ok"<for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
for(inti=0;i{A=producedate(3);MergeSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
MergeSort(A,SIZE);
"<system("pause");//delete[]A;this->printmenu();}/*ok*/templatevoidMenu::quickSort(){this->childmenu2();T*A;doubleduration;clock_tstart,finish;if(c==1){cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
quickSort()
this->childmenu2();
if(c==1)
cout<<"原始快速排序"<cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"直接用随机数据测试"<start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"ok"<for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
for(inti=0;i{A=producedate(3);QuickSort2(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
QuickSort2(A,SIZE);
"<system("pause");this->quickSort();}elseif(c==2){cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
system("pause");this->quickSort();
elseif(c==2)
cout<<"改进的快速排序"<cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"直接用随机数据测试"</*A=producedate(3);printout(A,SIZE);quick(A,SIZE);printout(A,SIZE);delete[]A;this->printmenu();*///T*A;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
/*A=producedate(3);
printout(A,SIZE);
quick(A,SIZE);
//T*A;
cout<<"ok"<for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
for(inti=0;i{A=producedate(3);quick(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;cout<<"用时:"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
"<system("pause");this->quickSort();}else{cout<<"error"<printmenu();}}templatevoidMenu::selectsort(){//this->childmenu();cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
this->quickSort();
else{cout<<"error"<printmenu();}
selectsort()
cout<<"简单选择排序"<cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"直接用随机数据测试"<T*A;doubleduration;clock_tstart,finish;start=clock();cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
cout<<"ok"<for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
for(inti=0;i{A=producedate(3);SelectSort(A,SIZE);delete[]A;}finish=clock();duration=(double)(finish-start)/CLOCKS_PER_SEC;//printout(A,SIZE);cout<<"用时:"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
SelectSort(A,SIZE);
"<system("pause");//delete[]A;this->printmenu();}/*ok!*/Mymain.cpp#include"Menu.h"intmain(){MenuMenuObj;MenuObj.printmenu();
/*ok!
Mymain.cpp
#include"Menu.h"
intmain()
MenuMenuObj;
MenuObj.printmenu();
copyright@ 2008-2022 冰豆网网站版权所有
经营许可证编号:鄂ICP备2022015515号-1