二叉树实现增删改查以及线索化二叉树详解

最新推荐文章于 2024-04-24 17:11:40 发布
最新推荐文章于 2024-04-24 17:11:40 发布
阅读量273 收藏 2
点赞数
文章标签： java 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53324833/article/details/121205635
版权

为什么需要树

在这里插入图片描述
在这里插入图片描述

二叉树介绍

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

二叉树遍历节点思路分析及代码实现

在这里插入图片描述
代码实现：

package 树;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        //测试
        //创建节点
        HeroNode root = new HeroNode(1,"宋江"); //宋江作为根节点传入树中建树
        HeroNode n2 = new HeroNode(2,"吴用");
        HeroNode n3 = new HeroNode(3,"卢俊义");
        HeroNode n4 = new HeroNode(4,"林冲");
        //说明，我们先手动创建二叉树，后面可用递归方式创建二叉树
        BinaryTree tree = new BinaryTree(root); //宋江为根节点
        root.left = n2; //按照博客上面的图，根节点的左子节点挂吴用
        root.right = n3; //右子节点挂卢俊义
        root.right.right = n4; //右子节点的右子节点挂林冲，等价于n3.right = n4
        //测试前序遍历
        System.out.println("前序遍历："); //输出1,2,3,4
        tree.preOrder();
        //测试中序遍历
        System.out.println("中序遍历：");
        tree.infixOrder(); //输出2,1,3,4
        //测试后序遍历
        System.out.println("后序遍历：");
        tree.postOrder(); //输出2,4,3,1
    }
}

//定义BinaryTree 二叉树
class BinaryTree{

    //使用一个根节点来创建二叉树
    public HeroNode root; //如果要创建一个二叉树，那么我们需要一个根节点

    //构造方法创建二叉树
    public BinaryTree(HeroNode root) {
        this.root = root;
    }

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

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

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

//先创建HeroNode节点
class HeroNode{
    public int no;
    public String name;
    public HeroNode left; //指向左子节点的指针
    public HeroNode right; //指向右子节点的指针

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    //打印节点信息
    @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); //先输出父节点
    }
}

再来做个题巩固一下：
在这里插入图片描述
应该遍历出来的顺序在如下测试代码中可以看到：

 //3号节点的左子节点挂一个关胜
        HeroNode n5 = new HeroNode(5,"关胜");
        n3.left = n5;
        //测试前序遍历
        System.out.println("前序遍历："); //输出1,2,3,5,4
        tree.preOrder();
        //测试中序遍历
        System.out.println("中序遍历：");
        tree.infixOrder(); //输出2,1,5,3,4
        //测试后序遍历
        System.out.println("后序遍历：");
        tree.postOrder(); //输出2,5,4,3,1

二叉树查找节点思路及代码实现

在这里插入图片描述
在这里插入图片描述

package 树;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        //测试
        //创建节点
        HeroNode root = new HeroNode(1,"宋江"); //宋江作为根节点传入树中建树
        HeroNode n2 = new HeroNode(2,"吴用");
        HeroNode n3 = new HeroNode(3,"卢俊义");
        HeroNode n4 = new HeroNode(4,"林冲");
        //说明，我们先手动创建二叉树，后面可用递归方式创建二叉树
        BinaryTree tree = new BinaryTree(root); //宋江为根节点
        root.left = n2; //按照博客上面的图，根节点的左子节点挂吴用
        root.right = n3; //右子节点挂卢俊义
        root.right.right = n4; //右子节点的右子节点挂林冲，等价于n3.right = n4
        //3号节点的左子节点挂一个关胜
        HeroNode n5 = new HeroNode(5,"关胜");
        n3.left = n5;
        //测试前序遍历
        System.out.println("前序遍历："); //输出1,2,3,5,4
        tree.preOrder();
        //测试中序遍历
        System.out.println("中序遍历：");
        tree.infixOrder(); //输出2,1,5,3,4
        //测试后序遍历
        System.out.println("后序遍历：");
        tree.postOrder(); //输出2,5,4,3,1
        //测试查找，查找关胜
        System.out.println("前序查找：");
        tree.preOrderSearch(n5);
        System.out.println("中序查找：");
        tree.infixOrderSearch(n5);
        System.out.println("后序查找：");
        tree.postOrderSearch(n5);
    }
}

