数据结构 - 二叉树(删除节点)

约定不等于承诺〃 2023-07-03 04:51 91阅读 0赞

#  #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA_size_16_color_FFFFFF_t_70]

### 因为二叉树是单向的，所以要判断当前节点的子节点(左或右)是否是被删除的节点 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA_size_16_color_FFFFFF_t_70 3]

//递归删除节点
        //规定：如果是叶子节点就删除节点，如果非叶子节点就删除子树
        public void delNode(int no){ 
            if (this.left !=null && this.left.no == no){ 
                this.left = null;
                return;
            }
            if (this.right != null && this.right.no == no){ 
                this.right = null;
                return;
            }
            if (this.left != null){ 
                this.left.delNode(no);
            }
            if (this.right != null){ 
                this.right.delNode(no);
            }
    
        }

//删除节点
        public void delNode(int no){ 
            if (root != null){ //判断root是不是要删除的节点
                if (root.getNo() == no){ 
                    root = null;
                }else { 
                    root.delNode(no);
                }
            }
        }

# 完整代码 #

package tree;
    
    public class BinaryTreeDemo { 
        public static void main(String[] args) { 
            //先需要创建一颗二叉树
            BinaryTree binaryTree = new BinaryTree();
    
            //创建需要的节点
            HeroNode root = new HeroNode(1, "宋江");
            HeroNode node2 = new HeroNode(2, "吴用");
            HeroNode node3 = new HeroNode(3, "卢俊义");
            HeroNode node4 = new HeroNode(4, "林冲");
            HeroNode node5 = new HeroNode(5, "关胜");
    
            //说明，先手动创建该二叉树，后面学习递归方式创建二叉树
            binaryTree.setRoot(root);
            root.setLeft(node2);
            root.setRight(node3);
            node3.setRight(node4);
            node3.setLeft(node5);
    
            //测试
    // System.out.println("前序遍历");
    // binaryTree.preOrder();
    // System.out.println("中序遍历");
    // binaryTree.infixOrder();
    // System.out.println("后序遍历");
    // binaryTree.postOrder();
    
            //测试查找
            //前序遍历查找
    // System.out.println("前序遍历查找：~~~~");
    // HeroNode heroNode1 = binaryTree.preOrederSearch(5);
    // if (heroNode1 != null){ 
    // System.out.println("找到节点：" + heroNode1.toString());
    // }else { 
    // System.out.println("没有找到");
    // }
    //
     //中序遍历查找
    // System.out.println("中序遍历查找：~~~~");
    // HeroNode heroNode2 = binaryTree.infixOrderSeach(5);
    // if (heroNode2 != null){ 
    // System.out.println("找到节点：" + heroNode2.toString());
    // }else { 
    // System.out.println("没有找到");
    // }
    //
    // //后序遍历查找
    // System.out.println("后序遍历查找：~~~~");
    // HeroNode heroNode3 = binaryTree.postOrderSeach(5);
    // if (heroNode3 != null){ 
    // System.out.println("找到节点：" + heroNode3.toString());
    // }else { 
    // System.out.println("没有找到");
    // }
    
    
            //删除前
            System.out.println("删除前，前序遍历");
            binaryTree.preOrder();
            binaryTree.delNode(3);
            System.out.println("删除后，前序遍历");
            binaryTree.preOrder();
        }
    }
    
    class BinaryTree{ 
        private HeroNode root;
        public void setRoot(HeroNode root){ 
            this.root = root;
        }
        //前序遍历
        public void preOrder(){ 
            if (this.root != null){ 
                this.root.preOrder();
            }else { 
                System.out.println("二叉树为空无法遍历");
            }
        }
    
        //中序遍历
        public void infixOrder(){ 
            if (this.root != null){ 
                this.root.infixOrder();
            }else { 
                System.out.println("二叉树为空无法遍历");
            }
        }
        //后序遍历
        public void postOrder(){ 
            if (this.root != null){ 
                this.root.postOrder();
            }else { 
                System.out.println("二叉树为空无法遍历");
            }
        }
    
        //前序查找
        public HeroNode preOrederSearch(int no){ 
            if (root != null){ 
                return root.preOrderSearch(no);
            }else { 
                return null;
            }
        }
        //中序查找
        public HeroNode infixOrderSeach(int no){ 
            if (root != null){ 
                return root.infixOrderSearch(no);
            }else { 
                return null;
            }
        }
        //后序查找
        public HeroNode postOrderSeach(int no){ 
            if (root != null){ 
                return root.postOrderSearch(no);
            }else { 
                return null;
            }
        }
    
        //删除节点
        public void delNode(int no){ 
            if (root != null){ //判断root是不是要删除的节点
                if (root.getNo() == no){ 
                    root = null;
                }else { 
                    root.delNode(no);
                }
            }
        }
    
    }
    class HeroNode{ 
        private int no;
        private String name;
        private HeroNode left;//默认null
        private HeroNode right;//默认null;
    
        public HeroNode(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 HeroNode getLeft() { 
            return left;
        }
    
        public void setLeft(HeroNode left) { 
            this.left = left;
        }
    
        public HeroNode getRight() { 
            return right;
        }
    
        public void setRight(HeroNode right) { 
            this.right = right;
        }
    
        @Override
        public String toString() { 
            return "HeroNode{" +
                    "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 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 static int i = 1, j = 1, k =1;
        //编写前序查找方法
        public HeroNode preOrderSearch(int no){ 
            System.out.println("前序遍历"+(i++)+"次");
            if (this.no == no){ 
                return this;
            }
            HeroNode heroNode = null;
            if (this.left != null){ 
                heroNode = this.left.preOrderSearch(no);
            }
            //不等于空说明在左边找到了
            if (heroNode != null){ 
                return heroNode;
            }
            if (this.right != null){ 
                heroNode = this.right.preOrderSearch(no);
            }
            return heroNode;
        }
    
        //中序遍历查找
        public HeroNode infixOrderSearch(int no){ 
    
            HeroNode heroNode = null;
            //先判断当前节点的左子节点是否为空，不为空继续进行中序查找
            if (this.left != null){ 
                heroNode = this.left.infixOrderSearch(no);
            }
            if (heroNode != null){ 
                return heroNode;
            }
            System.out.println("中序遍历"+(j++)+"次");
            if (this.no == no){ 
                return this;
            }
            if (this.right != null){ 
                heroNode = this.right.infixOrderSearch(no);
            }
    
            return heroNode;
        }
    
        //后序遍历查找
        public HeroNode postOrderSearch(int no){ 
    
            HeroNode heroNode = null;
            //判断当前节点的左子节点是否为空，不为空，则递归后序遍历查找
            if (this.left != null){ 
                heroNode = this.left.postOrderSearch(no);
            }
            if (heroNode != null){ 
                return heroNode;
            }
            //判断当前节点的右子节点是否为空，不为空，则递归后序遍历查找
            if (this.right != null){ 
                heroNode = this.right.postOrderSearch(no);
            }
            if (heroNode != null){ 
                return heroNode;
            }
            System.out.println("后序遍历"+(k++)+"次");
            //左右子树都没有找到，比较当前节点是不是
            if (this.no == no){ 
                return this;
            }
            return heroNode;
        }
    
        //递归删除节点
        //规定：如果是叶子节点就删除节点，如果非叶子节点就删除子树
        public void delNode(int no){ 
            if (this.left !=null && this.left.no == no){ 
                this.left = null;
                return;
            }
            if (this.right != null && this.right.no == no){ 
                this.right = null;
                return;
            }
            if (this.left != null){ 
                this.left.delNode(no);
            }
            if (this.right != null){ 
                this.right.delNode(no);
            }
    
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200202150348494.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020020215113447.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020020215215727.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200202152208653.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA==,size_16,color_FFFFFF,t_70