數據結構與算法---查找算法(Search Algorithm)

查找算法介紹

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

1. 順序(線性)查找
2. 二分查找/折半查找
3. 插值查找
4. 斐波那契查找

1)線性查找算法

示例：

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

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

public class SeqSearch {

    public static void main(String[] args) {
        int arr[] = { 1, 9, 11, -1, 34, 89 };// 沒有順序的數組
        int index = seqSearch(arr, -11);
        if(index == -1) {
            System.out.println("沒有找到到");
        } else {
            System.out.println("找到，下標為=" + index);
        }
    }

    /**
     * 這里我們實現的線性查找是找到一個滿足條件的值，就返回
     * @param arr
     * @param value
     * @return
     */
    public static int seqSearch(int[] arr, int value) {
        // 線性查找是逐一比對，發現有相同值，就返回下標
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == value) {
                return i;
            }
        }
        return -1;
    }

}

2)二分查找算法

示例：

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

思路：

public static void main(String[] args) {
        //int arr[] = { 1, 8, 10, 89,1000,1000, 1234 };
        int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 , 11, 12, 13,14,15,16,17,18,19,20 };
        

        //
        int resIndex = binarySearch(arr, 0, arr.length - 1, 1000);
        System.out.println("resIndex=" + resIndex);
        
        //List<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1, 1);
        //System.out.println("resIndexList=" + resIndexList);
    }

    // 二分查找算法
    /**
     * 
     * @param arr
     *            數組
     * @param left
     *            左邊的索引
     * @param right
     *            右邊的索引
     * @param findVal
     *            要查找的值
     * @return 如果找到就返回下標，如果沒有找到，就返回 -1
     */
    public static int binarySearch(int[] arr, int left, int right, int findVal) {
        

        // 當 left > right 時，說明遞歸整個數組，但是沒有找到
        if (left > right) {
            return -1;
        }
        int mid = (left + right) / 2;
        int midVal = arr[mid];

        if (findVal > midVal) { // 向 右遞歸
            return binarySearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) { // 向左遞歸
            return binarySearch(arr, left, mid - 1, findVal);
        } else {
            
            return mid;
        }

    }

拓展：

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

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

 思路：

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

public static void main(String[] args) {
        //int arr[] = { 1, 8, 10, 89,1000,1000, 1234 };
        int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 , 11, 12, 13,14,15,16,17,18,19,20 };
        

        //
//        int resIndex = binarySearch(arr, 0, arr.length - 1, 1000);
//        System.out.println("resIndex=" + resIndex);
        
        List<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1, 1);
        System.out.println("resIndexList=" + resIndexList);
    }

    // 二分查找算法
    /**
     * 
     * @param arr
     *            數組
     * @param left
     *            左邊的索引
     * @param right
     *            右邊的索引
     * @param findVal
     *            要查找的值
     * @return 如果找到就返回下標，如果沒有找到，就返回 -1
     */
    public static int binarySearch(int[] arr, int left, int right, int findVal) {
        

        // 當 left > right 時，說明遞歸整個數組，但是沒有找到
        if (left > right) {
            return -1;
        }
        int mid = (left + right) / 2;
        int midVal = arr[mid];

        if (findVal > midVal) { // 向 右遞歸
            return binarySearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) { // 向左遞歸
            return binarySearch(arr, left, mid - 1, findVal);
        } else {
            
            return mid;
        }

    }
    
    
    /*
     * {1,8, 10, 89, 1000, 1000，1234} 當一個有序數組中，
     * 有多個相同的數值時，如何將所有的數值都查找到，比如這里的 1000
     * 
     * 思路分析
     * 1. 在找到mid 索引值，不要馬上返回
     * 2. 向mid 索引值的左邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList
     * 3. 向mid 索引值的右邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList
     * 4. 將Arraylist返回
     */

    public static List<Integer> binarySearch2(int[] arr, int left, int right, int findVal) {

        System.out.println("hello~");
        // 當 left > right 時，說明遞歸整個數組，但是沒有找到
        if (left > right) {
            return new ArrayList<Integer>();
        }
        int mid = (left + right) / 2;
        int midVal = arr[mid];

        if (findVal > midVal) { // 向 右遞歸
            return binarySearch2(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) { // 向左遞歸
            return binarySearch2(arr, left, mid - 1, findVal);
        } else {
//             * 思路分析
//             * 1. 在找到mid 索引值，不要馬上返回
//             * 2. 向mid 索引值的左邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList
//             * 3. 向mid 索引值的右邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList
//             * 4. 將Arraylist返回
            
            List<Integer> resIndexlist = new ArrayList<Integer>();
            //向mid 索引值的左邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList
            int temp = mid - 1;
            while(true) {
                if (temp < 0 || arr[temp] != findVal) {//退出
                    break;
                }
                //否則，就temp 放入到 resIndexlist
                resIndexlist.add(temp);
                temp -= 1; //temp左移
            }
            resIndexlist.add(mid);  //
            
            //向mid 索引值的右邊掃描，將所有滿足 1000， 的元素的下標，加入到集合ArrayList
            temp = mid + 1;
            while(true) {
                if (temp > arr.length - 1 || arr[temp] != findVal) {//退出
                    break;
                }
                //否則，就temp 放入到 resIndexlist
                resIndexlist.add(temp);
                temp += 1; //temp右移
            }
            
            return resIndexlist;
        }

    }

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 的數組

 

public static void main(String[] args) {
        
//        int [] arr = new int[100];
//        for(int i = 0; i < 100; i++) {
//            arr[i] = i + 1;
//        }
        
        int arr[] = { 1, 8, 10, 89,1000,1000, 1234 };
        
        int index = insertValueSearch(arr, 0, arr.length - 1, 1234);
        //int index = binarySearch(arr, 0, arr.length, 1);
        System.out.println("index = " + index);
        
        //System.out.println(Arrays.toString(arr));
    }
    
    public static int binarySearch(int[] arr, int left, int right, int findVal) {
        System.out.println("二分查找被調用~");
        // 當 left > right 時，說明遞歸整個數組，但是沒有找到
        if (left > right) {
            return -1;
        }
        int mid = (left + right) / 2;
        int midVal = arr[mid];

        if (findVal > midVal) { // 向 右遞歸
            return binarySearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) { // 向左遞歸
            return binarySearch(arr, left, mid - 1, findVal);
        } else {

            return mid;
        }

    }

    //編寫插值查找算法
    //說明：插值查找算法，也要求數組是有序的
    /**
     * 
     * @param arr 數組
     * @param left 左邊索引
     * @param right 右邊索引
     * @param findVal 查找值
     * @return 如果找到，就返回對應的下標，如果沒有找到，返回-1
     */
    public static int insertValueSearch(int[] arr, int left, int right, int findVal) { 

        System.out.println("插值查找次數~~");
        
        //注意：findVal < arr[0]  和  findVal > arr[arr.length - 1] 必須需要
        //否則我們得到的 mid 可能越界
        if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
            return -1;
        }

        // 求出mid, 自適應
        int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
        int midVal = arr[mid];
        if (findVal > midVal) { // 說明應該向右邊遞歸
            return insertValueSearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) { // 說明向左遞歸查找
            return insertValueSearch(arr, left, mid - 1, findVal);
        } else {
            return mid;
        }

    }