//定义BinaryTree 二叉树
class BinaryTree{

    //使用一个根节点来创建二叉树
    public HeroNode root; //如果要创建一个二叉树，那么我们需要一个根节点

    //构造方法创建二叉树
    public BinaryTree(HeroNode root) {
        this.root = root;
    }

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

    //前序查找
    public void preOrderSearch(HeroNode n){
        if(root != null) {
            HeroNode node = root.preOrderSearch(n.no);
            System.out.println("查找到的英雄是："+node);
        }
        else System.out.println("二叉树为空，无法遍历");
    }

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

    //中序查找
    public void infixOrderSearch(HeroNode n){
        if(root != null) {
            HeroNode node = root.infixOrderSearch(n.no);
            System.out.println("查找到的英雄是："+node);
        }
        else System.out.println("二叉树为空，无法遍历");
    }

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

    //后序查找
    public void postOrderSearch(HeroNode n){
        if(root != null) {
            HeroNode node = root.postOrderSearch(n.no);
            System.out.println("查找到的英雄是："+node);
        }
        else System.out.println("二叉树为空，无法遍历");
    }
}

//先创建HeroNode节点
class HeroNode{
    public int no;
    public String name;
    public HeroNode left; //指向左子节点的指针
    public HeroNode right; //指向右子节点的指针

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    //打印节点信息
    @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(); //递归向右子树前序遍历
    }

    //编写前序查找的方法
    /**
     *
     * @param no 按编号查找
     * @return 找到则返回节点，没找到返回null
     */
    public HeroNode preOrderSearch(int no){
        if(this.no == no) return this; //先输出父节点
        //1、判断当前节点的左子节点是否为空，不为空则递归前序查找
        //2、如果左递归前序查找到了则返回
        HeroNode resNode = null;
        if(this.left != null) resNode = this.left.preOrderSearch(no);
        if(resNode != null) return resNode; //说明在左子树中找到了
        //1、判断当前节点的右子节点是否为空，不为空则递归前序查找
        //2、如果右递归前序查找，找到则返回
        if(this.right != null) resNode = this.right.preOrderSearch(no);
        if(resNode != null) return resNode; //说明在右子树中找到了
        return resNode;
    }

    //编写中序遍历的方法
    public void infixOrder(){
        if(this.left != null) this.left.infixOrder(); //递归向左子树中序遍历
        System.out.println(this); //先输出父节点
        if(this.right != null) this.right.infixOrder(); //递归向右子树中序遍历
    }

    //编写中序查找的方法
    /**
     *
     * @param no 按编号查找
     * @return 找到则返回节点，没找到返回null
     */
    public HeroNode infixOrderSearch(int no){
        //1、判断当前节点的左子节点是否为空，不为空则递归前序查找
        //2、如果左递归前序查找到了则返回
        HeroNode resNode = null;
        if(this.left != null) resNode = this.left.infixOrderSearch(no);
        if(resNode != null) return resNode; //说明在左子树中找到了

        if(this.no == no) return this; //先输出父节点

        //1、判断当前节点的右子节点是否为空，不为空则递归前序查找
        //2、如果右递归前序查找，找到则返回
        if(this.right != null) resNode = this.right.infixOrderSearch(no);
        return resNode;
    }

    //编写后序遍历的方法
    public void postOrder(){
        if(this.left != null) this.left.postOrder(); //递归向左子树后序遍历
        if(this.right != null) this.right.postOrder(); //递归向右子树后序遍历
        System.out.println(this); //先输出父节点
    }

    //编写后序查找的方法
    /**
     *
     * @param no 按编号查找
     * @return 找到则返回节点，没找到返回null
     */
    public HeroNode postOrderSearch(int no){
        //1、判断当前节点的左子节点是否为空，不为空则递归前序查找
        //2、如果左递归前序查找到了则返回
        HeroNode resNode = null;
        if(this.left != null) resNode = this.left.postOrderSearch(no);
        if(resNode != null) return resNode; //说明在左子树中找到了

        //1、判断当前节点的右子节点是否为空，不为空则递归前序查找
        //2、如果右递归前序查找，找到则返回
        if(this.right != null) resNode = this.right.postOrderSearch(no);
        if(resNode != null) return resNode; //说明在右子树中找到了
        if(this.no == no) return this; //先输出父节点
        return resNode;
    }
}

