Second smallest element in BST: done

Author: rampatra

src/main/java/com/rampatra/base/BinarySearchTree.java

@@ -5,11 +5,16 @@
 import static java.lang.System.out;
 
 /**
- * Created by IntelliJ IDEA.
- * User: rampatra
- * Date: 4/19/15
- * Time: 6:36 PM
- * To change this template go to Preferences | IDE Settings | File and Code Templates
+ * A binary search tree is a binary tree in which every node fits a specific ordering property: all left
+ * descendents <= n < all right descendents. This must be true for each node n.
+ * <p>
+ * Note: The definition of a binary search tree can vary slightly with respect to equality. Under some definitions, the
+ * tree cannot have duplicate values. In others, the duplicate values will be on the right or can be on either side. All
+ * are valid definitions, but you should clarify this with your interviewer
+ *
+ * @author rampatra
+ * @since 4/19/15
+ * @param <E>
  */
 public class BinarySearchTree<E extends Comparable<E>> extends BinaryTree<E> {
 

src/main/java/com/rampatra/trees/CheckForBST.java

@@ -9,11 +9,15 @@
 import static java.lang.System.out;
 
 /**
- * Created by IntelliJ IDEA.
+ * A binary search tree is a binary tree in which every node fits a specific ordering property: all left
+ * descendents <= n < all right descendents. This must be true for each node n.
+ * <p>
+ * Note: The definition of a binary search tree can vary slightly with respect to equality. Under some definitions, the
+ * tree cannot have duplicate values. In others, the duplicate values will be on the right or can be on either side. All
+ * are valid definitions, but you should clarify this with your interviewer
  *
  * @author rampatra
  * @since 6/26/15
- * @time: 7:14 PM
  */
 public class CheckForBST {
 

src/main/java/com/rampatra/trees/LeastCommonAncestor.java

@@ -42,7 +42,9 @@ public void leastCommonAncestor() {
      * @return
      */
     public static <E extends Comparable<E>> BinaryNode<E> leastCommonAncestor(BinaryNode<E> node, E value1, E value2) {
-        if (node == null || value1.compareTo(value2) > 0) throw new NoSuchElementException();
+        if (node == null || value1 == null || value2 == null || value1.compareTo(value2) > 0) {
+            throw new NoSuchElementException();
+        }
 
         if (value1.compareTo(node.value) <= 0 && value2.compareTo(node.value) >= 0) {
             return node;

src/main/java/com/rampatra/trees/SecondSmallestInBST.java

@@ -0,0 +1,108 @@
+package com.rampatra.trees;
+
+/**
+ * Given a Binary Search Tree, find out the second smallest element in the tree.
+ *
+ * @author rampatra
+ * @since 2019-04-02
+ */
+public class SecondSmallestInBST {
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int val) {
+            this.val = val;
+        }
+    }
+
+    private static TreeNode getSecondSmallestNode(TreeNode root) {
+        if (root == null) return null;
+
+        TreeNode curr = root;
+
+        if (curr.left == null) {
+            if (curr.right == null) {
+                return null;
+            } else {
+                return curr;
+            }
+        }
+
+        while (curr.left.left != null) {
+            curr = curr.left;
+        }
+
+        if (curr.left.right != null) {
+            return curr.left.right;
+        } else {
+            return curr;
+        }
+    }
+
+    public static void main(String[] args) {
+        /*
+            The BST looks like:
+            
+                      4
+                   /    \
+                  2      8
+                /  \   /  \
+               1   3  6   9
+              /
+             0
+             
+         */
+        TreeNode treeRoot = new TreeNode(4);
+        treeRoot.left = new TreeNode(2);
+        treeRoot.right = new TreeNode(8);
+        treeRoot.left.left = new TreeNode(1);
+        treeRoot.left.right = new TreeNode(3);
+        treeRoot.left.left.left = new TreeNode(0);
+        treeRoot.right.left = new TreeNode(6);
+        treeRoot.right.right = new TreeNode(9);
+
+        System.out.println(getSecondSmallestNode(treeRoot).val);
+        
+         /*
+            The BST looks like:
+            
+                      4
+                   /    \
+                  2      8
+                /  \   /  \
+               1   3  6   9
+             
+         */
+        treeRoot = new TreeNode(4);
+        treeRoot.left = new TreeNode(2);
+        treeRoot.right = new TreeNode(8);
+        treeRoot.left.left = new TreeNode(1);
+        treeRoot.left.right = new TreeNode(3);
+        treeRoot.right.left = new TreeNode(6);
+        treeRoot.right.right = new TreeNode(9);
+
+        System.out.println(getSecondSmallestNode(treeRoot).val);
+        
+        /*
+            The BST looks like:
+            
+                      4
+                   /    \
+                  2      8
+                   \   /  \
+                   3  6   9
+             
+         */
+        treeRoot = new TreeNode(4);
+        treeRoot.left = new TreeNode(2);
+        treeRoot.right = new TreeNode(8);
+        treeRoot.left.right = new TreeNode(3);
+        treeRoot.right.left = new TreeNode(6);
+        treeRoot.right.right = new TreeNode(9);
+
+        System.out.println(getSecondSmallestNode(treeRoot).val);
+    }
+}