[JAVA]寻找最低公共祖宗结点

题目来源：leetcode

题目描述：

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 p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

Given the following binary tree:  root = [3,5,1,6,2,0,8,null,null,7,4]

Example 1:

Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
Output: 3
Explanation: The LCA of nodes 5 and 1 is 3.

---

一开始就决定了要用深度优先遍历，因为这样会保存他的所有祖宗结点，企图用一个栈去判断，然后发现找俩个最前面那个的前面一个不满足条件（混乱……今天阿里面试还凉了( ╯□╰ )，所以还是两个栈各自保存，他们的祖宗结点路径，也就是先序遍历，然后比较得到最最近一个共同节点。


You are here!
Your runtime beats 100.00 % of java submissions

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        //bfs
        if(p.left==q||p.right==q) return p;
        if(q.left==p||q.right==p) return q;
        Stack<TreeNode> s1=new Stack();
        Stack<TreeNode> s2=new Stack();
        TreeNode visit=root;
        TreeNode r=root;
        while(root!=p)
        {
            if(root==null){
                root=s1.peek();
                if(root.right==null||root.right==visit) {  visit=root; s1.pop(); root=null;}
                else{
                    visit=root;
                    root=root.right;
                }
                
            }
             
            else{
                s1.push(root);
                root=root.left;
            }
        }
        s1.push(root);
        root=r;
         while(root!=q)
        {
            if(root==null){
                root=s2.peek();
                if(root.right==null||root.right==visit) {  visit=root; s2.pop(); root=null;}
                else{
                    visit=root;
                    root=root.right;
                }
                
            } 
            else{
           
                s2.push(root);
                root=root.left;
            }
        }
        s2.push(root);
        root=s1.peek();
        while(s2.search(root)==-1) {
            s1.pop();
            root=s1.peek();
        }
        return root;
    }
}
// public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    //     TreeNode pfather=findFather(root,p);
    //     TreeNode qfather=findFather(root,q);
    //     if(pfather!=qfather) return lowestCommonAncestor(root,pfather,qfather);
    //     return pfather;
    // }
    // public TreeNode findFather(TreeNode root, TreeNode kid)
    // {
    //     if(root==null) return null;
    //     if(root.left==kid||root.right==kid) return root;
    //     TreeNode l=findFather(root.left,kid);
    //     TreeNode r=findFather(root.right,kid);
    //     return l==null?r:l;
    // }空间受限

加油啊