java数据结构和算法——二叉树删除节点

一、二叉树删除节点的思路图解

二、二叉树删除节点的示例代码

1、代码

package com.rf.springboot01.dataStructure.tree;

/**
 * @description: 二叉树删除节点示例
 * @author: xiaozhi
 * @create: 2020-08-28 21:07
 */
public class BinaryTreeDemoThree {
    public static void main(String[] args) {
        //创建二叉树
        BinaryTree1 binaryTree1 = new BinaryTree1();
        //创建需要的结点
        UsersNode root = new UsersNode(1,"张三");
        UsersNode node2 = new UsersNode(2, "李四");
        UsersNode node3 = new UsersNode(3, "王五");
        UsersNode node4 = new UsersNode(4, "小志");
        UsersNode node5 = new UsersNode(5, "Tom");
        //手动创建该二叉树
        binaryTree1.setRoot(root);//创建根节点
        root.setLeft(node2);//创建根节点左边子节点
        root.setRight(node3);//创建根节点右边子节点
        node3.setRight(node4);//创建根节点右边子节点的右边子节点
        node3.setLeft(node5);//创建根节点右边子节点的左边子节点

        System.out.println("删除前，前序遍历结果如下===============");
        binaryTree1.preOrder();//输出的no的顺序为1,2,3,5,4
        binaryTree1.delNode(3);
        System.out.println("删除后，前序遍历结果如下===============");
        binaryTree1.preOrder();//输出的no的顺序为1,2

    }
}
/**
 * @Description: 创建BinaryTree1 二叉树
 * @Param:
 * @Author: xz
 * @return:
 * @Date: 2020-08-28 21:15
 */
class BinaryTree1{
    private UsersNode root;

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

    //前序遍历方法
    public void preOrder(){
        if(root !=null){
            this.root.preOrder();
        }else{
            System.out.println("二叉树为空，无法遍历");
        }
    }
    //删除结点
    public void delNode(int no) {
        if(root != null) {
            //如果只有一个root结点, 这里立即判断root是不是就是要删除结点
            if(root.getNo() == no) {
                root = null;
            } else {
                //递归删除
                root.deleteNode(no);
            }
        }else{
            System.out.println("空树，不能删除~");
        }
    }

}
/**
 * @Description: 先创建UserNode结点类
 * @Author: xz
 * @Date: 2020-08-28 21:10
 */
class UsersNode{

    private int no;
    private String name;
    private UsersNode left;//左节点，默认为null
    private UsersNode right;//左节点，默认为null

    public UsersNode(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 UsersNode getLeft() {
        return left;
    }

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

    public UsersNode getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "UsersNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    //前序遍历方法
    public void preOrder(){
        //先输出父节点
        System.out.println(this);
        //递归向左子树前序遍历
        if(this.left != null){
            this.left.preOrder();
        }
        //递归向右子树前序遍历
        if(this.right != null){
            this.right.preOrder();
        }
    }
    //删除节点方法
    public void deleteNode(int no){
        //如果当前节点的左子节点不为空，并且左子节点就是要删除节点，就将this.left=null; 并且返回(结束递归删除)
        if(this.left != null && this.left.no == no){
            this.left=null;
            return;
        }
        //如果当前节点的右子节点不为空，并且右子节点就是要删除节点，就将this.right=null;并且返回(结束递归删除)
        if(this.right != null && this.right.no == no){
            this.right=null;
            return;
        }
        //要向左子树进行递归删除
        if(this.left !=null){
            this.left.deleteNode(no);
        }
        //向右子树进行递归删除
        if(this.right !=null){
            this.right.deleteNode(no);
        }
    }


}

2、删除节点5的运行结果如下：

3、删除节点3的运行结果如下：