13.1.2 二叉树-删除节点（简单）

13.1.2 二叉树-删除节点（简单）

要求：

1. 如果删除的节点是叶子节点，则删除该节点
2. 入关删除的节点是非子叶节点，则删除该子树

思路：

1. 因为我们的二叉树是单向的，没办法找到前驱节点，所以我们判断当前节点的子节点是否需要删除，而不能去判断当前节点是不是需要删除的节点
2. 先判断当前节点的左子节点不为空，并且左子节点就是要删除的节点，this.left = null,并且返回（结束删除工作）
3. 如果当前节点的右子节点不为空，并且右子节点就是要删除的节点，this.right = null，并且返回（结束删除工作）
4. 如果我们第二步和第三步没有删除节点，我们就需要向左子树进行递归删除（不为空的话）
5. 如果第四步也没有删除节点，那么我们就需要右子树进行递归删除（不为空的话）
6. 如果是空树，或者只有二叉树只有一个节点，则等价于将二叉树置空

package tree;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        // 创建二叉树
        BinaryTree binaryTree = new BinaryTree();
        // 创建需要的节点
        Node1 root = new Node1(1,"a1");
        Node1 n2 = new Node1(2,"a2");
        Node1 n3 = new Node1(3,"a3");
        Node1 n4 = new Node1(4,"a4");
        // 说明，我们先手动创建二叉树，后面使用递归创建二叉树
        root.setLeft(n2);
        root.setRight(n3);
        n3.setRight(n4);
        binaryTree.setRoot(root);
       
        // 测试 删除
        System.out.println("删除前");
        binaryTree.preOrder();
        System.out.println("删除后");
        binaryTree.delNode(3);
        binaryTree.preOrder();
    }
}
// 定义二叉树
class BinaryTree{
    private Node1 root;

    public Node1 getRoot() {
        return root;
    }

    public void setRoot(Node1 root) {
        this.root = root;
    }

    // 前序遍历
    public void preOrder(){
        if (this.root != null){
            this.root.preOrder();
        }else{
            System.out.println("二叉树为空");
        }
    }
 
    // 删除节点
    public void delNode(int id){
        if (root == null){
            System.out.println("该树是空树");
        } else {
            // 如果只有一个根节点，且root还是要删除的节点
            if (root.getId() == id){
                root = null;
            } else{
                root.delNode(id);
            }
        }
    }
}
// 先创建节点
class Node1{
    private int id;
    private String name;
    private Node1 left;
    private Node1 right;

    public Node1(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Node1 getLeft() {
        return left;
    }

    public void setLeft(Node1 left) {
        this.left = left;
    }

    public Node1 getRight() {
        return right;
    }

    public void setRight(Node1 right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "Node1{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
    // 编写前序遍历
    public void preOrder(){
        System.out.println(this); //  先输出当前节点
        // 递归向左子树前序遍历
        if (this.left != null){
            this.left.preOrder();
        }
        // 递归向右子树前序遍历
        if (this.right != null){
            this.right.preOrder();
        }
    }
    // 递归删除节点
    // 1. 如果删除的是叶子节点，则删除该节点
    // 2. 如果删除的节点非叶子节点，则删除该子树
    public void delNode(int id){
        // 当左子树不为空的时候，判断左子树是否是要删除的节点，是就直接删除
        if (this.left != null && this.left.id == id){
            this.left = null;
            return;
        }
        // 当右子树不为空，判断右子树是否是要删除的节点，是就删除
        if (this.right != null && this.right.id == id){
            this.right = null;
            return ;
        }
        // 当左右字数都不为要删除的节点的时候进行递归，要注意是否为空
        if (this.left != null){
            this.left.delNode(id);
        }
        if (this.right != null){
            this.right.delNode(id);
        }


    }
}