Leetcode 236

最新推荐文章于 2023-04-11 21:42:43 发布

walter1990

最新推荐文章于 2023-04-11 21:42:43 发布

阅读量411

点赞数

分类专栏： Leetcode

本文链接：https://blog.csdn.net/suichen1/article/details/47690545

版权

Leetcode 专栏收录该内容

127 篇文章 0 订阅

订阅专栏

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.

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) {
        val = x;
    }
}
public class Solution236 {
    /*public boolean dfs(TreeNode root, TreeNode p, Stack<TreeNode> tmp) {
        *//*if(root == null || root == p) {
            if (root == null) return false;
            else {
                tmp.push(root);
                return true;
            }
        }
        tmp.push(root);
        if(dfs(root.left,p,tmp) || dfs(root.right, p, tmp)) {
            return true;
        }
        tmp.pop();
        return false;*//*

        if(root == null) return false;

        if(root == p) {
            tmp.push(p);
            return true;
        }
        tmp.push(root);
        if(dfs(root.left, p, tmp) || dfs(root.right, p, tmp)) {
            //tmp.push(root);
            return true;
        }
        tmp.pop();
        return false;
    }
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        Stack<TreeNode> queuep = new Stack<TreeNode>();
        Stack<TreeNode> queueq = new Stack<TreeNode>();

       // dfs(root, p, queuep);
        dfs(root, q, queueq);

        *//*TreeNode result = null;

        for (int i = 0; i < queuep.size() && i < queueq.size(); i++) {
           if(!queuep.get(i).equals(queueq.get(i))) {
               break;
           }
            result = queuep.get(i);
        }*//*

        Enumeration<TreeNode> itemsq = queueq.elements();

        while (itemsq.hasMoreElements()) {
            System.out.print(itemsq.nextElement().val+" ");
        }
        return null;

        //return result;
    }
*/
    public boolean dfs_s(TreeNode root, TreeNode p, Stack<TreeNode> tmp) {
        if(root == null || root == p) {
            if (root == null) return false;
            else {
                tmp.push(root);
                return true;
            }
        }

        if(dfs_s(root.left,p,tmp) || dfs_s(root.right, p, tmp)) {
            tmp.push(root);
            return true;
        }

        return false;
        /*tmp.push(root);  //如果用这种方法虽然结果是正确的，但是会发生栈溢出，
        if(dfs_s(root.left,p,tmp) || dfs_s(root.right, p, tmp)) {

            return true;
        }
        tmp.pop();
        return false;*/
    }
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        Stack<TreeNode> queuep = new Stack<TreeNode>();
        Stack<TreeNode> queueq = new Stack<TreeNode>();

        TreeNode result = null;

        if(dfs_s(root, p, queuep) && dfs_s(root, q, queueq))
        {
            for (int i = queuep.size()-1, j=queueq.size()-1; i >=0 && j >= 0; i--, j--) {
                if(!queuep.get(i).equals(queueq.get(j))) {
                    break;
                }
                result = queuep.get(i);
            }
        }

        return result;
    }
    public static void main(String[] args) {
        TreeNode p = null, q = null;
        TreeNode root = new TreeNode(3);
        root.left = new TreeNode(5);
        p = root.left;
        root.left.left = new TreeNode(6);
        root.left.right = new TreeNode(2);
        root.left.right.left = new TreeNode(7);
        root.left.right.right = new TreeNode(4);
        root.right = new TreeNode(1);
        //q = root.right;
        q=root.left.right.right;
        root.right.left = new TreeNode(0);
        root.right.right = new TreeNode(8);

        Solution236 ans = new Solution236();
        TreeNode result = ans.lowestCommonAncestor(root, p, q);
        //System.out.println(result);
    }
}