Leetcode-Java(十六)

152. Maximum Product Subarray

这道题看了讨论之后发现了一个很巧妙的解法，使用了两个变量imax，imin，当遇到数组中的负数时，交换两个数的位置。

class Solution {
    public int maxProduct(int[] nums) {
        if(nums==null || nums.length==0)
            return 0;
        int res = nums[0];
        int imax = nums[0];
        int imin = nums[0];
        for(int i=1;i

153. Find Minimum in Rotated Sorted Array

二分查找的思想：
1、当mid大于0，且mid位置的数比左边的数小的时候，我们已经找到了目标
2、如果mid位置的数大于等于left位置的数，且大于right位置的数时，说明我们的目标在mid的右边，所以left = mid + 1
3、否则 right = mid-1
4、跳出循环说明我们的目标在数组的两头，返回left位置的数。

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

154. Find Minimum in Rotated Sorted Array II

class Solution {
    public int findMin(int[] nums) {
         int l = 0, r = nums.length-1;
     while (l < r) {
         int mid = (l + r) / 2;
         if (nums[mid] < nums[r]) {
             r = mid;
         } else if (nums[mid] > nums[r]){
             l = mid + 1;
         } else {  
             r--;  //nums[mid]=nums[r] no idea, but we can eliminate nums[r];
         }
     }
     return nums[l];
    }
}

155. Min Stack

这里用两个stack，一个stack用于保存栈的元素，另一个stack用于保存栈到当前栈顶时的最小元素。

class MinStack {
    Stack stack = null;
    Stack minstack = null;
    /** initialize your data structure here. */
    public MinStack() {
        stack = new Stack();
        minstack = new Stack();
    }
    
    public void push(int x) {
        stack.push(x);
        if(minstack.empty())
            minstack.push(x);
        else
            minstack.push(Math.min(x,minstack.peek()));
    }
    
    public void pop() {
        if(!stack.empty()){
            stack.pop();
        minstack.pop();
        }
        
    }
    
    public int top() {
        if(!stack.empty()){
            return stack.peek();
        }
        else
            return 0;
    }
    
    public int getMin() {
        if(!stack.empty()){
            return minstack.peek();
        }
        else
            return 0;
        
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

中间的题上锁了。。。

160. Intersection of Two Linked Lists

用两个指针，一个先遍历第一个链表，再遍历第二个链表，另一个先遍历第二个链表，再遍历第一个链表，当两个指针相遇时，就是两个链表交叉的起始位置。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA==null || headB==null)
            return null;
        ListNode p = headA;
        ListNode q = headB;
        boolean flagA = true;
        boolean flagB = true;
        while(!(p==null && q==null)){
            if(p==q)
                return p;
            p = p.next;
            q = q.next;
            if(p==null && flagA){
                p = headB;
                flagA = false;
            }
            else if(p==null)
                return null;
            if(q==null && flagB){
                q = headA;
                flagB = false;
            }
            else if(q==null)
                return null;;
        }
        return null;
    }
}