新增2题，累积36题

Author: mercuriussss

src/com/cjl/leetcode/Question_20.java

@@ -0,0 +1,59 @@
+package com.cjl.leetcode;
+
+import com.cjl.common.ListNode;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
+
+/*
+    20. 有效的括号
+        给定一个只包括 '('，')'，'{'，'}'，'['，']'的字符串 s ，判断字符串是否有效。
+        有效字符串需满足：
+        左括号必须用相同类型的右括号闭合。
+        左括号必须以正确的顺序闭合。
+        每个右括号都有一个对应的相同类型的左括号。
+    示例 1：
+        输入：s = "()"
+        输出：true
+    示例 2：
+        输入：s = "()[]{}"
+        输出：true
+    示例 3：
+        输入：s = "(]"
+        输出：false
+    提示：
+        1 <= s.length <= 10^4
+        s 仅由括号 '()[]{}' 组成
+ */
+public class Question_20 {
+
+    // 时间复杂度O(N)，空间复杂度O(N)
+    public boolean solution1(String s) {
+        if (s.isEmpty()) {
+            return false;
+        }
+        Stack<Character> stack = new Stack<>();
+        Map<Character, Character> map = new HashMap<Character, Character>() {
+            {
+                put('(',')');
+                put('[',']');
+                put('{','}');
+            }
+        };
+        for (int i = 0; i < s.length() ; i++) {
+            switch (s.charAt(i)) {
+                case '(':
+                case '[':
+                case '{':
+                    stack.push(map.get(s.charAt(i)));
+                    break;
+                default:
+                    if (stack.isEmpty() || stack.pop() != s.charAt(i)) {
+                        return false;
+                    }
+            }
+        }
+        return true;
+    }
+}

src/com/cjl/leetcode/Question_42.java

@@ -24,20 +24,16 @@ public int solution1(int[] height) {
         int sum = 0;
         // 去掉头尾两端的列
         for (int i = 1; i < height.length - 1; i++) {
-            int max_left = 0;
+            int maxLeft = 0;
             for (int j = i - 1; j >= 0; j--) {
-                if (height[j] > max_left) {
-                    max_left = height[j];
-                }
+                maxLeft = Math.max(maxLeft, height[j]);
             }
-            int max_right = 0;
-            for (int j = i + 1; j < height.length - 1; j++) {
-                if (height[j] > max_right) {
-                    max_right = height[j];
-                }
+            int maxRight = 0;
+            for (int j = i + 1; j < height.length; j++) {
+                maxRight = Math.max(maxRight, height[j]);
             }
             // 木桶效应，两者取其短
-            int min = Math.min(max_left, max_right);
+            int min = Math.min(maxLeft, maxRight);
             // 最短的要大于当前列才能蓄水
             if (min > height[i]) {
                 sum = sum + (min - height[i]);
@@ -61,7 +57,7 @@ public int solution2(int[] height) {
         for (int i = 1; i < height.length - 1; i++) {
             int min = Math.min(max_left[i],max_right[i]);
             if(min > height[i]){
-                sum += min;
+                sum += (min - height[i]);
             }
         }
         return sum;

src/com/cjl/leetcode/Question_704.java

@@ -0,0 +1,66 @@
+package com.cjl.leetcode;
+
+/*
+    20. 有效的括号
+        给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
+    示例 1:
+        输入: nums = [-1,0,3,5,9,12], target = 9
+        输出: 4
+        解释: 9 出现在 nums 中并且下标为 4
+    示例 2:
+        输入: nums = [-1,0,3,5,9,12], target = 2
+        输出: -1
+        解释: 2 不存在 nums 中因此返回 -1
+    提示：
+        你可以假设 nums 中的所有元素是不重复的。
+        n 将在 [1, 10000]之间。
+        nums 的每个元素都将在 [-9999, 9999]之间。
+ */
+public class Question_704 {
+
+    // 遍历法
+    // 时间复杂度O(nlogn)，空间复杂度O(1)
+    public int solution1(int[] nums, int target) {
+        int left = 0;
+        int right = nums.length - 1;
+        while (left <= right) {
+            int mid = (right - left) / 2 + left;
+            if (nums[mid] == target) {
+                return mid;
+            } else if (nums[mid] > target) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return -1;
+    }
+
+    // 递归处理法
+    // 时间复杂度O(nlogn)，空间复杂度O(N)
+    public int solution2(int[] nums, int target) {
+        if (nums[nums.length - 1] < target) {
+            return -1;
+        }
+        return findTarget(nums, 0, nums.length - 1, target);
+    }
+
+    public int findTarget(int[] nums, int left, int right, int target) {
+        if (nums[left] == target) {
+            return left;
+        } else if (nums[right] == target) {
+            return right;
+        }
+
+        if (left == right || right - left == 1) {
+            return -1;
+        }
+
+        int mid = (left + right) / 2;
+        if (nums[mid] < target) {
+            return findTarget(nums, mid, right, target);
+        } else {
+            return findTarget(nums, left, mid, target);
+        }
+    }
+}