Ⅰ c語言排序演算法
#include<stdio.h>
#defineN100000//定義最多輸入的數據
intsort(int*a,intn){
inti,j,m;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(a[i]>a[j]){
m=a[i];a[i]=a[j];a[j]=m;
}
return0;
}
intmain(){
inta[N];
inti=0,n,ii;
while(1){
//printf("輸入n ");
scanf("%d",&n);
a[i++]=n;
if(n==0)break;
ii=i;
for(;i<n+ii;i++)
scanf("%d",&a[i]);
}
i=0;
while(a[i]!=0){
sort(a+i+1,a[i]);
for(n=1;n<=a[i];n++)
printf("%d",a[i+n]);
printf(" ");
i=i+a[i]+1;
}
}
Ⅱ c語言三種排序
常用的c語言排序演算法主要有三種即冒泡法排序、選擇法排序、插入法排序。
一、冒泡排序冒泡排序：
是從第一個數開始，依次往後比較，在滿足判斷條件下進行交換。代碼實現（以降序排序為例）
#include<stdio.h>
int main()
{
int array[10] = { 6,9,7,8,5,3,4,0,1,2 };
int temp;
for (int i = 0; i < 10; i++)
{//循環次數
for (int j = 0; j <10 - i-1; j++)
{
if (array[j] < array[j+1])
{//前面一個數比後面的數大時發生交換 temp = array[j];
array[j] = array[j+1];
array[j + 1] = temp;
}
}
} //列印數組 for (int i = 0; i < 10; i++) printf("%2d", array[i]); return 0;}}
二、選擇排序以升序排序為例：
就是在指定下標的數組元素往後（指定下標的元素往往是從第一個元素開始，然後依次往後），找出除指定下標元素外的值與指定元素進行對比，滿足條件就進行交換。與冒泡排序的區別可以理解為冒泡排序是相鄰的兩個值對比，而選擇排序是遍歷數組，找出數組元素與指定的數組元素進行對比。（以升序為例）
#include<stdio.h>
int main()
{
int array[10] = { 6,9,7,8,5,3,4,0,1,2 };
int temp, index;
for (int i = 0; i < 9; i++) {
index = i;
for (int j = i; j < 10; j++)
{
if (array[j] < array[index])
index = j;
}
if(i != index)
{
temp = array[i];
array[i] = array[index];
array[index] = temp;
}
for(int i=0;i<10:i++)
printf("%2d"array[i]）
return 0；
}
三、快速排序
是通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
void QuickSort(int* arr, int size)
{
int temp, i, j;
for(i = 1; i <size; i++)
for(j=i; j>0; j--)
{
if(arr[j] <arr[j-1])
{
temp = arr[j];
arr[j]=arr[j-1];
arr[j-1]=temp;
}
}
}
Ⅲ 數據結構排序演算法（C描述）
看看可以不#include<stdio.h>#include<stdlib.h> #define TRUE 1#define FALSE 0#define OK 1#define ERROR#define OVERFLOW -2#define MAXSIZE 20 //一個用作示例的小順序表的最大長度#define LT(a,b) ((a)<(b))#define LQ(a,b) ((a)<=(b)) typedef int KeyType;//定義關鍵字類型為整數類型typedef int InfoType;typedef struct{ KeyType key;//關鍵字項 InfoType otherinfo;//其他數據項}RedType;//記錄類型typedef struct{ RedType r[MAXSIZE+1];//r[0]閑置或用作哨兵單元 int length;//順序表長度}SqList;//順序表類型 int InitList_Sq(SqList &L){//構造一個空的順序表L。 int i; printf("請輸入待排序的記錄的個數："); scanf("%d",&L.length); printf("請輸入待排序的記錄的關鍵字（整型數）："); for(i=1;i<=L.length;i++) scanf("%d",&L.r[i]); return OK;} void Print_Sq(SqList &L) //輸出{ int i; for(i=1;i<=L.length;i++) { printf("%4d",L.r[i]); } printf("\n");} //------------插入排序---void InsertSort(SqList &L){//對順序表L作直接插入排序。 int i,j; for(i=2;i<=L.length;++i) if(LT(L.r[i].key,L.r[i-1].key))//「<」，需將L.r[i]插入有序子表 { L.r[0]=L.r[i];//復制為哨兵 L.r[i]=L.r[i-1]; for(j=i-2;LT(L.r[0].key,L.r[j].key);--j) L.r[j+1]=L.r[j];//記錄後移 L.r[j+1]=L.r[0];//插入到正確位置 }}//--------------冒泡排序---void BubbleSort(SqList &L){//L.r是待排序的文件，採用自下向上掃描，對L.r做冒泡排序 int i,j; int exchange; // 交換標志 for(i=1;i<L.length;i++) {// 最多做 n-1 趟排序 exchange=FALSE; // 本趟排序開始前，交換標志應為假 for(j=L.length-1;j>=i;j--) // 對當前無序區 R[i..n] 自下向上掃描 if(LT(L.r[j+1].key,L.r[j].key)) { // 交換記錄 L.r[0]=L.r[j+1]; //L.r[0]不是哨兵，僅做暫存單元 L.r[j+1]=L.r[j]; L.r[j]=L.r[0]; exchange=TRUE; // 發生了交換，故將交換標志置為真 } if(!exchange) // 本趟排序未發生交換，提前終止演算法 return; } }//-----------快速排序---int Partition(SqList &L,int low,int high){//交換順序表L中子表r[low..high]的記錄，樞軸記錄到位，並返回其所在位置，此時 //在它之前（後）的記錄均不大（小）於它。 KeyType pivotkey; L.r[0]=L.r[low];//用子表的第一個記錄作樞軸記錄 pivotkey=L.r[low].key;//樞軸記錄關鍵字 while(low<high) {//從表的兩端交替地向中間掃描 while (low<high&&L.r[high].key>=pivotkey) --high; L.r[low]=L.r[high];//將比樞軸記錄小的記錄移到低端 while (low<high&&L.r[low].key<=pivotkey) ++low; L.r[high]=L.r[low];//將比樞軸記錄大的記錄移到高端 } L.r[low]=L.r[0];//樞軸記錄到位 return low;//返回樞軸位置} void QSort(SqList &L,int low,int high){//對順序表L中的子序列L.r[low..high]進行快速排序 int pivotloc; if(low<high) {//長度大於1 pivotloc=Partition(L,low,high);//將L.r[low..high]一分為二 QSort(L,low,pivotloc-1);//對低子表遞歸排序pivotloc是樞軸位置 QSort(L,pivotloc+1,high);//對高子表遞歸排序 }} void QuickSort(SqList &L){//對順序表L作快速排序。 QSort(L,1,L.length);}//----------歸並排序---void Merge(RedType SR[],RedType TR[],int i,int m,int n){//將有序的SR[i..m]和SR[m+1..n]歸並為有序的TR[i..n] int j,k; for(j=m+1,k=i;i<=m&&j<=n;++k) {//將SR中記錄由小到大地並入TR if LQ(SR[i].key,SR[j].key) TR[k]=SR[i++]; else TR[k]=SR[j++]; } if(i<=m)//TR[k..n]=SR[i..m];將剩餘的SR[i..m]復制到TR while(k<=n&&i<=m) TR[k++]=SR[i++]; if(j<=n)//將剩餘的SR[j..n]復制到TR while(k<=n&&j<=n) TR[k++]=SR[j++];} void MSort(RedType SR[],RedType TR1[],int s,int t){//將SR[s..t]歸並排序為TR1[s..t]。 int m; RedType TR2[20]; if(s==t) TR1[t] = SR[s]; else { m=(s+t)/2;//將SR[s..t]平分為SR[s..m]和SR[m+1..t] MSort(SR,TR2,s,m);//遞歸地將SR[s..m]歸並為有序的TR2[s..m] MSort(SR,TR2,m+1,t);//將SR[m+1..t]歸並為有序的TR2[m+1..t] Merge(TR2,TR1,s,m,t);//將TR2[s..m]和TR2[m+1..t]歸並到TR1[s..t] }} void MergeSort(SqList &L){// 對順序表L作歸並排序。 MSort(L.r, L.r, 1, L.length);}//-----------堆排序---void HeapAdjust(SqList &H,int s,int m){//已知H.r[s..m]中記錄的關鍵字除H.r[s].key之外均滿足堆的定義， //本函數調整H.r[s]的關鍵字，使H.r[s..m]成為一個大頂堆 //（對其中記錄的關鍵字而言） int j; RedType rc; rc=H.r[s]; for(j=2*s;j<=m;j*=2) {//沿key較大的孩子結點向下篩選 if(j<m&&H.r[j].key<H.r[j+1].key) ++j;//j為key較大的記錄的下標 if(rc.key>=H.r[j].key) break;//rc應插入在位置s上 H.r[s]=H.r[j]; s=j; } H.r[s]=rc;//插入} void HeapSort(SqList &H){//對順序表H進行堆排序。 int i; RedType temp; for(i=H.length/2;i>0;--i)//把H.r[1..H.length]建成大頂堆 HeapAdjust(H,i,H.length); for(i=H.length;i>1;--i) { temp=H.r[i]; H.r[i]=H.r[1]; H.r[1]=temp;//將堆頂記錄和當前未經排序子序列Hr[1..i]中 //最後一個記錄相互交換 HeapAdjust(H,1,i-1);//將H.r[1..i-1]重新調整為大頂堆 }} void main(){ SqList S; printf("---------- 五種排序演算法 ----------\n"); InitList_Sq(S); printf(" 1.簡單插入排序\n"); InsertSort(S); Print_Sq(S); printf(" 2.冒泡排序\n"); BubbleSort(S); Print_Sq(S); printf(" 3.快速排序\n"); QuickSort(S); Print_Sq(S); printf(" 4.歸並排序\n"); MergeSort(S); Print_Sq(S); printf(" 5.堆排序\n"); HeapSort(S); Print_Sq(S);}
Ⅳ 數據結構C語言——實現各種排序演算法，一定要c語言
你也太貪了....這全寫一遍得累死我....
Ⅳ C語言排序演算法一共多少種
選擇排序
#include<iostream>
usingnamespacestd;
voidselect_sort(intarr[],intnum);
voidoutput_array(intarr[],intnum);
intmain()
{
inta[10];
for(inti=0;i<10;i++)
{
cin>>a[i];
}
select_sort(a,10);
output_array(a,10);
return0;
}
voidselect_sort(intarray[],intn)//形參array是數組名
{
inti,j,k,t;
for(i=0;i<n-1;i++)
{
k=i;//先設第i個就為最小
for(j=i+1;j<n;j++)
if(array[j]<array[k])
k=j;//通過循環，得到k為最小
t=array[k];//交換a[i]和a[k]
array[k]=array[i];
array[i]=t;
}
return;
}
voidoutput_array(intarr[],intnum)
{
inti;
for(i=0;i<num;i++)
{
cout<<arr[i];
cout<<endl;
}
return;
}
2.冒泡排序
#include<stdio.h>
intmain()
{
inti,j,a[10],t;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for(i=0;i<10;i++)
for(j=i+1;j<10;j++)
if(a[i]>a[j])
{
t=a[j];
a[j]=a[i];
a[i]=t;
}
for(i=0;i<10;i++)
printf("%d",a[i]);
return0;
}
3.堆排序
#include<iostream>
usingnamespacestd;
voidpaii(inta[20],inti,intm)
{
intk,t;
t=a[i];
k=2*i+1;
while(k<m)
{
if((k<m-1)&&(a[k]<a[k+1]))
k++;
if(t<a[k])
{
a[i]=a[k];
i=k;
k=2*i+1;
}
elsebreak;
}
a[i]=t;
}
voidipai(inta[20],intn)
{
inti,k;
for(i=n/2-1;i>=0;i--)
paii(a,i,n);
for(i=n-1;i>=1;i--)
{
k=a[0];
a[0]=a[i];
a[i]=k;
paii(a,0,i);
}}
intmain()
{
inta[10],i;
for(i=0;i<10;i++)
cin>>a[i];
ipai(a,10);
for(i=0;i<10;i++)
cout<<a[i]<<endl;
}
4.快速排序
#include<iostream>
usingnamespacestd;
voidQuicksort(inta[],intlow,inthigh)
{
if(low>=high)
{
return;
}
intfirst=low;
intlast=high;
intkey=a[first];
while(first<last)
{
while(first<last&&a[last]>=key)
--last;
a[first]=a[last];
while(first<last&&a[first]<=key)
++first;
a[last]=a[first];
}
a[first]=key;
Quicksort(a,low,first-1);
Quicksort(a,last+1,high);
}
intmain()
{
inti,a[100],x,n=0;
while(cin>>x)
{
a[n]=x;
n++;
}
n--;
Quicksort(a,0,n);
for(i=0;i<=n;i++)
cout<<a[i]<<"";
cout<<endl;
return0;
}
5. 基數排序
#include<stdio.h>
#include<stdlib.h>
intmain(){
intdata[10]={73,22,93,43,55,14,82,65,39,81};//對十個數進行排序
inttemp[10][10]={0};//構造一個臨時二維數組，其值為0
intorder[10]={0};//構造一維數組，其值為0
inti,j,k,n,lsd;
k=0;n=1;
for(i=0;i<10;i++)printf("%d",data[i]);//在排序前，對這10個數列印一遍
putchar(' ');
while(n<=10){
for(i=0;i<10;i++){
lsd=((data[i]/n)%10);//lsd先對個位取余，然後再對十位取余，注意循環
temp[lsd][order[lsd]]=data[i];//temp[3][0]=73,temp[2][0]=22,temp[3][1]=93,temp[3][2]=43,⋯⋯
order[lsd]++;//需要區分的是lsd和order[lsd]，這兩個不是一樣的概念嗷
}
printf(" 重新排列:");
for(i=0;i<10;i++){
if(order[i]!=0)
for(j=0;j<order[i];j++){
data[k]=temp[i][j];
printf("%d",data[k]);
k++;
}
order[i]=0;
}
n*=10;//第二次用十位
k=0;
}
putchar(' ');
printf(" 排序後:");
for(i=0;i<10;i++)printf("%d",data[i]);
return0;
}
6.希爾排序
#include<iostream>
usingnamespacestd;
voidshell_sort(inta[],intn);
intmain()
{
intn,a[10000];
cin>>n;
for(inty=0;y<n;y++)
cin>>a[y];
shell_sort(a,n);
for(inti=0;i<n;i++)
cout<<a[i]<<"";
cout<<endl;
}
voidshell_sort(inta[],intn)
{
intgap,k,temp;//定義增量；
for(gap=3;gap>0;gap--)//設置初始增量，遞減；
{
for(inti=0;i<gap;i++)//按增量分組；
{
for(intj=i+gap;j<n;j=j+gap)//每組分別比較大小；
{
if(a[j]<a[j-gap])
{
temp=a[j];
k=j-gap;
while(k>=0&&a[k]>temp)
{
a[k+gap]=a[k];
k=k-gap;
}
a[k+gap]=temp;
}
}
}
}
}
7.歸並排序
#include<iostream>
usingnamespacestd;
voidMergeSort(intp[],ints,intm,intt)
{
intq[100];//q[100]用來存放排好的序列
inti=s;
intj=m+1;
intk=s;
while(i<=m&&j<=t)
{
if(p[i]<=p[j])
q[k++]=p[i++];
else
q[k++]=p[j++];
}
if(i<=m)
while(i<=m)
q[k++]=p[i++];
elsewhile(j<=t)
q[k++]=p[j++];
for(intn=s;n<=t;n++)
p[n]=q[n];
}
voidMerge(intp[],ints,intt)
{
if(s<t)
{
intm=(s+t)/2;//將數組分成兩半
Merge(p,s,m);//遞歸拆分左數組
Merge(p,m+1,t);//遞歸拆分右數組
MergeSort(p,s,m,t);//合並數組
}
}
intmain()
{
intn;
intp[100];
cin>>n;
for(inti=0;i<n;i++)
cin>>p[i];
Merge(p,0,n-1);
for(intj=0;j<n;j++)
cout<<p[j]<<"";
cout<<endl;
return0;
}
排序方法基本就這些，還有雙向冒泡這種拓展的排序方法，還有直接排序如桶排序
Ⅵ 冒泡排序演算法 C語言的
#include<stdio.h>
int main()
{
int n;
while(scanf("%d",&n),n)//n個數
{
int i,j,t,s[105];
for(i=0;i<n;i++)//輸入n個數
scanf("%d",s+i);
for(i=0;i<n;i++)//排序
for(j=i+1;j<n;j++)
if(s[i]<s[j])
{
t=s[i];
s[i]=s[j];
s[j]=t;
}
for(i=0;i<n;i++)//輸出
printf("%d ",s[i]);
puts("");
}
}
Ⅶ 快速排序演算法c語言
quick明顯有問題，1.存在死循環2.使用遞歸是想實現什麼？
如果想實現快速排序的話可以參考一下程序段，盡量精簡交換操作增加排序速度:
voidquick(int*arr,intlen)
{
inti,j,k,z;
for(i=0;i<len-1;i++)
{
for(j=0,k=0;j<len-i-1;j++)
{
if(arr[k]<arr[j+1])
k=j+1;
}
if(k!=len-i-1)
{
z=arr[len-i-1];
arr[len-i-1]=arr[k];
arr[k]=z;
}
}
}
Ⅷ C語言，排序演算法
對數組中的10個元數前幾個進行排序，安從小到大的順序。設n=5
如：10個元數是1，9，8，7，5
i=1時。temp=v[1]=9；j=0 v[j]=v[0]=1；不符合循環條件，不做；
i=2時。temp=v[2]=8；j=1 v[j]=v[1]=9；符合循環條件，做循環體；
v[1]=8；v[2]=9；這時數組為1，8，9，7，5
i=3時。temp=v[3]=7，j=2 v[j]=v[2]=9；符號循環條件。做循環體
v[1]=7,v[2]=8,v[3]=9。數組為1，7，8，9，5。
i=4時。做法是一樣的
最後結果為1，5，7，8，9
不知道對不對，我是這么認為的
Ⅸ C語言，快速排序演算法
0和N-1表示的是數組下標。快排每一趟排序的目的是使值比設定的key值小的數都排到數組前部分，大的都排到後部分；然後對這兩部分用新的關鍵值key分別重復上一步的操作；遞歸，直到數組有序。
其中關鍵值key=a[low]。
用題目給定的數組模擬第一趟排序如下：
下標0123456789
值91647824661232551
low=0high=9
part_element=a[low]=9
進入for循環
進入第一個while
part_element<51，於是high--,high=8;
part_element<25，high--,high=7;
part_element>3,不滿足，結束while
a[low]=a[0]=a[high]=a[7]=3,low++,low=1;
進入第二個while
part_element<16,不滿足，結束while
a[high]=a[7]=a[low]=a[1]=16,high--,high=6
for第一個循環結束，數組如下
316478246612162551
low=1,high=6
for第二個循環同上，結束時數組如下
344782476612162551
low=2,high=3
for第三個循環，第一個while中high--以後，low==high，直接break跳出for循環，此時
344782476612162551
low=2,high=2
結束for以後
a[high]=a[2]=part_element=9,得到
34982476612162551
split函數returnhigh=2
quicksort函數中middle=2;
下面兩句遞歸，仍然是調用split函數，對數組
0-2,3-9兩部分分別重復上述操作
最後直到數組數據有序
Ⅹ 數據結構C語言——實現各種排序演算法
剛做完的
#include <iostream>
using namespace std;
void BiInsertsort(int r[], int n) //插入排序（折半）
{
for(int i=2;i<=n;i++)
{
if (r[i]<r[i-1])
{
r[0] = r[i]; //設置哨兵
int low=1,high=i-1; //折半查找
while (low<=high)
{
int mid=(low+high)/2;
if (r[0]<r[mid]) high=mid-1;
else low = mid+1;
}
int j;
for (j=i-1;j>high;j--) r[j+1] = r[j]; //後移
r[j+1] = r[0];
}
}
for(int k=1;k<=n;k++) cout<<r[k]<<" ";
cout<<"\n";
}
void ShellSort ( int r[], int n) //希爾排序
{
for(int d=n/2;d>=1;d=d/2) //以d為增量進行直接插入排序
{
for (int i=d+1;i<=n;i++)
{
r[0] = r[i]; //暫存被插入記錄
int j;
for( j=i-d; j>0 && r[0]<r[j]; j=j-d) r[j+d] = r[j]; //記錄後移d個位置
r[j+d] = r[0];
}
}
for(int i=1;i<=n;i++) cout<<r[i]<<" ";
cout<<"\n";
}
void BubbleSort(int r[], int n) //起泡排序
{
int temp,exchange,bound;
exchange=n; //第一趟起泡排序的范圍是r[0]到r[n-1]
while (exchange) //僅當上一趟排序有記錄交換才進行本趟排序
{
bound=exchange;
exchange=0;
for (int j=1; j<bound; j++) //一趟起泡排序
if (r[j]>r[j+1])
{
temp=r[j];
r[j]=r[j+1];
r[j+1]=temp;
exchange=j; //記錄每一次發生記錄交換的位置
}
}
for(int i=1;i<=n;i++) cout<<r[i]<<" ";
cout<<"\n";
}
int Partition(int r[], int first, int end) //快速排序一次劃分
{
int i=first; //初始化
int j=end;
r[0]=r[first];
while (i<j)
{
while (i<j && r[0]<= r[j]) j--; //右側掃描
r[i]=r[j];
while (i<j && r[i]<= r[0]) i++; //左側掃描
r[j]=r[i];
}
r[i]=r[0];
return i; //i為軸值記錄的最終位置
}
void QuickSort(int r[], int first, int end) //快速排序
{
if (first<end)
{ //遞歸結束
int pivot=Partition(r, first, end); //一次劃分
QuickSort(r, first, pivot-1);//遞歸地對左側子序列進行快速排序
QuickSort(r, pivot+1, end); //遞歸地對右側子序列進行快速排序
}
}
void SelectSort(int r[ ], int n) //簡單選擇排序
{
int i,j,index,temp;
for (i=1; i<n; i++) //對n個記錄進行n-1趟簡單選擇排序
{
index=i;
for (j=i+1; j<=n; j++) //在無序區中選取最小記錄
if (r[j]<r[index]) index=j;
if (index!=i)
{
temp=r[i];
r[i]=r[index];
r[index]=temp;
}
}
for(i=1;i<=n;i++) cout<<r[i]<<" ";
cout<<"\n";
}
void main()
{
const int numv=12;
int a[3][numv]={{0,6,13,19,23,37,39,41,45,48,58,86},{0,86,58,48,45,41,39,37,23,19,13,6},{0,23,13,48,86,19,6,41,58,37,45,39}};
int z1[numv],z2[numv];
int m,n;
cout<<"請選擇測試數據類型：⑴正序 ⑵逆序 ⑶隨機 [ 若跳出,請按⑷ ]" <<endl;
cin>>m;
while(m>0&&m<4)
{
cout<<"請選擇排序演算法：⑴直接插入排序 ⑵希爾排序 ⑶冒泡排序 ⑷快速排序 \n ⑸簡單選擇排序"<<endl;
cin>>n;
switch(n)
{
case 1:
cout << "直接插入排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n直接插入排序結果為：" << "\n";
BiInsertsort(a[m-1],numv-1);
break;
case 2:
cout << "\n希爾排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n希爾排序結果為：" << "\n";
ShellSort(a[m-1], numv-1);
break;
case 3:
cout << "\n冒泡排序前：" << "\n";
for(int k=1;k<numv;k++) cout<<a[m-1][k]<<" ";
cout << "\n冒泡排序結果為：" << "\n";
BubbleSort(a[m-1], numv-1);
break;
case 4:
cout << "\n快速排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n快速排序結果為：" << "\n";
QuickSort(a[m-1],0,numv-1);
for(int i=1;i<numv;i++)
cout<<a[m-1][i]<<" ";
cout<<"\n";
break;
case 5:
cout << "\n簡單選擇排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n簡單選擇排序結果為：" << "\n";
SelectSort(a[m-1],numv-1);
break;
default:
cout<<"輸入錯誤！"<<endl;
}
m=0;
cout<<"請選擇測試數據類型：⑴正序 ⑵逆序 ⑶隨機 [ 若跳出,請按⑷ ]" <<endl;
cin>>m;
}
if(m==4) cout<<"(*^__^*) 再見！"<<endl;
else cout<<"輸入錯誤！"<<endl;
}