插值查找注意事項：

 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} ，輸入一個數看看該數組是否存在此數，並且求出下標，如果沒有就提示"沒有這個數"。

public static int maxSize = 20;
    public static void main(String[] args) {
        int [] arr = {1,8, 10, 89, 1000, 1234};
        
        System.out.println("index=" + fibSearch(arr, 189));// 0
        
    }

    //因為后面我們mid=low+F(k-1)-1，需要使用到斐波那契數列，因此我們需要先獲取到一個斐波那契數列
    //非遞歸方法得到一個斐波那契數列
    public static int[] fib() {
        int[] f = new int[maxSize];
        f[0] = 1;
        f[1] = 1;
        for (int i = 2; i < maxSize; i++) {
            f[i] = f[i - 1] + f[i - 2];
        }
        return f;
    }
    
    //編寫斐波那契查找算法
    //使用非遞歸的方式編寫算法
    /**
     * 
     * @param a  數組
     * @param key 我們需要查找的關鍵碼(值)
     * @return 返回對應的下標，如果沒有-1
     */
    public static int fibSearch(int[] a, int key) {
        int low = 0;
        int high = a.length - 1;
        int k = 0; //表示斐波那契分割數值的下標
        int mid = 0; //存放mid值
        int f[] = fib(); //獲取到斐波那契數列
        //獲取到斐波那契分割數值的下標
        while(high > f[k] - 1) {
            k++;
        }
        //因為 f[k] 值 可能大於 a 的 長度，因此我們需要使用Arrays類，構造一個新的數組，並指向temp[]
        //不足的部分會使用0填充
        int[] temp = Arrays.copyOf(a, f[k]);
        //實際上需求使用a數組最后的數填充 temp
        //舉例:
        //temp = {1,8, 10, 89, 1000, 1234, 0, 0}  => {1,8, 10, 89, 1000, 1234, 1234, 1234,}
        for(int i = high + 1; i < temp.length; i++) {
            temp[i] = a[high];
        }
        
        // 使用while來循環處理，找到我們的數 key
        while (low <= high) { // 只要這個條件滿足，就可以找
            mid = low + f[k - 1] - 1;
            if(key < temp[mid]) { //我們應該繼續向數組的前面查找(左邊)
                high = mid - 1;
                //為甚是 k--
                //說明
                //1. 全部元素 = 前面的元素 + 后邊元素
                //2. f[k] = f[k-1] + f[k-2]
                //因為 前面有 f[k-1]個元素,所以可以繼續拆分 f[k-1] = f[k-2] + f[k-3]
                //即 在 f[k-1] 的前面繼續查找 k--
                //即下次循環 mid = f[k-1-1]-1
                k--;
            } else if ( key > temp[mid]) { // 我們應該繼續向數組的后面查找(右邊)
                low = mid + 1;
                //為什么是k -=2
                //說明
                //1. 全部元素 = 前面的元素 + 后邊元素
                //2. f[k] = f[k-1] + f[k-2]
                //3. 因為后面我們有f[k-2] 所以可以繼續拆分 f[k-1] = f[k-3] + f[k-4]
                //4. 即在f[k-2] 的前面進行查找 k -=2
                //5. 即下次循環 mid = f[k - 1 - 2] - 1
                k -= 2;
            } else { //找到
                //需要確定，返回的是哪個下標
                if(mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }