[Function add]:1. Add leetcode solutions with tag list.

Botao Xiao · Botao Xiao · commit 53ee6782a958 · 2019-04-15T20:20:50.000-04:00
diff --git a/leetcode/450. Delete Node in a BST.md b/leetcode/450. Delete Node in a BST.md
@@ -0,0 +1,86 @@
+## 450. Delete Node in a BST
+
+### Question
+Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST.
+
+Basically, the deletion can be divided into two stages:
+
+Search for a node to remove.
+If the node is found, delete the node.
+Note: Time complexity should be O(height of tree).
+
+```
+Example:
+
+root = [5,3,6,2,4,null,7]
+key = 3
+
+    5
+   / \
+  3   6
+ / \   \
+2   4   7
+
+Given key to delete is 3. So we find the node with value 3 and delete it.
+
+One valid answer is [5,4,6,2,null,null,7], shown in the following BST.
+
+    5
+   / \
+  4   6
+ /     \
+2       7
+
+Another valid answer is [5,2,6,null,4,null,7].
+
+    5
+   / \
+  2   6
+   \   \
+    4   7
+```
+
+### Solution
+* Method 1: recursion
+  ![Imgur](https://i.imgur.com/rShtr1p.png)
+  ```Java
+  /**
+   * Definition for a binary tree node.
+   * public class TreeNode {
+   *     int val;
+   *     TreeNode left;
+   *     TreeNode right;
+   *     TreeNode(int x) { val = x; }
+   * }
+   */
+  class Solution {
+      public TreeNode deleteNode(TreeNode root, int key) {
+          if(root == null) return root;
+          if(key < root.val) root.left = deleteNode(root.left, key);
+          else if(key > root.val) root.right = deleteNode(root.right, key);
+          else{
+              TreeNode res = null;
+              if(root.left == null) res = root.right;
+              else if(root.right == null) res = root.left;
+              else{ // both left and right are not null.
+                  TreeNode parent = root;
+                  res = root.right;
+                  while(res.left != null){
+                      parent = res;
+                      res = res.left;
+                  }
+                  if(parent != root){
+                      parent.left = res.right;
+                      res.right = root.right;
+                  }
+                  res.left = root.left;
+              }
+              return res;
+          }
+          return root;
+      }
+  }
+  ```
+
+### Reference
+1. [花花酱 LeetCode 450. Delete Node in a BST](http://zxi.mytechroad.com/blog/tree/leetcode-450-delete-node-in-a-bst/)
diff --git a/leetcode/819. Most Common Word.md b/leetcode/819. Most Common Word.md
@@ -0,0 +1,92 @@
+## 819. Most Common Word
+
+### Question
+Given a paragraph and a list of banned words, return the most frequent word that is not in the list of banned words.  It is guaranteed there is at least one word that isn't banned, and that the answer is unique.
+
+Words in the list of banned words are given in lowercase, and free of punctuation.  Words in the paragraph are not case sensitive.  The answer is in lowercase.
+
+```
+Example:
+
+Input:
+paragraph = "Bob hit a ball, the hit BALL flew far after it was hit."
+banned = ["hit"]
+Output: "ball"
+Explanation:
+"hit" occurs 3 times, but it is a banned word.
+"ball" occurs twice (and no other word does), so it is the most frequent non-banned word in the paragraph.
+Note that words in the paragraph are not case sensitive,
+that punctuation is ignored (even if adjacent to words, such as "ball,"),
+and that "hit" isn't the answer even though it occurs more because it is banned.
+
+
+Note:
+
+1 <= paragraph.length <= 1000.
+0 <= banned.length <= 100.
+1 <= banned[i].length <= 10.
+The answer is unique, and written in lowercase (even if its occurrences in paragraph may have uppercase symbols, and even if it is a proper noun.)
+paragraph only consists of letters, spaces, or the punctuation symbols !?',;.
+There are no hyphens or hyphenated words.
+Words only consist of letters, never apostrophes or other punctuation symbols.
+```
+
+### Solution
+* Method 1: HashMap
+  ```Java
+  class Solution {
+      public String mostCommonWord(String paragraph, String[] banned) {
+          paragrap
+          h = paragraph.replaceAll("[\\!\\?',;\\.]", " ");
+          String[] tokens = paragraph.toLowerCase().split(" ");
+          Map<String, Integer> map = new HashMap<>();
+          int max = 0;
+          Set<String> ban = new HashSet<>();
+          for(String word: banned) ban.add(word);
+          for(String token : tokens){
+              token = token.trim();
+              if(ban.contains(token) || token.length() == 0) continue;
+              System.out.println(token);
+              int occur = map.containsKey(token) ? map.get(token): 0;
+              map.put(token, occur + 1);
+              max = Math.max(max, occur + 1);
+          }
+          for(Map.Entry<String, Integer> entry : map.entrySet()){
+              if(entry.getValue() == max) return entry.getKey();
+          }
+          return "";
+      }
+  }
+  ```
+
+  * Method 2: Use StringBuilder, O(n)
+    ```Java
+    class Solution {
+      public String mostCommonWord(String paragraph, String[] banned) {
+          paragraph += ".";
+          Set<String> set = new HashSet<>();
+          for(String ban : banned) set.add(ban);
+          StringBuilder sb = new StringBuilder();
+          Map<String, Integer> map = new HashMap<>();
+          int max = 0;
+          String res = "";
+          for(char c : paragraph.toCharArray()){
+              if(Character.isLetter(c)){
+                  sb.append(Character.toLowerCase(c));
+              }else if(sb.length() > 0){
+                  String token = sb.toString();
+                  if(!set.contains(token)){
+                      int occur = map.getOrDefault(token, 0);
+                      if(occur + 1 > max){
+                          max = occur + 1;
+                          res = token;
+                      }
+                      map.put(token, occur + 1);
+                  }
+                  sb = new StringBuilder();
+              }
+          }
+          return res;
+      }
+  }
+    ```
