树结构的基础部分「Java数据结构与算法学习笔记9」

岛雨QA2026-02-26 15:40

🔥工程代码已上传至github：github.com/doublev2026...

二叉树

树说明及示意图

为什么需要树这种数据结构：

  • 数组存储方式的分析
    • 优点：通过下标方式访问元素速度快。对于有序数组，还可使用二分查找提高检索速度
    • 缺点：如果要检索具体某个值，或者插入值（按一定顺序）会整体移动，效率较低
      • 数组扩容：每次在底层都需要创建新的数组，要将原来的数据拷贝到数组，并插入新的数据
      • ArrayList底层仍然是进行数组扩容
  • 链式存储方式的分析
    • 优点：在一定程度上对数组存储方式有优化。比如：插入一个数值节点，只需要将插入节点，链接到链表中即可，删除效率也很好
    • 缺点：在进行检索时，效率仍然较低。比如：检索某个值，需要从头节点开始遍历
  • 树存储方式的分析
    • 能提高数据存储、读取的效率, 比如利用二叉排序树（Binary Sort Tree），既可以保证数据的检索速度，同时也可以保证数据的插入、删除、修改的速度

树示意图：

树的常用术语：

  • 节点/节点对象
  • 根节点
  • 父节点
  • 子节点
  • 叶子节点（没有子节点的节点）
  • 节点的权（节点值，自定义的）
  • 路径（从根节点找到该节点的路线）
  • 层
  • 子树
  • 树的高度（最大层数）
  • 森林：多颗子树构成森林

二叉树概念

  • 树有很多种，每个节点最多只能有两个子节点 的一种形式称为二叉树。
  • 二叉树的子节点分为左节点和右节点。
  • 如果该二叉树的所有叶子节点都在最后一层 ，并且 结点总数= 2^n-1（n为层数） ，则我们称为满二叉树。
  • 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层 ，而且最后一层的叶子节点在左边连续 ，倒数第二层的叶子节点在右边连续 ，我们称为完全二叉树。

遍历二叉树

使用前序、中序和后序对二叉树进行遍历：

  1. 前序遍历：先输出父节点，再遍历左子树和右子树
  2. 中序遍历：先遍历左子树，再输出父节点，再遍历右子树
  3. 后序遍历：先遍历左子树，再遍历右子树，最后输出父节点
  4. 小结：看输出父节点的顺序，就确定是前序，中序还是后序

代码实现：

java 复制代码 
package com.datastructures.tree.binarytree;

/**
 * HeroNode 节点
 */
public 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 + '\'' +
                '}';
    }

    /**
     * 前序遍历
     * <p>
     * 1、先输出当前节点（初始的时候是root节点）
     * 2、如果左子节点不为空，则递归继续前序遍历
     * 3、如果右子节点不为空，则递归继续前序遍历
     */
    public void preOrder() {
        // 先输出当前节点
        System.out.println(this);
        // 如果左子节点不为空，则递归继续前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        // 如果右子节点不为空，则递归继续前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    /**
     * 中序遍历
     * <p>
     * 1、如果当前节点的左子节点不为空，则递归继续中序遍历
     * 2、输出当前节点
     * 3、如果当前节点的右子节点不为空，则递归继续中序遍历
     */
    public void infixOrder() {
        // 如果当前节点的左子节点不为空，则递归继续中序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        // 输出当前节点
        System.out.println(this);
        // 如果当前节点的右子节点不为空，则递归继续中序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    /**
     * 后序遍历
     * <p>
     * 1、如果当前节点的左子节点不为空，则递归继续后序遍历
     * 2、如果当前节点的右子节点不为空，则递归继续后序遍历
     * 3、输出当前节点
     */
    public void postOrder() {
        //如果当前节点的左子节点不为空，则递归继续后序遍历
        if (this.left != null) {
            this.left.postOrder();
        }
        // 如果当前节点的右子节点不为空，则递归继续后序遍历
        if (this.right != null) {
            this.right.postOrder();
        }
        // 输出当前节点
        System.out.println(this);
    }
}
java 复制代码 
package com.datastructures.tree.binarytree;

public 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("二叉树为空，无法遍历");
        }
    }
}
java 复制代码 
package com.datastructures.tree.binarytree;

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.setLeft(node5);
        node3.setRight(node4);

        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();
    }
}

