leetcode刷题-Lowest Common Ancestor of a Binary Tree

CodingBoy121

于 2016-12-29 16:58:01 发布

阅读量271

点赞数

分类专栏： leetcode刷题C++

本文链接：https://blog.csdn.net/u013676711/article/details/53930240

版权

leetcode刷题C++ 专栏收录该内容

43 篇文章 0 订阅

订阅专栏

236. Lowest Common Ancestor of a Binary Tree

My Submissions

Total Accepted: 76416
Total Submissions: 261454
Difficulty: Medium
Contributors: Admin

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

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).”

        _______3______
       /              \
    ___5__          ___1__
   /      \        /      \
   6      _2       0       8
         /  \
         7   4

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

//方法一 前序遍历 将遍历的路径用list存储起来，直到找到第一个节点 停止查询，如果一直没找到 就pop出来
//最后在两个list里找到最后一个相同的节点即可。
bool GetNodePath(TreeNode* pRoot, TreeNode* pNode, list<TreeNode*>& path)
{
  if(pRoot == pNode)
    return true;
  path.push_back(pRoot);
  bool found = false;

  vector<TreeNode*>::iterator i = pRoot -> m_vChildren.begin();
  while(!found && i < pRoot -> m_vChildren.end())
  {
    found = GetNodePath(*i,pNode,path);
    ++i;
  }
  if(!found)
    path.pop_back();
  return found;
}

TreeNode* GetLastCommonNode(const list<TreeNode*>& path1,const list<TreeNode*>& path2)
{
  list<TreeNode*>::const_iterator iterator1 = path1.begin();
  list<TreeNode*>::const_iterator iterator2 = path2.begin();

  TreeNode* pLast = NULL;
  while(iterator1 != path1.end() && iterator2 != path2.end())
  {
    if(*iterator1 == *iterator2)
      pLast = *iterator1;
    iterator1++;
    iterator2++;
  }
  return pLast;
}
TreeNode* GetLastCommonParent(TreeNode* pRoot, TreeNode* pNode1, TreeNode* pNode2)
{
  if(pRoot == NULL || pNode1 == NULL || pNode2 == NULL)
      return NULL;
  list<TreeNode*> path1;
  GetNodePath(pRoot,pNode1,path1);

  list<TreeNode*> path2;
  GetNodePath(pRoot,pNode2,path2);
  return GetLastCommonNode(path1,path2);
}

//方法二：也是先序遍历，直到找到一样的节点 直接返回该节点的root节点，如果左右都不为空 那么就是该root节点  然后一直返回
//如果左边找到了 右边没找到  那么会等找到右边后的root就是最后的公共节点
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == NULL || root == p || root == q)
            return root;
        TreeNode* left = lowestCommonAncestor(root -> left, p, q);
        TreeNode* right = lowestCommonAncestor(root -> right, p, q);
        if(left != NULL && right != NULL)
            return root;
        return left == NULL ? right : left;
    }
};