235 Lowest Common Ancestor of a Binary Search Tree

最新推荐文章于 2024-10-30 19:10:39 发布

weixin_30466421

最新推荐文章于 2024-10-30 19:10:39 发布

阅读量82

点赞数

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/nvbxmmd/p/4696231.html

版权

　　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.

/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/

/**********编写下面代码的时候我还不了解二叉搜索树的特点，以下代码对于任何二叉树均适用，关于二叉搜索树的知识将转载到数据结构分类中*********/

方法一：编写函数找到两个节点的根路径，存储在两个vector里，再通过遍历vector找到相同的最后面一个元素

 1 class Solution {
 2 public:
 3     bool TraceNode(TreeNode* root, TreeNode* p, vector<TreeNode*>& vec) {
 4         if(!root) {
 5             return false;
 6         }
 7         vec.push_back(root);
 8         if(root == p) {
 9             return true;
10         }
11         if(!TraceNode(root->left, p, vec)) {
12             if(root->left != NULL) {
13                 vec.pop_back();
14             }
15             if(!TraceNode(root->right, p, vec)) {
16                 if(root->right != NULL) {
17                     vec.pop_back();
18                 }
19                 return false;
20             } else {
21                 return true;
22             }
23         } else {
24             return true;
25         }
26     }
27     TreeNode* GetlowestCommonEle(vector<TreeNode*> vec1, vector<TreeNode*> vec2) {
28         for(int i = vec1.size() - 1; i >= 0; i--) {
29             for(int j = vec2.size() - 1; j >= i; j--) {
30                 if(vec1[i] == vec2[j]) {
31                     return vec1[i];
32                 }
33             }
34         }
35     }
36     TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
37           TraceNode(root, p, vec1);
38           TraceNode(root, q, vec2);
39           if(vec1.size() < vec2.size()) {
40               return GetlowestCommonEle(vec1, vec2);
41           } else {
42               return GetlowestCommonEle(vec2, vec1);
43           }
44     }
45 private:
46     vector<TreeNode*> vec1;
47     vector<TreeNode*> vec2;
48 };