[Function add]

1. Add leetcode solutions.

Author: Botao Xiao

README.md

@@ -401,6 +401,12 @@
 
 [228. Summary Ranges](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/228.%20Summary%20Ranges.md)
 
+[229. Majority Element II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/229.%20Majority%20Element%20II.md)
+
+[230. Kth Smallest Element in a BST](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/230.%20Kth%20Smallest%20Element%20in%20a%20BST.md)
+
+[231. Power of Two](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/231.%20Power%20of%20Two.md)
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

leetcode/169. Majority Element.md

@@ -93,4 +93,30 @@ class Solution {
         return save;
     }
 }
-```
+```
+
+### 三刷
+1. Redo the method 3 however think in a different way:
+  * when we see 2 different numbers, we will remove both of them;
+  * when we see 2 same numbers, we will increase the number of appears of current number.
+  * the majority number will remove all other numbers and finally leaves as a result;
+```Java
+class Solution {
+    public int majorityElement(int[] nums) {
+        int result = nums[0], cnt = 1;
+        for(int i = 1; i < nums.length; i++){            
+            if(nums[i] == result){
+                cnt++;
+            }else{
+                if(cnt == 0){
+                    result = nums[i];
+                    cnt = 1;
+                }else{
+                    cnt--;
+                }
+            }
+        }
+        return result;
+    }
+}
+```

leetcode/229. Majority Element II.md

@@ -81,4 +81,69 @@ class Solution {
         return result;
     }
 }
-```
+```
+
+### 二刷
+1. Use map to save the appearance of current number and it appears times.
+```Java
+class Solution {
+    public List<Integer> majorityElement(int[] nums) {
+        List<Integer> result = new LinkedList<>();
+        if(nums == null || nums.length == 0) return result;
+        Map<Integer, Integer> map = new HashMap<>();
+        for(Integer num : nums){
+            map.put(num, map.containsKey(num) ? map.get(num) + 1: 1);
+        }
+        int cmp = nums.length / 3;
+        Set<Map.Entry<Integer, Integer>> entrySet = map.entrySet();
+        for(Map.Entry<Integer, Integer> entry : entrySet){
+            if(entry.getValue() > cmp){
+                result.add(entry.getKey());
+            }
+        }
+        return result;
+    }
+}
+```
+
+2. This question is a improvement of question [169. Majority Element](https://seanforfun.github.io/leetcode/2018/12/21/169.-Majority-Element.html).
+  * we use two counts to record the appearance number of majority.
+  * if same, we increase the count and not same, we minus the count number.
+  * this method will only record the most two majority numbers but won't check if appears more than L / 3.
+```Java
+class Solution {
+    public List<Integer> majorityElement(int[] nums) {
+        List<Integer> result = new LinkedList<>();
+        if(nums == null || nums.length == 0) return result;
+        else if(nums.length == 1){
+            result.add(nums[0]);
+            return result;
+        }
+        int major1 = 0, major2 = 0, cnt1 = 0, cnt2 = 0;
+        for(int num : nums){
+            if(num == major1){
+                cnt1 ++;
+            }else if(num == major2){
+                cnt2 ++;
+            }else if(cnt1 == 0){
+                major1 = num;
+                cnt1 = 1;
+            }else if(cnt2 == 0){
+                major2 = num;
+                cnt2 = 1;
+            }else{
+                cnt1 --;
+                cnt2 --;
+            }
+        }
+        cnt1 = 0; cnt2 = 0;
+        for(int i = 0; i < nums.length; i++){
+            if(nums[i] == major1) cnt1++;
+            else if(nums[i] == major2) cnt2++;
+        }
+        if(cnt1 > nums.length / 3)  result.add(major1);
+        if(cnt2 > nums.length / 3)  result.add(major2);
+        return result;
+    }
+}
+```

leetcode/230. Kth Smallest Element in a BST.md

@@ -59,4 +59,34 @@ class Solution {
         inorder(root.right, result, k);
     }
 }
-```
+```
+
+### 二刷
+1. The method of this question is to add all numbers into the list by inorder traversal.
+2. I added another quit point for recursive so it will significantly increase the efficiency.
+```Java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int kthSmallest(TreeNode root, int k) {
+        List<Integer> result = new LinkedList<>();
+        inorder(result, root, k);
+        return result.get(k - 1);
+    }
+    private void inorder(List<Integer> result, TreeNode node, int k){
+        if(node == null || result.size() >= k){
+            return;
+        }
+        inorder(result, node.left, k);
+        result.add(node.val);
+        inorder(result, node.right, k);
+    }
+}
+```

leetcode/231. Power of Two.md

@@ -7,7 +7,7 @@ Given an integer, write a function to determine if it is a power of two.
 Example 1:
 
 Input: 1
-Output: true 
+Output: true
 Explanation: 20 = 1
 
 Example 2:
@@ -39,4 +39,40 @@ class Solution {
         return count == 1;
     }
 }
-```
+```
+
+### 二刷
+1. I just checked if a number can be fully divided by 2.
+```Java
+class Solution {
+    public boolean isPowerOfTwo(int n) {
+        if(n == 1) return true;
+        else if(n <= 0) return false;
+        while(n != 1){
+            if(n % 2 != 0) return false;
+            n /= 2;
+        }
+        return true;
+    }
+}
+```
+
+2. bit manipulation
+```Java
+class Solution {
+    public boolean isPowerOfTwo(int n) {
+        if(n <= 0) return false;
+        int temp = 0;
+        int count = 0;
+        for(int i = 0; i < 31; i++){
+            temp = n & 1;            
+            if(temp == 1){
+                count ++;
+                if(count > 1) return false;
+            }
+            n >>= 1;            
+        }
+        return true;
+    }
+}
+```