二叉树删除节点思路及代码实现

删除节点究竟怎么删除，我们先做一个删除节点的规范，如下：

在这里插入图片描述
先实现简单的，后面会实现比较难的删除算法。
思路：
在这里插入图片描述
代码实现：

package 树;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        //测试
        //创建节点
        HeroNode root = new HeroNode(1,"宋江"); //宋江作为根节点传入树中建树
        HeroNode n2 = new HeroNode(2,"吴用");
        HeroNode n3 = new HeroNode(3,"卢俊义");
        HeroNode n4 = new HeroNode(4,"林冲");
        //说明，我们先手动创建二叉树，后面可用递归方式创建二叉树
        BinaryTree tree = new BinaryTree(root); //宋江为根节点
        root.left = n2; //按照博客上面的图，根节点的左子节点挂吴用
        root.right = n3; //右子节点挂卢俊义
        root.right.right = n4; //右子节点的右子节点挂林冲，等价于n3.right = n4
        //3号节点的左子节点挂一个关胜
        HeroNode n5 = new HeroNode(5,"关胜");
        n3.left = n5;
        //先用前序遍历看看
        tree.preOrder(); //输出1,2,3,5,4
        //现在我们删除5号节点关胜
        tree.delNode(n5.no);
        System.out.println("--------------------删除后-------------------");
        //再用前序遍历看看是否被删除
        tree.preOrder(); //输出1,2,3,4

    }
}

//定义BinaryTree 二叉树
class BinaryTree{

    //使用一个根节点来创建二叉树
    public HeroNode root; //如果要创建一个二叉树，那么我们需要一个根节点

    //构造方法创建二叉树
    public BinaryTree(HeroNode root) {
        this.root = root;
    }

    //删除节点
    public void delNode(int no){
        if(root != null){
            //一定要先判断我们的root是不是就是要删除的节点
            if(root.no == no) root = null;
            else root.delNode(no); //递归删除
        }else{
            System.out.println("空树，无法删除");
        }
    }

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

    //前序查找
    public void preOrderSearch(HeroNode n){
        if(root != null) {
            HeroNode node = root.preOrderSearch(n.no);
            System.out.println("查找到的英雄是："+node);
        }
        else System.out.println("二叉树为空，无法遍历");
    }

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

    //中序查找
    public void infixOrderSearch(HeroNode n){
        if(root != null) {
            HeroNode node = root.infixOrderSearch(n.no);
            System.out.println("查找到的英雄是："+node);
        }
        else System.out.println("二叉树为空，无法遍历");
    }

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

    //后序查找
    public void postOrderSearch(HeroNode n){
        if(root != null) {
            HeroNode node = root.postOrderSearch(n.no);
            System.out.println("查找到的英雄是："+node);
        }
        else System.out.println("二叉树为空，无法遍历");
    }
}

//先创建HeroNode节点
class HeroNode{
    public int no;
    public String name;
    public HeroNode left; //指向左子节点的指针
    public HeroNode right; //指向右子节点的指针

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    //打印节点信息
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    //递归删除节点
    //1、如果删除的节点是叶子节点，则删除该节点
    //2、如果删除的节点是非叶子节点，则删除该子树
    public void delNode(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.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(); //递归向右子树前序遍历
    }

    //编写前序查找的方法
    /**
     *
     * @param no 按编号查找
     * @return 找到则返回节点，没找到返回null
     */
    public HeroNode preOrderSearch(int no){
        if(this.no == no) return this; //先输出父节点
        //1、判断当前节点的左子节点是否为空，不为空则递归前序查找
        //2、如果左递归前序查找到了则返回
        HeroNode resNode = null;
        if(this.left != null) resNode = this.left.preOrderSearch(no);
        if(resNode != null) return resNode; //说明在左子树中找到了
        //1、判断当前节点的右子节点是否为空，不为空则递归前序查找
        //2、如果右递归前序查找，找到则返回
        if(this.right != null) resNode = this.right.preOrderSearch(no);
        if(resNode != null) return resNode; //说明在右子树中找到了
        return resNode;
    }

