你好，這個我以前做過，一下代碼，給你做做參考吧，基本上能滿足，你提出的三點要求，有兩點點不同：1.數據時隨機產生的（產生1000個隨機數），不能手動輸入，這個你可以根據需要修改一下；2.每一次數據排序之后，都可以看到排序的移動，交換次數以及排序的時間，提示：排序的時間與電腦配置，性能和排序算法的有關要是電腦配置，性能好的話，時間太快，可能會出現時間為0 的情況代碼：#define CPP C++ //比較
#define MPP M++ //移動
#define MP2 M+=2
#define MP3 M+=3#include<iostream.h>
#include <string.h>
#include<stdlib.h>
#include <iomanip.h>
#include <math.h>
#include<time.h>//存儲結構（數組）
const int maxsize=1000; //排序表容量，假設為100..
typedef int datatype; //假設存儲元素是整形類型
typedef struct {
datatype key; //關鍵字域
}rectype; //記錄類型
typedef rectype list[maxsize+1]; //排序表類型，0號單元不用； __int64 C,M; //比較和移動次數void checkup(list R,int n) { //檢驗升序排序結果
int i;
for(i=2;i<=n;i++)
if(R[i].key<R[i-1].key) {cout<<"Error!\n";return;}
cout<<"Correct! "<<endl;
}void checkdown(list R,int n) { //檢驗降序排序結果
int i;
for(i=2;i<=n;i++)
if(R[i].key>R[i-1].key) {cout<<"Error!\n";return;}
cout<<"Correct! "<<endl;
}void disp(list R,int n) { //顯示數組中的數據
int i;
for(i=1;i<=n;i++) {
cout<<setw(8)<<R[i].key;
if(i%10==0) cout<<endl;
}
cout<<endl;
}int random1(int num) {return rand();} //0~RAND_MAX=32767int random2(int num) {//素數模乘同余法,0~M
int A=16807; // 16807,39722040,764261123,630360016 48271?
int M=2147483647; //有符號4字節最大素數,2^31-1
int Q=M/A;
int R=M%A;
static int x=1; //seed(set to 1)
int x1;
x1=A*(x%Q)-R*(x/Q);
if(x1>=0) x=x1;
else x=x1+M;
return x;
}
//直接插入排序(有監視哨)
void InsertSort(list R,int n){
int i,j;
for(i=2;i<=n;i++) { //依次插入R[2],R[],R[]... ....R[]
if(CPP,R[i].key>=R[i-1].key) continue; //R[i]插入時剛好是升序序列無需移動
MPP,R[0]=R[i]; //R[0]作為監視哨
j=i-1;
do{
MPP,R[j+1]=R[j]; j--;
}while(CPP,R[0].key<R[j].key);
MPP,R[j+1]=R[0];
}
}//希爾排序(無設置監視哨)
void ShellInsert(list R,int n,int h){ //一趟插入排序，h為本趟增量
int i,j,k;
for(i=1;i<=h;i++) { //i為組號
for(j=i+h;j<=n;j+=h){ //每組從第2個記錄開始插入
if(CPP,R[j].key>=R[j-h].key) continue; //R[j]大于有序區最后一個記錄，則不需要插入
MPP,R[0]=R[j];
k=j-h;
do{ //查找正確的插入位置
MPP,R[k+h]=R[k]; k=k-h; //后移記錄，繼續向前搜索
}while(CPP,k>0 && R[0].key<R[k].key);
MPP,R[k+h]=R[0];
}
}
}//希爾排序(調用若干趟插入排序)
void ShellSort(list R,int n,int d[],int t) {//d[]為增量序列，t為增量序列長度
int i;
for(i=0;i<t;i++) //各趟插入排序
ShellInsert(R,n,d[i]);
}/* 交換排序 */
//上升冒泡排序
void BubbleSort(list R,int n) {
int i,j,flag;
for(i=1;i<n-1;i++){ //做 n-1 趟掃描
flag=0; //直末交換標志
for(j=n;j>=1;j--) //從下往上掃描
if(CPP,R[j].key<R[j-1].key){
flag=1;
MP3,R[0]=R[j]; R[j]=R[j-1]; R[j-1]=R[0];
}
if(!flag) break;
}
}
//下沉冒泡排序
void BubbleSort0(list R,int n) {
int i,j,flag;
for(i=n-1;i>=1;i--){ //做 n-1 趟掃描
flag=0; //直末交換標志
for(j=n;j>=1;j--) //從下往上掃描
if(CPP,R[j].key>R[j-1].key){
flag=1;
MP3,R[0]=R[j]; R[j]=R[j-1]; R[j-1]=R[0];
}
if(!flag) break;
}
}//快速排序
int Partition(list R,int p,int q) { //被無序區R[p]到R[q]劃分，返回劃分后基準的位置
int i,j;
i=p;
j=q;
MPP,R[0]=R[i]; //R[0]作輔助量，存放基準，基準取為無序區第一個記錄
while(i<j) {
while(CPP,R[j].key>=R[0].key && i<j) j--; //從右向左掃描
if(i<j) { MPP,R[i]=R[j]; i++; } //交換 R[i] 和 R[i]
while(CPP,R[i].key<=R[0].key && i<j) i++; //從左向右掃描
if(i<j) { MPP,R[j]=R[i]; j--; } //交換 R[i] 和 R[i]
}
MPP,R[i]=R[0]; //將基準移到最后的正確位置
return i;
}
void QuickSort(list R,int s,int t) { //對R[s]到R[t]快速排序
int i;
if(s>=t) return; //只有一個記錄或無記錄時無需排序
i=Partition(R,s,t); //對R[s]到R[t]做劃分
QuickSort(R,s,i-1); //遞歸處理左區間
QuickSort(R,i+1,t); //遞歸處理右區間
}//直接選擇排序
void SelectSort(list R,int n){
int i,j,k;
for(i=1;i<=n-1;i++){ //n-1趟排序
k=i;
for(j=i+1;j<=n;j++) //在當前無序區中找鍵值最小的記錄R[k]
if(CPP,R[j].key<R[k].key) k=j;
if(k!=i) { MP3,R[0]=R[i]; R[i]=R[k]; R[k]=R[0]; }//交換R[k]和R[i]的值,R[0]坐中間輔助量
}
}

