參考：http://blog.csdn.net/hguisu/article/details/7776068

概述

排序有內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。

我們這裡說說八大排序就是內部排序。

    

    當n較大，則應採用時間複雜度為O(nlog2n)的排序方法：快速排序、堆排序或歸併排序序。

   快速排序：是目前基於比較的內部排序中被認為是最好的方法，當待排序的關鍵字是隨機分佈時，快速排序的平均時間最短；

1.插入排序—直接插入排序(Straight Insertion Sort)

基本思想:

將一個記錄插入到已排序好的有序表中，從而得到一個新，記錄數增1的有序表。即：先將序列的第1個記錄看成是一個有序的子序列，然後從第2個記錄逐個進行插入，直至整個序列有序為止。

要點：設立哨兵，作為臨時儲存和判斷陣列邊界之用。

直接插入排序示例：

如果碰見一個和插入元素相等的，那麼插入元素把想插入的元素放在相等元素的後面。所以，相等元素的前後順序沒有改變，從原無序序列出去的順序就是排好序後的順序，所以插入排序是穩定的。

演算法的實現：

1. publicstaticvoid inser(int a[], int n)    
2.     {    
3.         for(int i= 1; i<n; i++){    
4.             if(a[i] < a[i-1]){               //若第i個元素大於i-1元素，直接插入。小於的話，移動有序表後插入  
5.                 int j= i-1;     
6.                 int tmp = a[i];        //複製為哨兵，即儲存待排序元素  
7.                 while(j >= 0 && tmp < a[j]){  //查詢在有序表的插入位置  
8.                     a[j+1] = a[j];    
9.                     j--;         //元素後移  
10.                 }    
11.                 a[j+1] = tmp;      //插入到正確位置  
12.             }    
13.         }    
14.         for(int i=0;i<n;i++){  
15.             System.out.print(a[i]+",");  
16.         }  
17.     }    
18.     publicstaticvoid main(String[] args) {  
19.         int[] arr = {3,1,5,7,2,4,9,6};  
20.         inser(arr,8);  
21.     }  

效率：

時間複雜度：O（n^2）.