    //编写中序遍历的方法
    public void infixOrder(){
        if(this.left != null) this.left.infixOrder(); //递归向左子树中序遍历
        System.out.println(this); //先输出父节点
        if(this.right != null) this.right.infixOrder(); //递归向右子树中序遍历
    }

    //编写中序查找的方法
    /**
     *
     * @param no 按编号查找
     * @return 找到则返回节点，没找到返回null
     */
    public HeroNode infixOrderSearch(int no){
        //1、判断当前节点的左子节点是否为空，不为空则递归前序查找
        //2、如果左递归前序查找到了则返回
        HeroNode resNode = null;
        if(this.left != null) resNode = this.left.infixOrderSearch(no);
        if(resNode != null) return resNode; //说明在左子树中找到了

        if(this.no == no) return this; //先输出父节点

        //1、判断当前节点的右子节点是否为空，不为空则递归前序查找
        //2、如果右递归前序查找，找到则返回
        if(this.right != null) resNode = this.right.infixOrderSearch(no);
        return resNode;
    }

    //编写后序遍历的方法
    public void postOrder(){
        if(this.left != null) this.left.postOrder(); //递归向左子树后序遍历
        if(this.right != null) this.right.postOrder(); //递归向右子树后序遍历
        System.out.println(this); //先输出父节点
    }

    //编写后序查找的方法
    /**
     *
     * @param no 按编号查找
     * @return 找到则返回节点，没找到返回null
     */
    public HeroNode postOrderSearch(int no){
        //1、判断当前节点的左子节点是否为空，不为空则递归前序查找
        //2、如果左递归前序查找到了则返回
        HeroNode resNode = null;
        if(this.left != null) resNode = this.left.postOrderSearch(no);
        if(resNode != null) return resNode; //说明在左子树中找到了

        //1、判断当前节点的右子节点是否为空，不为空则递归前序查找
        //2、如果右递归前序查找，找到则返回
        if(this.right != null) resNode = this.right.postOrderSearch(no);
        if(resNode != null) return resNode; //说明在右子树中找到了
        if(this.no == no) return this; //先输出父节点
        return resNode;
    }
}

顺序存储二叉树思路及实现

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
代码实现上述需求：

package 树;
//顺序存储二叉树
public class ArrBinaryTreeDemo {
    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5,6,7};
        ArrBinaryTree binaryTree = new ArrBinaryTree(arr);
        //测试前序
        System.out.println("前序遍历：");
        binaryTree.preOreder(0); //1,2,4,5,3,6,7

        //测试中序
        System.out.println("中序遍历：");
        binaryTree.infixOreder(0); //4,2,5,1,6,3,7

        //测试后序
        System.out.println("后序遍历：");
        binaryTree.postOreder(0); //4,5,2,6,7,3,1
    }
}

//编写一个ArrBinaryTree，实现顺序存储二叉树遍历
class ArrBinaryTree{
    private int[] arr; //存储数据节点的数组

    public ArrBinaryTree(int[] arr){
        this.arr = arr;
    }

    //编写一个方法，完成顺序存储二叉树的前序遍历
    //index即思路图中的n值，指的是元素的下标
    public void preOreder(int index){
        //如果数组为空，或者arr.length == 0
        if(arr == null || arr.length == 0){
            System.out.println("数组为空，无法遍历");
        }
        //输出当前元素,即前序遍历顺序：根、左、右
        System.out.println(arr[index]);
        //数组下标不越界时，递归前序遍历
        //递归向左
        if((index*2+1) < arr.length) preOreder(index*2+1);
        //递归向右
        if((index*2+2) < arr.length) preOreder(index*2+2);
    }

    //中序遍历
    public void infixOreder(int index){
        //如果数组为空，或者arr.length == 0
        if(arr == null || arr.length == 0){
            System.out.println("数组为空，无法遍历");
        }
        //数组下标不越界时，递归中序遍历
        //递归向左
        if((index*2+1) < arr.length) infixOreder(index*2+1);
        System.out.println(arr[index]);
        //递归向右
        if((index*2+2) < arr.length) infixOreder(index*2+2);
    }

