leetcode 236. 二叉树的最近公共祖先

最新推荐文章于 2024-05-10 11:09:53 发布

houjibofa2050

最新推荐文章于 2024-05-10 11:09:53 发布

阅读量151

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/u011243684/article/details/104242385

版权

LeetCode 专栏收录该内容

139 篇文章 1 订阅

订阅专栏

解决办法:

方法一：

递归遍历 节点只能在左边或者右边，left 不为空，right为空，公共祖先是left;left为空，right不为空，公共祖先是right,left和right都不为空，公共祖先是root

方法二：

寻找两个节点的路径，找到第一个不相等的节点，返回上一个节点

代码：

public static void main(String[] args) {
        TreeNode treeNode1=new TreeNode(3);
        TreeNode treeNode2=new TreeNode(5);
        TreeNode treeNode3=new TreeNode(1);
        TreeNode treeNode4=new TreeNode(6);
        TreeNode treeNode5=new TreeNode(2);
        TreeNode treeNode6=new TreeNode(0);
        TreeNode treeNode7=new TreeNode(8);
        TreeNode treeNode8=new TreeNode(7);
        TreeNode treeNode9=new TreeNode(4);
        treeNode1.left=treeNode2;
        treeNode1.right=treeNode3;
        treeNode2.left=treeNode4;
        treeNode2.right=treeNode5;
        treeNode3.left=treeNode6;
        treeNode3.right=treeNode7;
        treeNode5.left=treeNode8;
        treeNode5.left=treeNode9;

        TreeNode treeNode = lowestCommonAncestor2(treeNode1, treeNode2, treeNode3);
        System.out.println(treeNode.val);
    }

    /**
     * @Description: 二叉树的最近公共祖先
     * 递归遍历 节点只能在左边或者右边，left 不为空，right为空，公共祖先是left;left为空，right不为空，公共祖先是right,left和right都不为空，公共祖先是root
     * @Date: 2020/2/9 22:55
     * @Author: fuguowen
     * @Return 
     * @Throws 
     */
    public static TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root==null){
            return null;
        }

        if(root==p || root==q){
            return root;
        }

        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if(left==null){
            return right;
        }
        if(right==null){
            return left;
        }
        if(left!=null && right!=null){
            return root;
        }
        return root;
    }

    /**
     * @Description: 二叉树的公共祖先
     * 解决方法： 寻找两个节点的路径，找到第一个不相等的节点，返回上一个节点
     * @Date: 2020/2/9 22:54
     * @Author: fuguowen
     * @Return 
     * @Throws 
     */
    public static TreeNode lowestCommonAncestor2(TreeNode root, TreeNode p, TreeNode q) {
        int[] flag=new int[1];
        LinkedList<TreeNode> pathList=new LinkedList<>();
        LinkedList<LinkedList<TreeNode>> resultList=new LinkedList<>();

        findParentNode(root,p,pathList,resultList,flag);
        pathList.clear();
        flag[0]=0;
        findParentNode(root,q,pathList,resultList,flag);
        int num;
        if(resultList.get(0).size()<resultList.get(1).size()){
            num=resultList.get(0).size();
        }else{
            num=resultList.get(1).size();
        }
        LinkedList<TreeNode> qResultList=resultList.get(1);
        LinkedList<TreeNode> pResultList=resultList.get(0);
        TreeNode parentNode=null;
        for(int i=0;i<num;i++){
            if(pResultList.get(i)==qResultList.get(i)){
                parentNode=pResultList.get(i);
            }else{
                break;
            }
        }

        return parentNode;
    }

    public static void findParentNode(TreeNode root, TreeNode p, LinkedList<TreeNode> pathList,
                               LinkedList<LinkedList<TreeNode>> resultList, int[] flag){

        if(root==null|| flag[0]==1){
            return ;
        }
        pathList.addLast(root);
        if(root.val==p.val){
            resultList.add(new LinkedList<>(pathList));
            flag[0]=1;
        }
        findParentNode(root.left,p,pathList,resultList,flag);
        findParentNode(root.right,p,pathList,resultList,flag);
        pathList.removeLast();

    }