查找---二分查找的三種實現和插值查找

二分查找

• 遞歸實現
• 區間爲左閉右閉
• 區間爲左閉右開

public class BinarySearchTest {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int index1 = binarySearch1(arr, 5);
        System.out.println(index1);

        int index2 = binarySearch2(arr, 5);
        System.out.println(index2);

        int index3 = binarySearchRecursion(arr, 5);
        System.out.println(index3);
    }

    //遞歸解法
    public static int binarySearchRecursion(int[] arr, int target) {
        return binarySearch3(arr, 0, arr.length - 1, target);
    }

    public static int binarySearch3(int[] arr, int left, int right, int target) {
        if(left > right) return -1;

        int mid = left + (right - left) / 2;

        if(arr[mid] > target) {
            return binarySearch3(arr, left, mid - 1, target);
        }else if(arr[mid] < target) {
            return binarySearch3(arr, mid + 1, right, target);
        }else {
            return mid;
        }
    }

    //區間：左閉右閉
    public static int binarySearch1(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;

        while(left <= right) {
            int mid = left + (right - left) / 2;
            if(arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            }else{
                right = mid - 1;
            }
        }
        return -1;
    }

    //區間：左閉右開
    public static int binarySearch2(int[] arr, int target) {
        int left = 0;
        int right = arr.length;

        while(left < right) {
            int mid = left + (right - left) / 2;
            if(target < arr[mid]) {
                right = mid;
            }else if(target > arr[mid]) {
                left = mid + 1;
            }else{
                return mid;
            }
        }

        return -1;
    }
}

擴展題

數組中有多個相同的目標值，把這些值的下標找出來，如{1,2,2,3,4} 目標值是2，則返回{1,2}

import java.util.ArrayList;
import java.util.List;

public class BinarySearchExtension {
    public static void main(String[] args) {
        int[] arr = {1,2,2,3,4,4,4};
        List<Integer> result = binarySearchRecursion(arr, 3);
        System.out.println(result);
    }
    
    public static List binarySearchRecursion(int[] arr, int target) {
        return binarySearch1(arr, 0, arr.length - 1, target);
    }

    public static List binarySearch1(int[] arr, int left, int right, int target) {
        if(left > right) {
            return new ArrayList<>();
        }

        int mid = left + (right - left) / 2;
        if(arr[mid] > target) {
            return binarySearch1(arr, left, mid - 1, target);
        }else if(arr[mid] < target) {
            return binarySearch1(arr, mid + 1, right, target);
        }else{
            int temp1 = mid - 1;
            int temp2 = mid + 1;
            int arrLen = arr.length;
            List<Integer> result = new ArrayList<>();
            //掃描mid左邊的值
            while(temp1 >= 0 && arr[temp1] == target) {
                result.add(temp1);
                temp1--;
            }
            result.add(mid);
            //掃描mid右邊的值
            while(temp2 < arrLen && arr[temp2] == target) {
                result.add(temp2);
                temp2++;
            }
            return result;
        }
    }
}

時間複雜度

每次查找，元素個數減小一半，即n，n/2，n/4，…, n/2^ k，k就是循環的次數，取n/2^ k=1，即k=logn（以2爲底），因此時間複雜度爲O(logN)

插值查找

二分查找中取中間元素mid= left + （right - left）/ 2，設想這樣一個例子：數據爲1到1000，查找元素1，那麼將會進行好幾次循環才能找到1。於是有個改進的算法即插值算法：mid=left + (right - left) * (target -arr[left]) / (arr[right] - arr[left])，target是要找到目標值。
對於數據量比較大，關鍵字分佈比較均勻的查找來說，採用插值查找速度較快。關鍵字分佈不均勻的情況下，該方法不一定比二分查找效率高。