幾種簡單排序方法

1. 排序方法都有哪幾種，比如1、2、3。。。。。。甲乙丙丁等

排序方法一般都就那幾種。像冒泡排序，直接插入排序，快速排序，簡單選擇排序，希爾排序，堆排序。其排序介紹自己看吧。
1、冒泡排序屬於穩定排序，是一種藉助「交換」進行排序的方法。首先要將第一個記錄的關鍵字和第二個記錄的關鍵字進行比較，若為逆序，則將兩個記錄交換之，然後比較第二個記錄與第三個記錄的關鍵字，以此類推，直至第n-1個記錄與第n個記錄的關鍵字進行比較為止，這一過程稱為第一趟冒泡排序，其結果使得關鍵字最大的記錄被安置在最後一個記錄的位置上；然後進行第二趟冒泡排序，對前N-1個記錄進行同樣操作；以此類推，直到在一趟排序過程中沒有進行過交換記錄的操作為止。
2、直接插入排序屬於穩定的排序，每次從無序表中取出第一個元素，把它插入到有序表的合適位置，使有序表仍然有序。第一趟將待比較的數值與它的前一個數值進行比較，當前一數值比待比較數值大的情況下繼續循環比較，依次進行下去，進行了(n-1)趟掃描以後就完成了整個排序過程，結束該次循環。
3、快速排序屬於不穩定排序，是對起泡排序的一種改進。它的基本思想是，通過一趟排序將待排記錄分割成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分記錄的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。假設待排序的序列為{R.[s],R.[s+1],…….,R.[t]},首先任意選取一個記錄，然後按下述原則從新排序記錄：將關鍵字較他小的記錄都安置在他的位置之前，將所有關鍵字較他大的記錄都安置在他的位置後面。由此可以該「樞軸」記錄最後所落的位置i作為分界線，將序列{R[s],R[s+1]…….R[t]}分割成兩個子序列｛R[s],R[s+1]…..R[i-1]｝和｛R[i+1]……R[t]｝，這個過程稱作一趟快速排序。一趟快速排序的具體做法是：附設兩個指針low和high，它們的初值分別指向數組第一個數據和最後一個數據，將樞軸記錄暫存在R[0]的位置上排序過程中只作R[low]或R[high]的單向移動，直至一趟排序結束後再將樞軸記錄移至正確位置上。
4、簡單選擇排序屬於不穩定排序，基本思想是，每一趟在n-i+1（i=1，2，…n-1）個記錄中選取關鍵字最小的記錄作為有序序列中第i個記錄。第i趟簡單選擇排序是指通過n-i次關鍵字的比較，從n-i+1個記錄中選出關鍵字最小的記錄，並和第i個記錄進行交換。共需進行n-1趟比較，直到所有記錄排序完成為止。例如：進行第i趟選擇時，從當前候選記錄中選出關鍵字最小的k號記錄，並和第i個記錄進行交換。
5、希爾排序屬於不穩定排序，也是一種屬插入排序類，它的基本思想是：先將整個待排記錄序列分割稱為若干個子序列分別進行直接插入排序，待整個序列中記錄「基本有序」時，再對全體記錄進行一次直接插入排序。希爾排序的一個特點是：子序列的構成不是簡單的「逐段分割」，而是將相隔某個「增量」的記錄組成一個子序列。
6、堆排序屬於不穩定排序，它的基本思想是，先將初始文件R[1..n]建成一個大根堆，此堆為初始的無序區，再將關鍵字最大的記錄R[1](即堆頂)和無序區的最後一個記錄R[n]交換，由此得到新的無序區R[1..n-1]和有序區R[n]，且滿足R[1..n-1].keys≤R[n].key；由於交換後新的根R[1]可能違反堆性質，故應將當前無序區R[1..n-1]調整為堆，然後再次將R[1..n-1]中關鍵字最大的記錄R[1]和該區間的最後一個記錄R[n-1]交換，由此得到新的無序區R[1..n-2]和有序區R[n-1..n]，且仍滿足關系R[1..n- 2].keys≤R[n-1..n].keys，同樣要將R[1..n-2]調整為堆。直到無序區只有一個元素為止

