代碼對比演算法
『壹』 用代碼實現幾種排序演算法的時間復雜度比較
一、簡單排序演算法
由於程序比較簡單，所以沒有加什麼注釋。所有的程序都給出了完整的運行代碼，並在我的VC環境
下運行通過。因為沒有涉及MFC和WINDOWS的內容，所以在BORLAND C++的平台上應該也不會有什麼
問題的。在代碼的後面給出了運行過程示意，希望對理解有幫助。
1.冒泡法：
這是最原始，也是眾所周知的最慢的演算法了。他的名字的由來因為它的工作看來象是冒泡：
#include <iostream>
using namespace std;
void BubbleSort(int * pData, int Count)
{
int iTemp;
for (int i=0; i<Count; i++)
{
for (int j=Count-1; j>i; j--)
{
if (pData[j]<pData[j-1])
{
iTemp = pData[j-1];
pData[j-1] = pData[j];
pData[j] = iTemp;
}
}
}
}
void main()
{
int data[7] = {10,9,8,7,6,5,4};
BubbleSort(data,7);
for (int i=0; i<7; i++)
{
cout<<data[i]<<" ";
}
cout<<endl;
system("PAUSE");
}
倒序(最糟情況)
第一輪：10，9，8，7->10，9，7，8->10，7，9，8->7，10，9，8(交換3次)
第二輪：7，10，9，8->7，10，8，9->7，8，10，9(交換2次)
第一輪：7，8，10，9->7，8，9，10(交換1次)
循環次數：6次
交換次數：6次
其他：
第一輪：8，10，7，9->8，10，7，9->8，7，10，9->7，8，10，9(交換2次)
第二輪：7，8，10，9->7，8，10，9->7，8，10，9(交換0次)
第一輪：7，8，10，9->7，8，9，10(交換1次)
循環次數：6次
交換次數：3次
上面我們給出了程序段，現在我們分析它：這里，影響我們演算法性能的主要部分是循環和交換，
顯然，次數越多，性能就越差。從上面的程序我們可以看出循環的次數是固定的，為1+2+...+n-1。
寫成公式就是1/2*(n-1)*n。
現在注意，我們給出O方法的定義：
若存在一常量K和起點n0，使當n>=n0時，有f(n)<=K*g(n)，則f(n) = O(g(n))。（呵呵，不要說沒學好數學呀，對於編程數學是非常重要的！！！）
現在我們來看1/2*(n-1)*n，當K=1/2，n0=1，g(n)=n*n時，1/2*(n-1)*n<=1/2*n*n=K*g(n)。所以f(n)
=O(g(n))=O(n*n)。所以我們程序循環的復雜度為O(n*n)。
再看交換。從程序後面所跟的表可以看到，兩種情況的循環相同，交換不同。其實交換本身同數據源的
有序程度有極大的關系，當數據處於倒序的情況時，交換次數同循環一樣（每次循環判斷都會交換），
復雜度為O(n*n)。當數據為正序，將不會有交換。復雜度為O(0)。亂序時處於中間狀態。正是由於這樣的
原因，我們通常都是通過循環次數來對比演算法。
2.交換法：
交換法的程序最清晰簡單，每次用當前的元素一一的同其後的元素比較並交換。
#include <iostream.h>
void ExchangeSort(int* pData，int Count)
{
int iTemp;
for(int i=0;i<Count-1;i++)
{ //共（count-1)輪，每輪得到一個最小值
for(int j=i+1;j<Count;j++)
{ //每次從剩下的數字中尋找最小值，於當前最小值相比，如果小則交換
if(pData[j]9，10，8，7->8，10，9，7->7，10，9，8(交換3次)
第二輪：7，10，9，8->7，9，10，8->7，8，10，9(交換2次)
第一輪：7，8，10，9->7，8，9，10(交換1次)
循環次數：6次
交換次數：6次
其他：
第一輪：8，10，7，9->8，10，7，9->7，10，8，9->7，10，8，9(交換1次)
第二輪：7，10，8，9->7，8，10，9->7，8，10，9(交換1次)
第一輪：7，8，10，9->7，8，9，10(交換1次)
循環次數：6次
交換次數：3次
從運行的表格來看，交換幾乎和冒泡一樣糟。事實確實如此。循環次數和冒泡一樣
也是1/2*(n-1)*n，所以演算法的復雜度仍然是O(n*n)。由於我們無法給出所有的情況，所以
只能直接告訴大家他們在交換上面也是一樣的糟糕（在某些情況下稍好，在某些情況下稍差）。
3.選擇法：
現在我們終於可以看到一點希望：選擇法，這種方法提高了一點性能（某些情況下）
這種方法類似我們人為的排序習慣：從數據中選擇最小的同第一個值交換，在從省下的部分中
選擇最小的與第二個交換，這樣往復下去。
#include <iostream.h>
void SelectSort(int* pData，int Count)
{
int iTemp;
int iPos;
for(int i=0;i<Count-1;i++)
{
iTemp = pData;
iPos = i;
for(int j=i+1;j<Count;j++)
{
if(pData[j]<iTemp)
{
iTemp = pData[j];
iPos = j;
}
}
pData[iPos] = pData;
pData = iTemp;
}
}
void main()
{
int data[] = {10，9，8，7，6，5，4};
SelectSort(data，7);
for (int i=0;i<7;i++)
cout<<data<<" ";
cout<<"\n";
}
倒序(最糟情況)
第一輪：10，9，8，7->(iTemp=9)10，9，8，7->(iTemp=8)10，9，8，7->(iTemp=7)7，9，8，10(交換1次)
第二輪：7，9，8，10->7，9，8，10(iTemp=8)->(iTemp=8)7，8，9，10(交換1次)
第一輪：7，8，9，10->(iTemp=9)7，8，9，10(交換0次)
循環次數：6次
交換次數：2次
其他：
第一輪：8，10，7，9->(iTemp=8)8，10，7，9->(iTemp=7)8，10，7，9->(iTemp=7)7，10，8，9(交換1次)
第二輪：7，10，8，9->(iTemp=8)7，10，8，9->(iTemp=8)7，8，10，9(交換1次)
第一輪：7，8，10，9->(iTemp=9)7，8，9，10(交換1次)
循環次數：6次
交換次數：3次
遺憾的是演算法需要的循環次數依然是1/2*(n-1)*n。所以演算法復雜度為O(n*n)。
我們來看他的交換。由於每次外層循環只產生一次交換（只有一個最小值）。所以f(n)<=n
所以我們有f(n)=O(n)。所以，在數據較亂的時候，可以減少一定的交換次數。
4.插入法：
插入法較為復雜，它的基本工作原理是抽出牌，在前面的牌中尋找相應的位置插入，然後繼續下一張
#include <iostream.h>
void InsertSort(int* pData，int Count)
{
int iTemp;
int iPos;
for(int i=1;i<Count;i++)
{
iTemp = pData[i]; //保存要插入的數
iPos = i-1; //被插入的數組數字個數
while((iPos>=0) && (iTemp9，10，8，7(交換1次)(循環1次)
第二輪：9，10，8，7->8，9，10，7(交換1次)(循環2次)
第一輪：8，9，10，7->7，8，9，10(交換1次)(循環3次)
循環次數：6次
交換次數：3次
其他：
第一輪：8，10，7，9->8，10，7，9(交換0次)(循環1次)
第二輪：8，10，7，9->7，8，10，9(交換1次)(循環2次)
第一輪：7，8，10，9->7，8，9，10(交換1次)(循環1次)
循環次數：4次
交換次數：2次
上面結尾的行為分析事實上造成了一種假象，讓我們認為這種演算法是簡單演算法中最好的，其實不是，
因為其循環次數雖然並不固定，我們仍可以使用O方法。從上面的結果可以看出，循環的次數f(n)<=
1/2*n*(n-1)<=1/2*n*n。所以其復雜度仍為O(n*n)（這里說明一下，其實如果不是為了展示這些簡單
排序的不同，交換次數仍然可以這樣推導）。現在看交換，從外觀上看，交換次數是O(n)（推導類似
選擇法），但我們每次要進行與內層循環相同次數的『=』操作。正常的一次交換我們需要三次『=』
而這里顯然多了一些，所以我們浪費了時間。
最終，我個人認為，在簡單排序演算法中，選擇法是最好的。
二、高級排序演算法
高級排序演算法中我們將只介紹這一種，同時也是目前我所知道（我看過的資料中）的最快的。
它的工作看起來仍然象一個二叉樹。首先我們選擇一個中間值middle程序中我們使用數組中間值，然後
把比它小的放在左邊，大的放在右邊（具體的實現是從兩邊找，找到一對後交換）。然後對兩邊分別使
用這個過程（最容易的方法——遞歸）。
1.快速排序：
#include <iostream.h>
void run(int* pData，int left，int right)
{
int i，j;
int middle，iTemp;
i = left;
j = right;
middle = pData[left];
do{
while((pData[i]<middle) && (i<right))//從左掃描大於中值的數
i++;
while((pData[j]>middle) && (j>left))//從右掃描大於中值的數
j--;
if(i<=j)//找到了一對值
{
//交換
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
i++;
j--;
}
}while(i<=j);//如果兩邊掃描的下標交錯，就停止（完成一次）
//當左邊部分有值(left<j)，遞歸左半邊
if(left<j)
run(pData，left，j);
//當右邊部分有值(right>i)，遞歸右半邊
if(right>i)
run(pData，i，right);
}
void QuickSort(int* pData，int Count)
{
run(pData，0，Count-1);
}
void main()
{
int data[] = {10，9，8，7，6，5，4};
QuickSort(data，7);
for (int i=0;i<7;i++)
cout<<data<<" ";
cout<<"\n";
}
這里我沒有給出行為的分析，因為這個很簡單，我們直接來分析演算法：首先我們考慮最理想的情況
1.數組的大小是2的冪，這樣分下去始終可以被2整除。假設為2的k次方，即k=log2(n)。
2.每次我們選擇的值剛好是中間值，這樣，數組才可以被等分。
第一層遞歸，循環n次，第二層循環2*(n/2)......
所以共有n+2(n/2)+4(n/4)+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n
所以演算法復雜度為O(log2(n)*n)
其他的情況只會比這種情況差，最差的情況是每次選擇到的middle都是最小值或最大值，那麼他將變
成交換法（由於使用了遞歸，情況更糟）。但是你認為這種情況發生的幾率有多大？？呵呵，你完全
不必擔心這個問題。實踐證明，大多數的情況，快速排序總是最好的。
如果你擔心這個問題，你可以使用堆排序，這是一種穩定的O(log2(n)*n)演算法，但是通常情況下速度要慢
『貳』 請教一個 c語言 字元串數組之間比較的演算法，謝謝
這種時候當然是使用標准容器拉
std::map可以滿足你的需要
10個ip 地址 復制給10個std::string. 然後構造一個 std::map<std::string, int> 再逐個使用insert方法插入， 如果插入成功（通過檢查insert的返回值, 具體請搜索msdn,這里篇幅有限。）
如果插入成功， 繼續； 不成功，就表示有重復，將返回的那個已經存在的ip對應的優先順序++， 再繼續。
map的特點就是不重復，你省去了自己去寫比較，去優化的繁瑣，而且一般stl實現的效率都是很高的絕對不是你這種40多次的O(N)的，應該至少都是o(ln N)
『叄』 比較兩個代碼的演算法復雜度
演算法復雜度是指演算法在編寫成可執行程序後，運行時所需要的資源，資源包括時間資源和內存資源。應用於數學和計算機導論。
『肆』 求一個比較大小的JAVA演算法
1.是的
2.a-可以直接求和，b-利用近似公式
3.近似公式為e=(1+1/n)^n,n->無窮大
4.這兩個公式都需要運算n到足夠大來減少誤差
假如你運算到n=k滿足精度需要了
那麼你首先要保證當n=k-1時算出的值與n=k的值差別小於0.0001
假如需要考慮截斷誤差，那麼你就要考慮到任何一個1/n或者1/n!的形式的截斷誤差，以及運算中每一步的累計誤差，都是可以計算的
從累積誤差的角度來說，第一個方法較優
因為每一個求和項目都是整數的倒數，只發生一次截斷
之後的誤差計算直接將最大誤差可能求和就可以了
而且每一次迭代可以應用上一次的結果，效率較高
但是缺點是當n比較大的時候，n!也會是一個比較大的數，n的類型定義得不好會溢出
第二個方法就需要計算一次截斷誤差，並且計算n次方的誤差累積
『伍』 C語言編寫代碼實現幾種內部排序演算法的性能比較，有償求代碼和簡要的實驗報告。
http://wenku..com/view/6ff074740912a216147929db.html
可以參考這個
部分代碼，使用了模板，其他演算法自己弄把，輸出的數據弄幾個表格就是結果了
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
voidtestSort(intlen);
intmain(intargc,char*argv[])
{
testSort(10000);
testSort(20000);
testSort(40000);
testSort(80000);
testSort(160000);
testSort(320000);
testSort(640000);
testSort(1280000);
testSort(2560000);
testSort(5120000);
testSort(10240000);
return0;
}
#defineCOUNT_SETVAL//測試消耗時間注釋掉這兩句
#defineCOUNT_COMPARE
#ifdefCOUNT_SETVAL
__int64gSetValTimes;
#endif
#ifdefCOUNT_COMPARE
__int64gCompareTimes;
#endif
//交換
template<classT>
inlinevoidswap(T&_X,T&_Y)
{
T_T=_X;
_X=_Y;
_Y=_T;
#ifdefCOUNT_SWAP
gSwapTimes++;
#endif
#ifdefCOUNT_SETVAL
gSetValTimes+=3;
#endif
}
//復制
template<classT>
inlinevoidsetVal(T&_X,T&_Y)
{
_X=_Y;
#ifdefCOUNT_SETVAL
gSetValTimes++;
#endif
}
//比較
template<classT>
inlineintcompare(T&_X,T&_Y)
{
#ifdefCOUNT_COMPARE
gCompareTimes++;
#endif
return_X<_Y;
}
//堆排序
template<classT,classS>
voidheap_sort(T*_A,S_N)
{
Stop,bot,nxt,cur;
top=bot=nxt=_N;
while(cur=nxt,bot>0)
{
if(cur*2+1<bot&&compare(_A[nxt],_A[cur*2+1]))nxt=cur*2+1;
if(cur*2+2<bot&&compare(_A[nxt],_A[cur*2+2]))nxt=cur*2+2;
if(cur<nxt)swap(_A[cur],_A[nxt]);
elsenxt=top?--top:(swap(_A[0],_A[--bot]),0);
}
}
//原地合並排序
template<classT,classS>
voidncmerge_sort(T*_A,S_N)
{
Sstep,ins,l,m,r,pos0,pos1;
T*_T=newT[_N];
for(step=2;step<_N*2;step*=2)
{
for(l=0;l+step/2<_N;l+=step)
{
m=l+step/2;
r=m+step/2<_N?m+step/2:_N;
pos0=l;pos1=m;ins=0;
while(pos0<m&&pos1<r)
{
if(compare(_A[pos1],_A[pos0]))setVal(_T[ins++],_A[pos1++]);
elsesetVal(_T[ins++],_A[pos0++]);
}
while(pos0<m)setVal(_T[ins++],_A[pos0++]);
while(pos1<r)setVal(_T[ins++],_A[pos1++]);
while(ins>0)setVal(_A[--r],_T[--ins]);
}
}
delete[]_T;
}
//冒泡排序
template<classT,classS>
voidbubble_sort(T*_A,S_N)
{
Si,j,pos;
for(i=0;i<_N;i++)
{
pos=i;
for(j=i+1;j<_N;j++)if(compare(_A[j],_A[pos]))pos=j;
if(pos!=i)swap(_A[i],_A[pos]);
}
}
//快速排序
template<classT,classS>
voidquick_sort(T*_A,S_N)
{
Tpivot;
Sl=0;
Sm=_N/2;
Sr=_N-1;
if(_N>1)
{
if(compare(_A[r],_A[l]))swap(_A[l],_A[r]);
if(compare(_A[m],_A[l]))swap(_A[l],_A[m]);
if(compare(_A[r],_A[m]))swap(_A[m],_A[r]);
setVal(pivot,_A[m]);
while(l<=r)
{
while(compare(_A[l],pivot))l++;
while(compare(pivot,_A[r]))r--;
if(l<=r)swap(_A[l++],_A[r--]);
}
quick_sort(_A,r+1);
quick_sort(_A+l,_N-l);
}
return;
}
template<classT,classS>
voidheap2_sort(T*_A,S_N)
{
Ttempitem;
Scurrent,next;
Stop=_N/2;
while(_N>0)
{
if(top>0)top-=1;elseswap(_A[--_N],_A[0]);
setVal(tempitem,_A[top]);
current=top;
while(1)
{
next=current*2+1;
if(next+1<_N&&compare(_A[next],_A[next+1]))
{
next+=1;
}
if(next<_N)
{
setVal(_A[current],_A[next]);
current=next;
}
elsebreak;
}
while(next>0)
{
next=(current-1)/2;
if(next>=top&&compare(_A[next],tempitem))
{
setVal(_A[current],_A[next]);
current=next;
}
elsebreak;
}
setVal(_A[current],tempitem);
}
}
template<classT,classS>
voidcomb_sort(T*_A,S_N)
{
Snoswap=1;
Sdelta=_N;
Si;
while(!noswap||delta>1)
{
if(delta>1)
{
delta=(S)(delta/1.25);
}
for(noswap=1,i=0;i+delta<_N;i++)
{
if(compare(_A[i+delta],_A[i]))
{
noswap=0;
swap(_A[i+delta],_A[i]);
}
}
}
return;
}
voidtestSort(intlen)
{
srand(time(NULL));
int*Array=newint[len];
for(inti=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
clock_ttb=clock();
quick_sort(Array,len);
printf("quick:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("復制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比較:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb); for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
heap_sort(Array,len);
printf("heap:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("復制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比較:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb); for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
ncmerge_sort(Array,len);
printf("ncmerge:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("復制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比較:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb); for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
heap2_sort(Array,len);
printf("heap2:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("復制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比較:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb);
for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
comb_sort(Array,len);
printf("comb:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("復制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比較:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb);
if(len<50000)
{
for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
bubble_sort(Array,len);
printf("bubble:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("復制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比較:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb);
}
printf(" ");
}
『陸』 幾種經典排序演算法優劣比較的C++程序實現
一、低級排序演算法
1.選擇排序
（1）排序過程
給定一個數值集合，循環遍歷集合，每次遍歷從集合中選擇出最小或最大的放入集合的開頭或結尾的位置，下次循環從剩餘的元素集合中遍歷找出最小的並如上操作，最後直至所有原集合元素都遍歷完畢，排序結束。
（2）實現代碼
//選擇排序法
template
void Sort：：SelectSort（T* array， int size）
{
int minIndex；
for（int i = 0； i < size； i++）
{
minIndex = i；
for（int j = i + 1； j < size； j++）
{
if（array[minIndex] > array[j]）
{
minIndex = j；
}
}
if（minIndex ！= i）
{
Swap（array， i， minIndex）；
}
}
}
（3）分析總結
選擇排序時間復雜度比較高，達到了O（n^2），每次選擇都要遍歷一遍無序區間。選擇排序對一類重要的元素序列具有較好的效率，就是元素規模很大，而排序碼卻比較小的序列。另外要說明的是選擇排序是一種不穩定的排序方法。
2.冒泡排序
（1）排序過程
冒泡排序的過程形如其名，就是依次比較相鄰兩個元素，優先順序高（或大或小）的元素向後移動，直至到達序列末尾，無序區間就會相應地縮小。下一次再從無序區間進行冒泡操作，依此循環直至無序區間為1，排序結束。
（2）實現代碼
//冒泡排序法
template
void Sort：：BubbleSort（T* array， int size）
{
for（int i = 0； i < size； i++）
{
for（int j = 1； j < size - i； j++）
{
if（array[j] < array[j - 1]）
{
Swap（array， j， j - 1）；
}
}
}
}
（3）分析總結
冒泡排序的時間復雜度也比較高，達到O（n^2），每次遍歷無序區間都將優先順序高的元素移動到無序區間的末尾。冒泡排序是一種穩定的排序方式。
二、高級排序演算法
（1）排序過程
歸並排序的原理比較簡單，也是基於分治思想的。它將待排序的元素序列分成兩個長度相等的子序列，然後為每一個子序列排序，然後再將它們合並成一個序列。
（2）實現代碼
//歸並排序
template
void Sort：：MergeSort（T* array， int left， int right）
{
if（left < right）
{
int mid = （left + right） / 2；
MergeSort（array， left， mid）；
MergeSort（array， mid + 1， right）；
Merge（array， left， mid， right）；
}
}
//合並兩個已排好序的子鏈
template
void Sort：：Merge（T* array， int left， int mid， int right）
{
T* temp = new T[right - left + 1]；
int i = left， j = mid + 1， m = 0；
while（i <= mid && j <= right）
{
if（array[i] < array[j]）
{
temp[m++] = array[i++]；
}
else
{
temp[m++] = array[j++]；
}
}
while（i <= mid）
{
temp[m++] = array[i++]；
}
while（j <= right）
{
temp[m++] = array[j++]；
}
for（int n = left， m = 0； n <= right； n++， m++）
{
array[n] = temp[m]；
}
delete temp；
}
（3）分析總結
歸並排序最好、最差和平均時間復雜度都是O（nlogn），是一種穩定的排序演算法。
『柒』 演算法設計：比較兩個文件的差別
兩個文件可以比較是否相同，不同在哪裡？
最簡單辦法：comp file1 file2 d/a/l/n=n/c/off n
但是如何進行更改的，就涉及到操作的追溯。這個過程是不可逆的。所以無解。
除非有操作記錄表！可以追溯。
『捌』 排序演算法性能比較（數據結構）C語言程序
這題你只要把每個演算法的程序代碼看一下，在計算下就行
冒泡排序：兩個循環，從1加到N，(1+N)N/2 = 500500,最壞交換情況是每次判斷都要交換，既500500*3次
選擇排序：也是兩個循環，比較次數跟冒泡排序一樣500500，但是這個只要底層循環交換，既只需1000*3 = 3000次賦值。
插入排序：循環次數一樣500500，但是這個最壞情況是每比較一次就賦值一次，既需500500次賦值
希爾排序：時間復雜度是N^1.3倍，比較次數和賦值應該是1000^1.3次方。
歸並排序和快速排序，你去查查它的時間復雜度是怎麼算，O(lgN*N),好像有系數，演算法導論那本書上有，現在不記得是多少了。
希望能幫到你，
『玖』 vc6.0 比較代碼的優異
人家只是為了衡量演算法的效率，不用又是時間復雜度又是空間復雜度的，你只需要用GetTickCount()函數獲取兩個演算法運行的時間就可以了。
DWORD dwBegin = GetTickCount();
演算法1
DWORD dwEnd = GetTickCount();
DWORD dwSpan = dwEnd - dwBegin；// 獲得演算法1的耗時(單位毫秒)
dwBegin = GetTickCount();
演算法2
dwEnd = GetTickCount();
DWORD dwSpan1 = dwEnd - dwBegin；// 獲得演算法2的耗時(單位毫秒)
比較dwSpan 和dwSpan1 就知道孰優孰劣了。
『拾』 c語言代碼的比較
C代碼質量現在主要考慮時間效率。好的結構和演算法能極大的優化時間效率。比較的話，很白痴級的，你把同樣功能的，分別運行比較下時間和佔用內存就能看出來了。