【算法与数据结构】二叉树删除结点

尚硅谷Java数据结构与java算法课程第99p课后作业

视频链接：https://www.bilibili.com/video/BV1E4411H73v?p=100

课后题要求：

 按以上要求以及当前二叉树来删除二叉树结点，代码如下，代码片段为70~80行以及172~207行，这里只是多加了一个判断。

BinaryTreeDemo.class

package tree;

public class BinaryTreeDemo {
    public static void main(String[] args){
        BinaryTree binaryTree = new BinaryTree();
        PlayerNode root = new PlayerNode(1,"james");
        PlayerNode node2 = new PlayerNode(2, "wade");
        PlayerNode node3 = new PlayerNode(3, "kobe");
        PlayerNode node4 = new PlayerNode(4, "davais");
        PlayerNode node5 = new PlayerNode(5, "jodan");

        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        binaryTree.setRoot(root);
        //遍历
        System.out.println("前序遍历");//1,2,3,5,4
        binaryTree.preOrder();

        System.out.println("中序遍历");//2,1,5,3,4
        binaryTree.infixOrder();

        System.out.println("后序遍历");//2,5,4,3,1
        binaryTree.postOrder();

        //查找
        System.out.println("前序查找");
        PlayerNode resNode = binaryTree.preOrderSearch(5);
        if (resNode != null){
            System.out.printf("找到了，信息为 no = %d,name = %s
",resNode.getNo(),resNode.getName());
        }else {
            System.out.printf("没有找到 no = %d的球员", 5);
        }

        System.out.println("中序查找");
        PlayerNode resNode1 = binaryTree.infixOrderSearch(5);
        if (resNode != null){
            System.out.printf("找到了，信息为 no = %d,name = %s
",resNode1.getNo(),resNode1.getName());
        }else {
            System.out.printf("没有找到 no = %d的球员", 5);
        }

        System.out.println("后序查找");
        PlayerNode resNode2 = binaryTree.postOrderSearch(5);
        if (resNode != null){
            System.out.printf("找到了，信息为 no = %d,name = %s
",resNode2.getNo(),resNode2.getName());
        }else {
            System.out.printf("没有找到 no = %d的球员", 5);
        }

        //删除结点
        System.out.println("删除前，前序遍历");//1 2 3 5 4 
        binaryTree.preOrder();
        binaryTree.delNode(3);
        System.out.println("删除后，前序遍历");//1 2 5 4
        binaryTree.preOrder();

    }
}


class BinaryTree{
    private PlayerNode root;
    public void setRoot(PlayerNode root){
        this.root = root;
    }

    //删除结点
    public void delNode(int no){
        if (root != null){
            if (root.getNo() == no){
                root = null;
            }else {
                root.delNode(no);
            }
        }else {
            System.out.println("树空，不能删除");
        }
    }

    public void preOrder(){
        if (this.root != null){
            root.preOrder();
        }else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    public void infixOrder(){
        if (this.root != null){
            root.infixOrder();
        }else {
            System.out.println("二叉树为空，无法遍历");
        }
    }
    public void postOrder(){
        if (this.root != null){
            root.postOrder();
        }else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    public PlayerNode preOrderSearch(int no){
        if (root != null){
            return root.preOrdersearch(no);
        }else {
            return null;
        }
    }

    public PlayerNode infixOrderSearch(int no){
        if (root != null){
            return root.infixOrderSearch(no);
        }else {
            return null;
        }
    }

    public PlayerNode postOrderSearch(int no){
        if (root != null){
            return root.postOrderSearch(no);
        }else {
            return null;
        }
    }
}


class PlayerNode{
    private int no;
    private String name;
    private PlayerNode left;
    private PlayerNode right;
    public PlayerNode(int no, String name){
        this.no = no;
        this.name = name;
    }
    public int getNo(){
        return no;
    }
    public void setNo(int no){
        this.no = no;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public PlayerNode getLeft(){
        return left;
    }
    public void setLeft(PlayerNode left){
        this.left = left;
    }
    public PlayerNode getRight(){
        return right;
    }
    public void setRight(PlayerNode right){
        this.right = right;
    }
    @Override
    public String toString(){
        return "PlayerNode [no=" + no + ",name=" + name + "]";
    }

    //递归删除结点
    //1.如果删除的节点是叶子节点，则删除该节点
    //2.如果删除的节点是非叶子节点，则删除该子树
    public void delNode(int no){
        if (this.left != null && this.left.no == no){
            PlayerNode tempNode = this.left.right;
            if (this.left.left != null){
                this.setLeft(this.left.left);
                this.left.setRight(tempNode);
                return;
            }
            if (this.left.right != null){
                this.setLeft(this.left.right);
                return;
            }
            this.left = null;
            return;
        }
        if (this.right != null && this.right.no == no){
            PlayerNode tempNode1 = this.right.right;
            if (this.right.left != null){
                this.setRight(this.right.left);
                this.right.setRight(tempNode1);
                return;
            }
            if (this.right.right != null){
                this.setRight(this.right.right);
                return;
            }
            this.right = null;
            return;
        }
        if (this.left != null){
            this.left.delNode(no);
        }
        if (this.right != null){
            this.right.delNode(no);
        }
    }

    //遍历
    public void preOrder(){
        System.out.println(this);//父结点
        if(this.left != null){
            this.left.preOrder();
        }
        if(this.right != null){
            this.right.preOrder();
        }
    }

    public void infixOrder(){
        if (this.left != null){
            this.left.infixOrder();
        }
        System.out.println(this);
        if (this.right != null){
            this.right.infixOrder();
        }
    }

    public void postOrder(){
        if (this.left != null){
            this.left.postOrder();
        }
        if (this.right != null){
            this.right.postOrder();
        }
        System.out.println(this);
    }

    //查找
    public PlayerNode preOrdersearch(int no){
        System.out.println("进入前序查找");
        if (this.no == no){
            return this;
        }
        PlayerNode resNode = null;
        if (this.left != null){
            resNode = this.left.preOrdersearch(no);
        }
        if (resNode != null){
            return resNode;
        }
        if(this.right != null){
            resNode = this.right.preOrdersearch(no);
        }
        return resNode;
    }

    public PlayerNode infixOrderSearch(int no){
        PlayerNode resNode = null;
        if (this.left != null){
            resNode = this.left.infixOrderSearch(no);
        }
        if (resNode != null){
            return resNode;
        }
        System.out.println("进入中序查找");
        if (this.no == no){
            return this;
        }
        if (this.right != null){
            resNode = this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    public PlayerNode postOrderSearch(int no){
        PlayerNode resNode = null;
        if (this.left != null){
            resNode = this.left.postOrderSearch(no);
        }
        if (resNode != null){
            return resNode;
        }
        if (this.right != null){
            resNode = this.right.postOrderSearch(no);
        }
        if (resNode != null){
            return resNode;
        }
        System.out.println("进入后序查找");
        if (this.no == no){
            return this;
        }
        return resNode;
    }
}

运行结果：

删除前，前序遍历
PlayerNode [no=1,name=james]
PlayerNode [no=2,name=wade]
PlayerNode [no=3,name=kobe]
PlayerNode [no=5,name=jodan]
PlayerNode [no=4,name=davais]
删除后，前序遍历
PlayerNode [no=1,name=james]
PlayerNode [no=2,name=wade]
PlayerNode [no=5,name=jodan]
PlayerNode [no=4,name=davais]