7.1 順序查找
算法思想
順序查找，就是逐個遍歷數組中的每一個元素，逐個比較它們和關鍵字是否相等，當查找到相等元素時， 遍歷停止。當數組的規模逐漸擴大時候， 因爲比較次數太多，順序查找耗時太長。
算法實現
public class SqeSearchTest {
public static void main(String[] args) {
int[] array = {1, 9, 11, -1, 34, 89};
int search = search(array, -1);
System.err.println(search);
}
private static int search(int[] array, int value) {
int index = -1;
if (null == array || array.length == 0) {
return index;
}
for (int i = 0; i < array.length; i++) {
if (value == array[i]) {
index = i;
break;
}
}
return index;
}
}
7.2 二分查找
算法思路
基於數組的有序性，每次都將當前的數組分爲兩半，通過關鍵字和中間元素的比較，立即排除掉其中不可能存在和鍵值相等的元素的那一半。這樣每次減少的一半元素的比較，前後疊加起來，就是二分查找相對於順序查找提高的性能。
算法描述
- 首先確定數組的中間下標 mid = (low + high) / 2
- 然後將需要查找的 key 和 array[mid] 進行比較。
- 如果 key > array[mid] 說明查找的 key 在 mid 的右邊，因此需要向右遞歸查找。
- 如果 key < array[mid] 說明查找的 key 在 mid 的左邊，因此需要向左遞歸查找。
- 如果 key == array[mid] 說明已經找到，結束遞歸。
- 如果 low > high 則結束遞歸。
算法實現
public class BinarySearchTest {
public static void main(String[] args) {
int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
System.err.println(Arrays.toString(array));
List<Integer> index = binarySearch(array, 0, array.length - 1, 3);
System.err.println(index);
}
private static List<Integer> binarySearch(int[] arrar, int left, int right, int value) {
if (null == arrar || arrar.length == 0 || left > right) {
return null;
}
int midIndex = (left + right) / 2;
int midValue = arrar[midIndex];
if (value > midValue) {
return binarySearch(arrar, midIndex + 1, right, value);
} else if (value < midValue) {
return binarySearch(arrar, left, midIndex - 1, value);
} else {
/**
* 1. 在找到 midIndex 索引值，不要馬上返回
* 2. 向 midIndex 索引值的左邊掃描，將所有滿足的元素的下標加入到集合 ArrayList
* 3. 向 midIndex 索引值的右邊掃描，將所有滿足的元素的下標加入到集合 ArrayList
* 4. 將 Arraylist 返回
*/
List<Integer> list = new ArrayList<>();
list.add(midIndex);
int temp = midIndex - 1;
while (true) {
if (temp < 0 || arrar[temp] != value) {
break;
}
list.add(temp--);
}
temp = midIndex + 1;
while (true) {
if (temp > arrar.length - 1 || arrar[temp] != value) {
break;
}
list.add(temp++);
}
return list;
}
}
}
7.3 插值查找
算法思路
插值查找算法類似於二分查找，不同的是插值查找每次從自適應 mid 處開始查找。
算法描述
- 二分查找中求 mid 索引的公式，left 表示左邊索引，right 表示右邊索引：mid = (left + right) / 2 = left + 1/2 * (right - left)
- 插值查找中求自適應 mid 索引的公式：mid = low + (right - left) * (findVal – arr[left]) / (arr[right] – arr[left])
- 對於數據量較大且關鍵字分佈比較均勻的查找表來說，採用插值查找速度較快，對於關鍵字分佈不均勻的情況下，該方法不一定比二分查找要好。
算法實現
public class InsertValueSearchTest {
public static void main(String[] args) {
int[] array = new int[]{1, 8, 1000, 1000, 1000, 1000, 1234};
System.err.println(Arrays.toString(array));
List<Integer> index = insertValueSearch(array, 0, array.length - 1, 1000);
System.err.println(index);
}
private static List<Integer> insertValueSearch(int[] arrar, int left, int right, int value) {
if (null == arrar || arrar.length == 0 || left > right || value < arrar[0] || value > arrar[arrar.length - 1]) {
return null;
}
// 插值
int midIndex = left + (right - left) * (value - arrar[left]) / (arrar[right] - arrar[left]);
int midValue = arrar[midIndex];
if (value > midValue) {
return insertValueSearch(arrar, midIndex + 1, right, value);
} else if (value < midValue) {
return insertValueSearch(arrar, left, midIndex - 1, value);
} else {
List<Integer> list = new ArrayList<>();
list.add(midIndex);
int temp = midIndex - 1;
while (true) {
if (temp < 0 || arrar[temp] != value) {
break;
}
list.add(temp--);
}
temp = midIndex + 1;
while (true) {
if (temp > arrar.length - 1 || arrar[temp] != value) {
break;
}
list.add(temp++);
}
return list;
}
}
}
7.4 斐波那契查找
黃金分割點是指把一條線段分割爲兩部分，使其中一部分與全長之比等於另一部分與這部分之比。取其前三位
數字的近似值是 0.618，由於按此比例設計的造型十分美麗，因此稱爲黃金分割，也稱爲中外比。
斐波那契數列 {1, 1, 2, 3, 5, 8, 13, 21, 34, 55 } 發現數列的兩個相鄰數的比例無限接近黃金分割值0.618。
算法思路
斐波那契查找原理與前兩種相似，僅僅改變了中間結點 mid 的位置，mid 不再是中間或插值得到，而是位於黃金分割點附近，即 mid = low + F(k - 1) - 1（F 代表斐波那契數列）。
算法描述
- 由於斐波那契數列具有 F[k] = F[k - 1] + F[k - 2] 的性質，可以得到 (F[k] - 1) = (F[k - 1] - 1) + (F[k - 2] - 1) + 1
- 只要順序數組的長度爲 F[k] - 1，則可以將該表分成長度爲 F[k - 1] - 1 和 F[k - 2] - 1 的兩段，即中間值爲 mid = low + F(k - 1) - 1
- 順序數組長度 length 不一定剛好等於 F[k] - 1，所以需要將原來的順序表長度 length 增加至 F[k] - 1，這裏的 k 值只要能使得 F[k] - 1 恰好大於或等於 length 即可，新增的位置(從 n+1 到 F[k] - 1 位置)都賦爲 length - 1 位置的值即可。
算法實現
public class FibonacciSearchTest {
public static void main(String[] args) {
int[] array = new int[]{1, 8, 98, 105, 1000, 1070, 1234};
System.err.println(Arrays.toString(array));
int search = fibSearch(array, 1000);
System.err.println(search);
}
private static int fibSearch(int[] array, int value) {
int low = 0;
// 數組最大下標
int high = array.length - 1;
// 表示斐波那契分割數值的下標
int k = 0;
// 獲取到斐波那契數列
int fibArray[] = fibArray(20);
// 找到有序表元素個數在斐波那契數列中最接近的最大數列值
while (high > fibArray[k] - 1) {
k++;
}
// 補齊有序表並指向 temp[]，不足的部分會使用 0 填充
int[] temp = Arrays.copyOf(array, fibArray[k]);
for (int i = high + 1; i < temp.length; i++) {
temp[i] = array[high];
}
// 使用 while 來循環找到 key，需要滿足條件 low <= high
while (low <= high) {
int mid = low + fibArray[k - 1] - 1;
// 繼續向數組的前面查找（左邊）
if (value < temp[mid]) {
high = mid - 1;
// 因爲前面有 f[k-1] 個元素，所以可以繼續拆分 f[k-1] = f[k-2] + f[k-3]
k--;
} else if (value > temp[mid]) {
// 繼續向數組的後面查找（右邊）
low = mid + 1;
// 因爲後面有 f[k-2] 個元素，所以可以繼續拆分 f[k-2] = f[k-3] + f[k-4]，即下次循環 mid = f[k - 1 - 2] - 1
k -= 2;
} else {
if (mid <= high) {
return mid;
} else {
return high;
}
}
}
return -1;
}
private static int[] fibArray(int maxSize) {
int[] array = new int[maxSize];
array[0] = 1;
array[1] = 1;
for (int i = 2; i < maxSize; i++) {
array[i] = array[i - 1] + array[i - 2];
}
return array;
}
}