Kth smallest element in binary search tree problem

Author: mandliya

README.md

@@ -6,7 +6,7 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 161 |
+| Total Problems | 162 |
 
 </center>
 
@@ -111,7 +111,7 @@ Include contains single header implementation of data structures and some algori
 |Recursive Level order traveral of Tree | [levelOrderTraversalRecursive.cpp](tree_problems/levelOrderTraversalRecursive.cpp)|
 |ZigZag Traversal of Tree | [zigZagTraversal.cpp](tree_problems/zigZagTraversal.cpp)|
 |Predecessor and Successor of a given node in Binary Search Tree | [predecessorSuccessor.cpp](tree_problems/predecessorSuccessor.cpp)|
-|Given values of two nodes in a Binary Search Tree, find the Lowest Common Ancestor (LCA). Assume that both the values exist in the tree.| [lowest-common-ancestor.cpp](tree_problems/lowest-common-ancestor.cpp)|
+|Given values of two nodes in a Binary Search Tree, find the Lowest Common Ancestor (LCA). Assume that both the values exist in the tree.| [lowest-common-ancestor.cpp] (tree_problems/lowest-common-ancestor.cpp)|
 |Given a binary tree (unlike binary search tree), find the Lowest Common Ancestor (LCA).|[lowest-common-ancestor-binary-tree.cpp](tree_problems/lowest-common-ancestor-binary-tree.cpp)|
 |Given a binary tree, print out all of its root-to-leaf paths one per line.| [printAllRootToLeafPath.cpp](tree_problems/printAllRootToLeafPath.cpp)
 |Determine if a tree is sum tree. A SumTree is a Binary Tree where the value of a node is equal to sum of the nodes present in its left subtree and right subtree. An empty tree is SumTree and sum of an empty tree can be considered as 0. A leaf node is also considered as SumTree.| [sumTree.cpp](tree_problems/sumTree.cpp)|
@@ -124,6 +124,7 @@ Include contains single header implementation of data structures and some algori
 | Given a binary tree, print its nodes level by level in reverse order. i.e. all nodes present at last level should be printed first followed by nodes of second-last level and so on.. All nodes for any level should be printed from left to right. | [reverseLevelOrderTraversal.cpp](tree_problems/reverseLevelOrderTraversal.cpp) |
 | Invert a binary tree, recursively and iteratively.| [invert_a_tree.cpp](tree_problems/invert_a_tree.cpp) |
 | Given a Binary Search Tree, find ceil and floor of a given key in it. If the given key lie in the BST, then both floor and ceil is equal to that key, else ceil is equal to next greater key (if any) in the BST and floor is equal to previous greater key (if any) in the BST | [floor_ceil_bst.cpp](tree_problems/floor_ceil_bst.cpp) |
+| Find kth smallest element in a binary search tree | [kth_smallest.cpp](tree_problems/kth_smallest.cpp)|
 
 ### String Problems
 | Problem | Solution |

tree_problems/kth_smallest.cpp

@@ -0,0 +1,91 @@
+/*
+ * Given a binary search tree, find the kth smallest element in it.
+ * Assumption: k is always valid i.e. 1 <= k <= total number of nodes in BST
+ *
+ *          8
+ *        /   \
+ *       /     \
+ *      4      10
+ *     / \     / \
+ *    /   \   /   \
+ *   2     6 9    12
+ *  k = 2, answer: 4
+ *  k = 7, answer: 12
+ */
+
+#include <iostream>
+
+struct TreeNode {
+    int data;
+    TreeNode* left;
+    TreeNode* right;
+    TreeNode(int d):
+        data{d}, left{nullptr}, right{nullptr} { }
+};
+
+int countNodes(TreeNode* root)
+{
+    if (root == nullptr) {
+        return 0;
+    }
+    return 1 + countNodes(root->left) + countNodes(root->right);
+}
+
+int kthSmallest(TreeNode* root, int k)
+{
+    int count = countNodes(root->left);
+    if (k <= count && root->left) {
+        return kthSmallest(root->left, k);
+    } else if ( k + 1 >= count && root->right) {
+        return kthSmallest(root->right, k - count - 1);
+    }
+    return root->data;
+}
+
+void insertNode(TreeNode* &root, int d)
+{
+    if (!root) {
+        TreeNode* newNode = new TreeNode(d);
+        root = newNode;
+        return;
+    }
+    if (root->data >= d) {
+        insertNode(root->left, d);
+    }
+    else {
+        insertNode(root->right, d);
+    }
+}
+
+void inorder(TreeNode* root)
+{
+    if (root) {
+        inorder(root->left);
+        std::cout << root->data << " ";
+        inorder(root->right);
+    }
+}
+
+int main()
+{
+    TreeNode* root = nullptr;
+    insertNode(root, 8);
+    insertNode(root, 4);
+    insertNode(root, 10);
+    insertNode(root, 2);
+    insertNode(root, 6);
+    insertNode(root, 9);
+    insertNode(root, 12);
+    std::cout << "Inorder traversal of tree:" << std::endl;
+    inorder(root);
+    std::cout << std::endl;
+
+    std::cout << "2nd smallest element in tree: " << kthSmallest(root, 2)
+        << std::endl;
+    std::cout << "4th smallest element in tree: " << kthSmallest(root, 4)
+        << std::endl;
+    std::cout << "7th smallest element in tree: " << kthSmallest(root, 7)
+        << std::endl;
+    return 0;
+}
+