add 230

fishercoder1534 · fishercoder1534 · commit 937861a7483c · 2017-05-19T07:59:09.000-07:00
diff --git a/README.md b/README.md
@@ -254,6 +254,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |235|[Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/)|[Solution](../master/src/main/java/com/stevesun/solutions/_235.java)| O(h)|O(1) | Easy| DFS
 |233|[Number of Digit One](https://leetcode.com/problems/number-of-digit-one/)|[Solution](../master/src/main/java/com/stevesun/solutions/NumberofDigitOne.java)| O(n)|O(1) | Hard| Math
 |232|[Implement Queue using Stacks](https://leetcode.com/problems/implement-queue-using-stacks/)|[Solution](../master/src/main/java/com/stevesun/solutions/_232.java)| O(n)|O(n) | Medium| Stack, Design
+|230|[Kth Smallest Element in a BST](https://leetcode.com/problems/kth-smallest-element-in-a-bst/)|[Solution](../master/src/main/java/com/stevesun/solutions/_230.java)| O(n)|O(k) | Medium| Tree
 |229|[Majority Element II](https://leetcode.com/problems/majority-element-ii/)|[Solution](../master/src/main/java/com/stevesun/solutions/MajorityElementII.java)| O(n)|O(n) | Medium|
 |228|[Summary Ranges](https://leetcode.com/problems/summary-ranges/)|[Solution](../master/src/main/java/com/stevesun/solutions/SummaryRanges.java)| O(n)|O(1) | Medium| Array
 |226|[Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/)|[Solution](../master/src/main/java/com/stevesun/solutions/InvertBinaryTree.java)| O(n)|O(h) | Easy| DFS, recursion
diff --git a/src/main/java/com/stevesun/solutions/_230.java b/src/main/java/com/stevesun/solutions/_230.java
@@ -0,0 +1,58 @@
+package com.stevesun.solutions;
+
+import com.stevesun.common.classes.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 230. Kth Smallest Element in a BST
+ *
+ * Given a binary search tree, write a function kthSmallest to find the kth smallest element in it.
+
+ Note:
+ You may assume k is always valid, 1 ? k ? BST's total elements.
+
+ Follow up:
+ What if the BST is modified (insert/delete operations) often and you need to find the kth smallest frequently? How would you optimize the kthSmallest routine?
+
+ */
+public class _230 {
+
+    public static class MostNaiveWay {
+        public int kthSmallest(TreeNode root, int k) {
+            List<Integer> inorderList = new ArrayList<>();
+            inorder(root, inorderList);
+            return inorderList.get(k-1);
+        }
+
+        private void inorder(TreeNode root, List<Integer> inorderList) {
+            if (root == null) return;
+            if (root.left != null) inorder(root.left, inorderList);
+            inorderList.add(root.val);
+            if (root.right != null) inorder(root.right, inorderList);
+            return;
+        }
+    }
+
+    public static class BetterWay {
+        int count = 0;
+        int result = Integer.MIN_VALUE;
+        public int kthSmallest(TreeNode root, int k) {
+            inorder(root, k);
+            return result;
+        }
+
+        private void inorder(TreeNode root, int k) {
+            if (root == null) return;
+            inorder(root.left, k);
+            count++;
+            if (count == k) {
+                result = root.val;
+                return;
+            }
+            inorder(root.right, k);
+        }
+    }
+
+}
diff --git a/src/test/java/com/stevesun/_230Test.java b/src/test/java/com/stevesun/_230Test.java
@@ -0,0 +1,41 @@
+package com.stevesun;
+
+import com.stevesun.common.classes.TreeNode;
+import com.stevesun.solutions._230;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Created by stevesun on 5/19/17.
+ */
+public class _230Test {
+    private static _230.MostNaiveWay naiveWay;
+    private static _230.BetterWay betterWay;
+    private static TreeNode root;
+    private static int k;
+
+    @BeforeClass
+    public static void setup(){
+        naiveWay = new _230.MostNaiveWay();
+        betterWay = new _230.BetterWay();
+    }
+
+    @Test
+    public void test1(){
+        root = new TreeNode(1);
+        k = 1;
+        assertEquals(1, naiveWay.kthSmallest(root, k));
+        assertEquals(1, betterWay.kthSmallest(root, k));
+    }
+
+    @Test
+    public void test2(){
+        root = new TreeNode(2);
+        root.left = new TreeNode(1);
+        k = 1;
+        assertEquals(1, naiveWay.kthSmallest(root, k));
+        assertEquals(1, betterWay.kthSmallest(root, k));
+    }
+}
