代码随想录算法训练营第二十天| 235. 二叉搜索树的最近公共祖先701.二叉搜索树中的插入操作450.删除二叉搜索树中的节点

今日任务

235. 二叉搜索树的最近公共祖先

701.二叉搜索树中的插入操作

450.删除二叉搜索树中的节点

 
235. 二叉搜索树的最近公共祖先

题目链接： . - 力扣（LeetCode）

/**
 * 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) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        Stack<List<TreeNode>> pathstack = new Stack<List<TreeNode>>();
        List<TreeNode>  pList = new ArrayList<>();
        List<TreeNode> qList = new ArrayList<>();
        List<TreeNode> rootList = new ArrayList<>();
        if (root == null) return root;
        rootList.add(root);
        stack.push(root);
        pathstack.push(rootList);
        while (!stack.isEmpty() && !pathstack.isEmpty()) {
            List<TreeNode> tmpList = pathstack.pop();
            TreeNode tmpNOde = (TreeNode)stack.pop();
            if (tmpNOde.val == p.val) {pList = tmpList;}
            if (tmpNOde.val == q.val) {qList = tmpList;}
            
            if (tmpNOde.right != null) {
                stack.push(tmpNOde.right);
                List<TreeNode> leftList = new ArrayList<>();
                leftList.addAll(tmpList);
                leftList.add(tmpNOde.right);
                pathstack.push(leftList);
            }
            if (tmpNOde.left != null) {
                stack.push(tmpNOde.left);
                List<TreeNode> leftList = new ArrayList<>();
                leftList.addAll(tmpList);
                leftList.add(tmpNOde.left);
                pathstack.push(leftList);
            }
        }

        for (TreeNode node:pList){
            System.out.println("The pList is " + node.val);
        }
        for (TreeNode node:qList){
            System.out.println("The qList is " + node.val);
        }

        Set<TreeNode> set = new HashSet<>();
        for (TreeNode node:pList){
            set.add(node);
        }
        for (int i = qList.size() - 1; i >= 0; i--) {
            if (set.contains(qList.get(i))) {
                return qList.get(i);
            }
        }
        return null;
    }
}

/**
 * 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) {
        /*
        * 递归法
        * */
        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 null;
        } else if (left == null && right != null) {
            System.out.println("" + right.val);
            return right;
        } else if (left != null && right == null) {
            System.out.println("" + left.val);
            return left;
        } else {
            System.out.println("" + root.val);
            return root;
        }
    }
}

701.二叉搜索树中的插入操作

题目链接：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        if (root == null) {
            TreeNode newNode = new TreeNode(val);
            root = newNode;
            return root;
        }
        if (val < root.val) {
            root.left = insertIntoBST(root.left, val);
        }
        if (val > root.val) {
            root.right = insertIntoBST(root.right, val);
        }
        return root;
    }
}

450.删除二叉搜索树中的节点 

题目链接：  . - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        if (root == null) return root;
        if (root.val == key) {
            if (root.right == null) {
                return root.left;
            } else if (root.left == null) {
                return root.right;
            } else {
                TreeNode cur = root.right;
                while (cur.left != null) {
                    cur = cur.left;
                }
                cur.left = root.left;
                root = root.right;
                return root;
            }
        }
        if (root.val > key) {root.left = deleteNode(root.left, key);}
        if (root.val < key) {root.right = deleteNode(root.right, key);}
        return root;
    }
}