    //后序遍历
    public void postOreder(int index){
        //如果数组为空，或者arr.length == 0
        if(arr == null || arr.length == 0){
            System.out.println("数组为空，无法遍历");
        }
        //数组下标不越界时，递归后序遍历
        //递归向左
        if((index*2+1) < arr.length) postOreder(index*2+1);
        //递归向右
        if((index*2+2) < arr.length) postOreder(index*2+2);
        System.out.println(arr[index]);
    }
}

线索化二叉树

问题引入：
在这里插入图片描述
在这里插入图片描述
基本介绍：
在这里插入图片描述
线索化二叉树的意思是将一个数列构建成二叉树之后，按照原来数列中的前驱和后继顺序将每个叶子节点的左指针和右指针充分利用起来让其指向前驱节点和后继节点的一种二叉树形式。
实现思路：
在这里插入图片描述
在这里插入图片描述
代码实现上述案例：

package 树.线索化二叉树;


//线索化二叉树
public class ThreadedBinaryTreeDemo {
    public static void main(String[] args) {
        //测试
        HeroNode root = new HeroNode(1, "tom");
        HeroNode n2 = new HeroNode(3, "jack");
        HeroNode n3 = new HeroNode(6, "smith");
        HeroNode n4 = new HeroNode(8, "marry");
        HeroNode n5 = new HeroNode(10, "king");
        HeroNode n6 = new HeroNode(14, "dim");

        root.setRight(n3);
        root.setLeft(n2);
        n2.setRight(n5);
        n2.setLeft(n4);
        n3.setLeft(n6);

        //测试线索化
        threadedBinaryTree threadedBinaryTree = new threadedBinaryTree();
        threadedBinaryTree.setRoot(root);
        threadedBinaryTree.threadedNodes();

        //以10号节点为例
        HeroNode leftNode = n5.getLeft();
        HeroNode rightNode = n5.getRight();
        System.out.println("10号节点的前驱节点是 = "+leftNode);
        System.out.println("10号节点的后继节点是 = "+rightNode);
    }
}


//创建ThreadedBinaryTree
//实现线索化功能
class threadedBinaryTree {
    private HeroNode root; //父节点

    //为了实现线索化，需要创建一个指向当前节点的前驱节点的指针
    //在递归进行线索化时，pre总是保留前一个节点
    private HeroNode pre = null;

    //只需要设置父节点就好了，因为后面有遍历操作，所以不需要get方法
    //你要创建一个二叉树，那必然要有节点，所以是HeroNode类型
    public void setRoot(HeroNode root) {
        this.root = root; //因为重名，所以加this表示该root是当前二叉树类的对象的属性
    }

    //重载一下threadedNodes
    public void threadedNodes(){
        this.threadedNodes(root);
    }


    //编写对二叉树进行中序线索化的方法
    public void threadedNodes(HeroNode node){

        //如果node==null，不能线索化
        if(node == null) return;

        //先线索化左子树
        threadedNodes(node.getLeft());
        //线索化当前节点(有难度)

        //处理当前节点的前驱节点
        //以8节点来理解
        //8节点的.left==null，8节点的.leftType = 1
        if(node.getLeft() == null){
            //让当前节点的左指针指向前驱节点
            node.setLeft(pre);
            //修改当前节点的左指针的类型，指向前驱节点
            node.setLeftType(1);
        }

        //处理后继节点
        if(pre != null && pre.getRight() == null){
            //让前驱节点的右指针指向当前节点
            pre.setRight(node);
            //修改前驱节点的右指针类型
            pre.setRightType(1);
        }
        //!!!每处理一个节点后，让当前节点是下一个节点的前驱节点
        pre = node;

        //再线索化右子树
        threadedNodes(node.getRight());

    }


