新增5题，累积33题

Author: mercuriussss

src/com/cjl/leetcode/Question_103.java

@@ -0,0 +1,56 @@
+package com.cjl.leetcode;
+
+import com.cjl.common.TreeNode;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/*
+    103. 二叉树的锯齿形层序遍历
+    问题描述：
+        给定一个二叉树，返回其节点值的锯齿形层序遍历。
+        （即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
+    例如：
+        给定二叉树[3,9,20,null,null,15,7],
+            3
+           / \
+          9  20
+            /  \
+           15   7
+    返回锯齿形层序遍历如下：
+        [
+          [3],
+          [20,9],
+          [15,7]
+        ]
+ */
+public class Question_103 {
+
+    // 时间复杂度是O(N)，空间复杂度是O(1)
+    public List<List<Integer>> solution1(TreeNode root) {
+        // LinkedList插入的时候时间复杂度O(1)，ArrayList插入时间复杂度O(n-k)
+        List<List<Integer>> res = new LinkedList<>();
+        dfs(root, res, 0);
+        return res;
+    }
+
+    private void dfs(TreeNode root, List<List<Integer>> res, int level) {
+        if(root == null) {
+            return;
+        }
+
+        if(res.size() == level) {
+            res.add(new LinkedList<>());
+        }
+
+        // 判断层数的奇偶数，奇数从右到左添加，偶数从左到右添加
+        if((level & 1) == 1) {
+            res.get(level).add(0,root.val);
+        }else {
+            res.get(level).add(root.val);
+        }
+
+        dfs(root.left, res, level + 1);
+        dfs(root.right, res, level + 1);
+    }
+}

src/com/cjl/leetcode/Question_124.java