查找节点

需求要求：

  1. 请编写前序查找、中序查找和后序查找的方法
  2. 并分别使用三种查找方式，查找 heroNO = 5 的节点
  3. 分析各种查找方式，分别比较了多少次

思路分析：

代码实现：

java 复制代码 
package com.datastructures.tree.binarytree;

/**
 * HeroNode 节点
 */
public class HeroNodeFind {
    private int no;
    private String name;
    private HeroNodeFind left; // 默认null
    private HeroNodeFind right; // 默认null

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

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

    public HeroNodeFind getRight() {
        return right;
    }

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

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

    /**
     * 前序遍历查找
     *
     * @param no 要查找的no
     * @return 如果找到就返回该 Node，如果没找到就返回 null
     */
    public HeroNodeFind preOrderSearch(int no) {
        System.out.println("进入前序遍历查找");
        // 比较当前节点是不是
        if (this.no == no) {
            return this;
        }
        // 不相等，判断当前节点的左子节点是否为空，如果不为空，则向左递归前序查找
        // 如果左递归前序查找找到了就返回
        HeroNodeFind resultNode = null;
        if (this.left != null) { // 如果不为空，则向左递归前序查找
            resultNode = this.left.preOrderSearch(no);
        }
        if (resultNode != null) { // 说明在递归的时候找到了
            return resultNode;
        }
        // 继续判断，当前节点的右子节点是否为空，如果不为空则继续向右递归前序查找
        if (this.right != null) {
            resultNode = this.right.preOrderSearch(no);
        }
        return resultNode; // 不管是否递归找到，都要返回，后面判断
    }

    /**
     * 中序遍历查找
     */
    public HeroNodeFind infixOrderSearch(int no) {
        // 判断当前节点的左子节点是否为空，如果不为空，则递归中序查找
        HeroNodeFind resultNode = null;
        if (this.left != null) {
            resultNode = this.left.infixOrderSearch(no);
        }
        // 如果找到了就返回
        if (resultNode != null) { // 说明找到了
            return resultNode;
        }
        System.out.println("进入中序遍历查找");
        // 如果没找到，就和当前节点比较，如果相等则返回当前节点
        if (this.no == no) {
            return this;
        }
        // 否则继续进行向右递归的中序查找
        if (this.right != null) {
            resultNode = this.right.infixOrderSearch(no);
        }
        return resultNode; // 不管是否递归找到，都要返回，后面判断
    }

    /**
     * 后序遍历查找
     */
    public HeroNodeFind postOrderSearch(int no) {
        // 判断当前节点的左子节点是否为空，如果不为空，则递归后序查找
        HeroNodeFind resultNode = null;
        if (this.left != null) {
            resultNode = this.left.postOrderSearch(no);
        }
        // 如果找到了就返回
        if (resultNode != null) { // 说明左子树找到了
            return resultNode;
        }
        // 如果没找到，就判断前节点的右子节点是否为空，如果不为空则继续向右递归前序查找
        if (this.right != null) {
            resultNode = this.right.postOrderSearch(no);
        }
        if (resultNode != null) { // 说明右子树找到了
            return resultNode;
        }
        System.out.println("进入后序遍历查找");
        // 如果没找到，就和当前节点比较，如果相等则返回当前节点，否则返回null
        if (this.no == no) {
            return this;
        }
        return resultNode; // 不管是否递归找到，都要返回，后面判断
    }
}
java 复制代码 
package com.datastructures.tree.binarytree;

public class BinaryTreeFind {
    private HeroNodeFind root;

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

    // 前序遍历查找
    public HeroNodeFind preOrderSearch(int no) {
        if (this.root != null) {
            return this.root.preOrderSearch(no);
        } else {
            return null;
        }
    }

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

    // 后序遍历查找
    public HeroNodeFind postOrderSearch(int no) {
        if (this.root != null) {
            return this.root.postOrderSearch(no);
        } else {
            return null;
        }
    }
}
java 复制代码 
package com.datastructures.tree.binarytree;

