垂直排列演算法

A. 排序法都有哪些

一、插入排序(InsertionSort)
1.基本思想：
每次將一個待排序的數據元素，插入到前面已經排好序的數列中的適當位置，使數列依然有序；直到待排序數據元素全部插入完為止。
2.排序過程：
【示例】：
[初始關鍵字][49]38659776132749
J=2(38)[3849]659776132749
J=3(65)[384965]9776132749
J=4(97)[38496597]76132749
J=5(76)[3849657697]132749
J=6(13)[133849657697]2749
J=7(27)[13273849657697]49
J=8(49)[1327384949657697]

1. ProcereInsertSort(VarR:FileType);
   
2. //對R[1..N]按遞增序進行插入排序,R[0]是監視哨//
   
3. Begin
   
4. forI:=2ToNDo//依次插入R[2],...,R[n]//
   
5. begin
   
6. R[0]:=R;J:=I-1;
   
7. WhileR[0]<R[J]Do//查找R的插入位置//
   
8. begin
   
9. R[J+1]:=R[J];//將大於R的元素後移//
   
10. J:=J-1
    
11. end
    
12. R[J+1]:=R[0];//插入R//
    
13. end
    
14. End;//InsertSort//

復制代碼二、選擇排序
1.基本思想：
每一趟從待排序的數據元素中選出最小（或最大）的一個元素，順序放在已排好序的數列的最後，直到全部待排序的數據元素排完。
2.排序過程：
【示例】：
初始關鍵字[4938659776132749]
第一趟排序後13［38659776492749]
第二趟排序後1327［659776493849]
第三趟排序後132738[9776496549]
第四趟排序後13273849[49976576]
第五趟排序後1327384949[979776]
第六趟排序後132738494976[7697]
第七趟排序後13273849497676[97]
最後排序結果1327384949767697

1. ProcereSelectSort(VarR:FileType);//對R[1..N]進行直接選擇排序//
   
2. Begin
   
3. forI:=1ToN-1Do//做N-1趟選擇排序//
   
4. begin
   
5. K:=I;
   
6. ForJ:=I+1ToNDo//在當前無序區R[I..N]中選最小的元素R[K]//
   
7. begin
   
8. IfR[J]<R[K]ThenK:=J
   
9. end;
   
10. IfK<>IThen//交換R和R[K]//
    
11. beginTemp:=R;R:=R[K];R[K]:=Temp;end;
    
12. end
    
13. End;//SelectSort//

復制代碼三、冒泡排序(BubbleSort)
1.基本思想：
兩兩比較待排序數據元素的大小，發現兩個數據元素的次序相反時即進行交換，直到沒有反序的數據元素為止。
2.排序過程：
設想被排序的數組R［1..N］垂直豎立，將每個數據元素看作有重量的氣泡，根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組R，凡掃描到違反本原則的輕氣泡，就使其向上"漂浮"，如此反復進行，直至最後任何兩個氣泡都是輕者在上，重者在下為止。
【示例】：
4913131313131313
3849272727272727
6538493838383838
9765384949494949
7697654949494949
1376976565656565
2727769776767676
4949497697979797

1. ProcereBubbleSort(VarR:FileType)//從下往上掃描的起泡排序//
   
2. Begin
   
3. ForI:=1ToN-1Do//做N-1趟排序//
   
4. begin
   
5. NoSwap:=True;//置未排序的標志//
   
6. ForJ:=N-1DownTo1Do//從底部往上掃描//
   
7. begin
   
8. IfR[J+1]<R[J]Then//交換元素//
   
9. begin
   
