refactor 230

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_230.java

@@ -5,65 +5,28 @@
 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 Solution1 {
-        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 Solution2 {
         /**
          * Inorder traversal gives the natural ordering of a BST, no need to sort.
          */
-        int count = 0;
-        int result = Integer.MIN_VALUE;
-
         public int kthSmallest(TreeNode root, int k) {
-            inorder(root, k);
-            return result;
+            List<Integer> inorder = new ArrayList();
+            dfs(root, inorder, k);
+            return inorder.get(k - 1);
         }
 
-        private void inorder(TreeNode root, int k) {
+        private void dfs(TreeNode root, List<Integer> list, int k) {
             if (root == null) {
                 return;
             }
-            inorder(root.left, k);
-            count++;
-            if (count == k) {
-                result = root.val;
+            dfs(root.left, list, k);
+            list.add(root.val);
+            dfs(root.right, list, k);
+            if (list.size() >= (k - 1)) {
                 return;
             }
-            inorder(root.right, k);
         }
     }
 

src/test/java/com/fishercoder/_230Test.java

@@ -12,22 +12,19 @@
  */
 public class _230Test {
     private static _230.Solution1 solution1;
-    private static _230.Solution2 solution2;
     private static TreeNode root;
     private static int k;
 
     @BeforeClass
     public static void setup() {
         solution1 = new _230.Solution1();
-        solution2 = new _230.Solution2();
     }
 
     @Test
     public void test1() {
         root = new TreeNode(1);
         k = 1;
         assertEquals(1, solution1.kthSmallest(root, k));
-        assertEquals(1, solution2.kthSmallest(root, k));
     }
 
     @Test
@@ -36,6 +33,5 @@ public void test2() {
         root.left = new TreeNode(1);
         k = 1;
         assertEquals(1, solution1.kthSmallest(root, k));
-        assertEquals(1, solution2.kthSmallest(root, k));
     }
 }