public class BinaryTreeFindDemo {
    public static void main(String[] args) {
        // 首先需要创建一棵二叉树
        BinaryTreeFind binaryTree = new BinaryTreeFind();
        // 创建节点
        HeroNodeFind root = new HeroNodeFind(1, "宋江");
        HeroNodeFind node2 = new HeroNodeFind(2, "吴用");
        HeroNodeFind node3 = new HeroNodeFind(3, "卢俊义");
        HeroNodeFind node4 = new HeroNodeFind(4, "林冲");
        HeroNodeFind node5 = new HeroNodeFind(5, "关胜");
        // 这里先手动创建二叉树（后续使用递归的方式）
        binaryTree.setRoot(root);
        root.setLeft(node2);
        root.setRight(node3);
        node3.setLeft(node5);
        node3.setRight(node4);

        System.out.println("前序遍历查找："); // 结果：4次
        HeroNodeFind result1 = binaryTree.preOrderSearch(5);
        if (result1 != null){
            System.out.println("查找成功，节点信息 = " + result1.toString());
        } else {
            System.out.println("查找失败-" + 5);
        }

        System.out.println("中序遍历查找："); // 结果：3次
        HeroNodeFind result2 = binaryTree.infixOrderSearch(5);
        if (result2 != null){
            System.out.println("查找成功，节点信息 = " + result2.toString());
        } else {
            System.out.println("查找失败-" + 5);
        }

        System.out.println("后序遍历查找："); // 结果：2次
        HeroNodeFind result3 = binaryTree.postOrderSearch(5);
        if (result3 != null){
            System.out.println("查找成功，节点信息 = " + result3.toString());
        } else {
            System.out.println("查找失败-" + 5);
        }
    }
}

删除节点

需求要求：

  1. 如果删除的节点是叶子节点，则删除该节点
  2. 如果删除的节点是非叶子节点，则删除该子树
  3. 测试：删除掉5号叶子节点和3号子树

思路分析：

代码实现：

java 复制代码 
package com.datastructures.tree.binarytree;

/**
 * HeroNode 节点
 */
public class HeroNodeDelete {
    private int no;
    private String name;
    private HeroNodeDelete left; // 默认null
    private HeroNodeDelete right; // 默认null

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

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

    public HeroNodeDelete getRight() {
        return right;
    }

    public void setRight(HeroNodeDelete 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();
        }
    }

    /**
     * 递归删除节点
     * <p>
     * 1. 如果删除的节点是叶子节点，则删除该节点
     * 2. 如果删除的节点是非叶子节点，则删除该子树
     *
     * @param no
     */
    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);
        }
    }
}
java 复制代码 
package com.datastructures.tree.binarytree;

public class BinaryTreeDelete {
    private HeroNodeDelete root;

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

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

    /**
     * 删除节点
     *
     * @param no
     */
    public void deleteNode(int no) {
        if (root != null) {
            // 如果只有一个root节点，这里判断是不是就是要删除的
            if (root.getNo() == no) {
                root = null;
            } else { // 递归删除
                root.deleteNode(no);
            }
        } else {
            System.out.println("空树，无法删除");
        }
    }
}
java 复制代码 
package com.datastructures.tree.binarytree;

