數據結構與算法-二分查找

完成了四個簡單的二分變形，以及leetcode81題解答，不過這個解答一開始想不明白，後來剽竊了大神們的答案，才恍然大悟，我真是太菜了。代碼如下：

package com.freshbin.dataStructAndAlgo.chapter15.mycode;

import com.freshbin.dataStructAndAlgo.chapter11.mycode.MySimpleSorts;
import com.freshbin.dataStructAndAlgo.utils.MyArrayUtil;

/**
 * 二分查找
 * @author freshbin
 * @date 2020/4/17 17:14
 */
public class BinarySearch {
    public static int simpleBSearch(int[] arr, int targetValue) {
        if(arr.length < 1) {
            return -1;
        }

        int low = 0, high = arr.length - 1, middle = low + (high - low)/2;
        while(low <= high) {
            if(arr[middle] == targetValue) {
                return middle;
            } else if(arr[middle] < targetValue) {
                low = middle + 1;
            } else {
                high = middle - 1;
            }
            middle = low + (high - low)/2;
        }
        return -1;
    }

    public static int diguiBSearch(int[] arr, int targetValue) {
        if(arr.length < 1) {
            return -1;
        }

        int index = diguiBSearch(arr, 0, arr.length/2, targetValue);

        return index;
    }

    private static int diguiBSearch(int[] arr, int low, int high, int targetValue) {
        if(low > high) {
            return -1;
        }
        int middle = low + (high-low) / 2;
        if(arr[middle] == targetValue) {
            return middle;
        } else if(arr[middle] > targetValue) {
            diguiBSearch(arr, low, middle-1, targetValue);
        } else {
            diguiBSearch(arr, middle+1, high, targetValue);
        }

        return -1;
    }

    /**
     * 查找一個數的平方根，保留6位小數
     *
     * 思路：首先用這個數的一半的平方與該值比較大小
     * 如果相等，那麼直接返回，否則看是大了還是小了，大了就取low到middle-1的一半，否則取middle+1到high的一半，循環。
     * @param n
     * @return
     */
    public static double getNumSqrt(double n) {
        double low = 0;
        double high = n;
        double middle = high / 2;

        while(low <= high) {
            double result = middle*middle;
            if(result == n) {
                return middle;
            } else if(result > n) {
                high = middle;
            } else {
                low = middle;
            }
            middle = low + (high - low) / 2;

            // 判斷是否6位小數了
            String pointNum = String.valueOf(middle);
            int pointIndex = pointNum.indexOf(".");
            if(pointIndex > 0) {
                pointNum = pointNum.substring(pointIndex+1, pointNum.length());
                if(pointNum.length() > 5) {
                    return middle;
                }
            }
        }
        return 0;
    }

    /**
     * 查找第一個值等於給定值的元素
     * @param arr
     * @param targetValue
     * @return
     */
    public static int searchFirstEqualNum(int[] arr, int targetValue) {
        if(arr.length < 1) {
            return -1;
        }
        int low = 0;
        int high = arr.length-1;

        while(low <= high) {
            int middle = low + ((high - low) >> 1);
            if(arr[middle] == targetValue) {
                // 判斷該值是否是第一個元素，或者該值的上一個元素是否等於目標值，如果不等於，說明該值是第一個等於目標值的元素
                if(middle == 0 || arr[middle-1] != targetValue) {
                    return middle;
                }
                // 否則,前面還有等於目標值的數
                high = middle - 1;
            } else if(arr[middle] > targetValue) {
                // 目標值在前半部分
                high = middle - 1;
            } else {
                // 目標值在後半部分
                low = middle + 1;
            }
        }
        return -1;
    }

    /**
     * 查找最後一個值等於給定值的元素
     * @param arr
     * @param targetValue
     * @return
     */
    public static int searchLastEqualNum(int[] arr, int targetValue) {
        if(arr.length < 1) {
            return -1;
        }
        int low = 0;
        int high = arr.length-1;

        while(low <= high) {
            int middle = low + ((high - low) >> 1);
            if(arr[middle] == targetValue) {
                // 判斷該值是否是最後一個元素，或者該值的下一個元素是否等於目標值，如果不等於，說明該值是最後一個等於目標值的元素
                if(middle == arr.length-1 || arr[middle+1] != targetValue) {
                    return middle;
                }
                // 否則,後面還有等於目標值的數
                low = middle + 1;
            } else if(arr[middle] > targetValue) {
                // 目標值在前半部分
                high = middle - 1;
            } else {
                // 目標值在後半部分
                low = middle + 1;
            }
        }
        return -1;
    }

