Update solved leetcode question and answers

xiaoyaoworm · xiaoyaoworm · commit c14ea7453f61 · 2015-11-06T20:18:42.000-08:00
diff --git a/14_longestCommonPrefix.java b/14_longestCommonPrefix.java
@@ -0,0 +1,23 @@
+public class Solution {
+    public String longestCommonPrefix(String[] strs) {
+        if(strs == null || strs.length == 0) return "";
+        int minLen = Integer.MAX_VALUE;
+        for(String str: strs){
+            if(str.length() < minLen){
+                minLen = str.length();
+            }
+        }
+        
+        String prev = "";
+        for(int i = 0; i < minLen; i++){
+            char current = strs[0].charAt(i);
+            for(int j = 1; j < strs.length; j++){
+                if(current!=strs[j].charAt(i)){
+                    return prev;
+                }
+            }
+            prev =  strs[0].substring(0,i+1);
+        }
+        return prev;
+    }
+}
diff --git a/150_evaluateReversePolishNotation.java b/150_evaluateReversePolishNotation.java
@@ -0,0 +1,25 @@
+public class Solution {
+    public int evalRPN(String[] tokens) {
+        Stack<String> stack = new Stack<String>();
+        for(String token: tokens){
+            if("+-*/".contains(token)){
+                int b = Integer.valueOf(stack.pop());
+                int a = Integer.valueOf(stack.pop());
+                int result = 0;
+                if(token.equals("+")){
+                    result = a+b;
+                } else if(token.equals("-")){
+                    result = a-b;
+                } else if(token.equals("*")){
+                    result = a*b;
+                } else if(token.equals("/")){
+                    result = a/b;
+                }
+                stack.push(String.valueOf(result));
+            } else{
+                stack.push(token);
+            }
+        }
+        return Integer.valueOf(stack.pop());
+    }
+}
diff --git a/152_maxProduct.java b/152_maxProduct.java
@@ -0,0 +1,15 @@
+public class Solution {
+    public int maxProduct(int[] nums) {
+        int[] max = new int[nums.length];
+        int[] min = new int[nums.length];
+        int result = nums[0];
+        max[0] = nums[0];
+        min[0] = nums[0];
+        for(int i = 1; i < nums.length; i++){
+            max[i] = Math.max(Math.max(nums[i],nums[i]*max[i-1]),nums[i]*min[i-1]);
+            min[i] = Math.min(Math.min(nums[i],nums[i]*max[i-1]),nums[i]*min[i-1]);
+            result = Math.max(max[i],result);
+        }
+        return result;
+    }
+}
diff --git a/160_getIntersectionNode.java b/160_getIntersectionNode.java
@@ -0,0 +1,45 @@
+/**
+ * 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) {
+        ListNode runA = headA;
+        ListNode runB = headB;
+        int lengthA = 0;
+        int lengthB = 0;
+        while(runA!=null){
+            runA = runA.next;
+            lengthA++;
+        }
+        while(runB!=null){
+            runB = runB.next;
+            lengthB++;
+        }
+        int gap = lengthA-lengthB;
+        if(gap >= 0){
+            while( gap > 0){
+                headA = headA.next;
+                gap--;
+            }
+        } else{
+            while( gap < 0){
+                headB = headB.next;
+                gap++;
+            }
+        }
+        
+        while(headA!=headB){
+            headA = headA.next;
+            headB = headB.next;
+        }
+        return headA;
+    }
+}
diff --git a/205_isIsomorphic.java b/205_isIsomorphic.java
@@ -0,0 +1,25 @@
+public class Solution {
+    public boolean isIsomorphic(String s, String t) {
+        if(s == null && t == null) return true;
+        if(s == null || t == null) return false;
+        if(s.length()!=t.length()) return false;
+        
+        HashMap<Character, Character> map1 = new HashMap<Character, Character>();
+        HashMap<Character, Character> map2 = new HashMap<Character, Character>();
+        
+        int length = s.length();
+        for(int i = 0; i < length; i++){
+            char m = s.charAt(i);
+            char n = t.charAt(i);
+            if(map1.containsKey(m)){
+                if(map1.get(m)!=n) return false;
+            }
+            if(map2.containsKey(n)){
+                if(map2.get(n)!=m) return false;
+            }
+            map1.put(m,n);
+            map2.put(n,m);
+        }
+        return true;
+    }
+}
diff --git a/21_mergeTwoList.java b/21_mergeTwoList.java
@@ -0,0 +1,34 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        ListNode fakeNode = new ListNode(0);
+        ListNode run = fakeNode;
+        while(l1!=null && l2!=null){
+            if(l1.val < l2.val){
+                run.next = l1;
+                run = run.next;
+                l1 = l1.next;
+            } else{
+                run.next = l2;
+                run = run.next;
+                l2 = l2.next;
+            }
+        }
+        
+        if(l1!=null){
+            run.next = l1;
+        }
+        
+        if(l2!=null){
+            run.next = l2;
+        }
+        return fakeNode.next;
+    }
+}
diff --git a/235_lowestCommonAncestor_BST.java b/235_lowestCommonAncestor_BST.java
@@ -0,0 +1,19 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        // bottom to top
+        if(root == null) return null;
+        if(root.val < p.val && root.val > q.val) return root;
+        if(root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right,p,q);
+        if(root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left,p,q);
+        return root;
+    }
+}
diff --git a/236_lowestCommonAncestor.java b/236_lowestCommonAncestor.java
@@ -9,7 +9,7 @@
  */
 public class Solution {
     public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-        // bottom to top
+        // top to bottom!!!
         if(root == null) return null;
         if(root == p||root == q) return root;
         TreeNode left = lowestCommonAncestor(root.left,p,q);
diff --git a/23_mergeKLists.java b/23_mergeKLists.java
@@ -0,0 +1,43 @@
+Time complexity: log(k)*n
+
+
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public ListNode mergeKLists(ListNode[] lists) {
+        if(lists == null || lists.length == 0) return null;
+         
+        PriorityQueue<ListNode> pq = new PriorityQueue<ListNode>(lists.length,new Comparator<ListNode>(){
+            public int compare(ListNode l1, ListNode l2){
+                return l1.val - l2.val;
+            }
+        });
+         
+        for(ListNode l:lists){
+            if(l!=null){
+                pq.add(l);
+            }
+        }
+         
+        ListNode fakeNode = new ListNode(0);
+        ListNode run = fakeNode;
+         
+        while(!pq.isEmpty()){
+            ListNode current = pq.poll();
+            run.next = current;
+            current = current.next;
+            run = run.next;
+            if(current!=null){
+                pq.add(current);
+            }
+        }
+         
+        return fakeNode.next;
+    }
+}
diff --git a/33_searchInRoatedArray.java b/33_searchInRoatedArray.java
@@ -0,0 +1,30 @@
+public class Solution {
+    public int search(int[] nums, int target) {
+        int pivot = findPivot(nums);
+        if (target >= nums[0]){
+            return searchHelper(nums, target,0, pivot);  
+        } else{
+            return searchHelper(nums, target,pivot+1, nums.length-1);
+        }
+    }
+     
+     
+    public int searchHelper(int[] nums, int target, int low, int high){
+        if(low > high) return -1;
+        int mid = low + (high-low)/2;
+        if(target == nums[mid]) return mid;
+        else if(target > nums[mid]) return searchHelper(nums,target,mid+1, high);
+        else return searchHelper(nums,target,low,mid-1);
+    }
+     
+    public int findPivot(int[] nums){
+        int i = 0;
+        while(i < nums.length -1){
+            if(nums[i] > nums[i+1]){
+                return i;
+            }
+            i++;
+        }
+        return i;
+    }
+}
diff --git a/3_lengthOfLongestSubstring.java b/3_lengthOfLongestSubstring.java
@@ -0,0 +1,24 @@
+public class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        if(s == null) return 0;
+        boolean[] flag = new boolean[256];
+        int start = 0;
+        int result = 0;
+        
+        for(int i = 0; i < s.length(); i++){
+            char c = s.charAt(i);
+            if(flag[c]){
+                result = Math.max(result, i-start);
+                for(int k = start; k < i; k++){
+                    if(s.charAt(k) == c){
+                        start = k+1;
+                        break;
+                    }
+                }
+            } else{
+                flag[c] = true;
+            }
+        }
+        return Math.max(result, s.length()-start);
+    }
+}
diff --git a/46_permutation.java b/46_permutation.java
@@ -0,0 +1,32 @@
+public class Solution {
+    public List<List<Integer>> permute(int[] nums) {
+        List<List<Integer>> result = new ArrayList<List<Integer>>();
+        permuteHelper(nums,0,result);
+        return result;
+    }
+    
+    public void permuteHelper(int[] nums, int start, List<List<Integer>> result){
+        if(start == nums.length) {
+            result.add(toList(nums));
+        }
+        for(int i = start; i < nums.length;i++){
+            swap(nums,i,start);
+            permuteHelper(nums,start+1,result);
+            swap(nums,i,start);
+        }
+    }
+    
+    public List<Integer> toList(int[] nums){
+        List<Integer> result = new ArrayList<Integer>();
+        for(int s: nums){
+            result.add(s);
+        }
+        return result;
+    }
+    
+    public void swap(int[] nums, int i, int j){
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+}
diff --git a/47_permuteUnique.java b/47_permuteUnique.java
@@ -0,0 +1,44 @@
+public class Solution {
+    public List<List<Integer>> permuteUnique(int[] nums) {
+        List<List<Integer>> result = new ArrayList<List<Integer>>();
+        int k = nums.length;
+        dfs(nums,0,k,result);
+        return result;
+    }
+    
+    public void dfs(int[] nums,int i, int k, List<List<Integer>> result){
+        if(i == k){
+            result.add(toList(nums));
+        }
+        for(int j = i; j < k; j++){
+            if(checkNoDuplicate(nums,i,j)){ // Most Important condition to check, if there are no duplicate
+                swap(nums,i,j);
+                dfs(nums,i+1,k,result);
+                swap(nums,i,j);
+            }
+        }
+    }
+    
+    public List<Integer> toList(int[] nums){
+        List<Integer> result = new ArrayList<Integer>();
+        for(int s: nums){
+            result.add(s);
+        }
+        return result;
+    }
+    
+    public void swap(int[] nums, int i, int j){
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+    
+    public boolean checkNoDuplicate(int[] nums, int i, int j){
+        for(int start = i; start< j; start++){
+            if(nums[start] == nums[j]){
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/50_pow.java b/50_pow.java
diff --git a/53_maxSubArray.java b/53_maxSubArray.java
diff --git a/57_insertIntervals.java b/57_insertIntervals.java
diff --git a/72_minDistance.java b/72_minDistance.java
