二分搜索

局部最小值位置

题目：
定义局部最小的概念。arr长度为1时，arr[0]是局部最小。arr的长度为N(N>1)时，如果arr[0]

public class Solution {
    public int getLessIndex(int[] arr) {

        //特殊情况判断
        if(arr==null||arr.length==0){
            return -1;
        }

        int n = arr.length;

        if(arr.length==1){
            return 0;
        }

        if(arr[0]<arr[1]){
            return 0;
        }

        if(arr[n-2]>arr[n-1]){
            return n-1;
        }



       //二分搜索 
        int left = 0;
        int right = arr.length-1;
        int middle = 0;

        while(left<right){

            middle = left+(right-left)/2;

            if(arr[middle]<arr[middle-1]&&arr[middle]<arr[middle+1]){
                return middle;

            }else if(arr[middle]>arr[middle-1]){
                right = middle;
            }else if(arr[middle]>arr[middle+1]){
                left = middle;
            }

        }

        return -1;

    }
}

元素最左出现

题目：
对于一个有序数组arr，再给定一个整数num，请在arr中找到num这个数出现的最左边的位置。

给定一个数组arr及它的大小n，同时给定num。请返回所求位置。若该元素在数组中未出现，请返回-1。

测试样例：
[1,2,3,3,4],5,3
返回：2

代码：

import java.util.*;

public class LeftMostAppearance {
    public int findPos(int[] arr, int n, int num) {
        //边界条件判定
        if(arr==null||arr.length==0){
            return -1;
        }

        //定义一个全局标志变量
        int result = -1;
        int left = 0;
        int right = n-1;
        int middle = 0;

        while(left<=right){

            middle = left + (right-left)/2;

            if(num<arr[middle]){
                right = middle -1;
            }else if(num>arr[middle]){
                left = middle + 1;
            }else{
                //记录符合条件的位置，依次向左边更新
                result = middle;
                right = middle -1;
            }

        }

        return result;
    }
}

循环有序数组最小值

题目：
对于一个有序循环数组arr，返回arr中的最小值。有序循环数组是指，有序数组左边任意长度的部分放到右边去，右边的部分拿到左边来。比如数组[1,2,3,3,4]，是有序循环数组，[4,1,2,3,3]也是。

给定数组arr及它的大小n，请返回最小值。

测试样例：
[4,1,2,3,3],5
返回：1

代码：

import java.util.*;

public class MinValue {
    public int getMin(int[] arr, int n) {
        //边界条件判定
        //if(arr==null||arr.length=0){
        //    return null;
       // }
        //长度为1，直接返回即可
        if(arr.length==1){
            return arr[0];
        }

        //循环比较，采用二分搜索方法
        int left = 0;
        int right = n-1;
        int middle = 0;

        while(left<=right){
            //这种取中间位置坐标的写法更安全，不会超出整形取值范围
            middle = left + (right-left)/2;
            //中间值小于最左边值，最小值在left和middle之间
           if(arr[middle]<arr[left]){

                right = middle -1;
            //中间值大于最右边值，最小值在right和middle之间
            }else if(arr[middle]>arr[right]){

               left = middle + 1;
           //不满足上述两种情况，则遍历循环查找最小值
           }else {
                int min = 0;
                for(int i=0;i<n;i++){
                    if(arr[i]<arr[min]){
                        min = i;
                    }
                }

                return arr[min]; 
           }   
        }

        return arr[left];    
    }
}

最左原位

题目：
有一个有序数组arr，其中不含有重复元素，请找到满足arr[i]==i条件的最左的位置。如果所有位置上的数都不满足条件，返回-1。

给定有序数组arr及它的大小n，请返回所求值。

测试样例：
[-1,0,2,3],4
返回：2

代码：

import java.util.*;

public class Find {
    public int findPos(int[] arr, int n) {
        //边界条件判定
        if(arr==null||arr.length==0){
            return -1;
        }
        //因为不含有重复元素，且下标严格递增
        if(arr[0]>0||arr[n-1]<n-1){
            return -1;
        }

        //定义全局变量，记录最左边的满足条件的位置
        int result = -1;

        int left = 0;
        int middle = 0;
        int right = n-1;

        while(left<=right){

            middle = left + (right-left)/2;

            if(arr[middle]>middle){
                right = middle -1;
            }else if(arr[middle]<middle){
                left = middle + 1;
            }else {
                result = middle;
                right = middle -1;
            } 
        }

        return result;
    }
}

快速N次方

题目：
如果更快的求一个整数k的n次方。如果两个整数相乘并得到结果的时间复杂度为O(1)，得到整数k的N次方的过程请实现时间复杂度为O(logN)的方法。

给定k和n，请返回k的n次方，为了防止溢出，请返回结果Mod 1000000007的值。

测试样例：
2,3
返回：8

代码：

import java.util.*;
//核心思想是利用N的8次方等于N的4次方乘以N的4次方这种思路，提升求解效率
public class QuickPower {
    public int getPower(int k, int N) {
        // write code here
        if(k==1||N==0){
            return 1;
        }

        if(k==0){
            return 0;
        }

        if(N==1){
            return k;
        }

        //递归求解,分奇数偶数
        if(N%2==0){

            long temp = getPower(k,N/2);
            temp = temp*temp;
            temp = temp%1000000007;

            return (int)temp;

        }else{
            //这里会调用偶数的方法步骤
            long temp = getPower(k,(N-1)/2);
            temp = temp*temp;
            temp = temp%1000000007;
            //最后乘以一个K即可
            temp = temp*k%1000000007;
            return (int)temp;
        }


    }
}