2. 排序法都有哪些

一、插入排序(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)當記錄本身信息量較大時，為避免耗費大量時間移動記錄，可以用鏈表作為存儲結構。

3. 排序法都有哪些

排序法可分為簡單排序法和交替排序法。

4. 幾種常見簡單排序演算法

排序演算法一般分為以下幾種：
（1）非線性時間比較類排序：交換類排序（快速排序和冒泡排序）、插入類排序（簡單插入排序和希爾排序）、選擇類排序（簡單選擇排序和堆排序）、歸並排序（二路歸並排序和多路歸並排序）；
（2）線性時間非比較類排序：計數排序、基數排序和桶排序。

5. JAVA中有哪幾種常用的排序方法

1、冒泡排序
冒泡排序是一個比較簡單的排序方法。在待排序的數列基本有序的情況下排序速度較快。若要排序的數有n個，則需要n-1輪排序，第j輪排序中，從第一個數開始，相鄰兩數比較，若不符合所要求的順序，則交換兩者的位置；直到第n+1-j個數為止，第一個數與第二個數比較，第二個數與第三個數比較，......，第n-j個與第n+1-j個比較，共比較n-1次。此時第n+1-j個位置上的數已經按要求排好，所以不參加以後的比較和交換操作。例如：第一輪排序：第一個數與第二個數進行比較，若不符合要求的順序，則交換兩者的位置，否則繼續進行二個數與第三個數比較......。直到完成第n-1個數與第n個數的比較。此時第n個位置上的數已經按要求排好，它不參與以後的比較和交換操作；第二輪排序：第一個數與第二個數進行比較，......直到完成第n-2個數與第n-1個數的比較；......第n-1輪排序：第一個數與第二個數進行比較，若符合所要求的順序，則結束冒泡法排序；若不符合要求的順序，則交換兩者的位置，然後結束冒泡法排序。
共n-1輪排序處理，第j輪進行n-j次比較和至多n-j次交換。
從以上排序過程可以看出，較大的數像氣泡一樣向上冒，而較小的數往下沉，故稱冒泡法。

2、選擇排序
選擇法的原理是先將第一個數與後面的每一個數依次比較,不斷將將小的賦給第一個數,從而找出最小的,然後第二個數與後面的每一個數依次比較,從而找出第二小的,然後第三個數與後面的

3、插入排序
插入排序的原理是對數組中的第i個元素，認為它前面的i-1個已經排序好，然後將它插入到前面的i-1個元素中。插入排序對少量元素的排序較為有效.

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

6. 常見的排序方法有哪些

一、直接插入排序(插入排序)。二、希爾排序(插入排序)三、冒泡排序(交換排序)四、快速排序(交換排序)五、直接選擇排序(選擇排序)六、堆排序七、歸並排序
八、
基數排序

7. Excel表格排序的幾種方法

方法一：日期按時間排序
進入到操作界面，如圖所示，首先選中需要排序的單元格區域，在選中開始菜單上的「數據」，至「排序」選項卡，在彈出的「自定義排序次序」中找到日期的排序方式即可，然後在點擊確定即可完成操作，
相關教程：excel輸入日期
現在我們來預覽排序完成後的效果吧。
方法二：數據按住數字大小排序
進入到操作幾面，小編隨便輸入幾個數字
選中需要排序的單元格，在選中開始菜單上的「數據」，至「排序」選項卡，然後在點擊「選項」命令，彈出「排序選項」，然後直接點擊「按列排序」方式，即可這樣單元格裡面的數字就是按列小到大的排序了。
方法三：名稱按字母來排序
小編就隨便輸入幾個名字。同樣按照上面的方式，進入到排序選項窗口
然後在「排序選項」上選擇「按字母排序」即可完成操作了
你可以還想了解：excel中如何拆分和凍結單元格
方法四：當然，這幾種方式還是比較簡單的，常用的幾種方法。有的時候需要按別的方式排序的話，就可以再「自定義選項」中添加排序方式即可
以上就是Excel表格排序的幾種方法。所有的排序要先選擇要排序的內容，要包括每列表頭，然後點「數據
-
排序
」在對話框里選擇「主關鍵字」、或次關鍵字，再選擇排序順序，排序方式按從大到小或從小到大。