    /**
     * 查找第一個值大於等於給定值的元素
     * @param arr
     * @param targetValue
     * @return
     */
    public static int searchFirstGreaterEqualNum(int[] arr, int targetValue) {
        if(arr.length < 1) {
            return -1;
        }
        int low = 0;
        int high = arr.length-1;

        while(low <= high) {
            int middle = low + ((high - low) >> 1);
            if(arr[middle] >= targetValue) {
                // 判斷該值是否是第一個元素，或者該值的上一個元素是否小於目標值，如果小於，說明該值是第一個大於等於目標值的元素
                if(middle == 0 || arr[middle-1] < targetValue) {
                    return middle;
                }
                // 否則,前面還有大於等於目標值的數
                high = middle - 1;
            } else {
                // 目標值在後半部分
                low = middle + 1;
            }
        }
        return -1;
    }

    /**
     * 查找最後一個值小於等於給定值的元素
     * @param arr
     * @param targetValue
     * @return
     */
    public static int searchLastLessEqualNum(int[] arr, int targetValue) {
        if(arr.length < 1) {
            return -1;
        }
        int low = 0;
        int high = arr.length-1;

        while(low <= high) {
            int middle = low + ((high - low) >> 1);
            if(arr[middle] <= targetValue) {
                // 判斷該值是否是最後一個元素，或者該值的下一個元素是否大於目標值，如果大於，說明該值是最後一個小於等於目標值的元素
                if(middle == arr.length - 1 || arr[middle+1] > targetValue) {
                    return middle;
                }
                // 否則,後面還有小於等於目標值的數
                low = middle + 1;
            } else {
                // 目標值在前半部分
                high = middle - 1;
            }
        }
        return -1;
    }

    /**
     * leetcode 81：
     * 假設按照升序排序的數組在預先未知的某個點上進行了旋轉。
     * ( 例如，數組 [0,0,1,2,2,5,6] 可能變爲 [2,5,6,0,0,1,2] )。
     * 編寫一個函數來判斷給定的目標值是否存在於數組中。若存在返回 true，否則返回 false
     *
     * 思路：數組從中間切分，通過low與middle值的比較，可以知道
     * 1、如果low=middle,說明數組有重複數據，可以把low一直往high遞增，
     * 直到low>high爲止
     * 2、那麼如果low<middle,說明左邊有序，右邊循環；
     * 3、如果low>middle，說明左邊循環，右邊有序，
     * 我們總是在有序部分裏面判斷目標值是屬於左邊部分還是右邊部分。
     *
     * @param arr
     * @param targetValue
     * @return
     */
    public static Boolean searchCyclicArr(int[] arr, int targetValue) {
        if(arr.length < 1) {
            return false;
        }
        int low = 0;
        int high = arr.length - 1;
        while(low <= high) {
            int middle = low + ((high-low)>>1);
            if(arr[middle] == targetValue) {
                return true;
            }
            if(arr[low] == arr[middle]) {
                low++;
                continue;
            }

            if(arr[low] < arr[middle]) {
                // 說明左邊有序，右邊循環
                if(targetValue >= arr[low] && targetValue < arr[middle]) {
                    // 目標值在左部分
                    high = middle - 1;
                } else {
                    // 目標值在右部分
                    low = middle + 1;
                }

            } else {
                // 說明左邊循環，右邊有序
                if(targetValue > arr[middle] && targetValue <= arr[high]) {
                    // 目標值在右部分
                    low = middle + 1;
                } else {
                    high = middle - 1;
                }
            }
        }
        return false;
    }

    public static void main(String[] arg) {
        int size = 10;
        int range = 10;
        int[] arr = MyArrayUtil.initArray(size, range);
        int targetValue = 6;
//        arr[(int)(Math.random()*size)] = targetValue;
        MySimpleSorts.quickSort(arr, 0, arr.length-1);
        System.out.println("數組：");
        MyArrayUtil.display(arr);
        System.out.println("簡單二分查找：目標數在數組的下標值爲：" + simpleBSearch(arr, targetValue));
        System.out.println("遞歸二分查找：目標數在數組的下標值爲：" + simpleBSearch(arr, targetValue));

        System.out.println("=======================");

        double sqrtValue = getNumSqrt(7);
        System.out.println("7的平方根爲：" + sqrtValue + "，該數平方值爲:" + sqrtValue*sqrtValue);

        System.out.println("=======================");

        System.out.println("查找第一個值等於給定值的元素：目標數在數組的下標值爲：" + searchFirstEqualNum(arr, targetValue));
        System.out.println("查找最後一個值等於給定值的元素：目標數在數組的下標值爲：" + searchLastEqualNum(arr, targetValue));
        System.out.println("查找第一個值大於等於給定值的元素：目標數在數組的下標值爲：" + searchFirstGreaterEqualNum(arr, targetValue));
        System.out.println("查找最後一個值小於等於給定值的元素：目標數在數組的下標值爲：" + searchLastLessEqualNum(arr, targetValue));

        System.out.println("=======================");
        int[] cyclicArr = new int[]{1};
        targetValue = 0;
        System.out.println("數組：");
        MyArrayUtil.display(cyclicArr);
        System.out.println("目標值" + targetValue + "是否存在於數組中：" + searchCyclicArr(cyclicArr, targetValue));
    }
}

github地址:https://github.com/freshbin/dataStructAndAlgo