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<nums.length;i++){
if(nums[i]<0){
int temp = imax;
imax = imin;
imin = temp;
}
imax = Math.max(nums[i],imax * nums[I]);
imin = Math.min(nums[i],imin * nums[I]);
res = Math.max(res,imax);
}
return res;
}
}
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[mid-1])
return nums[mid];
else if(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<Integer> stack = null;
Stack<Integer> minstack = null;
/** initialize your data structure here. */
public MinStack() {
stack = new Stack<Integer>();
minstack = new Stack<Integer>();
}
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;
}
}
