寻找局部最小

一、定义

局部最小：

arr长度为1时，arr[0]是局部最小。

arr的长度为N(N>1)时，

        如果arr[0]<arr[1]，那么arr[0]是局部最小；

        如果 arr[N-1]<arr[N-2]，那么arr[N-1]是局部最小；

        如果0<i<N-1，既有arr[i]<arr[i-1]，又有arr[i]<arr[i+1]，那么arr[i]是局部最小。

二、题目

        给定无序数组arr，已知arr中任意两个相邻的数都不相等。写一个方法，返回数组中其中一个局部最小位置，若不存在返回-1。

三、上代码

package find;

/**
 * 寻找局部最小
 *
 * @author codelmh
 * @data 2021/12/7
 */
public class OneMindIndex {
    public static void main(String[] args) {
        // 对数器
        int maxLen = 100;
        int maxValue = 200;
        int testTime = 1000000;
        for (int i = 0; i < testTime; i++) {
            int[] arr = randomArray(maxLen, maxValue);
            int ans = oneMindIndex(arr);
            if (!check(arr, ans)) {
                System.out.println("出错数组:");
                printArray(arr);
                System.out.println("出错局部最小:" + ans);
                break;
            }
        }
    }

    /**
     * 思路：
     *   如果数组长度为1 则 0是局部最小
     *   如果长度 N > 1
     *      arr[0] < arr[1] 下标 0是局部最小
     *      arr[N - 1] < arr[N - 2] 则 N-1 是局部最小
     *   若以上都没有得到局部最小
     *      则现在可以确定 下标 0  1 是递减趋势
     *                   下标N-2 N-1 是递增趋势
     *      递减 又 递增  则可以假设  0 ~ N-1 必有 局部最小
     *   那么我们使用二分法 L = 0  R = N - 1;
     *          得到 mid = L + (L + R)/2;
     *          若：  arr[mid] < arr[mid + 1] && arr[mid] < arr[mid - 1] 则mid就是局部最小        位置
     *           判断：arr[mid - 1] < arr[mid] 是   则 mid - 1 mid   是递增
     *                                   又分：就得到 L = 0 R = mid - 1
     *                                        否   则 mid  mid + 1  是递增
     *                                   又分：就得到 L = mid+1 R = N -1
     *    若这种情况 mid 没有找到局部最小
     *    则还有一个种可能 arr = {5, 1, 6, 2, 3}
     *    这时 L = 1 R = 3 可以看到 mid =(R+L) /2 不是局部最小
     *    那么 L = 1  R = 2 就不能用 mid =(R + L) / 2 了就会越界
     *    所以 当出现这种情况时 若 arr[L] < arr[R] 则  L就是局部最小
     *                       否则  R就是局部最小
     * @param arr
     * @return
     */
    public static int oneMindIndex(int[] arr) {
        if (arr == null || arr.length == 0) {
            return -1;
        }
        int N = arr.length;
        // 如果 数组长度为1 或者 arr[0] < arr[1] 下标 0是局部最小
        if (N == 1 || arr[0] < arr[1]) {
            return 0;
        }
        // 如果数组 arr[N - 1] < arr[N - 2] 则 N-1 是局部最小
        if (arr[N - 1] < arr[N - 2]) {
            return N - 1;
        }
        int L = 0;
        int R = N - 1;
        while (L < R - 1) {
            int mid = (L + R) / 2;
            // 若 arr[mid] < arr[mid + 1] && arr[mid]<arr[mid - 1] 则 mid是局部最小
            if (arr[mid] < arr[mid + 1] && arr[mid] < arr[mid - 1]) {
                return mid;
            }
            if (arr[mid] > arr[mid - 1]) {
                R = mid - 1;
            } else {
                L = mid + 1;
            }
        }
        return arr[L] < arr[R] ? L : R;
    }

    public static boolean check(int[] arr, int midIndex) {
        if (arr.length == 0) {
            return midIndex == -1;
        }
        int left = midIndex - 1;
        int right = midIndex + 1;
        boolean leftBigger = left <= 0 || arr[left] > arr[midIndex];
        boolean rightBigger = right >= arr.length || arr[right] > arr[midIndex];
        return leftBigger && rightBigger;
    }

    public static void printArray(int[] arr) {
        for (int a : arr) {
            System.out.print(a + " ");
        }
        System.out.println();
    }

    /**
     * 生成随机数组 且相邻 不相等
     *
     * @param maxLen
     * @param maxValue
     * @return
     */
    public static int[] randomArray(int maxLen, int maxValue) {
        int len = (int) (Math.random() * maxLen);
        int[] arr = new int[len];
        if (len > 0) {
            arr[0] = (int) (Math.random() * maxValue);
            for (int i = 1; i < len; i++) {
                do {
                    arr[i] = (int) (Math.random() * maxValue);
                } while (arr[i] == arr[i - 1]);
            }
        }
        return arr;
    }
}