10. Temp:=R[J+1];R[J+1:=R[J];R[J]:=Temp;
    
11. NoSwap:=False
    
12. end;
    
13. end;
    
14. IfNoSwapThenReturn//本趟排序中未發生交換，則終止演算法//
    
15. end
    
16. End;//BubbleSort//

復制代碼四、快速排序（QuickSort）
1.基本思想：
在當前無序區R[1..H]中任取一個數據元素作為比較的"基準"(不妨記為X)，用此基準將當前無序區劃分為左右兩個較小的無序區：R[1..I-1]和R[I+1..H]，且左邊的無序子區中數據元素均小於等於基準元素，右邊的無序子區中數據元素均大於等於基準元素，而基準X則位於最終排序的位置上，即R[1..I-1]≤X.Key≤R[I+1..H](1≤I≤H)，當R[1..I-1]和R[I+1..H]均非空時，分別對它們進行上述的劃分過程，直至所有無序子區中的數據元素均已排序為止。
2.排序過程：
【示例】：
初始關鍵字[4938659776132749］
第一次交換後
［2738659776134949］
第二次交換後
［2738499776136549］
J向左掃描，位置不變，第三次交換後
［2738139776496549］
I向右掃描，位置不變，第四次交換後
［2738134976976549］
J向左掃描
［2738134976976549］
（一次劃分過程）

初始關鍵字
［4938659776132749］
一趟排序之後
［273813］49［76976549］
二趟排序之後
［13］27［38］49［4965］76［97］
三趟排序之後1327384949［65］7697
最後的排序結果1327384949657697
各趟排序之後的狀態

1. ProcereParttion(VarR:FileType;L,H:Integer;VarI:Integer);
   
2. //對無序區R[1,H]做劃分，I給以出本次劃分後已被定位的基準元素的位置//
   
3. Begin
   
4. I:=1;J:=H;X:=R;//初始化，X為基準//
   
5. Repeat
   
6. While(R[J]>=X)And(I<J)Do
   
7. begin
   
8. J:=J-1//從右向左掃描，查找第1個小於X的元素//
   
9. IfI<JThen//已找到R[J]〈X//
   
10. begin
    
11. R:=R[J];//相當於交換R和R[J]//
    
12. I:=I+1
    
13. end;
    
14. While(R<=X)And(I<J)Do
    
15. I:=I+1//從左向右掃描，查找第1個大於X的元素///
    
16. end;
    
17. IfI<JThen//已找到R>X//
    
18. begin R[J]:=R;//相當於交換R和R[J]//
    
19. J:=J-1
    
20. end
    
21. UntilI=J;
    
22. R:=X//基準X已被最終定位//
    
23. End;//Parttion//

復制代碼

1. ProcereQuickSort(VarR:FileType;S,T:Integer);//對R[S..T]快速排序//
   
2. Begin
   
3. IfS<TThen//當R[S..T]為空或只有一個元素是無需排序//
   
4. begin
   
5. Partion(R,S,T,I);//對R[S..T]做劃分//
   
6. QuickSort(R,S,I-1);//遞歸處理左區間R[S,I-1]//
   
7. QuickSort(R,I+1,T);//遞歸處理右區間R[I+1..T]//
   
8. end;
   
9. End;//QuickSort//

復制代碼五、堆排序(HeapSort)
1.基本思想：
堆排序是一樹形選擇排序，在排序過程中，將R[1..N]看成是一顆完全二叉樹的順序存儲結構，利用完全二叉樹中雙親結點和孩子結點之間的內在關系來選擇最小的元素。
2.堆的定義:N個元素的序列K1,K2,K3,...,Kn.稱為堆，當且僅當該序列滿足特性：
Ki≤K2iKi≤K2i+1(1≤I≤[N/2])


堆實質上是滿足如下性質的完全二叉樹：樹中任一非葉子結點的關鍵字均大於等於其孩子結點的關鍵字。例如序列10,15,56,25,30,70就是一個堆，它對應的完全二叉樹如上圖所示。這種堆中根結點（稱為堆頂）的關鍵字最小，我們把它稱為小根堆。反之，若完全二叉樹中任一非葉子結點的關鍵字均大於等於其孩子的關鍵字，則稱之為大根堆。
3.排序過程：
堆排序正是利用小根堆（或大根堆）來選取當前無序區中關鍵字小（或最大）的記錄實現排序的。我們不妨利用大根堆來排序。每一趟排序的基本操作是：將當前無序區調整為一個大根堆，選取關鍵字最大的堆頂記錄，將它和無序區中的最後一個記錄交換。這樣，正好和直接選擇排序相反，有序區是在原記錄區的尾部形成並逐步向前擴大到整個記錄區。
【示例】：對關鍵字序列42，13，91，23，24，16，05，88建堆

1. ProcereSift(VarR:FileType;I,M:Integer);
   
2. //在數組R[I..M]中調用R，使得以它為完全二叉樹構成堆。事先已知其左、右子樹(2I+1<=M時)均是堆//
   
3. Begin
   
4. X:=R;J:=2*I;//若J<=M,R[J]是R的左孩子//
   
5. WhileJ<=MDo//若當前被調整結點R有左孩子R[J]//
   
6. begin
   
7. If(J<M)AndR[J].Key<R[J+1].KeyThen
   
8. J:=J+1//令J指向關鍵字較大的右孩子//
   
9. //J指向R的左、右孩子中關鍵字較大者//
   
10. IfX.Key<R[J].KeyThen//孩子結點關鍵字較大//
    
11. begin
    
12. R:=R[J];//將R[J]換到雙親位置上//
    
13. I:=J;J:=2*I//繼續以R[J]為當前被調整結點往下層調整//
    
14. end;
    
15. Else
    
16. Exit//調整完畢，退出循環//
    
17. end
    
18. R:=X;//將最初被調整的結點放入正確位置//
    
19. End;//Sift//

復制代碼

1. ProcereHeapSort(VarR:FileType);//對R[1..N]進行堆排序//
   
2. Begin
   
3. ForI:=NDivDownto1Do//建立初始堆//
   
4. Sift(R,I,N)
   
5. ForI:=NDownto2do//進行N-1趟排序//
   
6. begin
   
7. T:=R[1];R[1]:=R;R:=T;//將當前堆頂記錄和堆中最後一個記錄交換//
   
8. Sift(R,1,I-1)//將R[1..I-1]重成堆//
   
9. end
   
10. End;//HeapSort//

復制代碼六、幾種排序演算法的比較和選擇
1.選取排序方法需要考慮的因素：
(1)待排序的元素數目n；
(2)元素本身信息量的大小；
(3)關鍵字的結構及其分布情況；
(4)語言工具的條件，輔助空間的大小等。
2.小結：
(1)若n較小(n<=50)，則可以採用直接插入排序或直接選擇排序。由於直接插入排序所需的記錄移動操作較直接選擇排序多，因而當記錄本身信息量較大時，用直接選擇排序較好。
(2)若文件的初始狀態已按關鍵字基本有序，則選用直接插入或冒泡排序為宜。
(3)若n較大，則應採用時間復雜度為O(nlog2n)的排序方法：快速排序、堆排序或歸並排序。
快速排序是目前基於比較的內部排序法中被認為是最好的方法。
(4)在基於比較排序方法中，每次比較兩個關鍵字的大小之後，僅僅出現兩種可能的轉移，因此可以用一棵二叉樹來描述比較判定過程，由此可以證明：當文件的n個關鍵字隨機分布時，任何藉助於"比較"的排序演算法，至少需要O(nlog2n)的時間。

這句話很重要它告訴我們自己寫的演算法是有改進到最優當然沒有必要一直追求最優
(5)當記錄本身信息量較大時，為避免耗費大量時間移動記錄，可以用鏈表作為存儲結構。

B. 數據結構演算法設計C++實現

所謂排序，就是要整理文件中的記錄，使之按關鍵字遞增(或遞減)次序排列起來。其確切定義如下：
輸入：n個記錄R1，R2，…，Rn，其相應的關鍵字分別為K1，K2，…，Kn。
輸出：Ril，Ri2，…，Rin，使得Ki1≤Ki2≤…≤Kin。(或Ki1≥Ki2≥…≥Kin)。 這里，我們簡單介紹幾種排序方法，直接插入排序、希兒排序、冒泡排序、快速排序、直接選擇排序，文中所提及的代碼在IE6下測試通過。 直接插入排序基本思想
假設待排序的記錄存放在數組R[1..n]中。初始時，R[1]自成1個有序區，無序區為R[2..n]。從i=2起直至i=n為止，依次將R[i]插入當前的有序區R[1..i-1]中，生成含n個記錄的有序區。 演算法描述
function InsertSort(arr) { //插入排序->直接插入法排序
var st = new Date();
var temp, j;
for(var i=1; i<arr.length; i++) {
if((arr[i]) < (arr[i-1])) {
temp = arr[i];
j = i-1;
do {
arr[j+1] = arr[j];
j--;
}
while (j>-1 && (temp) < (arr[j]));
arr[j+1] = temp;
}//endif
}
status = (new Date() - st) + ' ms';
return arr;
} 希爾排序基本思想
先取一個小於n的整數d1作為第一個增量，把文件的全部記錄分成d1個組。所有距離為dl的倍數的記錄放在同一個組中。先在各組內進行直接插人排序；然後，取第二個增量d2<d1重復上述的分組和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有記錄放在同一組中進行直接插入排序為止。
該方法實質上是一種分組插入方法。 演算法描述
function ShellSort(arr) { //插入排序->希兒排序
var st = new Date();
var increment = arr.length;
do {
increment = (increment/3|0) + 1;
arr = ShellPass(arr, increment);
}
while (increment > 1) status = (new Date() - st) + ' ms';
return arr;
}
function ShellPass(arr, d) { //希兒排序分段執行函數
var temp, j;
for(var i=d; i<arr.length; i++) {
if((arr[i]) < (arr[i-d])) {
temp = arr[i]; j = i-d;
do {
arr[j+d] = arr[j];
j = j-d;
}
while (j>-1 && (temp) < (arr[j]));
arr[j+d] = temp;
}//endif
}
return arr;
} 再舉個例子:#include "iostream.h"
void shellSort(int *arr, int len, int *p, int len1);
int main()
{
int num[15]={100,12,20,31,1,5,44,66,61,200,30,80,150,4,8};
int i;
cout<<"待排數據d=(5,3,1): ";
for(i=0;i<15;i++)
{
cout<<num[i]<<" ";
}
int s[3]={5,3,1};
shellSort(num,15, s,3);
cout<<"\n";
return 0;
} void shellSort(int *arr, int len, int *p, int len1)
{
for (int i = 0; i < len1; i++)
{
int d = p[i];
for (int n = 0; n < d; n ++)
{
for (int j = n + d; j < len; j = j + d)
{
if (arr[j] < arr[j - d])
{
int tmp = arr[j];
for (int k = j - d; k >= 0 && arr[k] > tmp; k = k - d)
{
arr[k + d] = arr[k];
}
arr[k + d] = tmp;
}
}
}
cout<<"第"<<i+1<<"趟排序結果：";
for(int m=0;m<15;m++)
cout<<arr[m]<<" ";
cout<<"\n";
}
}
冒泡排序基本思想
將被排序的記錄數組R[1..n]垂直排列，每個記錄R[i]看作是重量為R[i].key的氣泡。根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組R：凡掃描到違反本原則的輕氣泡，就使其向上"飄浮"。如此反復進行，直到最後任何兩個氣泡都是輕者在上，重者在下為止。
演算法描述
function BubbleSort(arr) { //交換排序->冒泡排序
var st = new Date();
var temp;
var exchange;
for(var i=0; i<arr.length; i++) {
exchange = false;
for(var j=arr.length-2; j>=i; j--) {
if((arr[j+1]) < (arr[j])) {
temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
exchange = true;
}
}
if(!exchange) break;
}
status = (new Date() - st) + ' ms';
return arr;
} 快速排序基本思想
將原問題分解為若干個規模更小但結構與原問題相似的子問題。遞歸地解這些子問題，然後將這些子問題的解組合為原問題的解。
在R[low..high]中任選一個記錄作為基準(Pivot)，以此基準將當前無序區劃分為左、右兩個較小的子區間R[low..pivotpos-1)和R[pivotpos+1..high]，並使左邊子區間中所有記錄的關鍵字均小於等於基準記錄(不妨記為pivot)的關鍵字pivot.key，右邊的子區間中所有記錄的關鍵字均大於等於pivot.key，而基準記錄pivot則位於正確的位置(pivotpos)上，它無須參加後續的排序。 演算法描述
function QuickSort(arr) { //交換排序->快速排序
if (arguments.length>1) {
var low = arguments[1];
var high = arguments[2];
} else {
var low = 0;
var high = arr.length-1;
}
if(low < high){
// function Partition
var i = low;
var j = high;
var pivot = arr[i];
while(i<j) {
while(i<j && arr[j]>=pivot)
j--;
if(i<j)
arr[i++] = arr[j];
while(i<j && arr[i]<=pivot)
i++;
if(i<j)
arr[j--] = arr[i];
}//endwhile
arr[i] = pivot;
// end function
var pivotpos = i; //Partition(arr，low，high);
QuickSort(arr, low, pivotpos-1);
QuickSort(arr, pivotpos+1, high);
} else
return;
return arr;
} 直接選擇排序基本思想
n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果：
①初始狀態：無序區為R[1..n]，有序區為空。
②第1趟排序
在無序區R[1..n]中選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R[1]交換，使R[1..1]和R[2..n]分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
……
③第i趟排序
第i趟排序開始時，當前有序區和無序區分別為R[1..i-1]和R[i..n](1≤i≤n-1)。該趟排序從當前無序區中選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R[i]交換，使R[1..i]和R[i+1..n]分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
這樣，n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果。 演算法描述
function SelectSort(arr) { //選擇排序->直接選擇排序
var st = new Date();
var temp;
for(var i=0; i<arr.length; i++) {
var k = i;
for(var j=i+1; j<arr.length; j++) {
if((arr[j]) < (arr[k]))
k = j;
}
if (k != i){
temp = arr[i];
arr[i] = arr[k];
arr[k] = temp;
}
}
status = (new Date() - st) + ' ms';
return arr;
}
從運行速度上來看，快速排序是最快的。 另外把二分查找演算法也放這里算了:template<class Type> int BinarySearch(Type a[],const Type& x,int n) { int left=0; int right=n-1; while(left<=right){ int middle=(left+right)/2; if (x==a[middle]) return middle; if (x>a[middle]) left=middle+1; else right=middle-1; } return -1; }

C. 道教與佛教的三十三天有何不同。。。

論原始道教的天層，就要排除唐代後世，仿禪理篡改過天層境界的道經。例如，《玉皇經》。印光大師在《復蔡錫鼎居士書》三」中說：「《無上玉皇本行集經》乃道家竊取佛經之義偽造之經。汝不知是偽，故認做成佛已竟，方為玉帝。玉帝乃忉利天王，是欲界第二天。（中略... ）汝見《玉皇經》說得極高極深，而不知是妄人偽造之經。」 《太清元道真經》、《太上老君常說清靜經》、《太上中道妙法蓮華經》、《太上洞玄靈寶無量度人上品妙經》、《觀空篇》、《太玄真一本際經》... 等等，諸如此類，亦復如是，皆不能作為原始道教的境界參考。

道教《雲笈七簽》色界十八天：【雲其界有色無情慾，不交陰陽，人民化生。但綍香，無復便止之患，故曰色界。】佛教《瑜伽師地論》卷五，本地分中有尋有伺等三地之二雲：【一切欲界天眾，無有處女胎藏，然四大王眾天，於父母肩上或於懷中，如五歲兒歘然化出。】可以看出，即使是欲界六天最低層的四大天王，也全是化生，與道教以為的欲界六天完全不是一個層次。可以肯定，道教以為的欲界六天，比佛教欲界六天中的最低天更低。詳細對照佛經，你會發現道教並不了解佛教的三界、法界，全是盲編瞎套。

原始道教只有三十三天。道教的三清天，是南北朝末期，彷彿教的法報化三身，根據道教的元神對應佛教的法身編寫的。可是元神並不是法身，也不是阿賴耶識，屬於意識層面。主元神、復元神、三魂七魄，都是業障聚合，因果生滅的業報身。對於這一點，全真派在金朝的三次佛道御前辯論中全盤辯輸。

何為色界因？藏傳佛教《大圓滿心性休息》顯宗部分：「無念明現色界因」。色界初禪已經沒有任何念頭，但還存在比較明顯的明分，無念的心識習氣存在阿賴耶上，成為色界之因。可是頓教大乘也有「一念妄動變現十法界」的方便說法，導致上清一脈，以及全部道教主流，對佛教的天層、法界全部誤解。這種誤解，比印度的吠檀多和商羯羅更惡劣。吠檀多哲學和商羯羅，是把無色界上層的無明分覺知，淆成佛說的覺性（把非想非非想處天，錯解成佛教的色空不二）。而早期的上清系，則是把欲界上層近似於無念頭的感知（元神），混淆成佛說的覺性。

《勝鬘寶窟》卷下：「此言三十三天者，中國（新中國成立後新譯）言悉怛梨余惡衛陵，此中唯取怛梨二字為忉利天也。怛梨，忉利，彼國音不同耳。」《大智度論》卷九：「須彌山高八萬四千由旬，上有三十三天城。」在須彌山頂中央，為「帝釋天」，四方各有八天，合為「三十三天」。四方各有金剛手葯叉為守護神。」原始道教的三十三天，就是佛教的三十三天。玉皇大帝，就是佛教的忉利天，在欲界第二天三十三天的中心。天位對應完全吻合。

道教三十六天結構（未亂套佛經欲界、色界、無色界、法界概念前的原貌）

大羅天（可化三清天、三十六天）

玉清天

上清天

太清天

玉皇天：在三十三天中心的玉皇閣。主宰日月，運行日月。

玉皇大帝對應先天八卦位的中心，先天八卦位的東南西北四方對應四御，四御協助玉皇大帝各管八天，四方合共三十二天：黃曾天、玉完天、何童天、平育天、舉文天、摩夷天、越沖天、蒙翳天、和陽天、恭華天、宗飄天、皇笳天、堂曜天、端靜天、恭慶天、極瑤天、孔升天、皇厓天、極風天、孝芒天、翁重天、江由天、阮樂天、曇誓天、霄慶天、元洞天、妙成天、禁上天、常融天、玉隆天、梵度天、賈奕天。連中央的玉皇天，共三十三天。加上太清、上清、玉清，是道教全部三十六天。

—— 可對照《雲笈七簽》《度人經》

佛教欲界諸天之道教三十六天排法

他化自在天：空居天，未來禪（可於第六意識幻化以下諸天人境）

化樂天：空居天，欲界定。

兜率天：空居天，細心住。

夜摩天：空居天，粗心住。

忉利天：地居天，居三十三天中心的喜見城天。超日月明，運行日月。

忉利天對應須彌山頂的中心，須彌山腰處的東南西北四方對應四天王天，四天王協助忉利天各管八天，四方合共三十二天：善法堂天、山峰天、山頂天、缽私他天、俱吒天、雜殿天、歡喜園天、光明天、波利耶多天、離險岸天、谷崖岸天、摩尼藏天、施行天、金殿天、鬘形天、柔軟天、雜庄嚴天、如意天、微細行天、歌音樂天、威德輪天、日行天、閻摩那娑羅天、連行天、影照天、智慧行天、眾分天、曼陀羅天、上行天、威德顏天、威德焰輪光天、清凈天。連中央的忉利天，共三十三天。加上夜摩天、兜率天、化樂天，是他化自在天第六意識下受用的全部欲界三十六天。

—— 依據《正法念處經》

日月：指一須彌（卍）世界單位的兩極。

真假三界：每個宗教都有三界、三天的說法。神祖人三界，天人地三界，種種三界，都是依上中下三界劃分。只有佛經嚴謹的劃分了：三十三天以下的諸天地人境，以及三十三天以上的粗心住、細心住、欲界定、未來禪，初禪三天，二禪三天、三禪三天、四禪九天，無色界四空天；並詳細嚴謹的闡述了每一天的成因、性質、受用、身量和壽量。若不了解佛教的天層次第，只是以淺陋的上中下關系劃分三界，大三界蘊含無量小三界，真三界蘊含無量大三界，大小三界的相對原理雷同，就很容易搞混。

三十三天：原始儒道眼裡的超越善惡，在欲界第二天，一個基本的宇宙單位「卍」以這里為中心。人間一切因果律法，由這里維持平衡。例如：印度禪宗傳到達摩為第二十八代，印度禪宗在中國到六祖止傳時是三十三代。耶穌三十三歲傳道圓滿，行使了三十三次奇跡。阿們在數字上等於三十三。人類脊椎骨共有三十三塊。等等... 在自然科學中，三十三是黃金分割數列。

三十三天以上屬空居天，是「道」的境界，「禪」的境界，屬於粗心住、細心住、欲界定和未來禪的階段。

三十三天以下屬地居天，是「教」的境界，「理性思維」的境界，人間一切宗教、包括佛教，由這里產生。

三十三天以上傳道不傳教，三十三天以下還未入道，只能傳教。

兜率天：未來佛彌勒菩薩現居都率天，將來下生人間成佛，並在末法之後再度開弘佛法。當年釋迦摩尼也是從都率天下生人間示現成佛。一貫道和道教靈寶派眼中的元始天尊弟子化佛就在這個地方，商羯羅眼中的毗濕奴化身佛也在這個地方。這些佛菩薩偶像只是如來的方便法門，是六地菩薩化身為魔王「毗舍闍摩醯首羅」，魔王化身為三界，依靠魔子「他化自在天」的願力，顯化在欲界諸天的層層國土，以及「都率天」的佛菩薩偶像。所以，欲界天也有佛，也有聲聞、圓覺、菩薩。就像我們人間也有釋迦摩尼，也有活佛、活四聖。但這些偶像都是虛幻的，無常的，和生活中的其它人事物一樣，是心識投射的幻相。

D. c語言冒泡排序的編程

#include <stdio.h>
void sort(int *a,int len)
{int i=0;
int j;
int t;
for(i=0;i<len-1;i++)
{
for(j=0;j<len-i-1;j++)
{
if(a[j]>a[j+1])
{
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
}
}
int main(int argc, char *argv[])
{
int a[10]={
-999,2,3,77,12,88,0,-8,99,100
};
int i=0;
sort(a,10);
for(i=0;i<10;i++)
{
printf(%d ,a[i]);
}
return 0;
}
冒泡演算法冒泡排序的演算法分析與改進 交換排序的基本思想是：兩兩比較待排序記錄的關鍵字，發現兩個記錄的次序相反時即進行交換，直到沒有反序的記錄為止。 應用交換排序基本思想的主要排序方法有：冒泡排序和快速排序。
冒泡排序 1、排序方法 將被排序的記錄數組R[1..n]垂直排列，每個記錄R看作是重量為R.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上，結果是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）具體演算法 void BubbleSort(SeqList R) { //R（l..n)是待排序的文件，採用自下向上掃描，對R做冒泡排序 int i，j； Boolean exchange； //交換標志 for(i=1;i<n;i++){ //最多做n-1趟排序 exchange=FALSE； //本趟排序開始前，交換標志應為假 for(j=n-1;j>=i；j--) //對當前無序區R[i..n]自下向上掃描 if(R[j+1].key<R[j].key){//交換記錄 R[0]=R[j+1]； //R[0]不是哨兵，僅做暫存單元 R[j+1]=R[j]； R[j]=R[0]； exchange=TRUE； //發生了交換，故將交換標志置為真 } if(!exchange) //本趟排序未發生交換，提前終止演算法 return； } //endfor(外循環) } //BubbleSort
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趟掃描。 ③改進不對稱性的方法 在排序過程中交替改變掃描方向，可改進不對稱性。

E. 用java中ArrayList類實現一個冒泡排序

java.util.Collections類中有
sort
public static <T extends Comparable<? super T>> void sort(List<T> list)根據元素的自然順序 對指定列表按升序進行排序。列表中的所有元素都必須實現 Comparable 介面。此外，列表中的所有元素都必須是可相互比較的（也就是說，對於列表中的任何 e1 和 e2 元素，e1.compareTo(e2) 不得拋出 ClassCastException）。
此排序方法具有穩定性：不會因調用 sort 方法而對相等的元素進行重新排序。

指定列表必須是可修改的，但不必是大小可調整的。

該排序演算法是一個經過修改的合並排序演算法（其中，如果低子列表中的最高元素小於高子列表中的最低元素，則忽略合並）。此演算法提供可保證的 n log(n) 性能。 此實現將指定列表轉儲到一個數組中，並對數組進行排序，在重置數組中相應位置處每個元素的列表上進行迭代。這避免了由於試圖原地對鏈接列表進行排序而產生的 n2 log(n) 性能。

參數：
list - 要排序的列表。
拋出：
ClassCastException - 如果列表包含不可相互比較 的元素（例如，字元串和整數）。
UnsupportedOperationException - 如果指定列表的列表迭代器不支持 set 操作。
另請參見：
Comparable

--------------------------------------------------------------------------------

sort
public static <T> void sort(List<T> list,
Comparator<? super T> c)根據指定比較器產生的順序對指定列表進行排序。此列表內的所有元素都必須可使用指定比較器相互比較（也就是說，對於列表中的任意 e1 和 e2 元素，c.compare(e1, e2) 不得拋出 ClassCastException）。
此排序被保證是穩定的：不會因調用 sort 而對相等的元素進行重新排序。

排序演算法是一個經過修改的合並排序演算法（其中，如果低子列表中的最高元素小於高子列表中的最低元素，則忽略合並）。此演算法提供可保證的 n log(n) 性能。 指定列表必須是可修改的，但不必是可大小調整的。此實現將指定列表轉儲到一個數組中，並對數組進行排序，在重置數組中相應位置每個元素的列表上進行迭代。這避免了由於試圖原地對鏈接列表進行排序而產生的 n2 log(n) 性能。

參數：
list - 要排序的列表。
c - 確定列表順序的比較器。null 值指示應該使用元素的自然順序。
拋出：
ClassCastException - 如果列表中包含不可使用指定比較器相互比較 的元素。
UnsupportedOperationException - 如果指定列表的列表迭代器不支持 set 操作。
另請參見：
Comparator

F. 一段代碼如下：

交換排序的基本思想是：兩兩比較待排序記錄的關鍵字，發現兩個記錄的次序相反時即進行交換，直到沒有反序的記錄為止。
應用交換排序基本思想的主要排序方法有：冒泡排序和快速排序。

冒泡排序

冒泡排序（Bubble Sorting）的基本思想是：設待排序n個元素存放在數組a[n]中,無序區范圍初始為(a(0),a(1),a(2),...,a[n-1]),冒泡排序方法是在當前無序區內,從最上面的元素a[0]開始,對每兩個相鄰的元素a[i+1]和a[i](i=0,1,...,n-1)進行比較,且使值較小的元素換至值較大的元素之上(若a[i]>a[i+1],則a[i]和a[i+1]的值互換),這樣經過一趟冒泡排序後,假設最後下移的元素為a[k],則無序區中值較大的幾個元素到達下端並從小到大依次存放在a[k+1],a[k+2],...a[n-1]中,這樣無序區范圍變為(a[0],a[1],a[2],...,a[k])。在當前無序區內進行下一趟冒泡排序。這個過程一直到某一趟排序中不出現元素交換的動作，排序結束。整個排序過程最多執行n-1遍。這種排序方法是通過相鄰元素之間的比較與交換，使值較小的元素逐漸從後部移向前部（從下標較大的單元移向下標較小的單元），就象水底下的氣泡一樣逐漸向上冒。故稱為冒泡排序法。
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）具體演算法
void BubbleSort(SeqList R)
{ //R（l..n)是待排序的文件，採用自下向上掃描，對R做冒泡排序
int i，j；
Boolean exchange； //交換標志
for(i=1;i<n;i++){ //最多做n-1趟排序
exchange=FALSE； //本趟排序開始前，交換標志應為假
for(j=n-1;j>=i；j--) //對當前無序區R[i..n]自下向上掃描
if(R[j+1].key<R[j].key){//交換記錄
R[0]=R[j+1]； //R[0]不是哨兵，僅做暫存單元
R[j+1]=R[j]；
R[j]=R[0]；
exchange=TRUE； //發生了交換，故將交換標志置為真
}
if(!exchange) //本趟排序未發生交換，提前終止演算法
return；
} //endfor(外循環)
} //BubbleSort
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趟掃描。

③改進不對稱性的方法
在排序過程中交替改變掃描方向，可改進不對稱性。

G. 初始狀態有序的表,哪種排序方式最快

用直接插入排序最快。

表格，又稱為表，既是一種可視化交流模式，又是一種組織整理數據的手段。人們在通訊交流、科學研究以及數據分析活動當中廣泛採用著形形色色的表格。各種表格常常會出現在印刷介質、手寫記錄、計算機軟體、建築裝飾、交通標志等許許多多地方。

隨著上下文的不同，用來確切描述表格的慣例和術語也會有所變化。此外，在種類、結構、靈活性、標注法、表達方法以及使用方面，不同的表格之間也炯然各異。在各種書籍和技術文章當中，表格通常放在帶有編號和標題的浮動區域內，以此區別於文章的正文部分。

排版

先將表格的左右寬度適當縮小，再將整個表格調整到文檔的居中位置，然後進行以下操作：

① 用"表格和邊框"工具欄上的"對齊"按鈕，將最後一行以外的各行設置為垂直居中；

② 用"表格和邊框"工具欄上的"對齊"按鈕，將最後一行設置為底端對齊；

表格中文字的方向可使用工具欄上的"更改文字方向"按鈕進行調整。

方法

好的排序方法可以有效提高排序速度，提高排序效果。

在計算機領域主要使用數據排序方法根據佔用內存的方式不同分為2大類：內部排序方法與外部排序方法。

內部排序方法

若整個排序過程不需要訪問外存便能完成，則稱此類排序問題為內部排序。

內排序的方法有許多種，按所用策略不同，可歸納為五類：插入排序、選擇排序、交換排序、歸並排序和基數排序。

H. 最快的排序方法和題目.

快速排序是對冒泡排序的一種改進。它的基本思想是：通過一躺排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一不部分的所有數據都要小，然後再按次方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

假設要排序的數組是A[1]……A[N]，首先任意選取一個數據（通常選用第一個數據）作為關鍵數據，然後將所有比它的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一躺快速排序。一躺快速排序的演算法是：

1）、設置兩個變數I、J，排序開始的時候I：=1，J：=N；

2）以第一個數組元素作為關鍵數據，賦值給X，即X：=A[1]；

3）、從J開始向前搜索，即由後開始向前搜索（J：=J-1），找到第一個小於X的值，兩者交換；

4）、從I開始向後搜索，即由前開始向後搜索（I：=I+1），找到第一個大於X的值，兩者交換；

5）、重復第3、4步，直到I=J；

例如：待排序的數組A的值分別是：（初始關鍵數據X：=49）

A[1] A[2] A[3] A[4] A[5] A[6] A[7]：

49 38 65 97 76 13 27

進行第一次交換後： 27 38 65 97 76 13 49

( 按照演算法的第三步從後面開始找

進行第二次交換後： 27 38 49 97 76 13 65

( 按照演算法的第四步從前面開始找>X的值，65>49,兩者交換，此時I：=3 )

進行第三次交換後： 27 38 13 97 76 49 65

( 按照演算法的第五步將又一次執行演算法的第三步從後開始找

進行第四次交換後： 27 38 13 49 76 97 65

( 按照演算法的第四步從前面開始找大於X的值，97>49,兩者交換，此時J：=4 )

此時再執行第三不的時候就發現I=J，從而結束一躺快速排序，那麼經過一躺快速排序之後的結果是：27 38 13 49 76 97 65，即所以大於49的數全部在49的後面，所以小於49的數全部在49的前面。

快速排序就是遞歸調用此過程——在以49為中點分割這個數據序列，分別對前面一部分和後面一部分進行類似的快速排序，從而完成全部數據序列的快速排序，最後把此數據序列變成一個有序的序列，根據這種思想對於上述數組A的快速排序的全過程如圖6所示：

初始狀態 {49 38 65 97 76 13 27}

進行一次快速排序之後劃分為 {27 38 13} 49 {76 97 65}

分別對前後兩部分進行快速排序 {13} 27 {38}

結束 結束 {49 65} 76 {97}

49 {65} 結束

結束

圖6 快速排序全過程

1）、設有N（假設N=10）個數，存放在S數組中；
2）、在S[1。。N]中任取一個元素作為比較基準，例如取T=S[1]，起目的就是在定出T應在排序結果中的位置K，這個K的位置在：S[1。。K-1]<=S[K]<=S[K+1..N]，即在S[K]以前的數都小於S[K]，在S[K]以後的數都大於S[K]；

3）、利用分治思想（即大化小的策略）可進一步對S[1。。K-1]和S[K+1。。N]兩組數據再進行快速排序直到分組對象只有一個數據為止。 1 2 3 4 5 6 7 8 9 10

如具體數據如下，那麼第一躺快速排序的過程是：

數組下標：

45 36 18 53 72 30 48 93 15 36

5） 36 36 18 15 30 45 48 93 72 534） 36 36 18 15 45 30 48 93 72 533） 36 36 18 15 72 30 48 93 45 532） 36 36 18 45 72 30 48 93 15 53

program kuaisu(input,output);
const n=10;
var
s:array[1..10] of integer;
k,l,m:integer;

procere qsort(lx,rx:integer);
var
I,j,t:integer;
Begin
I:lx;j:rx;t:s[I];
Repeat
While (s[j]>t) and (j>I) do
Begin
k:=k+1;
j:=j-1
end;
if I<j then
begin
s[I]:=s[j];I:=I+1;l:=l+1;
while (s[I]<t) and (I<j) do
begin
k:=k+1;
I:=I+1
End;
If I<j then
begin
S[j]:=s[I];j:=j-1;l:=l+1;
End;
End;
Until I=j;
S[I]:=t;I:=I+1;j:=j-1;l:=l+1;
If lx<j then qsort(lx,j);
If I<rx then qsort(I,rx)
End;{過程qsort結束}

Begin
Writeln('input 10 integer num:');
For m:=1 to n do read(s[m]);
K:=0;l:=0;
Qsort(l,n);
Writeln('排序後結果是：')；
For m:=1 to n do write(s[m]:4)
End.

通過一躺排序將45放到應該放的位置K，這里K=6，那麼再對S[1。。5]和S[6。。10]分別進行快速排序。程序代碼如下：<49,兩者交換，此時J:=6>

I. C語言冒泡排序不太理解

C語言冒泡排序就是將被排序的記錄數組R[1..n]垂直排列，每個記錄R看作是重量為R.key的氣泡。根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組R：凡掃描到違反本原則的輕氣泡，就使其向上"飄浮"。如此反復進行，直到最後任何兩個氣泡都是輕者在上，重者在下為止。
冒泡演算法冒泡排序的演算法分析與改進 交換排序的基本思想是：
兩兩比較待排序記錄的關鍵字，發現兩個記錄的次序相反時即進行交換，直到沒有反序的記錄為止。 應用交換排序基本思想的主要排序方法有：冒泡排序和快速排序。
冒泡排序
1、排序方法 將被排序的記錄數組R[1..n]垂直排列，每個記錄R看作是重量為R.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上，結果是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）具體演算法 void BubbleSort(SeqList R) { //R（l..n)是待排序的文件，採用自下向上掃描，對R做冒泡排序 int i，j； Boolean exchange； //交換標志 for(i=1;i<n;i++){ //最多做n-1趟排序 exchange=FALSE； //本趟排序開始前，交換標志應為假 for(j=n-1;j>=i；j--) //對當前無序區R[i..n]自下向上掃描 if(R[j+1].key<R[j].key){//交換記錄 R[0]=R[j+1]； //R[0]不是哨兵，僅做暫存單元 R[j+1]=R[j]； R[j]=R[0]； exchange=TRUE； //發生了交換，故將交換標志置為真 } if(!exchange) //本趟排序未發生交換，提前終止演算法 return； } //endfor(外循環) } //BubbleSort
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趟掃描。 ③改進不對稱性的方法 在排序過程中交替改變掃描方向，可改進不對稱性。