Merge pull request #50 from nanhuaibeian/master

添加 0017.电话号码的字母组合/剑指Offer05.替换空格/删除字符串中的所有相邻重复项/滑动窗口最大值/摆动序列/完全平方数/不同的二叉搜索树/分割回文串 Java版本

problems/0017.电话号码的字母组合.md

@@ -240,7 +240,46 @@ public:
 
 
 Java：
+```Java
+class Solution {
 
+    //设置全局列表存储最后的结果
+    List<String> list = new ArrayList<>();
+
+    public List<String> letterCombinations(String digits) {
+        if (digits == null || digits.length() == 0) {
+            return list;
+        }
+        //初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
+        String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+        //迭代处理
+        backTracking(digits, numString, 0);
+        return list;
+
+    }
+
+    //每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以这里选择更为高效的 StringBuild
+    StringBuilder temp = new StringBuilder();
+
+    //比如digits如果为"23",num 为0，则str表示2对应的 abc
+    public void backTracking(String digits, String[] numString, int num) {
+        //遍历全部一次记录一次得到的字符串
+        if (num == digits.length()) {
+            list.add(temp.toString());
+            return;
+        }
+        //str 表示当前num对应的字符串
+        String str = numString[digits.charAt(num) - '0'];
+        for (int i = 0; i < str.length(); i++) {
+            temp.append(str.charAt(i));
+            //回溯
+            backTracking(digits, numString, num + 1);
+            //剔除末尾的继续尝试
+            temp.deleteCharAt(temp.length() - 1);
+        }
+    }
+}
+```
 
 Python：
 

problems/0020.有效的括号.md

@@ -138,7 +138,31 @@ public:
 
 
 Java：
