leetcode刷题13

j今天刷的题是LeetCode第235题。题目要求是：给定一个二叉搜索树，找到该树中两个指定节点的最近公共祖先

 即，对于有根树T的两个节点pq，最近公共祖先表示为一个节点x，满足pq是x的子节点且x的深度尽可能大

其中给定的二叉树，所有节点的值均不相同，并且pq为不同节点且在二叉树中

开始的时候，想通过暴力法求解：即找到pq的节点的所有祖先节点，然后找出公共的节点即可。但是这在遍历搜索的时候出了问题，暂时还没解决

然后是参考LeetCode的官方解答思路：因为二叉搜索树有一个特点，那就是左子树的节点值都比右子树节点值小

pq的存在一共有三种情况：①pq在节点的左右子树中，此时pq的值将根节点的值夹在中间；②pq在左子树中，此时，pq的值均小于根节点的值；③pq的值在右子树中，此时pq的值均大于根节点的值

具体地代码如下：

/**
 * 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) {
         // Value of current node or parent node.
        int parentVal = root.val;

        // Value of p
        int pVal = p.val;

        // Value of q;
        int qVal = q.val;

        if (pVal > parentVal && qVal > parentVal) {
            // If both p and q are greater than parent
            return lowestCommonAncestor(root.right, p, q);
        } else if (pVal < parentVal && qVal < parentVal) {
            // If both p and q are lesser than parent
            return lowestCommonAncestor(root.left, p, q);
        } else {
            // We have found the split point, i.e. the LCA node.
            return root;
        }
    }
}

 这个题我自己的思路就是像刚才说的那样，找到pq的所有祖先节点，然后再找到共同的节点。

具体地，思路是：①首先计算p的所有祖先节点。在计算的时候，有一个特别重要的变量，那就是全局变量flag，当找到p节点的时候，令flag为true，当然后递归添加祖先节点到一个list中

②然后再计算q的所有祖先节点，这里因为是同一个flag在起作用，判断是不是找到了q节点，因此需要在此将flag初始化为false，然后依然是同样地道理

③接下来就是遍历两个list，找到共同的祖先节点就好了

具体地代码如下：

import LeetcodePart6.TreeNode;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class LowestCommonAncestor_simple_235 {
    private static boolean flag=false;
    public static TreeNode solution(TreeNode root, TreeNode p,TreeNode q){
        List<TreeNode> plist=new ArrayList<>();
        recursion(root,p,plist);
        flag=false;
        List<TreeNode> qlist=new ArrayList<>();
        recursion(root,q,qlist);
        TreeNode result=new TreeNode(0);
        for (int i = plist.size() -1; i >=0; i--) {
            for (int j = qlist.size() -1; j >=0; j--) {
                if (plist.get(i)==qlist.get(j)){
                    result= plist.get(i);
                    break;
                }
            }
        }
        return result;
    }
    public static boolean recursion(TreeNode root, TreeNode p,List<TreeNode> list){
        if (root==null){
            return flag;
        }
        if (root.equals(p)){
            list.add(root);
            flag=true;
            return flag;
        }
        if (root!=null&& root.left!=null){

            if (recursion(root.left,p,list)){
                list.add(root);
            }
        }
        if (!flag && root!=null&& root.right!=null){
            //当在左边没找到的时候，在右边找
            if (recursion(root.right,p,list)){
                list.add(root);
            }
        }
        return flag;
    }
}