//堆排序
void Sift(list R,int p,int q){//堆范圍為R[p]~R[q],調整R[p]為堆，非遞歸算法
int j;
MPP,R[0]=R[p]; //R[0]作輔助量
j=2*p; //j指向R[p]的左孩子
while(j<=q)
{
if(CPP,j<q && R[j].key<R[j+1].key) j++; //j指向R[p]的右孩子
if(CPP,R[0].key>R[j].key) break; //結點鍵值大于孩子結點，已經是堆，調整結束！
MPP,R[p]=R[j]; //將R[j]換到雙親位置上
p=j; //修改當前被調整結點
j=2*p; //j指向R[p]的左孩子
}
MPP,R[p]=R[0]; //原根結點放入正確位置
}void HeapSort(list R,int n)
{
int i;
for(i=n/2;i>=1;i--) Sift(R,i,n); //建初始堆
for(i=n;i>=2;i--){ //進行n-1趟堆排序
MP3,R[0]=R[1];
R[1]=R[i];
R[i]=R[0]; //R[1]到R[i-1]重建成新堆
Sift(R,1,i-1);
}
}/* 歸并排序 */\//兩個子表合并
void Merge(list R,list R1,int low,int mid,int high){//合并R的兩個子表，結果在R1中
int i,j,k;
i=low; j=mid+1; k=low;
while(i<=mid && j<=high)
if(CPP,R[i].key<=R[j].key) MPP,R1[k++]=R[i++]; //取小者復制
else MPP,R1[k++]=R[j++];
while(i<=mid) MPP,R1[k++]=R[i++]; //復制左子表的剩余記錄
while(j<=high) MPP,R1[k++]=R[j++]; //復制右子表的剩余記錄
}//一趟歸并
void MergePass(list R,list R1,int n,int len){ //對R做一趟歸并，結果在R1中
int i=1,j; //i指向第一對子表的起始點
while(i+2*len-1<=n){ //歸并長度為len的兩個子表
Merge(R,R1,i,i+len-1,i+2*len-1);
i=i+2*len; //i指向下一子表起始點
}
if(i+len-1<=n) //剩下兩個子表，其中一個長度小于 len
Merge(R,R1,i,i+len-1,n);
else for(j=i;j<=n;j++) MPP,R1[j]=R[j];
}//二路歸并
void MergeSort(list R,list R1,int n) { //對R二路歸并排序，結果在R中（非遞歸算法）
int len;
len=1;
while(len<n) {
MergePass(R,R1,n,len); len=len*2; //一趟歸并，結果在R1中
MergePass(R1,R,n,len); len=len*2; //再次歸并結果在R中
}
}void main()
{
rectype *R,*R1,*S; //R1用于歸并排序的輔助存儲，S用于保存初始排序數據
R=new list; if(R==NULL) { cout<<"數組為空!\n";exit(-1); }
R1=new list; if(R1==NULL) { cout<<"數組為空!\n";exit(-1); }
S=new list; if(S==NULL) { cout<<"數組為空!\n";exit(-1); }
int i,n=maxsize;
int choice;
clock_t t1,t2;
for(i=1;i<=n;i++)
S[i].key=random1(n); //生成0-n之間的隨機數
disp(S,n); //輸出0到n之間的隨機數
do {
C=M=0;
for(i=1;i<=n;i++) R[i].key=S[i].key; //取出初始數據用于排序

cout<<"請選擇排序方法(0: 退出): \n\
1：直接插入(帶監視哨) \n\
2: 希爾排序 \n\
3：冒泡(上升) \n\
4：冒泡(下沉） \n\
5：快速排序 (遞歸) \n\
6：直接選擇排序 \n\
7：堆排序(非遞歸) \n\
8：二路歸并(非遞歸) \n";
cin>>choice;
switch(choice) {
case 0:
return;
break;
case 1:
t1=clock();
InsertSort(R,n); //有監視哨的直接插入排序
t2=clock();
checkup(R,n);
break;
case 2:
t1=clock();
int ts; //shell排序
ts=int(log(n)/log(2)-1);
int de[maxsize];
de[0]=int(n/2);
for(i=1;i<ts-1;i++)
de[i]=int(de[i-1]/2);
de[ts-1]=1;
ShellSort(R,n,de,ts);
t2=clock();
checkup(R,n);
break;
case 3:
t1=clock();
BubbleSort(R,n); //上升法冒泡
t2=clock();
checkup(R,n);
break;
case 4:
t1=clock();
BubbleSort0(R,n); //下沉法冒泡
t2=clock();
checkdown(R,n);
break;
case 5:
t1=clock();
QuickSort(R,1,n); //快速排序
t2=clock();
checkup(R,n);
break;
case 6:
t1=clock();
SelectSort(R,n); //直接選擇排序
t2=clock();
checkup(R,n);
break;
case 7:
t1=clock();
HeapSort(R,n); //堆排序，非遞歸
t2=clock();
checkup(R,n);
break;
case 8:
t1=clock();
MergeSort(R,R1,n);
t2=clock();
checkup(R,n);
break;
default:cout<<"輸入錯誤!請重新開始\n";
}
disp(R,n); //顯示排序后的數據
cout<<" C="<<C/1e6<<" M="<<M/1e6<<" C+M="<<(C+M)/1e6;
cout<<" 時間:"<<float(t2-t1)/CLK_TCK<<endl;
} while(choice!=0);
delete R;
delete S; //釋放空間
}演示：

很高興看到你的問題。
但是又很遺憾到現在還沒有人回答你的問題。
對于你的問題我愛莫能助！
可能是你問的問題有些專業了，或者別人沒有遇到或者接觸過你的問題，所以幫不了你。