public class BinaryTreeDeleteDemo {
    public static void main(String[] args) {
        // 首先需要创建一棵二叉树
        BinaryTreeDelete binaryTree = new BinaryTreeDelete();
        // 创建节点
        HeroNodeDelete root = new HeroNodeDelete(1, "宋江");
        HeroNodeDelete node2 = new HeroNodeDelete(2, "吴用");
        HeroNodeDelete node3 = new HeroNodeDelete(3, "卢俊义");
        HeroNodeDelete node4 = new HeroNodeDelete(4, "林冲");
        HeroNodeDelete node5 = new HeroNodeDelete(5, "关胜");
        // 这里先手动创建二叉树（后续使用递归的方式）
        binaryTree.setRoot(root);
        root.setLeft(node2);
        root.setRight(node3);
        node3.setLeft(node5);
        node3.setRight(node4);

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

进阶思考：

  1. 如果要删除的节点是非叶子节点，现在我们不希望将该非叶子节点为根节点的子树删除，需要指定规则**,** 假如规定如下:
    1. 如果该非叶子节点A只有一个子节点B，则子节点B替代节点A
    2. 如果该非叶子节点A有左子节点B和右子节点C，则让左子节点B替代节点A。
  2. 请思考，如何完成该删除功能

顺序存储二叉树

基本介绍

从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组，看下面的示意图。

要求：

  1. 上图的二叉树的结点，要求以数组的方式来存放 arr : [1, 2, 3, 4, 5, 6, 7]
  2. 要求在遍历数组 arr 时，仍然可以以前序遍历、中序遍历和后序遍历的方式完成结点的遍历

顺序存储二叉树的特点：

  1. 顺序二叉树通常只考虑完全二叉树
  2. 第n个元素的左子节点 为2 * n + 1
  3. 第n个元素的右子节点 为2 * n + 2
  4. 第n个元素的父节点 为 (n-1) / 2
  5. n : 表示二叉树中的第几个元素（按0开始编号如图所示）

遍历顺序存储二叉树

需求：一个数组{1,2,3,4,5,6,7}，要求以二叉树前序遍历的方式进行遍历。前序遍历的结果应当为 1,2,4,5,3,6,7

代码实现：

java 复制代码 
package com.datastructures.tree.binarytree;

/**
 * 实现顺序存储二叉树遍历
 */
public class ArrayBinaryTree {
    private int[] arr; // 存储数据节点的数组

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

    /**
     * 前序遍历
     *
     * @param index 数组的下标
     */
    public void preOrder(int index) {
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空，不能按照二叉树的前序遍历");
        }
        // 输出当前这个元素
        System.out.print(arr[index] + " ");
        // 向左递归遍历
        if ((index * 2 + 1) < arr.length) {
            preOrder(index * 2 + 1);
        }
        // 向右递归遍历
        if ((index * 2 + 2) < arr.length) {
            preOrder(index * 2 + 2);
        }
    }

    // 重载 preOrder 方法
    public void preOrder() {
        this.preOrder(0);
    }

    // 中序遍历
    public void infixOrder(int index) {
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空，不能按照二叉树的中序遍历");
        }
        // 向左递归遍历
        if ((index * 2 + 1) < arr.length) {
            infixOrder(index * 2 + 1);
        }
        // 输出当前这个元素
        System.out.print(arr[index] + " ");
        // 向右递归遍历
        if ((index * 2 + 2) < arr.length) {
            infixOrder(index * 2 + 2);
        }
    }

    // 重载 infixOrder 方法
    public void infixOrder() {
        this.infixOrder(0);
    }

    // 后序遍历
    public void postOrder(int index) {
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空，不能按照二叉树的后序遍历");
        }
        // 向左递归遍历
        if ((index * 2 + 1) < arr.length) {
            postOrder(index * 2 + 1);
        }
        // 向右递归遍历
        if ((index * 2 + 2) < arr.length) {
            postOrder(index * 2 + 2);
        }
        // 输出当前这个元素
        System.out.print(arr[index] + " ");
    }

    // 重载 postOrder 方法
    public void postOrder() {
        this.postOrder(0);
    }
}
java 复制代码 
package com.datastructures.tree.binarytree;

public class ArrayBinaryTreeTest {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};
        ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(arr);
        arrayBinaryTree.preOrder(); // 预期输出： 1 2 4 5 3 6 7
        System.out.println();
        arrayBinaryTree.infixOrder(); // 预期输出： 4 2 5 1 6 3 7
        System.out.println();
        arrayBinaryTree.postOrder(); // 预期输出： 4 5 2 6 7 3 1
    }
}

应用实例

八大排序算法中的堆排序，就会使用到顺序存储二叉树，关于堆排序，我们放在下一篇章节说明。

线索化二叉树

基本介绍

问题案例：将数列 {1, 3, 6, 8, 10, 14} 构建成一颗二叉树。（n+1=7 个空指针域）

问题分析:

  1. 当我们对上面的二叉树进行中序遍历时，数列为 {8, 3, 10, 1, 14, 6}
  2. 但是 6, 8, 10, 14 这几个节点的左右指针，并没有完全的利用上
  3. 如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点，怎么办?
  4. 解决方案：线索二叉树

