二叉树：21删除二叉搜索树中的节点

21删除二叉搜索树中的节点

/**
 * 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) {
        //五种情况
        /*
        1.找不到删除的节点
        能找到删除的节点
        2.叶子节点
        3.左空右不空
        4.右空左不空
        5.左右都不空：左子树的最大值、右子树的最小值提上来
        */
        TreeNode cur = root;
        TreeNode pre = null;
        while(cur != null) {
            boolean flag = true;//默认如果找到了是删除左子树
            if(cur.val < key) {
                pre = cur;
                cur = cur.right;
                flag = false;
            } else if(cur.val > key) {
                pre = cur;
                cur = cur.left;
            } else {
                //找到了需要删除的节点
                if(pre == null) return null;//说明第一个节点就需要删除，那么就是空树了
                if(cur.left == null && cur.right == null) {
                    if(flag) {
                        pre.left = null;
                    } else {
                        pre.right = null;
                    }
                } else if(cur.left == null) {
                    if(flag) {
                        pre.left = cur.right;
                    } else {
                        pre.right = cur.right;
                    }
                } else if(cur.right == null) {
                    if(flag) {
                        pre.left = cur.left;
                    } else {
                        pre.right = cur.left;
                    }
                } else {//左右子树都不为空
                    //这里采用右子树的最小值
                    TreeNode node = getMinTreeNode(cur.right);//返回最小节点
                    /*
                    1.调整先前节点子树
                    2.调整最小节点指针,来指向删除节点的左子树
                    */
                    if(flag) {
                        pre.left = cur.right;
                    } else {
                        pre.right = cur.right;
                    }

                    node.left = cur.left;
                    break;
                }
            }
        }
        return root;
    }
    TreeNode getMinTreeNode(TreeNode cur) {
        while(cur.left != null) {
            cur = cur.left;
        }
        return cur;
    }
}

class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        //五种情况
        /*
        1.找不到删除的节点
        能找到删除的节点
        2.叶子节点
        3.左空右不空
        4.右空左不空
        5.左右都不空：左子树的最大值、右子树的最小值提上来
        */
        if(root == null) return null;
        if(root.val == key) {//找到了需要删除的节点
            if(root.left == null && root.right == null) {//叶子结点
                return null;
            } else if(root.left == null) {
                    return root.right;
            } else if(root.right == null) {
                    return root.left;
            } else {//左右子树都不为空
                    //这里采用右子树的最小值
                    TreeNode node = getMinTreeNode(root.right);//返回最小节点
                    node.left = root.left;
                    return root.right;//注意返回值不是node啊，返回值是删除节点父节点应连接的孩子节点
                    // return node;
                    }
        }

        //单层递归
        root.left = deleteNode(root.left, key);
        root.right = deleteNode(root.right, key);

        return root;
    }
    TreeNode getMinTreeNode(TreeNode cur) {
        while(cur.left != null) {
            cur = cur.left;
        }
        return cur;
    }
}