（1）網絡字節序
htonl就是把本機字節順序轉化爲網絡字節順序
所謂網絡字節順序（大尾順序）就是指一個數在內存中存儲的時候“高對低，低對高”（即一個數的高位字節存放於低地址單元，低位字節存放在高地址單元中）。但是計算機的內存存儲數據時有可能是大尾順序或者小尾順序。
先舉個例子：
int a = 0x403214;
int b = htonl(a);
我在VC++6.0調試這段代碼，發現
&a的值爲：0x0012ff44
其中0x0012ff44、0x0012ff45、0x0012ff46、0x0012ff47這四個單元的值依次爲：14、32、40、00，即0x403214這個數的高位部分存放在高位地址中，低位部分存放在低位地址中，即小尾順序。
&b的值爲：0x0012ff40
其中0x0012ff40、0x0012ff41、0x0012ff42、0x0012ff43這四個單元的值依次爲：00、40、32、14，即把原數0x403214的高位部分存放在低位地址中，低位部分存放在高位地址中。
由此可見，如果一個數以小尾順序存儲，經htonl函數調用後這個數的高地位字節會完全顛倒過來成爲一個新的數。這個新的數在機器內部其實還是以小尾順序存儲的，但是相對於原來的數而言相當於是變成大尾順序的了。
long型的0x40寫完整爲:0x 00 00 00 40，共四個字節，調用htonl後四個字節顛倒順序，爲0x 40 00 00 00。
同樣，0x40 00 00 00調用htonl後變爲0x 00 00 00 40，即0x40
例程：#include <stdio.h>
int main()
{
int aaa = 0x01;
printf("%d",htonl(aaa)); 輸出爲 0x01 00 00 00 即 1 00000000 00000000 00000000 =2 ^ 24=16777216
return 0;
}
交換排序的基本思想是：兩兩比較待排序記錄的關鍵字，發現兩個記錄的次序相反時即進行交換，直到沒有反序的記錄爲止。
應用交換排序基本思想的主要排序方法有：冒泡排序和快速排序。
冒泡排序
1、排序方法
將被排序的記錄數組R[1..n]垂直排列，每個記錄R[i]看作是重量爲R[i].key的氣泡。根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組R：凡掃描到違反本原則的輕氣泡，就使其向上"飄浮"。如此反覆進行，直到最後任何兩個氣泡都是輕者在上，重者在下爲止。
（1）初始
R[1..n]爲無序區。
（2）第一趟掃描
從無序區底部向上依次比較相鄰的兩個氣泡的重量，若發現輕者在下、重者在上，則交換二者的位置。即依次比較(R[n]，R[n-1])，(R[n-1]，R[n-2])，…，(R[2]，R[1])；對於每對氣泡(R[j+1]，R[j])，若R[j+1].key<R[j].key，則交換R[j+1]和R[j]的內容。
第一趟掃描完畢時，"最輕"的氣泡就飄浮到該區間的頂部，即關鍵字最小的記錄被放在最高位置R[1]上。
（3）第二趟掃描
掃描R[2..n]。掃描完畢時，"次輕"的氣泡飄浮到R[2]的位置上……
最後，經過n-1 趟掃描可得到有序區R[1..n]
注意：
第i趟掃描時，R[1..i-1]和R[i..n]分別爲當前的有序區和無序區。掃描仍是從無序區底部向上直至該區頂部。掃描完畢時，該區中最輕氣泡飄浮到頂部位置R[i]上，結果是R[1..i]變爲新的有序區。
2、冒泡排序過程示例
對關鍵字序列爲49 38 65 97 76 13 27 49的文件進行冒泡排序的過程【參見動畫演示】
3、排序算法
（1）分析
因爲每一趟排序都使有序區增加了一個氣泡，在經過n-1趟排序之後，有序區中就有n-1個氣泡，而無序區中氣泡的重量總是大於等於有序區中氣泡的重量，所以整個冒泡排序過程至多需要進行n-1趟排序。
若在某一趟排序中未發現氣泡位置的交換，則說明待排序的無序區中所有氣泡均滿足輕者在上，重者在下的原則，因此，冒泡排序過程可在此趟排序後終止。爲此，在下面給出的算法中，引入一個布爾量exchange，在每趟排序開始前，先將其置爲FALSE。若排序過程中發生了交換，則將其置爲TRUE。各趟排序結束時檢查exchange，若未曾發生過交換則終止算法，不再進行下一趟排序。
（2）具體算法
#include <stdio.h>
void sort(int a[],int n)
{
int i,j,q,temp;
for(i=0;i<n-1;i++)
{
q=1;
for(j=0;j<n-i-1;j++)
{
if(a[j]>a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
q=0;
}
}
if(q==1)
{
return;
}
}
}
int main()
{
int a[10]={9,8,7,6,5,4,3,2,1,0};
int i;
sort(a,10);
printf("the out put is\n");
for(i=0;i<10;i++)
printf("%d\n",a[i]);
return 0;
}
4、算法分析
（1）算法的最好時間複雜度
若文件的初始狀態是正序的，一趟掃描即可完成排序。所需的關鍵字比較次數C和記錄移動次數M均達到最小值：
Cmin=n-1
Mmin=0。
冒泡排序最好的時間複雜度爲O(n)。
（2）算法的最壞時間複雜度
若初始文件是反序的，需要進行n-1趟排序。每趟排序要進行n-i次關鍵字的比較(1≤i≤n-1)，且每次比較都必須移動記錄三次來達到交換記錄位置。在這種情況下，比較和移動次數均達到最大值：
Cmax=n(n-1)/2=O(n2)
Mmax=3n(n-1)/2=O(n2)
冒泡排序的最壞時間複雜度爲O(n2)。
（3）算法的平均時間複雜度爲O(n2)
雖然冒泡排序不一定要進行n-1趟，但由於它的記錄移動次數較多，故平均時間性能比直接插入排序要差得多。
（4）算法穩定性
冒泡排序是就地排序，且它是穩定的。
5、算法改進
上述的冒泡排序還可做如下的改進：
(1)記住最後一次交換髮生位置lastExchange的冒泡排序
在每趟掃描中，記住最後一次交換髮生的位置lastExchange，（該位置之前的相鄰記錄均已有序）。下一趟排序開始時，R[1..lastExchange-1]是有序區，R[lastExchange..n]是無序區。這樣，一趟排序可能使當前有序區擴充多個記錄，從而減少排序的趟數。具體算法【參見習題】。
(2) 改變掃描方向的冒泡排序
①冒泡排序的不對稱性
能一趟掃描完成排序的情況：
只有最輕的氣泡位於R[n]的位置，其餘的氣泡均已排好序，那麼也只需一趟掃描就可以完成排序。
【例】對初始關鍵字序列12，18，42，44，45，67，94，10就僅需一趟掃描。
需要n-1趟掃描完成排序情況：
當只有最重的氣泡位於R[1]的位置，其餘的氣泡均已排好序時，則仍需做n-1趟掃描才能完成排序。
【例】對初始關鍵字序列：94，10，12，18，42，44，45，67就需七趟掃描。
②造成不對稱性的原因
每趟掃描僅能使最重氣泡"下沉"一個位置，因此使位於頂端的最重氣泡下沉到底部時，需做n-1趟掃描。
③改進不對稱性的方法
在排序過程中交替改變掃描方向，可改進不對稱性。具體算法【參見習題】。
快速排序(QuickSort)
1、算法思想
快速排序是C.R.A.Hoare於1962年提出的一種劃分交換排序。它採用了一種分治的策略，通常稱其爲分治法(Divide-and-ConquerMethod)。
（1） 分治法的基本思想
分治法的基本思想是：將原問題分解爲若干個規模更小但結構與原問題相似的子問題。遞歸地解這些子問題，然後將這些子問題的解組合爲原問題的解。
（2）快速排序的基本思想
設當前待排序的無序區爲R[low..high]，利用分治法可將快速排序的基本思想描述爲：
①分解：
在R[low..high]中任選一個記錄作爲基準(Pivot)，以此基準將當前無序區劃分爲左、右兩個較小的子區間R[low..pivotpos-1)和R[pivotpos+1..high]，並使左邊子區間中所有記錄的關鍵字均小於等於基準記錄(不妨記爲pivot)的關鍵字pivot.key，右邊的子區間中所有記錄的關鍵字均大於等於pivot.key，而基準記錄pivot則位於正確的位置(pivotpos)上，它無須參加後續的排序。
注意：
劃分的關鍵是要求出基準記錄所在的位置pivotpos。劃分的結果可以簡單地表示爲(注意pivot=R[pivotpos])：
R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys
其中low≤pivotpos≤high。
②求解：
通過遞歸調用快速排序對左、右子區間R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。
③組合：
因爲當"求解"步驟中的兩個遞歸調用結束時，其左、右兩個子區間已有序。對快速排序而言，"組合"步驟無須做什麼，可看作是空操作。
2、快速排序算法QuickSort
void QuickSort(SeqList R，int low，int high)
{ //對R[low..high]快速排序
int pivotpos； //劃分後的基準記錄的位置
if(low<high){//僅當區間長度大於1時才須排序
pivotpos=Partition(R，low，high)； //對R[low..high]做劃分
QuickSort(R，low，pivotpos-1)； //對左區間遞歸排序
QuickSort(R，pivotpos+1，high)； //對右區間遞歸排序
}
} //QuickSort
注意：
爲排序整個文件，只須調用QuickSort(R，1，n)即可完成對R[l..n]的排序。
3、劃分算法Partition
（1） 簡單的劃分方法
① 具體做法
第一步：(初始化)設置兩個指針i和j，它們的初值分別爲區間的下界和上界，即i=low，i=high；選取無序區的第一個記錄R[i](即R[low])作爲基準記錄，並將它保存在變量pivot中；
第二步：令j自high起向左掃描，直到找到第1個關鍵字小於pivot.key的記錄R[j]，將R[j])移至i所指的位置上，這相當於R[j]和基準R[i](即pivot)進行了交換，使關鍵字小於基準關鍵字pivot.key的記錄移到了基準的左邊，交換後R[j]中相當於是pivot；然後，令i指針自i+1位置開始向右掃描，直至找到第1個關鍵字大於pivot.key的記錄R[i]，將R[i]移到i所指的位置上，這相當於交換了R[i]和基準R[j]，使關鍵字大於基準關鍵字的記錄移到了基準的右邊，交換後R[i]中又相當於存放了pivot；接着令指針j自位置j-1開始向左掃描，如此交替改變掃描方向，從兩端各自往中間靠攏，直至i=j時，i便是基準pivot最終的位置，將pivot放在此位置上就完成了一次劃分。
②一次劃分過程
一次劃分過程中，具體變化情況【參見動畫演示】
③劃分算法：
int Partition(SeqList R，int i，int j)
{//調用Partition(R，low，high)時，對R[low..high]做劃分，
//並返回基準記錄的位置
ReceType pivot=R[i]； //用區間的第1個記錄作爲基準 '
while(i<j){ //從區間兩端交替向中間掃描，直至i=j爲止
while(i<j&&R[j].key>=pivot.key) //pivot相當於在位置i上
j--； //從右向左掃描，查找第1個關鍵字小於pivot.key的記錄R[j]
if(i<j) //表示找到的R[j]的關鍵字<pivot.key
R[i++]=R[j]； //相當於交換R[i]和R[j]，交換後i指針加1
while(i<j&&R[i].key<=pivot.key) //pivot相當於在位置j上
i++； //從左向右掃描，查找第1個關鍵字大於pivot.key的記錄R[i]
if(i<j) //表示找到了R[i]，使R[i].key>pivot.key
R[j--]=R[i]; //相當於交換R[i]和R[j]，交換後j指針減1
} //endwhile
R[i]=pivot； //基準記錄已被最後定位
return i；
} //partition
實例：
#include <stdio.h>
int part(int a[],int i,int j)
{
int pos=a[i];
while(i<j){
while(i<j&&a[j]>=pos) j--;
if(i<j) a[i++]=a[j];
while(i<j&&a[i]<=pos) i++;
if(i<j) a[j--]=a[i];
}
a[i]=pos;
return i;
}
void quicksort(int a[], int low, int high)
{
int pos;
if(low<high){
pos=part(a,low,high);
quicksort(a,low,pos-1);
quicksort(a,pos+1,high);
}
}
int main()
{
int a[10]={29,48,7,16,325,4,3,22,112,40};
int i;
quicksort(a,0,9);
printf("the out put is\n");
for(i=0;i<10;i++)
printf("%d\n",a[i]);
return 0;
}
4、快速排序執行過程
快速排序執行的全過程可用遞歸樹來描述。
分析：
（1）遞歸執行的路線如圖中帶箭頭的包絡線所示。
（2） 遞歸樹上每一結點左旁方括號表示當前待排序的區間，結點內的關鍵字是劃分的基準關鍵字
注意：
葉結點對應的子區間只有一個關鍵字，無須劃分，故葉結點內沒有基準關鍵字
（3） 劃分後得到的左、右兩個子區間分別標在該結點的左、右兩個孩子結點的左邊方括號內。
【例】根結點左旁方括號[49，38，65，97，76，13，27，49]表示初始待排序的關鍵字，根內的49表示所選的劃分基準記錄的關鍵字，劃分結果是[27，28，13]49[76，97，65，49_]，其左右子區間分別標在根結點的兩個孩子的左邊。
（4） 每個分支結點右旁圓括號中的內容表示對該結點左旁區間的排序過程結束之後返回的結果。它是其左右孩子對應的區間排序完成之後，將左右孩子對應的排序結果分別放在該分支結點的關鍵字前後所得到的關鍵字序列。
【例】分支結點76的左右孩子對應的區間排序後的結果分別是(49_，65)和(97)，將它們分別放在76的前後即得(49，65，76，97)，這是對結點76左旁區間[76，97，，65，49]排序的結果。
（5） 算法的執行順序是遞歸樹中的箭頭順序，實際上當把劃分操作視爲訪問結點的操作時，快速排序的執行過程相當於是先序遍歷其遞歸樹。
注意：
任何遞歸算法均可用遞歸樹來描述其執行過程。
5、快速排序各次劃分後的狀態變化
[49 38 65 97 76 13 27
49] //初始關鍵字
[27 38 13] 49[76 97 6549] //第1次劃分完成之後，對應遞歸樹第2層
[13] 27
[38] 49 [49 65] 76[97]//對上一層各無序區劃分完成後，對應遞歸樹第3層
13 27 38 49 49
[65] 76 97 //對上一層各無序區劃分完成後，對應遞歸樹第4層
13 27 38 49 49 65 76 97 //最後的排序結果
6、算法分析
快速排序的時間主要耗費在劃分操作上，對長度爲k的區間進行劃分，共需k-1次關鍵字的比較。
（1）最壞時間複雜度
最壞情況是每次劃分選取的基準都是當前無序區中關鍵字最小(或最大)的記錄，劃分的結果是基準左邊的子區間爲空(或右邊的子區間爲空)，而劃分所得的另一個非空的子區間中記錄數目，僅僅比劃分前的無序區中記錄個數減少一個。
因此，快速排序必須做n-1次劃分，第i次劃分開始時區間長度爲n-i+1，所需的比較次數爲n-i(1≤i≤n-1)，故總的比較次數達到最大值：
Cmax = n(n-1)/2=O(n2)
如果按上面給出的劃分算法，每次取當前無序區的第1個記錄爲基準，那麼當文件的記錄已按遞增序(或遞減序)排列時，每次劃分所取的基準就是當前無序區中關鍵字最小(或最大)的記錄，則快速排序所需的比較次數反而最多。
（2） 最好時間複雜度
在最好情況下，每次劃分所取的基準都是當前無序區的"中值"記錄，劃分的結果是基準的左、右兩個無序子區間的長度大致相等。總的關鍵字比較次數：
0(nlgn)
注意：
用遞歸樹來分析最好情況下的比較次數更簡單。因爲每次劃分後左、右子區間長度大致相等，故遞歸樹的高度爲O(lgn)，而遞歸樹每一層上各結點所對應的劃分過程中所需要的關鍵字比較次數總和不超過n，故整個排序過程所需要的關鍵字比較總次數C(n)=O(nlgn)。
因爲快速排序的記錄移動次數不大於比較的次數，所以快速排序的最壞時間複雜度應爲0(n2)，最好時間複雜度爲O(nlgn)。
（3）基準關鍵字的選取
在當前無序區中選取劃分的基準關鍵字是決定算法性能的關鍵。
①"三者取中"的規則
"三者取中"規則，即在當前區間裏，將該區間首、尾和中間位置上的關鍵字比較，取三者之中值所對應的記錄作爲基準，在劃分開始前將該基準記錄和該區伺的第1個記錄進行交換，此後的劃分過程與上面所給的Partition算法完全相同。
②取位於low和high之間的隨機數k(low≤k≤high)，用R[k]作爲基準
選取基準最好的方法是用一個隨機函數產生一個取位於low和high之間的隨機數k(low≤k≤high)，用R[k]作爲基準，這相當於強迫R[low..high]中的記錄是隨機分佈的。用此方法所得到的快速排序一般稱爲隨機的快速排序。具體算法【參見教材】
注意：
隨機化的快速排序與一般的快速排序算法差別很小。但隨機化後，算法的性能大大地提高了，尤其是對初始有序的文件，一般不可能導致最壞情況的發生。算法的隨機化不僅僅適用於快速排序，也適用於其它需要數據隨機分佈的算法。
（4）平均時間複雜度
儘管快速排序的最壞時間爲O(n2)，但就平均性能而言，它是基於關鍵字比較的內部排序算法中速度最快者，快速排序亦因此而得名。它的平均時間複雜度爲O(nlgn)。
（5）空間複雜度
快速排序在系統內部需要一個棧來實現遞歸。若每次劃分較爲均勻，則其遞歸樹的高度爲O(lgn)，故遞歸後需棧空間爲O(lgn)。最壞情況下，遞歸樹的高度爲O(n)，所需的棧空間爲O(n)。
（6）穩定性
快速排序是非穩定的，例如[2，2，1]