线索二叉树基本介绍：

  1. n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】个空指针域 。利用二叉链表中的空指针域，存放指向该结点在 某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）
  2. 这种加上了线索的二叉链表称为线索链表 ，相应的二叉树称为线索二叉树 （Threaded BinaryTree）。根据线索性质的不同，线索二叉树可分为前序线索二叉树 、中序线索二叉树 和后序线索二叉树三种
  3. 一个结点的前一个结点，称为前驱结点
  4. 一个结点的后一个结点，称为后继结点

应用实例

需求：将数列 {1, 3, 6, 8, 10, 14} 构建成一颗二叉树，进行中序线索二叉树。中序遍历的数列为 {8, 3, 10, 1, 14, 6}

思路分析：

说明: 当线索化二叉树后，Node节点的属性 left 和 right ，有如下情况：

  1. **left 指向的是左子树，也可能是指向的前驱节点。**比如 ① 节点 left 指向的左子树, 而 ⑩ 节点的 left 指向的就是前驱节点
  2. **right指向的是右子树，也可能是指向后继节点。**比如 ① 节点right 指向的是右子树，而⑩ 节点的right 指向的是后继节点

遍历线索化二叉树

因为线索化后，各个结点指向有变化，因此原来的遍历方式不能使用，这时需要使用新的方式遍历线索化二叉树，各个节点可以通过线型方式遍历，因此无需使用递归方式，这样也提高了遍历的效率。遍历的次序应当和中序遍历保持一致。

代码实现（实现+遍历）：

java 复制代码 
package com.datastructures.tree.binarytree2;

/**
 * HeroNode 节点
 */
public class HeroNode {
    private int no;
    private String name;
    private HeroNode left; // 默认null
    private HeroNode right; // 默认null

    /**
     * 定义线索化二叉树用到的新的属性：
     * 如果 leftType==0，表示指向的是【左子树】。如果 leftType==1，表示指向【前驱节点】
     * 如果 rightType==0，表示指向的是【右子树】。如果 rightType==1，表示指向【后继节点】
     */
    private int leftType;
    private int rightType;

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

    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 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 + '\'' +
                '}';
    }

    /**
     * 中序遍历
     * <p>
     * 1、如果当前节点的左子节点不为空，则递归继续中序遍历
     * 2、输出当前节点
     * 3、如果当前节点的右子节点不为空，则递归继续中序遍历
     */
    public void infixOrder() {
        // 如果当前节点的左子节点不为空，则递归继续中序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        // 输出当前节点
        System.out.println(this);
        // 如果当前节点的右子节点不为空，则递归继续中序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }
}
java 复制代码 
package com.datastructures.tree.binarytree2;

/**
 * 实现了线索化功能的二叉树
 */
public class ThreadedBinaryTree {
    private HeroNode root;

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

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

    /**
     * 重载 threadNodes 方法，让他从 root 开始线索化
     */
    public void threadedNodes() {
        this.threadedNodes(root);
    }

    /**
     * 对二叉树进行中序线索化的方法
     *
     * @param node 当前需要线索化的节点
     */
    public void threadedNodes(HeroNode node) {
        // 如果 node 为空，则不能线索化
        if (node == null) {
            return;
        }
        /**
         * 第一步：先线索化左子树
         */
        threadedNodes(node.getLeft());
        /**
         * 第二步：线索化当前节点
         */
        // 1、处理当前节点的前驱节点
        // 以 8 来理解，此时 node = 8，pre = null
        // 8的 left=null，8的 leftType = 1,表示指向前驱节点
        if (node.getLeft() == null) {
            // 让当前节点的左指针指向前驱节点
            node.setLeft(pre);
            // 修改当前节点的左指针的类型，指向前驱节点
            node.setLeftType(1);
        }
        // 2、处理当前节点的后继节点。此时pre = 8
        if (pre != null && pre.getRight() == null) {
            // 让前驱节点的右指针指向当前节点
            pre.setRight(node); // 8的 right（后继节点） 变为 3
            // 修改前驱节点的右指针类型
            pre.setRightType(1);
        }
        // 3、每处理一个节点后，让当前节点是下一个节点的前驱节点
        pre = node; // 处理完 8 后，此时pre = 8。处理完 3 后，此时 pre = 3
        /**
         * 第三步：线索化右子树
         */
        threadedNodes(node.getRight());
    }

