[leetcode] 题型整理之查找

1. 普通的二分法查找查找等于target的数字

2. 还可以查找小于target的数字中最小的数字和大于target的数字中最大的数字

由于新的查找结果总是比旧的查找结果更接近于target，因此只需不停更新result

3. 查找最接近于target的数字

这种情况下，新的查找结果不一定比旧的查找结果更接近target，所以要比较他们与target的差值。

题目：

74. Search a 2D Matrix

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

• Integers in each row are sorted from left to right.
• The first integer of each row is greater than the last integer of the previous row.

For example,

Consider the following matrix:

[
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]

Given target = 3, return true.

查找第一列中大于target的index1，查找最后一列中小于target的index2

数字在index1< n < index2列中

在每一列中再使用二分法

33. Search in Rotated Sorted Array

Suppose a sorted array is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

public class Solution {
    public int search(int[] nums, int target) {
        int length = nums.length;
        int start = 0;
        int end = length - 1;
        while (start <= end) {
            int mid = start + (end - start) / 2;
            int midNum = nums[mid];
            if (midNum == target) {
                return mid;
            }
            int startNum = nums[start];
            if (startNum <= midNum) {
                if (midNum < target) {
                    start = mid + 1;
                } else {
                    if (startNum == target) {
                        return start;
                    } else if (startNum < target) {
                        end = mid - 1;
                    } else {
                        start = mid + 1;
                    }
                }
            } else {
                if (midNum > target) {
                    end = mid - 1;
                } else {
                    int endNum = nums[end];
                    if (endNum == target) {
                        return end;
                    } else if (endNum > target) {
                        start = mid + 1;
                    } else {
                        end = mid - 1;
                    }
                }
            }
        }
        return -1;
    }
}

81. Search in Rotated Sorted Array II

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.

为了防止最坏情况的出现，从头搜到尾。。。

具体解释见九章算法

Search in Rotated Sorted Array II

162. Find Peak Element

A peak element is an element that is greater than its neighbors.

Given an input array where num[i] ≠ num[i+1], find a peak element and return its index.

The array may contain multiple peaks, in that case return the index to any one of the peaks is fine.

You may imagine that num[-1] = num[n] = -∞.

For example, in array [1, 2, 3, 1], 3 is a peak element and your function should return the index number 2.

click to show spoilers.

Note:

Your solution should be in logarithmic complexity.

public class Solution {
    public int findPeakElement(int[] nums) {
        int length = nums.length;
        if (length == 0) {
            return 0;
        }
        if (length == 1) {
            return 0;
        }
        if (nums[0] > nums[1]) {
            return 0;
        }
        if (nums[length - 1] > nums[length - 2]) {
            return length - 1;
        }
        int start = 1;
        int end = length - 2;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (nums[mid - 1] < nums[mid]) {
                start = mid;
            } else if (nums[mid] > nums[mid + 1]) {
                end = mid - 1;
            } else {
                end = mid - 1;
            }
        }
        if (nums[start] >= nums[end]) {
            return start;
        } else {
            return end;
        }
    }
}