@@ -25,7 +25,7 @@ public class Question_124 {
 
     // 时间复杂度是O(N)，空间复杂度是O(N)
     int result = Integer.MIN_VALUE;
-    public int maxPathSum(TreeNode root) {
+    public int solution1(TreeNode root) {
         dfs(root);
         return result;
     }

src/com/cjl/leetcode/Question_135.java

@@ -0,0 +1,55 @@
+package com.cjl.leetcode;
+
+import com.cjl.common.TreeNode;
+
+import java.util.Arrays;
+
+/*
+    135. 分发糖果
+    问题描述：
+        老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。
+        你需要按照以下要求，帮助老师给这些孩子分发糖果：
+        每个孩子至少分配到 1 个糖果。
+        评分更高的孩子必须比他两侧的邻位孩子获得更多的糖果。
+        那么这样下来，老师至少需要准备多少颗糖果呢？
+    示例1：
+        输入：[1,0,2]
+        输出：5
+        解释：你可以分别给这三个孩子分发 2、1、2 颗糖果。
+    示例2：
+        输入：[1,2,2]
+        输出：4
+        解释：你可以分别给这三个孩子分发 1、2、1 颗糖果。
+             第三个孩子只得到 1 颗糖果，这已满足上述两个条件。
+ */
+public class Question_135 {
+
+
+    public int candy(int[] ratings) {
+        int[] res = new int[ratings.length];
+
+        // 赋值
+        Arrays.fill(res, 1);
+
+        // 从左到右
+        for (int i = 1; i < ratings.length; i++) {
+            if(ratings[i] > ratings[i-1]) {
+                res[i] = res[i-1] + 1;
+            }
+        }
+
+        // 从右到左
+        for (int i = ratings.length - 2; i >= 0; i--) {
+            if(ratings[i] > ratings[i + 1]) {
+                res[i] = Math.max(res[i], res[i + 1] + 1);
+            }
+        }
+
+        int count = 0;
+        for (int re : res) {
+            count += re;
+        }
+
+        return count;
+    }
+}

src/com/cjl/leetcode/Question_32.java

@@ -0,0 +1,51 @@
+package com.cjl.leetcode;
+
+import com.sun.jmx.remote.internal.ArrayQueue;
+
+import java.util.*;
+
+/*
+    32. 最长有效括号
+    问题描述：
+            给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。
+    示例 1：
+        输入：s = "(()"
+        输出：2
+        解释：最长有效括号子串是 "()"
+    示例 2：
+        输入：s = ")()())"
+        输出：4
+        解释：最长有效括号子串是 "()()"
+    示例 3：
+        输入：s = ""
+        输出：0
+        提示：
+        0 <= s.length <= 3 * 10^4
+        s[i] 为 '(' 或 ')'
+ */
+public class Question_32 {
+
+    // 时间复杂度是O(N)，空间复杂度是O(1)
+    public int solution1(String s) {
+        if (s == null || s.length() == 0) {
+            return 0;
+        }
+        Deque<Integer> stack = new ArrayDeque<>();
+        stack.push(-1);
+        int res = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if(s.charAt(i) == '('){
+                stack.push(i);
+            }else{
+                stack.pop();
+                if(stack.isEmpty()) {
+                    stack.push(i);
+                }else{
+                    res = Math.max(res, i - stack.peek());
+                }
+            }
+        }
+
+        return res;
+    }
+}

src/com/cjl/leetcode/Question_72.java

@@ -0,0 +1,61 @@
+package com.cjl.leetcode;
+
+/*
+    72. 编辑距离
+    问题描述：
+        给你两个单词word1 和word2，请你计算出将word1转换成word2 所使用的最少操作数。
+        你可以对一个单词进行如下三种操作：
+        插入一个字符
+        删除一个字符
+        替换一个字符
+    示例1：
+        输入：word1 = "horse", word2 = "ros"
+        输出：3
+        解释：
+        horse -> rorse (将 'h' 替换为 'r')
+        rorse -> rose (删除 'r')
+        rose -> ros (删除 'e')
+    示例2：
+        输入：word1 = "intention", word2 = "execution"
+        输出：5
+        解释：
+        intention -> inention (删除 't')
+        inention -> enention (将 'i' 替换为 'e')
+        enention -> exention (将 'n' 替换为 'x')
+        exention -> exection (将 'n' 替换为 'c')
+        exection -> execution (插入 'u')
+ */
+public class Question_72 {
+
+    public int solution1(String word1, String word2) {
+        int len1 = word1.length();
+        int len2 = word2.length();
+
+        int[][] dp = new int[len1 + 1][len2 + 1];
+
+        // 插入操作
+        for (int i = 1; i <= len1; i++) {
+            dp[i][0] = dp[i - 1][0] + 1;
+        }
+
+        // 删除操作
+        for (int i = 1; i <= len2; i++) {
+            dp[0][i] = dp[0][i - 1] + 1;
+        }
+
+        for (int i = 1; i <= len1; i++) {
+            for (int j = 1; j <= len2; j++) {
+                if(word1.charAt(i - 1) == word2.charAt(j - 1)) {
+                    dp[i][j] = dp[i - 1][j - 1];
+                }else{
+                    // 删除操作：dp[i - 1][j]
+                    // 增加操作：dp[i][j - 1]
+                    // 替换操作：dp[i - 1][j - 1]
+                    dp[i][j] = Math.min(dp[i - 1][j], Math.min(dp[i - 1][j - 1], dp[i][j - 1])) + 1;
+                }
+            }
+        }
+
+        return dp[len1][len2];
+    }
+}

src/com/cjl/leetcode/Question_92.java

@@ -0,0 +1,47 @@
+package com.cjl.leetcode;
+
+import com.cjl.common.ListNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/*
+    92. 反转链表 II
+    问题描述：
+        给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。
+        请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。
+    示例 1：
+        输入：head = [1,2,3,4,5], left = 2, right = 4
+        输出：[1,4,3,2,5]
+    示例 2：
+        输入：head = [5], left = 1, right = 1
+        输出：[5]
+    提示：
+        链表中节点数目为 n
+        1 <= n <= 500
+        -500 <= Node.val <= 500
+        1 <= left <= right <= n
+ */
+public class Question_92 {
+
+    // 时间复杂度是O(N)，空间复杂度是O(1)
+    public ListNode solution1(ListNode head, int left, int right) {
+        ListNode result = new ListNode(0);
+        result.next = head;
+        ListNode pre = result;
+        for (int i = 1; i < left; i++) {
+            pre = pre.next;
+        }
+
+        head = pre.next;
+
+        for (int i = left; i < right; i++) {
+            ListNode next = head.next;
+            head.next = next.next;
+            next.next = pre.next;
+            pre.next = next;
+        }
+
+        return result.next;
+    }
+}