    //删除节点
    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(){//这里的preOrder方法是BinaryTree类里的，下面的调用的HeroNode类里的，没有关系
        if(this.root != null){ //这里的this是只当前对象：当前的BinaryTree对象
            this.root.preOrder(); //这里的root是HeroNode类型的，所以可调用HeroNode类里的方法
        }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 preOrderSearch(int no){
        //如果根节点不为空，则二叉树存在然后进行递归前序查找
        if(this.root != null) return this.root.preOrdersearch(no);
        else return null;
    }

    //中序查找
    public HeroNode infixOrderSearch(int no){
        if(this.root != null) return this.root.infixOrderSearch(no);
        else return null;
    }

    //后序查找
    public HeroNode postOrderSearch(int no){
        if(this.root != null) return root.postOrderSearch(no);
        else return null;
    }
}


//创建HeroNode，因为处于同一个包下，所以继承一下进行修改就行
class HeroNode{
    private int no;
    private String name;
    private HeroNode left; //默认为null，因为并不清楚后续有无子节点
    private HeroNode right; //默认为null，因为并不清楚后续有无子节点

    //说明
    //1.如果leftType == 0表示指向的是左子树，为1则表示指向前驱节点
    //1.如果rightType == 0表示指向的是右子树，为1则表示指向后继节点

    private int leftType;
    private int rightType;

    public int getLeftType() {
        return leftType;
    }

    public void setLeftType(int leftType) {
        this.leftType = leftType;
    }

    public int getRightType() {
        return rightType;
    }

    public void setRightType(int rightType) {
        this.rightType = rightType;
    }


    //构造器创建节点
    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;
    }

    //为了方便遍历，重写toString

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
        //不重写left和right是因为递归输出的时候会重复出现相同节点的信息
    }

    //递归删除节点
    //1.如果删除的节点是叶子节点，则删除该节点
    //2.如果删除的节点是非叶子节点，则删除该子树
    public void delNode(int no) { //no是要删除的英雄编号

        //如果当前节点的左子节点不为空，并且左子节点就是要删除节点，就将this.left=null，并且返回（结束递归并删除）
        if(this.left != null && this.left.no == no){
            this.left = null;
            return;
        }
        //如果当前节点的左子节点不为空，并且左子节点就是要删除节点，就将this.left=null，并且返回（结束递归并删除）
        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 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);
    }

    //前序遍历查找:找到返回该HeroNode，没找到就返回null
    public HeroNode preOrdersearch(int no){ //查找序号为no的节点
        System.out.println("进入前序遍历"); //观察查找次数
        //比较当前节点是不是该no
        if(this.no == no) return this; //返回当前对象
        //1.判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
        //2.如果左递归前序查找，找到节点，则返回
        HeroNode resNode = null; //接收结果的一个Node
        if(this.left != null) resNode = this.left.preOrdersearch(no);
        if(resNode != null) return resNode; //resNode不为空，说明找到了

        //1.右递归前序查找，找到节点，则返回，否则继续判断
        //2.当前的节点的右子节点是否为空,如果不空，则继续向右递归前序查找
        if(this.right != null) resNode = this.right.preOrdersearch(no);
        return resNode;
    }

    //中序查找
    public HeroNode infixOrderSearch(int no){
        //判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
        HeroNode resNode = null;
        if(this.left != null) resNode = this.left.infixOrderSearch(no);
        //resNode不为空，说明找到了，返回节点结束方法
        if(resNode != null) return resNode;
        //还没找到，则与当前节点比较，如果找到，返回当前节点
        System.out.println("进入中序查找"); //计算查找次数用的，不重要
        if(this.no == no) return this;
        //当前节点也不是，则右递归进行查找
        if(this.right != null) resNode = this.right.infixOrderSearch(no);
        //右递归中不管找不找到都要返回resNode
        return resNode;
    }

    //后序查找
    public HeroNode postOrderSearch(int no){
        HeroNode 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;
        else return resNode; //result最初为空嘛，和null差不多的
    }
}

遍历线索化二叉树

在这里插入图片描述
关键代码实现，也是使用上面的案例：
在这里插入图片描述
算法实现（这个方法应该放在树的类中）：