-
+```Java
+class Solution {
+    public boolean isValid(String s) {
+        Deque<Character> deque = new LinkedList<>();
+        char ch;
+        for (int i = 0; i < s.length(); i++) {
+            ch = s.charAt(i);
+            //碰到左括号，就把相应的右括号入栈
+            if (ch == '(') {
+                deque.push(')');
+            }else if (ch == '{') {
+                deque.push('}');
+            }else if (ch == '[') {
+                deque.push(']');
+            } else if (deque.isEmpty() || deque.peek() != ch) {
+                return false;
+            }else {//如果是右括号判断是否和栈顶元素匹配
+                deque.pop();
+            }
+        }
+        //最后判断栈中元素是否匹配
+        return deque.isEmpty();
+    }
+}
+```
 
 Python：
 ```python3

problems/0096.不同的二叉搜索树.md

@@ -165,7 +165,25 @@ public:
 
 
 Java：
-
+```Java
+class Solution {
+    public int numTrees(int n) {
+        //初始化 dp 数组
+        int[] dp = new int[n + 1];
+        //初始化0个节点和1个节点的情况
+        dp[0] = 1;
+        dp[1] = 1;
+        for (int i = 2; i <= n; i++) {
+            for (int j = 1; j <= i; j++) {
+                //对于第i个节点，需要考虑1作为根节点直到i作为根节点的情况，所以需要累加
+                //一共i个节点，对于根节点j时,左子树的节点个数为j-1，右子树的节点个数为i-j
+                dp[i] += dp[j - 1] * dp[i - j];
+            }
+        }
+        return dp[n];
+    }
+}
+```
 
 Python：
 

problems/0131.分割回文串.md

@@ -250,7 +250,46 @@ public:
 
 
 Java：
+```Java
+class Solution {
+    List<List<String>> lists = new ArrayList<>();
+    Deque<String> deque = new LinkedList<>();
 
+    public List<List<String>> partition(String s) {
+        backTracking(s, 0);
+        return lists;
+    }
+
+    private void backTracking(String s, int startIndex) {
+        //如果起始位置大于s的大小，说明找到了一组分割方案
+        if (startIndex >= s.length()) {
+            lists.add(new ArrayList(deque));
+            return;
+        }
+        for (int i = startIndex; i < s.length(); i++) {
+            //如果是回文子串，则记录
+            if (isPalindrome(s, startIndex, i)) {
+                String str = s.substring(startIndex, i + 1);
+                deque.addLast(str);
+            } else {
+                continue;
+            }
+            //起始位置后移，保证不重复
+            backTracking(s, i + 1);
+            deque.removeLast();
+        }
+    }
+    //判断是否是回文串
+    private boolean isPalindrome(String s, int startIndex, int end) {
+        for (int i = startIndex, j = end; i < j; i++, j--) {
+            if (s.charAt(i) != s.charAt(j)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
 
 Python：
 

problems/0239.滑动窗口最大值.md

@@ -207,7 +207,60 @@ public:
 
 
 Java：
+```Java
+//自定义数组
+class MyQueue {
+    Deque<Integer> deque = new LinkedList<>();
+    //弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
+    //同时判断队列当前是否为空
+    void poll(int val) {
+        if (!deque.isEmpty() && val == deque.peek()) {
+            deque.poll();
+        }
+    }
+    //添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出
+    //保证队列元素单调递减
+    //比如此时队列元素3,1，2将要入队，比1大，所以1弹出，此时队列：3,2
+    void add(int val) {
+        while (!deque.isEmpty() && val > deque.getLast()) {
+            deque.removeLast();
+        }
+        deque.add(val);
+    }
+    //队列队顶元素始终为最大值
+    int peek() {
+        return deque.peek();
+    }
+}
 
+class Solution {
+    public int[] maxSlidingWindow(int[] nums, int k) {
+        if (nums.length == 1) {
+            return nums;
+        }
+        int len = nums.length - k + 1;
+        //存放结果元素的数组
+        int[] res = new int[len];
+        int num = 0;
+        //自定义队列
+        MyQueue myQueue = new MyQueue();
+        //先将前k的元素放入队列
+        for (int i = 0; i < k; i++) {
+            myQueue.add(nums[i]);
+        }
+        res[num++] = myQueue.peek();
+        for (int i = k; i < nums.length; i++) {
+            //滑动窗口移除最前面的元素，移除是判断该元素是否放入队列
+            myQueue.poll(nums[i - k]);
+            //滑动窗口加入最后面的元素
+            myQueue.add(nums[i]);
+            //记录对应的最大值
+            res[num++] = myQueue.peek();
+        }
+        return res;
+    }
+}
+```
 
 Python：
 

problems/0279.完全平方数.md

@@ -159,7 +159,28 @@ public:
 
 
 Java：
-
+```Java
+class Solution {
+    public int numSquares(int n) {
+        int max = Integer.MAX_VALUE;
+        int[] dp = new int[n + 1];
+        //初始化
+        for (int j = 0; j <= n; j++) {
+            dp[j] = max;
+        }
+        //当和为0时，组合的个数为0
+        dp[0] = 0;
+        for (int i = 1; i * i <= n; i++) {
+            for (int j = i * i; j <= n; j++) {
+                if (dp[j - i * i] != max) {
+                    dp[j] = Math.min(dp[j], dp[j - i * i] + 1);
+                }
+            }
+        }
+        return dp[n];
+    }
+}
+```
 
 Python：
 

problems/0349.两个数组的交集.md

@@ -75,7 +75,37 @@ public:
 
 
 Java：
+```Java
+import java.util.HashSet;
+import java.util.Set;
 
+class Solution {
+    public int[] intersection(int[] nums1, int[] nums2) {
+        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
+            return new int[0];
+        }
+        Set<Integer> set1 = new HashSet<>();
+        Set<Integer> resSet = new HashSet<>();
+        //遍历数组1
+        for (int i : nums1) {
+            set1.add(i);
+        }
+        //遍历数组2的过程中判断哈希表中是否存在该元素
+        for (int i : nums2) {
+            if (set1.contains(i)) {
+                resSet.add(i);
+            }
+        }
+        int[] resArr = new int[resSet.size()];
+        int index = 0;
+        //将结果几何转为数组
+        for (int i : resSet) {
+            resArr[index++] = i;
+        }
+        return resArr;
+    }
+}
+```
 
 Python：
 

problems/0376.摆动序列.md

@@ -111,7 +111,31 @@ public:
 
 
 Java：
-
+```Java
+class Solution {
+    public int wiggleMaxLength(int[] nums) {
+        if (nums == null || nums.length <= 1) {
+            return nums.length;
+        }
+        //当前差值
+        int curDiff = 0;
+        //上一个差值
+        int preDiff = 0;
+        int count = 1;
+        for (int i = 1; i < nums.length; i++) {
+            //得到当前差值
+            curDiff = nums[i] - nums[i - 1];
+            //如果当前差值和上一个差值为一正一负
+            //等于0的情况表示初始时的preDiff
+            if ((curDiff > 0 && preDiff <= 0) || (curDiff < 0 && preDiff >= 0)) {
+                count++;
+                preDiff = curDiff;
+            }
+        }
+        return count;
+    }
+}
+```
 
 Python：
 

problems/1047.删除字符串中的所有相邻重复项.md

@@ -122,7 +122,28 @@ public:
 
 
 Java：
-
+```Java
+class Solution {
+    public String removeDuplicates(String S) {
+        Deque<Character> deque = new LinkedList<>();
+        char ch;
+        for (int i = 0; i < S.length(); i++) {
+            ch = S.charAt(i);
+            if (deque.isEmpty() || deque.peek() != ch) {
+                deque.push(ch);
+            } else {
+                deque.pop();
+            }
+        }
+        String str = "";
+        //剩余的元素即为不重复的元素
+        while (!deque.isEmpty()) {
+            str = deque.pop() + str;
+        }
+        return str;
+    }
+}
+```
 
 Python：
 

problems/剑指Offer05.替换空格.md

@@ -129,7 +129,26 @@ for (int i = 0; i < a.size(); i++) {
 
 
 Java：
-
+```Java
+//使用一个新的对象，复制 str，复制的过程对其判断，是空格则替换，否则直接复制，类似于数组复制
+public static String replaceSpace(StringBuffer str) {
+        if (str == null) {
+            return null;
+        }
+		//选用 StringBuilder 单线程使用，比较快，选不选都行
+        StringBuilder sb = new StringBuilder();
+		//使用 sb 逐个复制 str ，碰到空格则替换，否则直接复制
+        for (int i = 0; i < str.length(); i++) {
+		//str.charAt(i) 为 char 类型，为了比较需要将其转为和 " " 相同的字符串类型
+            if (" ".equals(String.valueOf(str.charAt(i)))){
+                sb.append("%20");
+            } else {
+                sb.append(str.charAt(i));
+            }
+        }
+        return sb.toString();
+    }
+```
 
 Python：