Leetcode 1064. Fixed Point, Java解法_力扣fixedpoint-CSDN博客

Given an array A of distinct integers sorted in ascending order, return the smallest index i that satisfies A[i] == i. Return -1 if no such i exists.

Example 1:

Input: [-10,-5,0,3,7]
Output: 3
Explanation: 
For the given array, A[0] = -10, A[1] = -5, A[2] = 0, A[3] = 3, thus the output is 3.

Example 2:

Input: [-10,-5,3,4,7,9]
Output: -1
Explanation: 
There is no such i that A[i] = i, thus the output is -1.

Note:

1 <= A.length < 10^4
-10^9 <= A[i] <= 10^9

Approach #1 Brute Force 我的解法

class Solution {
    public int fixedPoint(int[] A) {
        for(int i=0;i<A.length;i++){
            if(A[i]==i){
                return i;
            }
        }
        return -1;
    }
}

Approach #2 Binary Search

class Solution {
    public int fixedPoint(int[] A) {
        //Run binary search
        int lo = 0;
        int hi = A.length - 1;
        
        while (lo <= hi){
            int mi = lo + (hi - lo) / 2;
            if (A[mi] == mi) return mi;
            if (mi < A[mi]) hi = mi - 1;
            else lo = mi+1;
        }
        
        return -1;
    }
}

分析：

时间复杂度： O(log_2 n);

知识点：

二分查找的基本思想是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x,算法中止；如果x<a[n/2],则只要在数组a的左半部分继续搜索x,如果x>a[n/2],则只要在数组a的右半部搜索x.

时间复杂度无非就是while循环的次数！

总共有n个元素，

渐渐跟下去就是n,n/2,n/4,....n/2^k（接下来操作元素的剩余个数），其中k就是循环的次数

由于你n/2^k取整后>=1

即令n/2^k=1

可得k=log2n,（是以2为底，n的对数）

所以时间复杂度可以表示O(h)=O(log2n)

下面提供一段二分查找实现的伪代码:

BinarySearch(max,min,des)

mid-<(max+min)/2

while(min<=max)

mid=(min+max)/2

if mid=des then

return mid

elseif mid >des then

max=mid-1

else

min=mid+1

return max

折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。它的基本思想是：（这里假设数组元素呈升序排列）将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止；如果x<a[n/2]，则我们只要在数组a的左半部继续搜索x；如果x>a[n/2]，则我们只要在数组a的右半部继续搜索x。