【LeetCode 235】Lowest Common Ancestor of a Binary Search Tree

Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”

        _______6______

       /              \

    ___2__          ___8__

   /      \        /      \

   0      _4       7       9

         /   \

         3   5

For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.

思路：

　　利用BST的性质，若待查找两个结点的数值都小于当前结点则向左边查找（若有一个等于当前结点则当前结点就是其最小的公共结点，结束查找），反之向右边查找（同理），若一个大于一个小于，则当前结点就是其最小的公共结点，结束查找。

C++：

 1 /**

 2  * Definition for a binary tree node.

 3  * struct TreeNode {

 4  *     int val;

 5  *     TreeNode *left;

 6  *     TreeNode *right;

 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}

 8  * };

 9  */

10 class Solution {

11 private:

12     TreeNode *l, *r, *ret;

13 public:

14 

15     void rec(TreeNode *root)

16     {

17         int v = root->val;

18         if(l->val <= v && r->val <= v)

19         {

20             if(v == l->val || v == r->val)

21             {

22                 ret = root;

23                 return ;

24             }

25             

26             if(root->left != 0)

27                 rec(root->left);

28         }

29         else if(l->val < v && v < r->val)

30         {

31             ret = root;

32             return ;

33         }

34         else if(l->val >= v && r->val >= v)

35         {

36             if(v == l->val || v == r->val)

37             {

38                 ret = root;

39                 return ;

40             }

41             

42             if(root->right != 0)

43                 rec(root->right);

44         }

45     }

46 

47     TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {

48         if(root == 0)

49             return 0;

50         

51         if(p->val < q->val){

52             l = p;

53             r = q;

54         }

55         else{

56             l = q;

57             r = p;

58         }

59 

60         ret = 0;

61         

62         rec(root);

63         

64         return ret;

65     }

66 };