8. 排序有幾種方法

一. 冒泡排序

冒泡排序是是一種簡單的排序演算法。它重復地遍歷要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把它們交換過來。遍歷數列的工作是重復的進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢「浮」到數列的頂端

1.冒泡排序演算法的運作如下：
（1）比較相鄰的元素。如果第一個比第二個大（升序），就交換他們兩個
（2）對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素還是最大的數
（3）針對所有的元素重復以上的步驟，除了最後一個
二. 選擇排序
選擇排序是一種簡單直觀的排序演算法。他的工作原理如下：
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置（末尾位置），然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢
選擇排序的主要優點與數據移動有關。如果某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，他們當中至少有一個將被移到最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動 元素的排序方法中，選擇排序屬於非常好的一種
三. 插入排序

插入排序是一種簡單直觀的排序演算法。它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在從後向前掃描的過程中，需要反復把已排序元素逐步向後挪位，為最新元素提供插入空間
四. 快速排序
快速排序，又稱劃分交換排序。通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都要小，然後再按此方法對兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列
五 希爾排序過程

希爾排序是插入排序的一種，也稱縮小增量排序，是直接插入排序演算法的一種更高效的改進版本。希爾排序是非穩定排序演算法。希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序演算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，演算法便終止。
六. 歸並排序

歸並排序是採用分治法（把復雜問題分解為相對簡單的子問題，分別求解，最後通過組合起子問題的解的方式得到原問題的解）的一個非常典型的應用。歸並排序的思想就是先遞歸分解數組，再合並數組

將數組分解最小之後，然後合並兩個有序數組，基本思路是比較兩個數組的最前面的數，水小九先取誰，取了後相應的指針就往後移一位。然後比較，直至一個數組為空，最後把另一個數組的剩餘部分復制過來即可

9. 幾種排序方法

這兩天復習了一下排序方面的知識，現將目前比較常見的整理一下。 選擇排序選擇排序的思想是首先先找到序列中最大元素並將它與序列中最後一個元素交換，然後找下一個最大元素並與倒數第二個元素交換，依次類推。此排序很簡單，這不做多說，代碼實現如下：View Code插入排序演算法流程：1. 從第一個元素開始，該元素可以認為已經被排序 2. 取出下一個元素，在已經排序的元素序列中從後向前掃描 3. 如果該元素（已排序）大於新元素，將該元素移到下一位置 4. 重復步驟3，直到找到已排序的元素小於或者等於新元素的位置 5. 將新元素插入到下一位置中 6. 重復步驟2View Code冒泡排序依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。至此第一趟結束，將最大的數放到了最後。在第二趟：仍從第一對數開始比較（因為可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個數），將小數放前，大數放後，一直比較到倒數第二個數（倒數第一的位置上已經是最大的），第二趟結束，在倒數第二的位置上得到一個新的最大數（其實在整個數列中是第二大的數）。如此下去，重復以上過程，直至最終完成排序。 View Code合並排序在介紹合並排序之前，首先介紹下遞歸設計的技術，稱為分治法。分治法的核心思想是：當問題比較小時，直接解決。當問題比較大時，將問題分為兩個較小的子問題，每個子問題約為原來的一半。使用遞歸調用解決每個子問題。遞歸調用結束後，常常需要額外的處理，將較小的問題的結果合並，得到較大的問題的答案。 合並排序演算法在接近數組中間的位置劃分數組，然後使用遞歸運算對兩個一半元素構成的數組進行排序，最後將兩個子數組進行合並，形成一個新的已排好序的數組。 代碼如下：View Code快速排序快速排序與合並排序有著很多相似性。將要排序的數組分成兩個子數組，通過兩次遞歸調用分別對兩個數組進行排序，再將已經排好序的兩個數組合並成一個獨立的有序數組。但是，將數組一分為二的做法比合並排序中使用的簡單方法復雜的多。它需要將所有小於或者等於基準元素的元素放置到基準元素前面的位置，將大於基準的元素放置到基準後面的位置。 View Code堆排序View Code大概常用的幾種排序就這幾種，希望大家多多指正。