其他的插入排序有二分插入排序，2-路插入排序。

 2. 插入排序—希爾排序（Shell`s Sort）

希爾排序是1959 年由D.L.Shell 提出來的，相對直接排序有較大的改進。希爾排序又叫縮小增量排序。希爾排序是非穩定排序演算法。

基本思想：

希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序演算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個檔案恰被分成一組，演算法便終止。

操作方法：

排序過程：先取一個正整數d1<n，把所有序號相隔d1的陣列元素放一組，組內進行直接插入排序；然後取d2<d1，重複上述分組和排序操作；直至di=1，即所有記錄放進一個組中排序為止。

演算法實現：

我們簡單處理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n為要排序數的個數

即：先將要排序的一組記錄按某個增量d（n/2,n為要排序數的個數）分成若干組子序列，每組中記錄的下標相差d.對每組中全部元素進行直接插入排序，然後再用一個較小的增量（d/2）對它進行分組，在每組中再進行直接插入排序。繼續不斷縮小增量直至為1，最後使用直接插入排序完成排序。

[javascript] view plain copy

1. var arr=[49,38,65,97,76,13,27,49,55,04],  
2. len=arr.length;  
3. for(var fraction=Math.floor(len/2);fraction>0;fraction=Math.floor(fraction/2)){  
4.     for(var i=fraction;i<len;i++){  
5.        for(var j=i-fraction;j>=0&&arr[j]>arr[fraction+j];j-=fraction){  
6.            var temp=arr[j];  
7.            arr[j]=arr[fraction+j];  
8.            arr[fraction+j]=temp;  
9.        }  
10.     }  
11. }  
12. console.log(arr);  

1. publicstaticvoid main(String [] args)  
2.     {  
3.             int[] a={49,38,65,97,76,13,27,49,78,34,12,64,1,77,88,99,100,11,22,33,44,55,66};  
4.             //希爾排序
5.             int d=a.length;  
6.             while(true){  
7.                 d=d/2;  
8.                 for(int x=0;x<d;x++){  
9.                    for(int i=x+d;i<a.length;i=i+d){  
10.                        int temp=a[i];  
11.                        int j;  
12.                        for(j=i-d;j>=0&&a[j]>temp;j=j-d){  
13.                            a[j+d]=a[j];  
14.                        }  
15.                        a[j+d]=temp;  
16.                     }  
17.                  }  
18.                  if(d==1){  
19.                         break;  
20.                  }  
21.          }  
22.         System.out.println("排序之後：");  
23.         for(int i=0;i<a.length;i++){  
24.              System.out.print(a[i]+" ");  
25.         }  
26.     }  

希爾排序時效分析很難，關鍵碼的比較次數與記錄移動次數依賴於增量因子序列d的選取，特定情況下可以準確估算出關鍵碼的比較次數和記錄的移動次數。目前還沒有人給出選取最好的增量因子序列的方法。增量因子序列可以有各種取法，有取奇數的，也有取質數的，但需要注意：增量因子中除1 外沒有公因子，且最後一個增量因子必須為1。希爾排序方法是一個不穩定的排序方法。希爾排序時間複雜度的下界是n*log2n，因此中等大小規模表現良好。

3. 選擇排序—簡單選擇排序（Simple Selection Sort）

基本思想：

在要排序的一組數中，選出最小（或者最大）的一個數與第1個位置的數交換；然後在剩下的數當中再找最小（或者最大）的與第2個位置的數交換，依次類推，直到第n-1個元素（倒數第二個數）和第n個元素（最後一個數）比較為止。

簡單選擇排序的示例：

 

進行比較操作的時間複雜度為O(n^2)，進行移動操作的時間複雜度為O(n)。簡單選擇排序是不穩定排序。

操作方法：

第一趟，從n 個記錄中找出關鍵碼最小的記錄與第一個記錄交換；

第二趟，從第二個記錄開始的n-1 個記錄中再選出關鍵碼最小的記錄與第二個記錄交換；

以此類推.....

第i 趟，則從第i 個記錄開始的n-i+1 個記錄中選出關鍵碼最小的記錄與第i 個記錄交換，

直到整個序列按關鍵碼有序。

演算法實現：

1. publicstaticvoid sSort(int[] arr){  
2.         int len = arr.length;  
3.         for(int i=0;i<len;i++){  
4.             int position = i;  
5.             for(int j=i+1;j<len;j++){  
6.                 if(arr[j]<arr[position])  
7. 相關推薦

   Java版-九大排序演算法

   參考：http://blog.csdn.net/hguisu/article/details/7776068 概述 排序有內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。 我們這裡說說八

   java實現8 大排序演算法，不求最簡單，只求最容易理解

   8 大排序演算法 排序演算法可以分為內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。 常見的內部排序演算法有：插入排序、希爾排序、選擇排序、氣泡排序、歸併排序、快速排序、堆排序、基數排序等。

   九大排序演算法之插入排序（原理及實現）

   1、演算法思路：每趟將一個待排序的元素作為關鍵字，按照其關鍵字值得大小插入到已經排好的部分的適當位置上，知道插入完成。 2、演算法過程 舉個栗子（第一趟的排序過程） 原始序列：49、38、65、97、76、13、27、49 1)開始以第一個元素49為關鍵字，看成一個序列，其餘數看成另

   九大排序演算法

   概述排序有內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。 當n較大，則應採用時間複雜度為O(nlog2n)的排序方法：快速排序、堆排序或歸併排序序。 快速排序：是目前基於比較的內部

   九大排序演算法之選擇排序（原理及實現）

   1、演算法思想：選擇排序，從頭至尾掃描序列，找出最小的一個元素，和第一個元素交換，接著從剩下的元素中繼續這種選擇和交換方式，最終得到一個有序序列。 2、演算法過程 舉個栗子（第一趟的排序過程） 原始序列：49、38、65、97、76、13、27、49 1）在進行選擇排

   九大排序演算法-C語言實現及詳解

   概述 排序有內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。 我們這裡說說八大排序就是內部排序。     當n較大，則應採用時間複雜度為O(nlog2n)的排序方法：快

   九大排序演算法的手寫實現及時空複雜度分析

   一、氣泡排序  氣泡排序是一種簡單的排序方法，演算法如下：  1. 首先將所有待排序的數字放入工作列表中。  2. 從列表的第一個數字到倒數第二個數字，逐個檢查：若某一位上的數字大於他的下一位，則將它與它的下一位交換。  3. 重複2號步驟(倒數的數字加1。例

   java實現9大排序演算法

   排序大的分類可以分為兩種：內排序和外排序。 在排序過程中，全部記錄存放在記憶體，則稱為內排序，如果排序過程中需要使用外存，則稱為外排序。 一般來說外排序分為兩個步驟：預處理和合並排序。首先，根據可用記憶體的大小，將外存上含有n個紀錄的檔案分成若干長度為t的子檔案（或段）；其

   九大排序演算法的手寫實現及時空複雜度分析 筆試面試必備

   一、氣泡排序 氣泡排序是一種簡單的排序方法，演算法如下： 1. 首先將所有待排序的數字放入工作列表中。 2. 從列表的第一個數字到倒數第二個數字，逐個檢查：若某一位上的數字大於他的下一位，則將它與它的下一位交換。 3. 重複2號步驟(倒數的數字加1。例如

   九大排序演算法小結（複雜度）

                                     九大排序演算法小結 前面分別實現了幾大排序演算法的程式碼，但並未進行解析 現在就從演算法的時間複雜度，空間複雜度進行談起 下面這幅圖是網上考培得，但很清晰，但少了一個計數排序         

   資料結構---九大排序演算法再總結

   排序：對一序列物件根據某個關鍵字進行排序； 穩定：如果a原本在b前面，而a=b，排序之後a仍然在b的前面； 不穩定：如果a原本在b的前面，而a=b，排序之後a可能會出現在b的後面； 內排序：所有排序操作都在記憶體中完成； 外排序：由於資料太大，因此把資料放在磁碟中，而排

   C語言實現九大排序演算法

   - [C語言實現九大排序演算法](#c語言實現九大排序演算法) - [直接插入排序](#直接插入排序) - [折半插入排序](#折半插入排序) - [希爾排序](#希爾排序) - [氣泡排序](#氣泡排序) - [快速排序](#快速排序) - [直接選擇排序](

   十大排序演算法的實現 十大經典排序演算法最強總結（含JAVA程式碼實現）

   十大經典排序演算法最強總結（含JAVA程式碼實現）   最近幾天在研究排序演算法，看了很多部落格，發現網上有的文章中對排序演算法解釋的並不是很透徹，而且有很多程式碼都是錯誤的，例如有的文章中在“桶排序”演算法中對每個桶進行排序直接使用了Collection.sort

   Java實現九大內部排序

   Java實現九大內部排序 前言 氣泡排序 選擇排序 插入排序 希爾排序 歸併排序 快速排序 桶排序 基數排序 堆排序 後記 前言 排序，其實是一個我們從小就接觸的東西，上小學的時候，課後習

   java版資料結構與演算法—快速排序

   /** * @author zoujc * @date 2018/11/15 * 快速排序:時間複雜度：O(NlogN) */ public class ArrayQuickSort { public static void quickSort(int arr[], int low

   java版資料結構與演算法—選擇排序

   /** * 選擇排序：時間複雜度O(n^2)， * 比氣泡排序稍好點，交換次數少 */ class ArraySelect { public static void selectSort(int arr[]){ for(int i=0;i<arr.leng

   java版資料結構與演算法—氣泡排序

   /** * 氣泡排序規則： * 1.比較兩個相鄰物件 * 2.如果左邊的大於右邊的，則調換位置 * 3.向右移動一個位置，比較接下來的兩個物件 * 時間複雜度：O(log n^2) */ class ArrayBubble { public static void bub

   java版資料結構與演算法—插入排序

   /** * 插入排序:時間複雜度O(n^2),但比氣泡排序，選擇排序要好 * 把下標為1的先取出來，當做臨時變數，下標為0的元素相當於排好序的 * 然後把下標為1的元素與下標為0的元素比較(升序)，如果臨時變數比下標為0 * 的元素小，則下標為0的元素向後移動一個下標，臨時變數插到下

   java版資料結構與演算法—堆、堆排序

   優先順序佇列：用有序陣列實現，刪除最大數最快O(1)，插入最慢 用堆實現優先順序佇列，插入和刪除都很快O(logN) 堆:是一種樹，一種特殊的二叉樹 特點： 1.他是完全的二叉樹，除了樹的最後一層節點不需要是滿的，其他一層從左到右都是滿的。 2.它常常用一個數組實現。 3.堆中每一個節點都滿

   Java學習之路 幾大排序演算法練習

   幾大排序演算法練習 1、各種排序演算法** 氣泡排序 （Bubble Sort） 選擇排序 （Selection Sort） 插入排序 （Insertion Sort） 氣泡排序（Bubble Sort） 基本思想是對比相鄰的元素值，如果滿足條件就交換元