順序查找
- 如果線性表爲無序表，即表中元素的排列是無序的，則不管線性表採用順序存儲還是鏈式存儲，都必須使用順序查找。
- 如果線性表有序，但採用鏈式存儲結構，則也必須使用順序查找。
二分查找
必須遵循兩個條件：數組有序、符合左閉右開原則(是一種區間無重複的思想)
二分查找思想圖:
/***
* 二分查找
* binary search ,this is must be order array
* @param array 源數組
* @param fromIndex 開始索引
* @param toIndex 結束索引
* @param key 值
* @return
*/
public static int binarySearch(int[] array, int fromIndex, int toIndex, int key) {
int low = fromIndex;
/**左開右閉原則,保持連續空間**/
int high = toIndex - 1;
while (low <= high) {
/**查找中間的數**/
int midIndex = (low + high) >> 1;
int midValue = array[midIndex];
/**如果大於中間數，左邊查找**/
if (key > midValue) {
low = midIndex + 1;
/**如果小於中間數，右邊查找**/
} else if (key < midValue) {
high = midIndex - 1;
} else {
return midIndex;
}
}
/**low+1表示找不到時停在了第low+1個元素的位置**/
return -(low + 1);
}
快速排序
快速排序（Quicksort）是對冒泡排序的一種改進。 [1]
快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列
應用場景
數據量大並且是線性結構。
缺點
- 有大量重複數據的時候，性能不好
- 單向鏈式結構處理性能不好（鏈式不建議不使用）
思想圖：
/**
* 二叉樹快速排序
* quick sort ,this is out of order
* 其實就是中序的排法
*
* @param array
* @param begin 開始
* @param end 結束
*/
public static void quickSortArray(int[] array, int begin, int end) {
if (end - begin <= 0) return;
int x = array[begin];
int low = begin;
int high = end;
/**由於會從兩頭取數據，設置一個方向的標識位**/
boolean direction = true;
L:/**標籤，跳出這個循環的位**/
while (low < high) {
/**從左往右找**/
if (direction) {
for (int i = high; i > low; i--) {
if (array[i] <= x) {
array[low++] = array[i];
high = i;
direction = !direction;
continue L;
}
}
/**上面條件不成立，說明指針重合了**/
high = low;
} else {
for (int i = low; i < high; i++) {
if (array[i] >= x) {
array[high--] = array[i];
low = i;
direction = !direction;
continue L;
}
}
/**上面條件不成立，說明指針重合了**/
low = high;
}
}
/**把最後找到的值 放入中間位置
開始完成左右兩邊的操作**/
array[low] = x;
quickSortArray(array, begin, low - 1);
quickSortArray(array, low + 1, end);
}
歸併排序
歸併排序（MERGE-SORT）是建立在歸併操作上的一種有效的排序算法,該算法是採用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱爲二路歸併。歸併排序是一種穩定的排序方法。
應用場景
數據量大並且有很多重複數據，鏈式結構
缺點
需要空間足夠大
思想圖：
/**
* 歸併排序
* 後序
* @param array
* @param left
* @param right
*/
public static void mergeSort(int array[], int left, int right) {
if (left == right) {
return;
} else {
int mid = (left + right) / 2;
/**相當於後序排序 LRD
* 最底層拆分對比
* 左邊到中間->中間到右邊->歸併
* **/
mergeSort(array, left, mid);
mergeSort(array, mid + 1, right);
merge(array, left, mid + 1, right);
}
}
/***
* array 歸併
* @param array
* @param left
* @param mid
* @param right
*/
public static void merge(int[] array, int left, int mid, int right) {
int leftSize = mid - left;
int rightSize = right - mid + 1;
/**拆分兩個數組，填充數據，下標以index開始**/
int[] leftArray = new int[leftSize];
int[] rightArray = new int[rightSize];
for (int i = left; i < mid; i++) {
leftArray[i - left] = array[i];
}
for (int i = mid; i <= right; i++) {
rightArray[i - mid] = array[i];
}
/**合併的操作**/
int i = 0;
int j = 0;
int k = left;
while (i < leftSize && j < rightSize) {
if (leftArray[i] < rightArray[j]) {
array[k] = leftArray[i];
k++;
i++;
} else {
array[k] = rightArray[j];
k++;
j++;
}
}
/**如果左邊還有剩下的，直接cpoy**/
while (i < leftSize) {
array[k] = leftArray[i];
k++;
i++;
}
/**如果右邊還有剩下的，直接cpoy**/
while (j < rightSize) {
array[k] = rightArray[j];
k++;
j++;
}
}