//遍历线索化二叉树的方法
    public void threadedList(){
        //定义一个变量，存储当前遍历的节点，从root开始
        HeroNode node = root;
        while (node != null){
            //循环的找到leftType == 1的节点，第一个找到就是8节点
            //后面随着遍历而变化，因为当leftType==1时，说明该节点是按照线索化
            //处理后的有效节点
            while (node.getLeftType() == 0){
                node = node.getLeft();
            }
            //打印当前这个节点
            System.out.println(node);
            //如果当前节点的右指针指向的是后继节点，就一直输出
            while (node.getRightType() == 1){
                //获取到当前节点的后继节点
                node = node.getRight();
            }
            //替换这个遍历的节点
            node = node.getRight();
        }
    }
在地球迷路的怪兽
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于ThinkPHP的二叉树左右值无限极分类实现
Na.Johnny.Den
08-07 1700
说明： 每个数据项都有自己的左值和右值。所有数据的左右值是连续的数字。 ① 当右值比左值大1时，表示该数据无子集； ② 当某一数据项的左值大于另一数据项的左值，且该数据项的右值小于同另一数据项的右值时，该数据项属于另一数据项的子集； 例如：中国(1,8) 广东(2,5) 珠海(3,4) 江西(6,7) 数据库表结构： CREATE TABLE `jd_category` ( `id_c
数据结构之二叉搜索树的增删查改（图解，代码6000多字总结）
冷萃美式的博客
08-16 672
文章目录一：概念1.用处2.定义3. 性质4.遍历伪代码5.基本操作5.1 查找5.2 最小关键字5.3 最大关键字5.4 插入5.5 删除 一：概念 1.用处  二叉搜索树既可以作为一个字典又可以作为一个优先队列 2.定义  顾名思义，二叉搜索树是一颗具有一定性质的二叉树。 可以使用一个链表来表示，其中的每一个节点都是一个对象，除了key和卫星数据之外，么一个节点还包含属性left,right，parent。如果对应的节点不存在的时候，则相应属性的值为nil。 根节点是整棵树中唯一一个父指针为nil的节点
数据结构算法---C语言实现二叉树的增删改查（附完整源码）
m0_74408068的博客
02-22 408
判断当前队头元素是否存在左、右孩子。如果存在左、右孩子，则将其入队。获取队头元素，并进行打印。
二叉检索树的实现——增删改查、读取命令文件、将结果写入新文件
最新发布
2301_78696436的博客
04-24 1149
两者思路一致，将二叉树分为三部分：左子树，根结点，右子树。对左子树，右子树递归遍历。
二叉排序树增删改查
wdquan19851029的专栏
06-27 306
二叉排序树(BST--Binary Sort Tree)，要求任何一个非叶子节点，左子节点的值小于当前节点的值，右子节点的值大于当前节点的值。如果有相等的值，可以将其放在左子节点或者右子节点。 优点是既能快速查找，又能快速增删 其它数据结构的劣势： 数组（未排序）：查找速度慢（相对于二叉排序树） 数组（已排序）：可以使用二分查找、查找速度快，缺点：为了保证数组有序，在插入新数据，找到插入位置时，后面的数据需要整体迁移，速度慢。 链表：查找很慢，增删很快 package com.bruce....
好好学数据结构 - 手撕二叉树增删改查
LJHSkyWalker的博客
11-14 212
 呵。。写到删除的时候 说实话蒙的一比。充分暴露除了数据结构的不足。下面献上自己写的结构。粗略测过，供大家参考吧，如果有漏洞不足还请指出。。恩。 package binaryTree; import java.util.ArrayList; import java.util.List; public class BinaryTree&lt;E extends Comparable&lt;E...
实现二叉树的增删改查基本操作的c++程序
05-09
很好很强大的程序，实现二叉树的增删改查等基本操作，操作简单，程序结构清晰
C++二叉树，实现增删改查，多种遍历方式
12-30
本资源是以C++写的二叉树代码，实现删除、插入、查询、取值。以及前序遍历、中序遍历、后序遍历、层序遍历等。运用了C++的模板template ，以泛型编程的原则写的，泛型编程指编写完全一般化并可重复使用的算法，其...
PHP实现的线索二叉树及二叉树遍历方法详解
10-22
主要介绍了PHP实现的线索二叉树及二叉树遍历方法,结合实例形式较为详细的分析了线索二叉树的定义,创建,判断与遍历等技巧,需要的朋友可以参考下
线索化二叉树C实现代码
02-24
包含两种线索化二叉树方法，具体如下： 1.利用结点中的空指针域，使其指向后继结点； 2.利用线性表保存二叉树的遍历顺序。
线索二叉树的建立、删除、插入、恢复线索
06-29
线索二叉树的建立 删除 插入 恢复线索
二叉树（链表实现）--增、删、改、查
一名小白的博客
07-25 673
二叉树（链表实现） 1.1 树的基本定义 ​ 树是我们计算机中非常重要的一种数据结构，同时使用树这种数据结构，可以描述现实生活中的很多事物，例如家谱、单位的组织架构、等等。 ​ 树是由n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 树具有以下特点： 每个结点有零个或多个子结点； 没有父结点的结点为根结点； 每一个非根结点只有一个父结点； 每个结点及其后代结点整体上可以看做是一棵树，称为当前结点的父结点的一个子树；
Java二叉树的建立和增删改,平衡二叉树建立及其增删改查（JAVA）
weixin_39724009的博客
03-12 121
平衡二叉树：指的是左右子树高度差的绝对值不超过一的二叉排序树。主要思路：1、用左高度跟右高度代替平衡因子，大于1进行L~调整，小于-1进行R~调整2、每次插入都通过递归计算一次各结点高度，然后进行旋转调整3、判断旋转操作时只需判断从失衡节点开始前两个节点 LL:左左左 、 RR:右右右 、 LR:左右~ 、RL:右左~坑：贯穿整个树的各个部分的就是值传递跟引用传递l，因为java中主要是值...
C++实现二叉排序树的增删查改
weixin_45597497的博客
05-23 523
二叉排序树的基本操作 #include <iostream> #include <queue> #include <vector> #include <numeric> using namespace std; typedef int ElementType; typedef struct Node { ElementType data; struct Node* lchild; struct Node* rchild; }*BiTree; //
【二叉搜索树】增删改查功能代码实现
weixin_50563955的博客
06-27 403
二叉树的遍历规则，插入和删除，原理讲解和代码实现，全是干货，慢慢消化
完全使用c++类实现二叉树的增删操作
fang 0 jun的博客
04-10 423
写在前面： 1，*&一起用的参数：即指针的别名。通常用于在某一个函数修改指针变量的copy时，同步修改真正的指针变量 2，关于delete：很基本的一点是，new完内存以后才能对其使用delete，对象手动调用delete后，会调用析构函数 3，const是个指针常量！只能修改其内容，不要想着改方向 二叉树的删除 || 二叉树的删除需要分三种情况考虑：删除树叶节点，删除带有一个树叶...
java实现线索化二叉树(中序线索化)的创建以及遍历删除等操作
qq_38902844的博客
05-17 210
源代码 public class ThreadedBiTreeDemo{ public static void main(String[] args) { ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree(); TNode root = new TNode(1, "tom"); TNode node2 = new TNode(3, "jack"); TNode node3 = new TNode(6, "smi
java二叉树的增删改查原理_二叉树的增删改查
weixin_36417344的博客
02-26 111
package erTree;import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.List;import java.util.Stack;public class erTree {public static void main(String[] args) ...
java二叉树增删改查详解
0bug0warning的博客
10-03 1854
二叉树的删除和修改 二叉树的删除比较复杂。你要先找到要删除的结点。要删除的结点对象并不一定要删除。因为通过函数调用得到的只是他的副本。并不会真正的把他删掉。你只要让他不在树上就ok了。让删除结点的父节点，左右孩子结点用新的结点来指向就把该结点从树上删除了。 然后找到要插入的结点。 找法有三种情况： 删除结点有左孩子 这种情况下，找到左孩子的最右孩子。找到的结点是要上去的结点。如果该左孩子没有...
二叉树的增删改查 c语言
06-12
好的，下面是二叉树的增删改查的C语言代码示例。 首先，我们需要定义二叉树的结构体： ```c struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; }; ``` 接下来，我们分别实现二叉树...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

在地球迷路的怪兽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值