Trees: Kth Smallest Integer in BST | Construct Binary Tree from Preor…

…der and Inorder arrays

src/main/java/com/pallamsetty/trees/ConstructBinaryTreeFromPreorderInorder.java

@@ -0,0 +1,30 @@
+package com.pallamsetty.trees;
+
+import com.pallamsetty.trees.helpers.TreeNode;
+
+import java.util.HashMap;
+
+public class ConstructBinaryTreeFromPreorderInorder {
+    int preIndex = 0;
+    HashMap<Integer, Integer> indices = new HashMap<>();
+
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        for(int i = 0; i < inorder.length; i++) {
+            indices.put(inorder[i], i);
+        }
+        return dfs(preorder, 0, inorder.length - 1);
+    }
+
+    private TreeNode dfs(int[] preorder, int left, int right) {
+        if(left > right) {
+            return null;
+        }
+
+        int rootValue = preorder[preIndex++];
+        TreeNode root = new TreeNode(rootValue);
+        int mid = indices.get(root.val);
+        root.left = dfs(preorder, left, mid - 1);
+        root.right = dfs(preorder, mid + 1, right);
+        return root;
+    }
+}

src/main/java/com/pallamsetty/trees/KthSmallestIntegerInBST.java

@@ -0,0 +1,32 @@
+package com.pallamsetty.trees;
+
+/*
+*
+* */
+
+import com.pallamsetty.trees.helpers.TreeNode;
+
+import java.util.Stack;
+
+public class KthSmallestIntegerInBST {
+    public int getKthSmallest(TreeNode root, int k) {
+        Stack<TreeNode> stack = new Stack<>();
+        TreeNode current = root;
+
+        while(!stack.isEmpty() || current != null) {
+            while(current != null) {
+                stack.push(current);
+                current = current.left;
+            }
+            current = stack.pop();
+            k--;
+            if(k == 0) {
+                return current.val;
+            }
+
+            current = current.right;
+        }
+
+        return -1;
+    }
+}

src/main/java/com/pallamsetty/trees/helpers/TreeNode.java

@@ -0,0 +1,19 @@
+package com.pallamsetty.trees.helpers;
+
+public class TreeNode {
+    public int val;
+    public TreeNode left;
+    public TreeNode right;
+
+    public TreeNode() {}
+
+    public TreeNode(int val) {
+        this.val = val;
+    }
+
+    public TreeNode(int val, TreeNode left, TreeNode right) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}

src/test/java/com/pallamsetty/trees/ConstructBinaryTreeFromPreorderInorderTest.java

@@ -0,0 +1,88 @@
+package com.pallamsetty.trees;
+
+import com.pallamsetty.trees.helpers.TreeNode;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ConstructBinaryTreeFromPreorderInorderTest {
+    private final ConstructBinaryTreeFromPreorderInorder cbtfpi;
+
+    public ConstructBinaryTreeFromPreorderInorderTest() {
+        cbtfpi = new ConstructBinaryTreeFromPreorderInorder();
+    }
+
+    @Test
+    public void testBuildTree1() {
+        int[] preorderArr = { 5, 6, 8, 12, 13, 9, 7, 10, 11, 14, 16 };
+        int[] inorderArr = { 12, 8, 13, 6, 9, 5, 10, 7, 14, 11, 16 };
+
+        TreeNode expected = new TreeNode(5);
+
+        expected.left = new TreeNode(6);
+        expected.left.left = new TreeNode(8);
+        expected.left.right = new TreeNode(9);
+        expected.left.left.left = new TreeNode(12);
+        expected.left.left.right = new TreeNode(13);
+
+        expected.right = new TreeNode(7);
+        expected.right.left = new TreeNode(10);
+        expected.right.right = new TreeNode(11);
+        expected.right.right.left = new TreeNode(14);
+        expected.right.right.right = new TreeNode(16);
+
+        TreeNode actual = cbtfpi.buildTree(preorderArr, inorderArr);
+
+        assertTrees(expected, actual);
+    }
+
+    @Test
+    public void testBuildTree2() {
+        int[] preorder = { 3, 9, 20, 15, 7 };
+        int[] inorder = { 9, 3, 15, 20, 7 };
+
+        TreeNode expected = new TreeNode(3);
+        expected.left = new TreeNode(9);
+        expected.right = new TreeNode(20);
+        expected.right.left = new TreeNode(15);
+        expected.right.right = new TreeNode(7);
+
+        TreeNode actual = cbtfpi.buildTree(preorder, inorder);
+        assertTrees(expected, actual);
+    }
+
+    @Test
+    public void testBuildTree3() {
+        int[] preorder = { -1 };
+        int[] inorder = { -1 };
+
+        TreeNode expected = new TreeNode(-1);
+
+        TreeNode actual = cbtfpi.buildTree(preorder, inorder);
+        assertTrees(expected, actual);
+    }
+
+    @Test
+    public void testBuildTree4() {
+        int[] preorder = { 1, 2, 3, 4 };
+        int[] inorder = { 2, 1, 3, 4 };
+
+        TreeNode expected = new TreeNode(1);
+        expected.left = new TreeNode(2);
+        expected.right = new TreeNode(3);
+        expected.right.right = new TreeNode(4);
+
+        TreeNode actual = cbtfpi.buildTree(preorder, inorder);
+        assertTrees(expected, actual);
+    }
+
+    private void assertTrees(TreeNode expected, TreeNode actual) {
+        if(expected == null) {
+            assertNull(actual);
+        } else {
+            assertEquals(expected.val, actual.val);
+            assertTrees(expected.left, actual.left);
+            assertTrees(expected.right, actual.right);
+        }
+    }
+}

src/test/java/com/pallamsetty/trees/KthSmallestIntegerInBSTTest.java

@@ -0,0 +1,55 @@
+package com.pallamsetty.trees;
+
+import com.pallamsetty.trees.helpers.TreeNode;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class KthSmallestIntegerInBSTTest {
+    private final KthSmallestIntegerInBST ksiib;
+
+    public KthSmallestIntegerInBSTTest() {
+        ksiib = new KthSmallestIntegerInBST();
+    }
+
+    @Test
+    public void testGetKthSmallest1() {
+        TreeNode root = new TreeNode(2);
+        root.left = new TreeNode(1);
+        root.right = new TreeNode(3);
+        int k = 1;
+        assertEquals(1, ksiib.getKthSmallest(root, k));
+    }
+
+    @Test
+    public void testGetKthSmallest2() {
+        TreeNode root = new TreeNode(4);
+        root.left = new TreeNode(3);
+        root.left.left = new TreeNode(2);
+        root.right = new TreeNode(5);
+        int k = 4;
+        assertEquals(5, ksiib.getKthSmallest(root, k));
+    }
+
+    @Test
+    public void testGetKthSmallest3() {
+        TreeNode root = new TreeNode(3);
+        root.left = new TreeNode(1);
+        root.left.right = new TreeNode(2);
+        root.right = new TreeNode(4);
+        int k = 1;
+        assertEquals(1, ksiib.getKthSmallest(root, k));
+    }
+
+    @Test
+    public void testGetKthSmallest4() {
+        TreeNode root = new TreeNode(5);
+        root.left = new TreeNode(3);
+        root.left.left = new TreeNode(2);
+        root.left.right = new TreeNode(4);
+        root.left.left.left = new TreeNode(1);
+        root.right = new TreeNode(6);
+        int k = 3;
+        assertEquals(3, ksiib.getKthSmallest(root, k));
+    }
+}