285 inorder successor in BST

Author: Lei Cao

algorithms-java/src/inorderSuccessorInBST/TreeNode.java

@@ -0,0 +1,11 @@
+package inorderSuccessorInBST;
+
+/**
+ * Created by leicao on 5/10/15.
+ */
+public class TreeNode {
+     int val;
+     TreeNode left;
+     TreeNode right;
+     TreeNode(int x) { val = x; }
+}

algorithms-java/src/inorderSuccessorInBST/inorderSuccessorInBST.java

@@ -0,0 +1,65 @@
+// Source : http://www.lintcode.com/en/problem/inorder-successor-in-bst/
+//          https://leetcode.com/problems/inorder-successor-in-bst/
+// Inspired by : http://www.jiuzhang.com/solutions/inorder-successor-in-bst/
+// Author : Lei Cao
+// Date   : 2015-10-06
+
+/**********************************************************************************
+ *
+ * Given a binary search tree and a node in it, find the in-order successor of that node in the BST.
+ *
+ * Example
+ * Given tree = [2,1] and node = 1:
+ *
+ *    2
+ *   /
+ *  1
+ * return node 2.
+ *
+ * Given tree = [2,1,3] and node = 2:
+ *
+ *    2
+ *   / \
+ *  1  3
+ *
+ * return node 3.
+ *
+ * Note
+ * If the given node has no in-order successor in the tree, return null.
+ *
+ * Challenge
+ * O(h), where h is the height of the BST.
+ **********************************************************************************/
+
+package inorderSuccessorInBST;
+
+public class inorderSuccessorInBST {
+    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
+        TreeNode successor = null;
+        if (root == null) {
+            return null;
+        }
+        while (root != null && root.val != p.val) {
+            if (root.val > p.val) {
+                successor = root;
+                root = root.left;
+            } else {
+                root = root.right;
+            }
+        }
+
+        if (root == null) {
+            return null;
+        }
+
+        if (root.right == null) {
+            return successor;
+        }
+
+        root = root.right;
+        while (root.left != null) {
+            root = root.left;
+        }
+        return root;
+    }
+}

algorithms-java/src/inorderSuccessorInBST/inorderSuccessorInBSTTest.java

@@ -0,0 +1,53 @@
+package inorderSuccessorInBST;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by leicao on 7/10/15.
+ */
+public class inorderSuccessorInBSTTest {
+
+    @Test
+    public void testInorderSuccessor() throws Exception {
+        ArrayList<TreeNode> inputes = new ArrayList<TreeNode>();
+        ArrayList<TreeNode> targets = new ArrayList<TreeNode>();
+
+        TreeNode n0 = new TreeNode(2);
+        TreeNode n1 = new TreeNode(1);
+        TreeNode n2 = new TreeNode(3);
+        n0.left = n1;
+        n0.right = n2;
+        inputes.add(n0);
+        targets.add(n2);
+
+        TreeNode nn0 = new TreeNode(2);
+        TreeNode nn1 = new TreeNode(1);
+        nn0.left = nn1;
+        inputes.add(nn0);
+        targets.add(nn1);
+
+        TreeNode t0 = new TreeNode(1);
+        TreeNode t1 = new TreeNode(2);
+        t0.right = t1;
+        inputes.add(t0);
+        targets.add(t0);
+
+
+        ArrayList<TreeNode> results = new ArrayList<TreeNode>();
+        results.add(null);
+        results.add(nn0);
+        results.add(t1);
+
+        for (int i = 0; i < results.size(); i++) {
+            inorderSuccessorInBST finder = new inorderSuccessorInBST();
+            TreeNode node = finder.inorderSuccessor(inputes.get(i), targets.get(i));
+            System.out.println(node);
+            boolean result = node == results.get(i)  || node.val == results.get(i).val;
+            assertTrue(result);
+        }
+    }
+}