在二叉搜索树中找到两个节点的最低公共祖先

Question

Just wanted to know how efficient is the below algorithm to find the lowest common ancestor of two nodes in a binary search tree.

Node getLowestCommonAncestor (Node root, Node a, Node b) {

   Find the in-order traversal of Node root.
   Find temp1 = the in-order successor of Node a.
   Find temp2 = the in-order successor of Node b.

   return min (temp1, temp2);
}

Answer 1

Searching for the lowest common ancestor in a binary search tree is simpler than that: observe that the LCA is the node where the searches for item A and item B diverge for the first time.

Start from the root, and search for A and B at the same time. As long as both searches take you in the same direction, continue the search. Once you arrive at the node such that searching for A and B take you to different subtrees, you know that the current node is the LCA.

Answer 2

A node at the bottom of a large binary search trees can have an in-order successor close to it, for instance if it is the left child of a node, its in-order successor is its parent.

Two nodes descending from different children of the root will have the root as their least common ancestor, no matter where they are, so I believe that your algorithm gets this case wrong.

This is a discussion of efficient LCA algorithms (given time to build a preparatory data structure) at http://en.wikipedia.org/wiki/Lowest_common_ancestor , with pointers to code.

An inefficient but simple way of finding the LCA is as follows: in the tree keep pointers from children to parents and a note of the depth of each node. Given two nodes, move up from the deepest one until the depth if the same. If you are pointing at the other node, it is the LCA. Otherwise move up one step from each node and check again, and so on, until you meet at the LCA.

Answer 3

Finding LCA of BST is straight:

Find the node for which node1 and node2 are present on different sides. But if the node1 is an ancestor of node2 than also we will have to return node1 . Below code implements this algo.

---

TreeNode<K> commonAncestor(TreeNode t, K k1, K k2){
        if(t==null) return null;
        while(true)
        {
           int c1=t.k.compareTo(k1);
           int c2=t.k.compareTo(k2);
           if(c1*c2<=0)
           {
               return t;
           }
           else
           {
               if(c1<0)
               {
                   t = t.right;
               }
               else
               {
                   t = t.left;
               }
           }
        }
    }