Leetcode -- Day 20 & Day 21 & Day 27 & Day 31

Binary search in sorted Array

Question 1

Median of Two Sorted Arrays

There are two sorted arrays nums1 and nums2 of size m and n respectively. Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

Refer to this link below:

http://www.cnblogs.com/springfor/p/3861890.html

public class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if (nums1 == null || nums2 == null)
            return 0;
        int m = nums1.length;
        int n = nums2.length;
        int k = (m+n)/2;
        
        if ((m+n) % 2 == 0){
            double first = findMedianSortedArrays(nums1,0,m-1,nums2,0,n-1,k);
            double second = findMedianSortedArrays(nums1,0,m-1,nums2,0,n-1,k+1);
            return (first+second)/2;
        }
        else
            return findMedianSortedArrays(nums1,0,m-1,nums2,0,n-1,k+1);
    }
    
    public double findMedianSortedArrays(int[] A, int sA, int eA, int[] B, int sB, int eB, int k){
        int m = eA - sA + 1;
        int n = eB - sB + 1;
        if (m > n)
            return findMedianSortedArrays(B, sB, eB, A, sA, eA, k);
        if (m == 0)
            return B[k-1];
        if (k == 1)
            return Math.min(A[sA], B[sB]);
        int partA = Math.min(k/2, m);
        int partB = k - partA;
        if (A[sA + partA-1] < B[sB + partB - 1])
            return findMedianSortedArrays(A, sA + partA, eA, B, sB, eB, k-partA);
        else if (A[sA + partA-1] > B[sB + partB - 1])
            return findMedianSortedArrays(A, sA, eA, B, sB+partB, eB, k-partB);
        else
            return A[sA + partA - 1];
    }
}

 

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.

row and colum's product -1 is the total number of this values. And a trick here is mid/colum is the row and mid%colum is the column.

public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix == null || matrix.length < 1)
            return false;
        
        int left = 0;
        int right = matrix.length * matrix[0].length - 1;
        
        while (left <= right){
            int mid = (left + right)/2;
            int value = matrix[mid/matrix[0].length][mid % matrix[0].length];
            if (value == target){
                return true;
            }
            else if (value < target){
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }
        return false;
    }

This is my initial solution, using two loops, more complex but more directly.

public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix == null)
            return false;
            
        if (matrix[0][0] > target)
            return false;
        int row_mid;
        int col_mid;
        int row_start = 0;
        int col_start = 0;
        int row_end = matrix.length-1;
        int col_end = matrix[0].length-1;
        
        while (row_start <= row_end){
            row_mid = (row_start + row_end)/2;
            // matrix[row_mid][] is the one we are interested in
            if (matrix[row_mid][0] == target){
                return true;
            }
            else if (matrix[row_mid][0] > target){
                row_end = row_mid - 1; 
            }
            else {
                row_start = row_mid + 1;
            }
        }
        
        row_mid = row_end;
        if (row_mid < 0)
            return false;
            
        while (col_start <= col_end){
            col_mid = (col_start + col_end)/2;
            int value = matrix[row_mid][col_mid];
            if (value == target){
                return true;
            }
            else if (value < target){
                col_start = col_mid + 1;
            }
            else{
                col_end = col_mid - 1;
            }
        }
            
        return false;
    }

Question 2

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.

I use a hashmap tp record the index of each value in the array. Then I sort the array again and use binary search to find the value.

public int search(int[] nums, int target) {
        if (nums == null || nums.length < 1)
            return -1;
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i ++){
            map.put(nums[i], i);
        }
        Arrays.sort(nums);
        int start = 0;
        int end = nums.length - 1;
        int mid;
        while (start <= end){
            mid = (start + end) / 2;
            if (nums[mid] == target){
                return map.get(nums[mid]);
            }
            else if (nums[mid] < target){
                start = mid + 1;
            }
            else{
                end = mid - 1;
            }
        }
        return -1;
    }

This method only use the iterative not hash map. But you always need to compare the nums[left] and nums[mid] relations.  

public int search(int[] nums, int target) {
        if (nums == null || nums.length < 1)
            return -1;
        int left = 0;
        int right = nums.length - 1;
        int mid;
        while (left <= right){
            mid = (left + right)/2;
            if (nums[mid] == target){
                return mid;
            }
            if (nums[left] <= nums[mid]){
                if (nums[left] <= target && nums[mid] > target){
                    right = mid - 1;
                }
                else{
                    left = mid + 1;
                }
            }
            else if (nums[left] >= nums[mid]){
                if (nums[mid] < target && nums[right] >= target){
                    left = mid + 1;
                }
                else{
                    right = mid - 1;
                }
            }
        }
        return -1;
    }

Question 3

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.

I use iterative method here. Remember to add the method to check if there is duplicate. If the nums[left] == nums[mid] then if nums[mid] != nums[right], left directly change to mid + 1, else left ++;

public boolean search(int[] nums, int target) {
        if (nums == null || nums.length < 1)
            return false;
        int left = 0;
        int right = nums.length - 1;
        int mid;
        
        while (left <= right){
            mid = (right + left)/2;
            if (nums[mid] == target){
                return true;
            }
            else if (nums[left] > nums[mid]){
                if (nums[mid] < target && nums[right] >= target){
                    left = mid + 1;
                }
                else{
                    right = mid - 1;
                }
            }
            else if (nums[left] < nums[mid]){
                if (nums[left] <= target && nums[mid] > target){
                    right = mid - 1;
                }
                else{
                    left = mid + 1;
                }
            }
            else{
                if (nums[mid] != nums[right]){
                    left = mid + 1;
                }
                else left ++;
            } 
        }
        return false;
    }

 

Question 4

Find Minimum 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).

Find the minimum element.

You may assume no duplicate exists in the array.

If left < right, then means it is a sorted array, and left is the minimum value and should be returned. And if mid < right, then we don't need to consider the value from mid to right; so we make right = mid. And if mid > right and before left > right, then mid to right has the minimum value;

 

public int findMin(int[] nums) {
        if (nums == null || nums.length < 1){
            return Integer.MAX_VALUE;
        }
        int left = 0;
        int right = nums.length - 1;
        int mid;
        
        while (left != right){
            if (nums[left] <= nums[right])
                return nums[left];
            
            mid = (left + right)/2;
            
            if (nums[mid] < nums[right])
                right = mid;
            else
                left = mid + 1;
        }
        return nums[left];
    }

 

 

 

Find Minimum in Rotated Sorted Array II

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

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

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).

Find the minimum element.

The array may contain duplicates.

 This problem actually has the same solution as the above one. What is difference is that it may need O(n) complexity because of the duplication condition. If there are a lot of duplicate value, it will always run left++, then it will only need step by step working. 

    public int findMin(int[] num) {
        if(num == null || num.length==0)
            return 0;
        int l = 0;
        int r = num.length-1;
        int min = num[0];
        while(l<r-1)
        {
            int m = (l+r)/2;
            if(num[l]<num[m])
            {
                min = Math.min(num[l],min);
                l = m+1;
            }
            else if(num[l]>num[m])
            {
                min = Math.min(num[m],min);
                r = m-1;
            }
            else
            {
                l++;
            }
        }
        min = Math.min(num[r],min);
        min = Math.min(num[l],min);
        return min;
    }