重溫經(jīng)典排序思想--C語(yǔ)言常用排序全解
加入技術(shù)交流群
/*
本文引用地址：http://dyxdggzs.com/article/201612/341312.htm===============================================
作者：rerli
時(shí)間：2003-12-15
目的：重溫經(jīng)典排序思想，并用C語(yǔ)言指針實(shí)現排序算法
================================================
*/
/*
=============================================================================
相關(guān)知識介紹(所有定義只為幫助讀者理解相關(guān)概念，并非嚴格定義)：
1、穩定排序和非穩定排序
簡(jiǎn)單地說(shuō)就是所有相等的數經(jīng)過(guò)某種排序方法后，仍能保持它們在排序之前的相對次序，我們就
說(shuō)這種排序方法是穩定的。反之，就是非穩定的。
比如：一組數排序前是a1,a2,a3,a4,a5，其中a2=a4，經(jīng)過(guò)某種排序后為a1,a2,a4,a3,a5，
則我們說(shuō)這種排序是穩定的，因為a2排序前在a4的前面，排序后它還是在a4的前面。假如變成a1,a4,
a2,a3,a5就不是穩定的了。
2、內排序和外排序
在排序過(guò)程中，所有需要排序的數都在內存，并在內存中調整它們的存儲順序，稱(chēng)為內排序;
在排序過(guò)程中，只有部分數被調入內存，并借助內存調整數在外存中的存放順序排序方法稱(chēng)為外排序。
3、算法的時(shí)間復雜度和空間復雜度
所謂算法的時(shí)間復雜度，是指執行算法所需要的計算工作量。
一個(gè)算法的空間復雜度，一般是指執行這個(gè)算法所需要的內存空間。
================================================================================
*/
/*
================================================
功能：選擇排序
輸入：數組名稱(chēng)(也就是數組首地址)、數組中元素個(gè)數
================================================
*/
/*
====================================================
算法思想簡(jiǎn)單描述：
在要排序的一組數中，選出最小的一個(gè)數與第一個(gè)位置的數交換;
然后在剩下的數當中再找最小的與第二個(gè)位置的數交換，如此循環(huán)
到倒數第二個(gè)數和最后一個(gè)數比較為止。
選擇排序是不穩定的。算法復雜度O(n2)--[n的平方]
=====================================================
*/
void select_sort(int *x, int n)
{
int i, j, min, t;
for (i=0; i {
min = i; /*假設當前下標為i的數最小，比較后再調整*/
for (j=i+1; j {
if (*(x+j) < *(x+min))
{
min = j; /*如果后面的數比前面的小，則記下它的下標*/
}
}
if (min != i) /*如果min在循環(huán)中改變了，就需要交換數據*/
{
t = *(x+i);
*(x+i) = *(x+min);
*(x+min) = t;
}
}
}
/*
================================================
功能：直接插入排序
輸入：數組名稱(chēng)(也就是數組首地址)、數組中元素個(gè)數
================================================
*/
/*
====================================================
算法思想簡(jiǎn)單描述：
在要排序的一組數中，假設前面(n-1) [n>=2] 個(gè)數已經(jīng)是排
好順序的，現在要把第n個(gè)數插到前面的有序數中，使得這n個(gè)數
也是排好順序的。如此反復循環(huán)，直到全部排好順序。
直接插入排序是穩定的。算法時(shí)間復雜度O(n2)--[n的平方]
=====================================================
*/
void insert_sort(int *x, int n)
{
int i, j, t;
for (i=1; i {
/*
暫存下標為i的數。注意：下標從1開(kāi)始，原因就是開(kāi)始時(shí)
第一個(gè)數即下標為0的數，前面沒(méi)有任何數，單單一個(gè)，認為
它是排好順序的。
*/
t=*(x+i);
for (j=i-1; j>=0 && t<*(x+j); j--) /*注意：j=i-1，j--，這里就是下標為i的數，在它前面有序列中找插入位置。*/
{
*(x+j+1) = *(x+j); /*如果滿(mǎn)足條件就往后挪。最壞的情況就是t比下標為0的數都小，它要放在最前面，j==-1，退出循環(huán)*/
}
*(x+j+1) = t; /*找到下標為i的數的放置位置*/
}
}
/*
================================================
功能：冒泡排序
輸入：數組名稱(chēng)(也就是數組首地址)、數組中元素個(gè)數
================================================
*/
/*
====================================================
算法思想簡(jiǎn)單描述：
在要排序的一組數中，對當前還未排好序的范圍內的全部數，自上
而下對相鄰的兩個(gè)數依次進(jìn)行比較和調整，讓較大的數往下沉，較
小的往上冒。即：每當兩相鄰的數比較后發(fā)現它們的排序與排序要
求相反時(shí)，就將它們互換。
下面是一種改進(jìn)的冒泡算法，它記錄了每一遍掃描后最后下沉數的
位置k，這樣可以減少外層循環(huán)掃描的次數。
冒泡排序是穩定的。算法時(shí)間復雜度O(n2)--[n的平方]
=====================================================
*/
void bubble_sort(int *x, int n)
{
int j, k, h, t;
for (h=n-1; h>0; h=k) /*循環(huán)到?jīng)]有比較范圍*/
{
for (j=0, k=0; j {
if (*(x+j) > *(x+j+1)) /*大的放在后面，小的放到前面*/
{
t = *(x+j);
*(x+j) = *(x+j+1);
*(x+j+1) = t; /*完成交換*/
k = j; /*保存最后下沉的位置。這樣k后面的都是排序排好了的。*/
}
}
}
}
/*
================================================
功能：希爾排序
輸入：數組名稱(chēng)(也就是數組首地址)、數組中元素個(gè)數
================================================
*/
/*
====================================================
算法思想簡(jiǎn)單描述：
在直接插入排序算法中，每次插入一個(gè)數，使有序序列只增加1個(gè)節點(diǎn)，
并且對插入下一個(gè)數沒(méi)有提供任何幫助。如果比較相隔較遠距離(稱(chēng)為
增量)的數，使得數移動(dòng)時(shí)能跨過(guò)多個(gè)元素，則進(jìn)行一次比較就可能消除
多個(gè)元素交換。D.L.shell于1959年在以他名字命名的排序算法中實(shí)現
了這一思想。算法先將要排序的一組數按某個(gè)增量d分成若干組，每組中
記錄的下標相差d.對每組中全部元素進(jìn)行排序，然后再用一個(gè)較小的增量
對它進(jìn)行，在每組中再進(jìn)行排序。當增量減到1時(shí)，整個(gè)要排序的數被分成
一組，排序完成。
下面的函數是一個(gè)希爾排序算法的一個(gè)實(shí)現，初次取序列的一半為增量，
以后每次減半，直到增量為1。
希爾排序是不穩定的。
=====================================================
*/
void shell_sort(int *x, int n)
{
int h, j, k, t;
for (h=n/2; h>0; h=h/2) /*控制增量*/
{
for (j=h; j {
t = *(x+j);
for (k=j-h; (k>=0 && t<*(x+k)); k-=h)
{
*(x+k+h) = *(x+k);
}
*(x+k+h) = t;
}
}
}
/*
================================================
功能：快速排序
輸入：數組名稱(chēng)(也就是數組首地址)、數組中起止元素的下標
================================================
*/
/*
====================================================
算法思想簡(jiǎn)單描述：
快速排序是對冒泡排序的一種本質(zhì)改進(jìn)。它的基本思想是通過(guò)一趟
掃描后，使得排序序列的長(cháng)度能大幅度地減少。在冒泡排序中，一次
掃描只能確保最大數值的數移到正確位置，而待排序序列的長(cháng)度可能只
減少1?？焖倥判蛲ㄟ^(guò)一趟掃描，就能確保某個(gè)數(以它為基準點(diǎn)吧)
的左邊各數都比它小，右邊各數都比它大。然后又用同樣的方法處理
它左右兩邊的數，直到基準點(diǎn)的左右只有一個(gè)元素為止。它是由
C.A.R.Hoare于1962年提出的。
顯然快速排序可以用遞歸實(shí)現，當然也可以用?；膺f歸實(shí)現。下面的
函數是用遞歸實(shí)現的，有興趣的朋友可以改成非遞歸的。
快速排序是不穩定的。最理想情況算法時(shí)間復雜度O(nlog2n)，最壞O(n2)
=====================================================
*/
void quick_sort(int *x, int low, int high)
{
int i, j, t;
if (low < high) /*要排序的元素起止下標，保證小的放在左邊，大的放在右邊。這里以下標為low的元素為基準點(diǎn)*/
{
i = low;
j = high;
t = *(x+low); /*暫存基準點(diǎn)的數*/
while (i {
while (it) /*在右邊的只要比基準點(diǎn)大仍放在右邊*/
{
j--; /*前移一個(gè)位置*/
}
if (i {
*(x+i) = *(x+j); /*上面的循環(huán)退出：即出現比基準點(diǎn)小的數，替換基準點(diǎn)的數*/
i++; /*后移一個(gè)位置，并以此為基準點(diǎn)*/
}
while (i {
i++; /*后移一個(gè)位置*/
}
if (i {
*(x+j) = *(x+i); /*上面的循環(huán)退出：即出現比基準點(diǎn)大的數，放到右邊*/
j--; /*前移一個(gè)位置*/
}
}
*(x+i) = t; /*一遍掃描完后，放到適當位置*/
quick_sort(x,low,i-1); /*對基準點(diǎn)左邊的數再執行快速排序*/
quick_sort(x,i+1,high); /*對基準點(diǎn)右邊的數再執行快速排序*/
}
}
/*
================================================
功能：堆排序
輸入：數組名稱(chēng)(也就是數組首地址)、數組中元素個(gè)數
================================================
*/
/*
====================================================
算法思想簡(jiǎn)單描述：
堆排序是一種樹(shù)形選擇排序，是對直接選擇排序的有效改進(jìn)。
堆的定義如下：具有n個(gè)元素的序列(h1,h2,...,hn),當且僅當
滿(mǎn)足(hi>=h2i,hi>=2i+1)或(hi<=h2i,hi<=2i+1)(i=1,2,...,n/2)
時(shí)稱(chēng)之為堆。在這里只討論滿(mǎn)足前者條件的堆。
由堆的定義可以看出，堆頂元素(即第一個(gè)元素)必為最大項。完全二叉樹(shù)可以
很直觀(guān)地表示堆的結構。堆頂為根，其它為左子樹(shù)、右子樹(shù)。
初始時(shí)把要排序的數的序列看作是一棵順序存儲的二叉樹(shù)，調整它們的存儲順序，
使之成為一個(gè)堆，這時(shí)堆的根節點(diǎn)的數最大。然后將根節點(diǎn)與堆的最后一個(gè)節點(diǎn)
交換。然后對前面(n-1)個(gè)數重新調整使之成為堆。依此類(lèi)推，直到只有兩個(gè)節點(diǎn)
的堆，并對它們作交換，最后得到有n個(gè)節點(diǎn)的有序序列。
從算法描述來(lái)看，堆排序需要兩個(gè)過(guò)程，一是建立堆，二是堆頂與堆的最后一個(gè)元素
交換位置。所以堆排序有兩個(gè)函數組成。一是建堆的滲透函數，二是反復調用滲透函數
實(shí)現排序的函數。
堆排序是不穩定的。算法時(shí)間復雜度O(nlog2n)。
*/
/*
功能：滲透建堆
輸入：數組名稱(chēng)(也就是數組首地址)、參與建堆元素的個(gè)數、從第幾個(gè)元素開(kāi)始
*/
void sift(int *x, int n, int s)
{
int t, k, j;
t = *(x+s); /*暫存開(kāi)始元素*/
k = s; /*開(kāi)始元素下標*/
j = 2*k + 1; /*右子樹(shù)元素下標*/
while (j {
if (j {
j++;
}
if (t<*(x+j)) /*調整*/
{
*(x+k) = *(x+j);
k = j; /*調整后，開(kāi)始元素也隨之調整*/
j = 2*k + 1;
}
else /*沒(méi)有需要調整了，已經(jīng)是個(gè)堆了，退出循環(huán)。*/
{
break;
}
}
*(x+k) = t; /*開(kāi)始元素放到它正確位置*/
}
/*
功能：堆排序
輸入：數組名稱(chēng)(也就是數組首地址)、數組中元素個(gè)數
*/
void heap_sort(int *x, int n)
{
int i, k, t;
int *p;
for (i=n/2-1; i>=0; i--)
{
sift(x,n,i); /*初始建堆*/
}
for (k=n-1; k>=1; k--)
{
t = *(x+0); /*堆頂放到最后*/
*(x+0) = *(x+k);
*(x+k) = t;
sift(x,k,0); /*剩下的數再建堆*/
}
}
void main()
{
#define MAX 4
int *p, i, a[MAX];
/*錄入測試數據*/
p = a;
printf("Input %d number for sorting :n",MAX);
for (i=0; i {
scanf("%d",p++);
}
printf("n");
/*測試選擇排序*/
p = a;
select_sort(p,MAX);
/**/
/*測試直接插入排序*/
/*
p = a;
insert_sort(p,MAX);
*/
/*測試冒泡排序*/
/*
p = a;
insert_sort(p,MAX);
*/
/*測試快速排序*/
/*
p = a;
quick_sort(p,0,MAX-1);
*/
/*測試堆排序*/
/*
p = a;
heap_sort(p,MAX);
*/
for (p=a, i=0; i {
printf("%d ",*p++);
}
printf("n");
system("pause");
}
評論