    /**
     * 遍历线索化二叉树
     */
    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();
                System.out.println(node);
            }
            // 替换这个遍历的节点
            node = node.getRight();
        }
    }

    // 中序遍历
    public void infixOrder() {
        if (this.root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }
}
java 复制代码 
package com.datastructures.tree.binarytree2;

public class ThreadedBinaryTreeDemo {
    public static void main(String[] args) {
        HeroNode node1 = new HeroNode(1, "hao1");
        HeroNode node3 = new HeroNode(3, "hao3");
        HeroNode node6 = new HeroNode(6, "hao6");
        HeroNode node8 = new HeroNode(8, "hao8");
        HeroNode node10 = new HeroNode(10, "hao10");
        HeroNode node14 = new HeroNode(14, "hao14");

        // 创建成二叉树
        node1.setLeft(node3);
        node1.setRight(node6);
        node3.setLeft(node8);
        node3.setRight(node10);
        node6.setLeft(node14);

        // 测试中序线索化
        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
        threadedBinaryTree.setRoot(node1);
        threadedBinaryTree.threadedNodes();

        // 以 10 号节点测试
        HeroNode leftNode = node10.getLeft(); // 3
        HeroNode rightNode = node10.getRight(); // 1
        System.out.println("10号节点的前驱节点是：" + leftNode);
        System.out.println("10号节点的后继节点是：" + rightNode);

        // 以 8 号节点测试
        HeroNode leftNode1 = node8.getLeft(); // null
        HeroNode rightNode1 = node8.getRight(); // 3
        System.out.println("8号节点的前驱节点是：" + leftNode1);
        System.out.println("8号节点的后继节点是：" + rightNode1);

        // 以 14 号节点测试
        HeroNode leftNode2 = node14.getLeft(); // 1
        HeroNode rightNode2 = node14.getRight(); // 6
        System.out.println("14号节点的前驱节点是：" + leftNode2);
        System.out.println("14号节点的后继节点是：" + rightNode2);

        // 以 3 号节点测试
        HeroNode leftNode3 = node3.getLeft(); // 8
        HeroNode rightNode3 = node3.getRight(); // 10
        System.out.println("3号节点的前驱节点是：" + leftNode3);
        System.out.println("3号节点的后继节点是：" + rightNode3);

        // 当线索化二叉树后，不能再使用原来的遍历方式
        System.out.println("使用原来的遍历方式遍历线索化二叉树（不能用了）");
        // threadedBinaryTree.infixOrder();
        System.out.println("使用线索化的方式遍历线索化二叉树");
        threadedBinaryTree.threadedList(); // {8, 3, 10, 1, 14, 6}
    }
}
相关推荐
会编程的土豆1 小时前
2.25 做题
数据结构·c++·算法
Frostnova丶2 小时前
LeetCode 1356. 根据数字二进制下1的数目排序
数据结构·算法·leetcode
GEO行业研究员2 小时前
AI是否正在重构个体在健康相关场景中的决策路径——基于系统建模与决策链条结构分析的讨论
人工智能·算法·重构·geo优化·医疗geo·医疗geo优化
岛雨QA2 小时前
哈希表「Java数据结构与算法学习笔记8」
数据结构·算法
独自破碎E2 小时前
【DFS】BISHI76 迷宫寻路
算法·深度优先
寄存器漫游者2 小时前
Linux 线程间通信
数据库·算法
岛雨QA2 小时前
查找算法「Java数据结构与算法学习笔记7」
数据结构·算法
宝贝儿好2 小时前
【强化学习】第十章：连续动作空间强化学习：随机高斯策略、DPG算法
人工智能·python·深度学习·算法·机器人
isyoungboy2 小时前
从图像中提取亚像素边缘点
算法
热门推荐
01GitHub 镜像站点02【OpenClaw 本地实战 Ep.3】突破瓶颈：强制修改 openclaw.json 解锁 32k 上下文记忆03Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services04OpenClaw 使用和管理 MCP 完全指南05AI Agent 平台横评：ZeroClaw vs OpenClaw vs Nanobot06Clawdbot部署教程：解决‘gateway token missing’授权问题的完整步骤07AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南08让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南09AI agent：介绍 ZeroClaw 安装，使用10OpenClaw 安装之（三）DeepSeek模型接入配置和详细配置参数