局部最小问题：在数组中找到一个局部最小的值

在数组中找到一个局部最小的值

题目：给定一个整体无序的数组arr,arr相邻的两个数不相等。

请找出arr中任意一个局部最小的位置

局部最小的定义

1.当数组为空或者数组长度等于零时，返回-1.

2.当数组长度为1时，返回0.

3.当数组长度N>1时，

​ 1)如果arr[0]<arr[1],那么arr[0]是局部最小,返回0即可;

​ 2)如果arr[N-2]>arr[N-1]，那么arr[N-1]是局部最小,返回N-1即可；

​ 3)如果0＜i＜N-1，既有arr[i]＜arr[i-1]，又有arr[i]＜arr[i+1]，那么arr[i]是局部最小

分析普遍情况:

1)和2)两种情况去除，又因为arr相邻的两个数不相等，所以数组的头尾四个数的情况是这样的

**结论：**因为arr[0]~arr[1]是下降趋势, arr[n-2]~arr[n-1]是上升趋势，又因为arr相邻的两个数不相等，所以arr数组一定存在局部最小值。

设数组的中间位置为mid,那么mid有四种情况

①mid比它左边小，比它右边小，所以已经是局部最小，直接返回

②mid比它左边大，也比它右边大。此时arr[0]~arr[1]是下降趋势, arr[mid-1]~arr[mid]是上升趋势，所以在此范围内数组arr一定存在局部最小。去掉mid右边的范围，直接找mid左边。备注：虽然mid右边也存在局部最小，但是我们只需要返回一个局部最小，所以我们选择直接往mid左边找就可以了。

③此时arr[mid]~arr[mid+1]是下降趋势, arr[n-2]~arr[n-1]是上升趋势,所以在此范围内数组arr一定存在局部最小。去掉mid左边的范围，找mid右边。

④此时arr[0]~arr[1]是下降趋势， arr[mid-1]~arr[mid]是上升趋势，所以在此范围内数组arr一定存在局部最小。去掉mid右边的范围，找mid左边。

具体代码实现如下：

// arr 整体无序
// arr 相邻的数不相等！
public static int oneMinIndex(int[] arr) {
   if (arr == null || arr.length == 0) {
      return -1;
   }
   int N = arr.length;
   if (N == 1) {
      return 0;
   }
   if (arr[0] < arr[1]) {
      return 0;
   }
   if (arr[N - 1] < arr[N - 2]) {
      return N - 1;
   }
   int L = 0;
   int R = N - 1;
   /**
    *  L...R 肯定有局部最小
    *  保证L~R之间至少有三个数，我们才能进行二分
    *  如果L~R之间不够三个数,我们直接比较L和R哪个更小，哪个就是局部最小
    */
   while (L < R - 1) {
      int mid = (L + R) / 2;
      if (arr[mid] < arr[mid - 1] && arr[mid] < arr[mid + 1]) {
         return mid;
      } else {
         // 1 left>mid  mid>right
         // 2 left<mid  mid<right
         // 3 left<mid  mid>right
         if (arr[mid] > arr[mid - 1]) {
            R = mid - 1;
         } else {
            L = mid + 1;
         }
      }
   }
   //循环结束之后,L>=R-1. 数组内要么是两个数，要么是一个数
   return arr[L] < arr[R] ? L : R;
}

// 生成随机数组，且相邻数不相等
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;
}

// 检验oneMinIndex方法的正确与否
public static boolean check(int[] arr, int minIndex) {
   if (arr.length == 0) {
      return minIndex == -1;
   }
   int left = minIndex - 1;
   int right = minIndex + 1;
   boolean leftBigger = left >= 0 ? arr[left] > arr[minIndex] : true;
   boolean rightBigger = right < arr.length ? arr[right] > arr[minIndex] : true;
   return leftBigger && rightBigger;
}

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

public static void main(String[] args) {
   int maxLen = 10;
   int maxValue = 200;
   int testTime = 1000000;
   System.out.println("测试开始");
   for (int i = 0; i < testTime; i++) {
      int[] arr = randomArray(maxLen, maxValue);
      int ans = oneMinIndex(arr);
      if (!check(arr, ans)) {
         printArray(arr);
         System.out.println(ans);
         break;
      }
   }
   System.out.println("测试结束");
}