查找算法介紹

在java中，我們常用的查找有四種:

順序(線性)查找

二分查找/折半查找

插值查找

斐波那契查找

1)線性查找算法

示例：

有一個數列： {1,8, 10, 89, 1000, 1234} ，判斷數列中是否包含此名稱【順序查找】 要求: 如果找到了，就提示找到，并給出下標值。

思路：將數列遍歷匹配，就是用for循壞遍歷，if匹配數據，找到下標值輸出。

1 public class SeqSearch { 2 3 public static void main(String[] args) { 4 int arr[] = { 1, 9, 11, -1, 34, 89 };// 沒有順序的數組 5 int index = seqSearch(arr, -11); 6 if(index == -1) { 7 System.out.println("沒有找到到"); 8 } else { 9 System.out.println("找到，下標為=" + index); 10 } 11 } 12 13 /** 14 * 這里我們實現的線性查找是找到一個滿足條件的值，就返回 15 * @param arr 16 * @param value 17 * @return 18 */ 19 public static int seqSearch(int[] arr, int value) { 20 // 線性查找是逐一比對，發現有相同值，就返回下標 21 for (int i = 0; i < arr.length; i++) { 22 if(arr[i] == value) { 23 return i; 24 } 25 } 26 return -1; 27 } 28 29 } 代碼

2)二分查找算法

示例：

請對一個有序數組進行二分查找 {1,8, 10, 89, 1000, 1234} ，輸入一個數看看該數組是否存在此數，并且求出下標，如果沒有就提示"沒有這個數"。

思路：

1 public static void main(String[] args) { 2 //int arr[] = { 1, 8, 10, 89,1000,1000, 1234 }; 3 int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 , 11, 12, 13,14,15,16,17,18,19,20 }; 4 5 6 // 7 int resIndex = binarySearch(arr, 0, arr.length - 1, 1000); 8 System.out.println("resIndex=" + resIndex); 9 10 //List<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1, 1); 11 //System.out.println("resIndexList=" + resIndexList); 12 } 13 14 // 二分查找算法 15 /** 16 * 17 * @param arr 18 * 數組 19 * @param left 20 * 左邊的索引 21 * @param right 22 * 右邊的索引 23 * @param findVal 24 * 要查找的值 25 * @return 如果找到就返回下標，如果沒有找到，就返回 -1 26 */ 27 public static int binarySearch(int[] arr, int left, int right, int findVal) { 28 29 30 // 當 left > right 時，說明遞歸整個數組，但是沒有找到 31 if (left > right) { 32 return -1; 33 } 34 int mid = (left + right) / 2; 35 int midVal = arr[mid]; 36 37 if (findVal > midVal) { // 向 右遞歸 38 return binarySearch(arr, mid + 1, right, findVal); 39 } else if (findVal < midVal) { // 向左遞歸 40 return binarySearch(arr, left, mid - 1, findVal); 41 } else { 42 43 return mid; 44 } 45 46 } 代碼

拓展：

?當一個有序數組中，有多個相同的數值時，如何將所有的數值都查找到，比如這里的 1000，{1,8, 10, 89, 1000, 1000，1234}

?要查找出該數列中1000的下標，又怎么找出呢？

?思路：

1. 在找到mid 索引值，不要馬上返回
2. 向mid 索引值的左邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList
3. 向mid 索引值的右邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList
4. 將Arraylist返回

1 public static void main(String[] args) { 2 //int arr[] = { 1, 8, 10, 89,1000,1000, 1234 }; 3 int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 , 11, 12, 13,14,15,16,17,18,19,20 }; 4 5 6 // 7 // int resIndex = binarySearch(arr, 0, arr.length - 1, 1000); 8 // System.out.println("resIndex=" + resIndex); 9 10 List<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1, 1); 11 System.out.println("resIndexList=" + resIndexList); 12 } 13 14 // 二分查找算法 15 /** 16 * 17 * @param arr 18 * 數組 19 * @param left 20 * 左邊的索引 21 * @param right 22 * 右邊的索引 23 * @param findVal 24 * 要查找的值 25 * @return 如果找到就返回下標，如果沒有找到，就返回 -1 26 */ 27 public static int binarySearch(int[] arr, int left, int right, int findVal) { 28 29 30 // 當 left > right 時，說明遞歸整個數組，但是沒有找到 31 if (left > right) { 32 return -1; 33 } 34 int mid = (left + right) / 2; 35 int midVal = arr[mid]; 36 37 if (findVal > midVal) { // 向 右遞歸 38 return binarySearch(arr, mid + 1, right, findVal); 39 } else if (findVal < midVal) { // 向左遞歸 40 return binarySearch(arr, left, mid - 1, findVal); 41 } else { 42 43 return mid; 44 } 45 46 } 47 48 49 /* 50 * {1,8, 10, 89, 1000, 1000，1234} 當一個有序數組中， 51 * 有多個相同的數值時，如何將所有的數值都查找到，比如這里的 1000 52 * 53 * 思路分析 54 * 1. 在找到mid 索引值，不要馬上返回 55 * 2. 向mid 索引值的左邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList 56 * 3. 向mid 索引值的右邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList 57 * 4. 將Arraylist返回 58 */ 59 60 public static List<Integer> binarySearch2(int[] arr, int left, int right, int findVal) { 61 62 System.out.println("hello~"); 63 // 當 left > right 時，說明遞歸整個數組，但是沒有找到 64 if (left > right) { 65 return new ArrayList<Integer>(); 66 } 67 int mid = (left + right) / 2; 68 int midVal = arr[mid]; 69 70 if (findVal > midVal) { // 向 右遞歸 71 return binarySearch2(arr, mid + 1, right, findVal); 72 } else if (findVal < midVal) { // 向左遞歸 73 return binarySearch2(arr, left, mid - 1, findVal); 74 } else { 75 // * 思路分析 76 // * 1. 在找到mid 索引值，不要馬上返回 77 // * 2. 向mid 索引值的左邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList 78 // * 3. 向mid 索引值的右邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList 79 // * 4. 將Arraylist返回 80 81 List<Integer> resIndexlist = new ArrayList<Integer>(); 82 //向mid 索引值的左邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList 83 int temp = mid - 1; 84 while(true) { 85 if (temp < 0 || arr[temp] != findVal) {//退出 86 break; 87 } 88 //否則，就temp 放入到 resIndexlist 89 resIndexlist.add(temp); 90 temp -= 1; //temp左移 91 } 92 resIndexlist.add(mid); // 93 94 //向mid 索引值的右邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList 95 temp = mid + 1; 96 while(true) { 97 if (temp > arr.length - 1 || arr[temp] != findVal) {//退出 98 break; 99 } 100 //否則，就temp 放入到 resIndexlist 101 resIndexlist.add(temp); 102 temp += 1; //temp右移 103 } 104 105 return resIndexlist; 106 } 107 108 } 代碼

3)插值查找

?插值查找原理介紹:

1.插值查找算法類似于二分查找，不同的是插值查找每次從自適應mid處開始查找。

2.將折半查找中的求mid 索引的公式 , low 表示左邊索引left, high表示右邊索引right. key 就是前面我們講的 findVal

3.int mid = low + (high - low) * (key - arr[low]) / (arr[high] - arr[low])? ;/*插值索引*/

?對應前面的代碼公式：

int mid = left + (right – left) * (findVal – arr[left]) / (arr[right] – arr[left])

舉例說明插值查找算法 1-100 的數組

?

1 public static void main(String[] args) { 2 3 // int [] arr = new int[100]; 4 // for(int i = 0; i < 100; i++) { 5 // arr[i] = i + 1; 6 // } 7 8 int arr[] = { 1, 8, 10, 89,1000,1000, 1234 }; 9 10 int index = insertValueSearch(arr, 0, arr.length - 1, 1234); 11 //int index = binarySearch(arr, 0, arr.length, 1); 12 System.out.println("index = " + index); 13 14 //System.out.println(Arrays.toString(arr)); 15 } 16 17 public static int binarySearch(int[] arr, int left, int right, int findVal) { 18 System.out.println("二分查找被調用~"); 19 // 當 left > right 時，說明遞歸整個數組，但是沒有找到 20 if (left > right) { 21 return -1; 22 } 23 int mid = (left + right) / 2; 24 int midVal = arr[mid]; 25 26 if (findVal > midVal) { // 向 右遞歸 27 return binarySearch(arr, mid + 1, right, findVal); 28 } else if (findVal < midVal) { // 向左遞歸 29 return binarySearch(arr, left, mid - 1, findVal); 30 } else { 31 32 return mid; 33 } 34 35 } 36 37 //編寫插值查找算法 38 //說明：插值查找算法，也要求數組是有序的 39 /** 40 * 41 * @param arr 數組 42 * @param left 左邊索引 43 * @param right 右邊索引 44 * @param findVal 查找值 45 * @return 如果找到，就返回對應的下標，如果沒有找到，返回-1 46 */ 47 public static int insertValueSearch(int[] arr, int left, int right, int findVal) { 48 49 System.out.println("插值查找次數~~"); 50 51 //注意：findVal < arr[0] 和 findVal > arr[arr.length - 1] 必須需要 52 //否則我們得到的 mid 可能越界 53 if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) { 54 return -1; 55 } 56 57 // 求出mid, 自適應 58 int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]); 59 int midVal = arr[mid]; 60 if (findVal > midVal) { // 說明應該向右邊遞歸 61 return insertValueSearch(arr, mid + 1, right, findVal); 62 } else if (findVal < midVal) { // 說明向左遞歸查找 63 return insertValueSearch(arr, left, mid - 1, findVal); 64 } else { 65 return mid; 66 } 67 68 } 代碼

插值查找注意事項：

?1.對于數據量較大，關鍵字分布比較均勻的查找表來說，采用插值查找, 速度較快.

?2.關鍵字分布不均勻的情況下，該方法不一定比折半查找要好

?4)斐波那契(黃金分割法)查找算法

斐波那契(黃金分割法)查找基本介紹:

?1.黃金分割點是指把一條線段分割為兩部分，使其中一部分與全長之比等于另一部分與這部分之比。取其前三位數字的近似值是0.618。由于按此比例設計的造型十分美麗，因此稱為黃金分割，也稱為中外比。這是一個神奇的數字，會帶來意向不大的效果。

2.斐波那契數列 {1, 1, 2, 3, 5, 8, 13, 21, 34, 55 } 發現斐波那契數列的兩個相鄰數 的比例，無限接近 黃金分割值0.618

斐波那契(黃金分割法)原理:

?斐波那契查找原理與前兩種相似，僅僅改變了中間結點（mid）的位置，mid不再是中間或插值得到，而是位于黃金分割點附近，即mid=low+F(k-1)-1

F代表斐波那契數列），如下圖所示

?

對F(k-1)-1的理解：

?1.由斐波那契數列 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? ? ? ?

?2.類似的，每一子段也可以用相同的方式分割

?3.但順序表長度n不一定剛好等于F[k]-1，所以需要將原來的順序表長度n增加至F[k]-1。這里的k值只要能使得F[k]-1恰好大于或等于n即可，由以下代碼得到,順序表長度增加后，新增的位置（從n+1到F[k]-1位置），都賦為n位置的值即可。

?

斐波那契查找應用案例：

?請對一個有序數組進行斐波那契查找 {1,8, 10, 89, 1000, 1234} ，輸入一個數看看該數組是否存在此數，并且求出下標，如果沒有就提示"沒有這個數"。

1 public static int maxSize = 20; 2 public static void main(String[] args) { 3 int [] arr = {1,8, 10, 89, 1000, 1234}; 4 5 System.out.println("index=" + fibSearch(arr, 189));// 0 6 7 } 8 9 //因為后面我們mid=low+F(k-1)-1，需要使用到斐波那契數列，因此我們需要先獲取到一個斐波那契數列 10 //非遞歸方法得到一個斐波那契數列 11 public static int[] fib() { 12 int[] f = new int[maxSize]; 13 f[0] = 1; 14 f[1] = 1; 15 for (int i = 2; i < maxSize; i++) { 16 f[i] = f[i - 1] + f[i - 2]; 17 } 18 return f; 19 } 20 21 //編寫斐波那契查找算法 22 //使用非遞歸的方式編寫算法 23 /** 24 * 25 * @param a 數組 26 * @param key 我們需要查找的關鍵碼(值) 27 * @return 返回對應的下標，如果沒有-1 28 */ 29 public static int fibSearch(int[] a, int key) { 30 int low = 0; 31 int high = a.length - 1; 32 int k = 0; //表示斐波那契分割數值的下標 33 int mid = 0; //存放mid值 34 int f[] = fib(); //獲取到斐波那契數列 35 //獲取到斐波那契分割數值的下標 36 while(high > f[k] - 1) { 37 k++; 38 } 39 //因為 f[k] 值 可能大于 a 的 長度，因此我們需要使用Arrays類，構造一個新的數組，并指向temp[] 40 //不足的部分會使用0填充 41 int[] temp = Arrays.copyOf(a, f[k]); 42 //實際上需求使用a數組最后的數填充 temp 43 //舉例: 44 //temp = {1,8, 10, 89, 1000, 1234, 0, 0} => {1,8, 10, 89, 1000, 1234, 1234, 1234,} 45 for(int i = high + 1; i < temp.length; i++) { 46 temp[i] = a[high]; 47 } 48 49 // 使用while來循環處理，找到我們的數 key 50 while (low <= high) { // 只要這個條件滿足，就可以找 51 mid = low + f[k - 1] - 1; 52 if(key < temp[mid]) { //我們應該繼續向數組的前面查找(左邊) 53 high = mid - 1; 54 //為甚是 k-- 55 //說明 56 //1. 全部元素 = 前面的元素 + 后邊元素 57 //2. f[k] = f[k-1] + f[k-2] 58 //因為 前面有 f[k-1]個元素,所以可以繼續拆分 f[k-1] = f[k-2] + f[k-3] 59 //即 在 f[k-1] 的前面繼續查找 k-- 60 //即下次循環 mid = f[k-1-1]-1 61 k--; 62 } else if ( key > temp[mid]) { // 我們應該繼續向數組的后面查找(右邊) 63 low = mid + 1; 64 //為什么是k -=2 65 //說明 66 //1. 全部元素 = 前面的元素 + 后邊元素 67 //2. f[k] = f[k-1] + f[k-2] 68 //3. 因為后面我們有f[k-2] 所以可以繼續拆分 f[k-1] = f[k-3] + f[k-4] 69 //4. 即在f[k-2] 的前面進行查找 k -=2 70 //5. 即下次循環 mid = f[k - 1 - 2] - 1 71 k -= 2; 72 } else { //找到 73 //需要確定，返回的是哪個下標 74 if(mid <= high) { 75 return mid; 76 } else { 77 return high; 78 } 79 } 80 } 81 return -1; 82 } 代碼

轉載于:https://www.cnblogs.com/justBobo/p/11144914.html

總結

以上是生活随笔為你收集整理的数据结构与算法---查找算法(Search Algorithm)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。