一、對比分析圖
均按從小到大排列
k代表數值中的"數位"個數
n代表數據規模
m代表數據的最大值減最小值
穩定性：穩定排序算法會讓原本有相等鍵值的紀錄維持相對次序。也就是如果一個排序算法是穩定的，當有兩個相等鍵值的紀錄R和S，且在原本的列表中R出現在S之前，在排序過的列表中R也將會是在S之前。
二、冒泡排序
概述
冒泡排序通過重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來，直到沒有再需要交換的元素為止（對n個項目需要O(n^2)的比較次數）。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。
實現步驟
比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素會是最大的數。
針對所有的元素重復以上的步驟，除了最后一個。
持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
冒泡排序為一列數字進行排序的過程
實現性能
- 最差時間復雜度
O(n^2)
- 最優時間復雜度
O(n)
- 平均時間復雜度
O(n^2)
- 最差空間復雜度
總共O(n)，需要輔助空間O(1)
Java實現
public static void main(String[] args) {
int[] number = {95,45,15,78,84,51,24,12};
bubble_sort(number);
for(int i = 0; i < number.length; i++) {
System.out.print(number[i] + " ");
}
}
public static void bubble_sort(int[] arr) {
int temp, len = arr.length;
for (int i = 0; i < len - 1; i++)
for (int j = 0; j < len - 1 - i; j++)
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
三、選擇排序
選擇排序
常用的選擇排序方法有簡單選擇排序和堆排序，這里只說簡單選擇排序，堆排序后面再說。
簡單選擇排序
設所排序序列的記錄個數為n，i 取 1,2,…,n-1 。
從所有n-i+1個記錄（Ri,Ri+1,…,Rn）中找出排序碼最小（或最大）的記錄，與第i個記錄交換。執行n-1趟 后就完成了記錄序列的排序。
以排序數組｛3，2，1，4，6，5｝為例
簡單選擇排序性能
在簡單選擇排序過程中，所需移動記錄的次數比較少。最好情況下，即待排序記錄初始狀態就已經是正序排列了，則不需要移動記錄。
最壞情況下，即待排序記錄初始狀態是按第一條記錄最大，之后的記錄從小到大順序排列，則需要移動記錄的次數最多為3（n-1）。
簡單選擇排序過程中需要進行的比較次數與初始狀態下待排序的記錄序列的排列情況無關。
當i=1時，需進行n-1次比較；當i=2時，需進行n-2次比較；依次類推，共需要進行的比較次數是(n-1)+(n-2)+…+2+1=n(n-1)/2，即進行比較操作的時間復雜度為O(n^2)，進行移動操作的時間復雜度為O(n)。
簡單選擇排序是不穩定排序。
簡單選擇排序Java實現
public static void main(String[] args) {
int[] number = {3,1,2,8,4,5,24,12};
SimpleSort(number);
for(int i = 0; i < number.length; i++) {
System.out.print(number[i] + " ");
}
}
public static void SimpleSort(int[] arr) {
int length=arr.length;
int temp;
for(int i=0;i<length-1;i++){
int min=i;
for(int j=i+1;j<length;j++){ //尋找最小的數
if(arr[j]<arr[min]){
min =j;
}
}
if(min!=i){
temp = arr[min];
arr[min]=arr[i];
arr[i]=temp;
}
}
}
四、希爾排序
概述
希爾排序法(縮小增量法) 屬于插入類排序，是將整個無序列分割成若干小的子序列分別進行插入排序的方法。
把記錄按下標的一定增量分組，對每組使用直接插入排序算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，算法便終止。
希爾排序是基于插入排序的以下兩點性質而提出改進方法的：
插入排序在對幾乎已經排好序的數據操作時，效率高，即可以達到線性排序的效率。
但插入排序一般來說是低效的，因為插入排序每次只能將數據移動一位。
實現過程
先取一個正整數d1小于n，把所有序號相隔d1的數組元素放一組，組內進行直接插入排序；然后取d2小于d1，重復上述分組和排序操作；直至di=1，即所有記錄放進一個組中排序為止。
例如，假設有這樣一組數[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我們以步長為5開始進行排序，我們可以通過將這列表放在有5列的表中來更好地描述算法，這樣他們就應該看起來是這樣：
13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10
然后我們對每列進行排序：
10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45
將上述四行數字，依序接在一起時我們得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ].這時10已經移至正確位置了，然后再以3為步長進行排序：
10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45
排序之后變為：
10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94
最后以1步長進行排序（此時就是簡單的插入排序了）。
實現效率
希爾排序是一個不穩定的排序，其時間復雜度受步長（增量）的影響。
空間復雜度： Ｏ(1)
時間復雜度： 平均 O(n^1.3)
最好 O(n)
最壞 O(n^2)
Java實現
public static void shellSort(int[] a) {
int gap = 1, i, j, len = a.length;
int temp;//插入排序交換值的暫存
//確定初始步長
while (gap < len / 3){
gap = gap * 3 + 1;
}
for (; gap > 0; gap /= 3){//循環遍歷步長，最后必為1
for (i = gap; i < len; i++) {//每一列依次向前做插入排序
temp = a[i];
//每一列中在a[i]上面且比a[i]大的元素依次向下移動
for (j = i - gap; j >= 0 && a[j] > temp; j -= gap){
a[j + gap] = a[j];
}
//a[i]填補空白，完成一列中的依次插入排序
a[j + gap] = temp;
}
}
}
五、歸并排序
１.概述
歸并排序，是創建在歸并操作上的一種有效的排序算法該算法是采用分治法（Divide and Conquer）的一個非常典型的應用，且各層分治遞歸可以同時進行。
即先使每個子序列有序，再將兩個已經排序的序列合并成一個序列的操作。若將兩個有序表合并成一個有序表，稱為二路歸并。
例如：
設有數列{6，202，100，301，38，8，1}
初始狀態：6,202,100,301,38,8，1
第一次歸并后：{6,202},{100,301},{8,38},{1}，比較次數：3；
第二次歸并后：{6,100,202,301}，{1,8,38}，比較次數：4；
第三次歸并后：{1,6,8,38,100,202,301},比較次數：4；
總的比較次數為：3+4+4=11,；
逆序數為14；
歸并排序示意圖
２.效率
歸并排序速度僅次于快速排序，為穩定排序算法（即相等的元素的順序不會改變），一般用于對總體無序，但是各子項相對有序的數列.
時間復雜度為O(nlogn)
空間復雜度為 O(n)
歸并排序比較占用內存，但卻是一種效率高且穩定的算法。
3.迭代實現
3.１實現原理
①申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合并后的序列
②設定兩個指針，最初位置分別為兩個已經排序序列的起始位置
③比較兩個指針所指向的元素，選擇相對小的元素放入到合并空間，并移動指針到下一位置
④重復步驟③直到某一指針到達序列尾
⑤將另一序列剩下的所有元素直接復制到合并序列尾
3.２Java代碼
public static void main(String[] args) {
int [] arr ={6,5,3,1,8,7,2,4};
merge_sort(arr);
for(int i : arr){
System.out.println(i);
}
}
public static void merge_sort(int[] arr) {
int len = arr.length;
//用于合并的臨時數組
int[] result = new int[len];
int block, start;
//兩兩合并后塊大小變大兩倍 (注意最后一次block等于len)
for(block = 1; block <=len ; block *= 2) {
//把整個數組分成很多個塊，每次合并處理兩個塊
for(start = 0; start <len; start += 2 * block) {
int low = start;
int mid = (start + block) < len ? (start + block) : len;
int high = (start + 2 * block) < len ? (start + 2 * block) : len;
//兩個塊的起始下標及結束下標
int start1 = low, end1 = mid;
int start2 = mid, end2 = high;
//開始對兩個block進行歸并排序
while (start1 < end1 && start2 < end2) {
result[low++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
}
while(start1 < end1) {
result[low++] = arr[start1++];
}
while(start2 < end2) {
result[low++] = arr[start2++];
}
}
//每次歸并后把結果result存入arr中，以便進行下次歸并
int[] temp = arr;
arr = result;
result = temp;
}
}
4.遞歸實現
4.１實現原理
假設序列共有n個元素
①將序列每相鄰兩個數字進行歸并操作，形成floor(n/2)個序列，排序后每個序列包含兩個元素。
②將上述序列再次歸并，形成floor(n/4)個序列，每個序列包含四個元素
③重復步驟②，直到所有元素排序完畢
4.２Java代碼
public static void main(String[] args) {
int [] arr ={6,5,3,1,8,7,2,4};
int len = arr.length;
int[] reg = new int[len];
merge_sort_recursive(arr,reg,0,len-1);
for(int i : arr){
System.out.println(i);
}
}
static void merge_sort_recursive(int[] arr, int[] reg, int start, int end) {
if (start >= end)
return;
int len = end - start, mid = (len >> 1) + start;
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;
//遞歸到子序列只有一個數的時候，開始逐個返回
merge_sort_recursive(arr, reg, start1, end1);
merge_sort_recursive(arr, reg, start2, end2);
//-------合并操作，必須在遞歸之后（子序列有序的基礎上）----
int k = start;
while (start1 <= end1 && start2 <= end2)
reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
while (start1 <= end1)
reg[k++] = arr[start1++];
while (start2 <= end2)
reg[k++] = arr[start2++];
//借用reg數組做合并，然后把數據存回arr中
for (k = start; k <= end; k++)
arr[k] = reg[k];
}
六、快速排序
基本思想
快速排序（Quicksort）是對冒泡排序的一種改進，又稱劃分交換排序（partition-exchange sort。
快速排序使用分治法（Divide and conquer）策略來把一個序列（list）分為兩個子序列（sub-lists）。
步驟為：
①．從數列中挑出一個元素，稱為"基準"（pivot）
②．重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的后面（相同的數可以到任一邊）。在這個分區結束之后，該基準就處于數列的中間位置。這個稱為分區（partition）操作。
③．遞歸地（recursive）把小于基準值元素的子數列和大于基準值元素的子數列排序
使用快速排序法對一列數字進行排序的過程
排序效率
在平均狀況下，排序n個項目要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況并不常見。事實上，快速排序通常明顯比其他Ο(n log n)算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。
最差時間復雜度 Ο(n^2)
最優時間復雜度 Ο(n log n)
平均時間復雜度Ο(n log n)
最差空間復雜度 根據實現的方式不同而不同
Java實現
public static void main(String[] args) {
int [] arr = {8,1,0,4,6,2,7,9,5,3};
quickSort(arr,0,arr.length-1);
for(int i :arr){
System.out.println(i);
}
}
public static void quickSort(int[]arr,int low,int high){
if (low < high) {
int middle = getMiddle(arr, low, high);
quickSort(arr, low, middle - 1);
quickSort(arr, middle + 1, high);
}
}
public static int getMiddle(int[] list, int low, int high) {
int tmp = list[low];
while (low < high) {
while (low < high && list[high] >= tmp) {
high--;
}
list[low] = list[high];
while (low < high && list[low] <= tmp) {
low++;
}
list[high] = list[low];
}
list[low] = tmp;
return low;
}
運行結果：
分析：
取８為中值，紅色箭頭表示low，綠色箭頭表示high
①從high開始向前掃描到第一個比８小的值與８交換。
②從low向后掃描第一比8大的值與8交換。
③重復①②過程只到，high=low完成一次快速排序，然后遞歸子序列。
七、堆排序
淺析堆
堆排序(Heapsort)是指利用堆這種數據結構所設計的一種排序算法，它是選擇排序的一種。可以利用數組的特點快速定位指定索引的元素。堆分為大根堆和小根堆，是完全二叉樹。大根堆的要求是每個節點的值都不大于其父節點的值。
由于堆中每次都只能刪除第0個數據，通過 取出第０個數據再執行堆的刪除操作、重建堆（實際的操作是將最后一個數據的值賦給根結點，然后再從根結點開始進行一次從上向下的調整。），然后再取，如此重復實現排序。
堆的操作：
在堆的數據結構中，堆中的最大值總是位于根節點。堆中定義以下幾種操作：
最大堆調整（Max_Heapify）：將堆的末端子節點作調整，使得子節點永遠小于父節點
創建最大堆（Build_Max_Heap）：將堆所有數據重新排序
堆排序（HeapSort）：移除位在第一個數據的根節點，并做最大堆調整的遞歸運算
堆的存儲：
通常堆是通過一維數組來實現的。在數組起始位置為0的情形中：
父節點i的左子節點在位置(2*i+1);
父節點i的右子節點在位置(2*i+2);
子節點i的父節點在位置floor((i-1)/2);
Java代碼實現
public class HeapSort {
private static int[] sort = new int[]{1,0,10,20,3,5,6,4,9,8,12,17,34,11};
public static void main(String[] args) {
buildMaxHeapify(sort);
heapSort(sort);
print(sort);
}
private static void buildMaxHeapify(int[] data){
//沒有子節點的才需要創建最大堆，從最后一個的父節點開始
int startIndex = getParentIndex(data.length - 1);
//從尾端開始創建最大堆，每次都是正確的堆
for (int i = startIndex; i >= 0; i--) {
maxHeapify(data, data.length, i);
}
}
/**
* 創建最大堆
* @param data
* @param heapSize需要創建最大堆的大小，一般在sort的時候用到，因為最多值放在末尾，末尾就不再歸入最大堆了
* @param index當前需要創建最大堆的位置
*/
private static void maxHeapify(int[] data, int heapSize, int index){
// 當前點與左右子節點比較
int left = getChildLeftIndex(index);
int right = getChildRightIndex(index);
int largest = index;
if (left < heapSize && data[index] < data[left]) {
largest = left;
}
if (right < heapSize && data[largest] < data[right]) {
largest = right;
}
//得到最大值后可能需要交換，如果交換了，其子節點可能就不是最大堆了，需要重新調整
if (largest != index) {
int temp = data[index];
data[index] = data[largest];
data[largest] = temp;
maxHeapify(data, heapSize, largest);
}
}
/**
* 排序，最大值放在末尾，data雖然是最大堆，在排序后就成了遞增的
* @param data
*/
private static void heapSort(int[] data) {
//末尾與頭交換，交換后調整最大堆
for (int i = data.length - 1; i > 0; i--) {
int temp = data[0];
data[0] = data[i];
data[i] = temp;
maxHeapify(data, i, 0);
}
}
/**
* 父節點位置
* @param current
* @return
*/
private static int getParentIndex(int current){
return (current - 1) >> 1;
}
/**
* 左子節點position注意括號，加法優先級更高
* @param current
* @return
*/
private static int getChildLeftIndex(int current){
return (current << 1) + 1;
}
/**
* 右子節點position
* @param current
* @return
*/
private static int getChildRightIndex(int current){
return (current << 1) + 2;
}
private static void print(int[] data){
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " |");
}
}
}
八、桶排序
1.概念
桶排序（Bucket sort）或所謂的箱排序，是一個排序算法。
假設有一組長度為N的待排關鍵字序列K[1....n]。首先將這個序列劃分成M個的子區間(桶) 。然后基于某種映射函數 ，將待排序列的關鍵字k映射到第i個桶中(即桶數組B的下標 i) ，那么該關鍵字k就作為B[i]中的元素。接著對每個桶B[i]中的所有元素進行比較排序(可以使用快排)。然后依次枚舉輸出B[0]....B[M]中的全部內容即是一個有序序列。
桶排序的步驟：
①設置一個定量的數組當作空桶子。
②尋訪序列，并且把項目一個一個放到對應的桶子去。
③對每個不是空的桶子進行排序。
④從不是空的桶子里把項目再放回原來的序列中。
２.性能
數據結構 數組
最差時間復雜度 O(n^2)
平均時間復雜度 O(n+k)
最差空間復雜度 O(n*k)
平均情況下桶排序以線性時間運行，桶排序是穩定的，排序非常快,但是同時也非常耗空間,基本上是最耗空間的一種排序算法。
對N個關鍵字進行桶排序的時間復雜度分為兩個部分：
①循環計算每個關鍵字的桶映射函數，這個時間復雜度是O(N)。
②利用先進的比較排序算法對每個桶內的所有數據進行排序，其時間復雜度為 ∑ O(Ni*logNi) 。其中Ni 為第i個桶的數據量。
很顯然，第②部分是桶排序性能好壞的決定因素。盡量減少桶內數據的數量是提高效率的唯一辦法(因為基于比較排序的最好平均時間復雜度只能達到O(N*logN)了)。因此，我們需要盡量做到下面兩點：
① 映射函數f(k)能夠將N個數據平均的分配到M個桶中，這樣每個桶就有[N/M]個數據量。
②盡量的增大桶的數量。極限情況下每個桶只能得到一個數據，這樣就完全避開了桶內數據的“比較”排序操作。 當然，做到這一點很不容易，數據量巨大的情況下，f(k)函數會使得桶集合的數量巨大，空間浪費嚴重。這就是一個時間代價和空間代價的權衡問題了。
3.java實現
對０～１之間的一組浮點數進行升序排序：
BucketSort.java
public class BucketSort {
/**
* 對arr進行桶排序，排序結果仍放在arr中
*/
public static void bucketSort(double arr[]){
//-------------------------------------------------分桶-----------------------------------------------
int n = arr.length;
//存放桶的鏈表
ArrayList bucketList[] = new ArrayList [n];
//每個桶是一個list，存放此桶的元素
for(int i =0;i<n;i++){
//下取等
int temp = (int) Math.floor(n*arr[i]);
//若不存在該桶，就新建一個桶并加入到桶鏈表中
if(null==bucketList[temp])
bucketList[temp] = new ArrayList();
//把當前元素加入到對應桶中
bucketList[temp].add(arr[i]);
}
//-------------------------------------------------桶內排序-----------------------------------------------
//對每個桶中的數進行插入排序
for(int i = 0;i<n;i++){
if(null!=bucketList[i])
insert(bucketList[i]);
}
//-------------------------------------------------合并桶內數據-----------------------------------------------
//把各個桶的排序結果合并
int count = 0;
for(int i = 0;i<n;i++){
if(null!=bucketList[i]){
Iterator iter = bucketList[i].iterator();
while(iter.hasNext()){
Double d = (Double)iter.next();
arr[count] = d;
count++;
}
}
}
}
/**
* 用插入排序對每個桶進行排序
* 從小到大排序
*/
public static void insert(ArrayList list){
if(list.size()>1){
for(int i =1;i<list.size();i++){
if((Double)list.get(i)<(Double)list.get(i-1)){
double temp = (Double) list.get(i);
int j = i-1;
for(;j>=0&&((Double)list.get(j)>(Double)list.get(j+1));j--)
list.set(j+1, list.get(j)); //后移
list.set(j+1, temp);
}
}
}
}
}
測試代碼：
public static void main(String[] args) {
double arr [] ={0.21,0.23,0.76,0.12,0.89};
BucketSort.bucketSort(arr);
for(double a:arr){
System.out.println(a);
}
}
輸出結果：
九、基數排序
原理
基數排序（Radix sort）是一種非比較型整數排序算法，其原理是將整數按位數切割成不同的數字，然后按每個位數分別比較。由于整數也可以表達字符串（比如名字或日期）和特定格式的浮點數，所以基數排序也不是只能使用于整數。
將所有待比較數值（正整數）統一為同樣的數位長度，數位較短的數前面補零。然后，從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成以后，數列就變成一個有序序列。
效率
基數排序的時間復雜度是O(k·n)，其中n是排序元素個數，k是數字位數。注意這不是說這個時間復雜度一定優于O(n·log(n))，k的大小取決于數字位的選擇和待排序數據所屬數據類型的全集的大小；k決定了進行多少輪處理，而n是每輪處理的操作數目。
基數排序基本操作的代價較小，k一般不大于logn，所以基數排序一般要快過基于比較的排序，比如快速排序。
最差空間復雜度是O(k·n)
Java實現
現在有數組：278，109，63,930,589,184,505,269,8,83 。根據各位數將數組劃分為10個鏈表(當然其中的某些鏈表可能不含有元素)
第一次分配：
0:930
1:
2:
3:63,83
4:184
5:505
6：
7:
8:278,8
9:109,589,269
第一次收集后的數組：
930,63,83,184,505，278,8,109,589,269
第二次分配：
0:505,8,109
1:
2:
3:930
4:
5:
6：63,269
7:278
8:83,184，589
9:
第二次收集后的數組：
505,8,109，930，63,269，278，83,184，589
第三次分配：
0:8,63,83
1:109,184
2:278,269
3:
4:
5:505,589
6:
7:
8:
9:930
最后得到序列：
8,63,83,109,184，269,278,505,589,930
基數排序其實是利用多關鍵字先達到局部有序，再調整達到全局有序。
代碼實現：
public class Test {
public static void main(String[] args) {
int[] array = {278,109,63,930,589,184,505,269,8,83};
radixSort(array);
for(double a : array){
System.out.println(a);
}
}
public static void radixSort(int[] array){
//------------------------------------------確定排序的趟數----------------------------------
int max=array[0];
for(int i=1;i<array.length;i++){
if(array[i]>max){
max=array[i];
}
}
int time=0;
while(max>0){
max/=10;
time++;
}
//----------------------------------------初始化10個鏈表用戶分配時暫存-------------------------------
List<List<Integer>> list=new ArrayList<List<Integer>>();
for(int i=0;i<10;i++){
List<Integer> item=new ArrayList<Integer>();
list.add(item);
}
//-----------------------------------------進行time次分配和收集-------------------------------------
for(int i=0;i<time;i++){
//分配元素;
for(int j=0;j<array.length;j++){
int index = array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);
list.get(index).add(array[j]);
}
//收集元素;
int count=0;
for(int k=0;k<10;k++){
if(list.get(k).size()>0){
for(int a : list.get(k)){
array[count]=a;
count++;
}
//清除數據，以便下次收集
list.get(k).clear();
}
}
}
}
}
運行結果：
十、插入排序
概述
將一個數據插入到已經排好序的有序數據中，從而得到一個新的、個數加一的有序數據，算法適用于少量數據的排序，是穩定的排序方法。
插入排序又分為 直接插入排序 和 折半插入排序。
直接插入排序
把待排序的紀錄按其關鍵碼值的大小逐個插入到一個已經排好序的有序序列中，直到所有的紀錄插入完為止，得到一個新的有序序列。
Java實現
public static void insertSort(int a[]){
int j; //當前要插入值的位置
int preJ; //依次指向j前的位置
int key; //后移時來暫存要插入的值
//從數組的第二個位置開始遍歷值
for(j=1;j<a.length;j++){
key=a[j];
preJ=j-1;
//a[preJ]比當前值大時，a[preJ]后移一位
while(preJ>=0 && a[preJ]>key){
a[preJ+1]=a[preJ]; //將a[preJ]值后移
//這里注意: a[preJ+1]=a[j]=key,把插入值已經存在了 key中
//等于說, 留出來一個空白位置來實現依次后移（不會造成數據丟失問題）
preJ--; //preJ前移
}
//找到要插入的位置或已遍歷完成（(preJ=0）
a[preJ+1]=key; //將當前值插入 空白位置
}
}
備注很清楚，我就不多說了．．．．
效率分析
空間復雜度O(1)
平均時間復雜度O(n^2)
最差情況：反序，需要移動n*(n-1)/2個元素 ，運行時間為O(n^2)。
最好情況：正序，不需要移動元素，運行時間為O(n)．
折半插入排序
直接插入排序中要把插入元素與已有序序列元素依次進行比較，效率非常低。
折半插入排序,使用使用折半查找的方式尋找插入點的位置, 可以減少比較的次數,但移動的次數不變, 時間復雜度和空間復雜度和直接插入排序一樣，在元素較多的情況下能提高查找性能。
Java實現
private static void binaryInsertSort(int[] a)
{
//從數組的第二個位置開始遍歷值
for(int i = 1; i < a.length; i++) {
int key = a[i]; //暫存要插入的值
int pre = 0; //有序序列開始和結尾下標申明
int last = i - 1;
// 折半查找出插入位置 a[pre]
while(pre <= last) {
int mid = (pre + last) / 2;
if(key < a[mid]) {
last = mid - 1;
} else {
pre = mid + 1;
}
}
//a[i]已經取出來存放在key中，把下標從pre + 1到 i-1的元素依次后移
for(int j = i; j >= pre + 1; j--) {
a[j] = a[j - 1];
}
//把值插入空白位置
a[pre] = key;
}
}
直接插入排序是，比較一個后移一個；
折半插入排序是，先找到位置，然后一起移動；
<table>
<tr>
<td bgcolor=#f4f31a>
<font color=#00aaff size=5 face="微軟雅黑">
十一、補充
</font>
</td>
</tr>
</table>
1. 快排的partition函數
作用：給定一個數組arr[]和數組中任意一個元素a，重排數組使得a左邊都小于它，右邊都不小于它。
// A[]為數組，start、end分別為數組第一個元素和最后一個元素的索引
// povitIndex為數組中任意選中的數的索引
static int partition(int A[], int start, int end, int pivotIndex){
int i = start, j = end, pivot = A[pivotIndex];
swap<int>(A[end], A[pivotIndex]);
while(i < j){
while(i < j && A[i] <= pivot) ++i;
while(i < j && A[j] >= pivot) --j;
if(i < j) swap<int>(A[i], A[j]);
}
swap<int>(A[end], A[i]);
return i;
}
2. 冒泡排序的改進
思路：
①、加一個標志位，當某一趟冒泡排序沒有元素交換時，則冒泡結束，元素已經有序，可以有效的減少冒泡次數。
/**
* 引入標志位，默認為true
* 如果前后數據進行了交換，則為true，否則為false。如果沒有數據交換，則排序完成。
*/
public static int[] bubbleSort(int[] arr){
boolean flag = true;
int n = arr.length;
while(flag){
flag = false;
for(int j=0;j<n-1;j++){
if(arr[j] >arr[j+1]){
//數據交換
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
//設置標志位
flag = true;
}
}
n--;
}
return arr;
}
②、記錄每一次元素交換的位置，當元素交換的位置在第0個元素時，則排序結束。
3.快排優化
① 快速排序在處理小規模數據時的表現不好，這個時候可以改用插入排序。
②對于一個每個元素都完全相同的一個序列來講，快速排序也會退化到 O(n^2)。要將這種情況避免到，可以這樣做：
在分區的時候，將序列分為 3 堆，一堆小于中軸元素，一堆等于中軸元素，一堆大于中軸元素，下次遞歸調用快速排序的時候，只需對小于和大于中軸元素的兩堆數據進行排序，中間等于中軸元素的一堆已經放好。
