排序演算法比較
1. 排序演算法性能比較（數據結構）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),好像有系數，演算法導論那本書上有，現在不記得是多少了。
希望能幫到你，
2. 幾種排序演算法的比較
1.穩定性比較
插入排序、冒泡排序、二叉樹排序、二路歸並排序及其他線形排序是穩定的
選擇排序、希爾排序、快速排序、堆排序是不穩定的
2.時間復雜性比較
插入排序、冒泡排序、選擇排序的時間復雜性為O(n2)
其它非線形排序的時間復雜性為O(nlog2n)
線形排序的時間復雜性為O(n);
3.輔助空間的比較
線形排序、二路歸並排序的輔助空間為O(n),其它排序的輔助空間為O(1);
4.其它比較
插入、冒泡排序的速度較慢，但參加排序的序列局部或整體有序時，這種排序能達到較快的速度。
反而在這種情況下，快速排序反而慢了。
當n較小時，對穩定性不作要求時宜用選擇排序，對穩定性有要求時宜用插入或冒泡排序。
若待排序的記錄的關鍵字在一個明顯有限范圍內時,且空間允許是用桶排序。
當n較大時，關鍵字元素比較隨機，對穩定性沒要求宜用快速排序。
當n較大時，關鍵字元素可能出現本身是有序的，對穩定性有要求時，空間允許的情況下。
宜用歸並排序。
當n較大時，關鍵字元素可能出現本身是有序的，對穩定性沒有要求時宜用堆排序。
3. 幾種排序演算法效率的比較
插入排序，選擇排序，交換排序（冒泡），數據結構書上有詳細的介紹
以下是直接插入排序，選擇排序，希爾排序，冒泡排序的演算法
/*直接插入排序的基本思想是：順序地把待排序序
列中的各個記錄按其關鍵字的大小，插入到已排
序的序列的適當位置。
*/
void InsertSort(elemtype x[], int n)
{
int i,j;
elemtype s;
for(i=0;i<n-1;i )
{
s = x[i 1];
j = i;
while(j>-1 && s.key<x[j].key)
{
x[j 1] = x[j];
j--;
}
x[j 1]=s;
}
}
/*選擇排序的基本思想是：不斷從待排序的序列中
選取關鍵字最小的記錄放到已排序的記錄序列的
後面，知道序列中所有記錄都已排序為止。
*/
void SelectSort(elemtype x[], int n)
{
int i,j,Small;
elemtype Temp;
for(i=0;i<n-1;i )
{
Small = i;
for(j=i 1;j<n;j )
{
if(x[j].key<x[Small].key)
Small = j;
}
if(Small!=i)
{
Temp = x[i];
x[i] = x[Small];
x[Small] = Temp;
}
}
}
/*希爾排序的基本思想是：不斷把待排序的記錄分
成若干個小組，對同一組內的記錄進行排序，在
分組時，始終保證當前組內的記錄個數超過前面
分組排序時組內的記錄個數。
*/
void ShellSort(elemtype x[], int n, int d[], int Number)
{
int i, j, k, m, Span;
elemtype s;
for(m=0;m<Number;m )
{
Span = d[m];
for(k=0;k<Span;k )
{
for(i=k;i<n-Span;i =Span)
{
s = x[i Span];
j = i;
while(j>-1 && s.key<x[j].key)
{
x[j Span] = x[j];
j-=Span;
}
x[j Span] = s;
}
}
}
}
/*冒泡排序的基本思想是：將待排序序列中第一個
記錄的關鍵字R1與第二個記錄的關鍵字R2做比較，
如果R1>R2，則交換R1和R2的位置，否則不交換；
然後繼續對當前序列中的第二個記錄和第三個記
錄同樣的處理，依此類推。
*/
void BubbleSort(elemtype x[], int n)
{
int i,j,flag=1;
elemtype temp;
for(i=1;i<n && flag==1;i )
{
flag=0;
for(j=0;j<n-i;j )
{
if(x[j].key>x[j 1].key)
{
flag=1;
temp=x[j];
x[j]=x[j 1];
x[j 1]=temp;
}
}
}
}
4. 、題目：各種排序演算法實現和比較
給個聯系方式。我發給你！！！
5. 各種排序演算法的比較
小朋友啊，你這不是問題是作業啊。
6. 關於排序演算法比較的問題
樓上的說法不準確吧，不能說比較和交換的次數不是一個級別的，交換也不是最多隻有n次。比如一個逆序的數組進行升序的冒泡排序，交換就遠遠超過n次。
但是假設比較次數為P(n)，交換次數為Q(n)，那麼因為交換發生在比較之後（基本上排序演算法都是這樣，樓主可以自己想想），必然有Q(n)<=P(n)。如果時間復雜度為T(n)，那麼顯然根據時間復雜度的定義（極限定義），用大O表示法可以忽略Q(n)項（或用P(n)代替Q(n)），僅用P對T進行表示。
因為大O表示法是對時間復雜度上限的一個估計，而這種每比較一次就需要交換的情況確實存在（最差情況），所以在T(n)中使用P(n)對Q(n)進行替換並不會擴大對上限估計，而只是乘以了系數2，在大O表示法中常數項是不寫入的。
這些數學分析一般在國內的演算法教材中都不寫入的，MIT的《ITA》注重這方面的敘述。
關於總結其實樓主可以自己去搜，上來問這行為太懶了。不過我也幫你找來吧。
冒泡法：
這是最原始，也是眾所周知的最慢的演算法了。他的名字的由來因為它的工作看來象是冒泡： 復雜度為O(n*n)。當數據為正序，將不會有交換。復雜度為O(0)。
直接插入排序：O(n*n)
選擇排序：O(n*n)
快速排序：平均時間復雜度log2(n)*n，所有內部排序方法中最高好的，大多數情況下總是最好的。
歸並排序：log2(n)*n
堆排序：log2(n)*n
希爾排序：演算法的復雜度為n的1.2次冪
7. 求各種排序演算法的比較
給你一個國家集訓隊的快排吧，這個應該夠用了。
這個是對a數組從小到大排序，把這個添加到任何程序中都很快。這個肯定要比堆排序快。對於插入排序快的快排肯定要較慢。但這個比較穩定，要不國家集訓隊怎麼用它呢！！！！！！
procere qsort(l,r:longint);
var
i,j,x,yy:longint;
begin
i:=l;j:=r;x:=a[(i+j) shr 1];
repeat
while a[i]<x do inc(i);
while a[j]>x do dec(j);
if i<=j then
begin
yy:=a[i];a[i]:=a[j];a[j]:=yy;
inc(i);dec(j);
end;
until i>j;
if i<r then qsort(i,r);
if l<j then qsort(l,j);
end;
8. 排序演算法比較
Private Sub Command1_Click()
Dim a(1 To 100) As Integer
For i = 1 To 100
a(i) = Int(Rnd * 101)
Next
For i = 1 To 100
For j = 1 To i
If a(i) < a(j) Then t = a(i): a(i) = a(j): a(j) = t
Next
Next
For i = 1 To 100
Print a(i);
If i Mod 10 = 0
9. 數據結構中幾種常見的排序演算法之比較
實話實說，關於數據結構中幾種常見的排序演算法（例如：冒泡排序、SHELL排序、歸並排序、快速排序等）的性能好壞，還不只是學好了數據結構這門課程就能夠解決的問題，還必須要學習好、且精通掌握計算機軟體專業的另外一門非常重要的課程，才能夠解決這個問題。即：計算機演算法復雜性理論。
只有同時把這門課程學好了，那麼才能夠真正掌握數據結構中的各種排序演算法、以及各種查找演算法中所有涉及到的：比較次數、以及交換次數，最終才能夠根據具體的開發軟體規模的不同，選擇出一個適合開發該軟體的最佳演算法。
10. 排序演算法的實現和比較
int main()
{
int i,j,t,a[10];
printf("Please input 10 integers:\n");
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for(i=0;i<9;i++) /* 冒泡法排序 */
for(j=0;j<10-i-1;j++)
if(a[j]>a[j+1])
{t=a[j];/* 交換a[i]和a[j] */
a[j]=a[j+1];
a[j+1]=t;