Search in Rotated Sorted Array II

最新推荐文章于 2021-10-14 20:56:08 发布

原创最新推荐文章于 2021-10-14 20:56:08 发布 · 442 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode_Java 专栏收录该内容

121 篇文章

订阅专栏

本文介绍了一种在含有重复元素的旋转有序数组中查找特定目标值的方法。通过改进二分搜索算法，即使数组部分区域元素完全相同也能有效处理。文章提供了详细的代码实现及解析。

Follow up for "Search in Rotated Sorted Array":
What if duplicates are allowed?

Would this affect the run-time complexity? How and why?

Write a function to determine if a given target is in the array.

这道题目尽管用了 binary search，但 time complexity 依然是 n, 但是还是用binary search 实现了一下：

修改过的代码，比 “search in rotated sorted array” 只多了两个while 循环，但是也是反复修改才添加正确的，面试的时候不一定能一次写正取。

</pre><pre name="code" class="java">public class Solution {
    public boolean search(int[] A, int target) {
        if (A == null || A.length == 0) {
            return false;
        }
        int start = 0;
        int end = A.length - 1;
        int mid;
        boolean inLeft;
        while (start + 1 < end) {
            mid = start + (end - start) / 2;
            if (target == A[mid]) {
                return true;
            } else {
                /**
                 * 当while 循环被执行时，说明至少有一边的数据是完全相等的，例如 1121111，或者211111
                 * 对于112111，执行完两个while循环以后，start 和 end 都指向 2
                 * 则跳出最外层while循环
                 * 
                 * 对于211111这种，执行以后end ＝＝ mid，继续操作
                 * 所以两个while循环主要用来处理这种情况
                 * 处理完以后，就可以按照 “search in rotated sorted array ” 的方法来写
                 */
                while (start< A.length-1 && A[mid] == A[start]) {
                    start ++;
                }
                while (end > 0 && A[mid] == A[end]) {
                    end--;
                } if (target < A[mid]) {
                        if (A[mid] > A[end] && A[end] >= target) {
                            start = mid + 1;
                        } else {
                             end = mid - 1;
                        }
                } else {
                        if (A[mid] < A[start] && target >= A[start]) {
                            end = mid - 1;
                        } else {
                            start = mid + 1;
                         }
                }
                
            }
        }
        if (target == A[start] || target == A[end]) {
            return true;
        }
        return false;
    }
}

第一次写的答案：

public class Solution {
    public boolean search(int[] A, int target) {
        if (A == null || A.length == 0) {
            return false;
        }
        int start = 0;
        int end = A.length - 1;
        int mid;
        boolean inLeft;
        while (start + 1 < end) {
            mid = start + (end - start) / 2;
            if (target == A[mid]) {
                return true;
            } else {
                if (A[mid] == A[start] && A[mid] == A[end]) {
                    int i;
                    for (i = mid - 1; i >= 0; i--) {
                        if (A[i] != A[mid]) {
                            end = i ;
                            break;
                        }
                     }
                     if (end != i) {
                         start = mid + 1;
                     }
                } else if (A[mid] == A[start] && A[mid] != A[end]){
                    start = mid + 1;
                }else if (A[mid] != A[start] && A[mid] == A[end]){
                    end = mid - 1;
                } else {
                    if (target < A[mid]) {
                        if (A[mid] > A[end] && A[end] >= target) {
                            start = mid + 1;
                        } else {
                             end = mid - 1;
                        }
                    } else {
                        if (A[mid] < A[start] && target >= A[start]) {
                            end = mid - 1;
                        } else {
                            start = mid + 1;
                         }
                    }
                }
            }
        }
        if (target == A[start] || target == A[end]) {
            return true;
        }
        return false;
    }
}

别人的答案（我自己觉得第一份代码比这份答案看上去还要清晰一点）

public class Solution {
    public boolean search(int[] A, int target) {
        int start = 0, end = A.length-1;
        while(end - start >= 2) {
        	int middle = start + (end-start)/2;
        	if(A[middle] == target) return true;
        	if(A[start] < A[middle]) {
        		if(A[start] <= target && target < A[middle]) end = middle-1;
        		else start = middle+1;
        	}
        	if(A[middle] < A[end]) {
        		if(A[middle] < target && target <= A[end]) start = middle+1;
        		else end = middle-1;
        	}
        	if(A[start] == A[middle]) start++;
        	if(A[middle] == A[end]) end--;        	
        }
        for(int i = start; i <= end; i++) {
        	if(A[i] == target) return true;
        }
        return false;
    }
}