线索二叉树java实现

节点代码：

public class ClueNode <T>{
    public T data;
    public ClueNode<T> lChild;
    public ClueNode<T> rChild;
    public boolean lTag;
    public boolean rTag;

    // 默认构造函数，创建一个空节点
    public ClueNode() {
        this.data = null;
        this.lChild = null;
        this.rChild = null;
        this.lTag = false;
        this.rTag = false;
    }

    // 有参数的构造函数，用于创建带有数据元素的节点
    public ClueNode(T data) {
        this.data = data;
        this.lChild = null;
        this.rChild = null;
        this.lTag = false;
        this.rTag = false;
    }
}

这段代码定义了一个 ClueNode 类，该类表示线索二叉树中的节点。让我为你解释这个类的主要部分：

1. 数据成员：

   • public T data;: 这是节点存储的数据元素，使用泛型 T 表示。可以是任何数据类型，例如整数、字符串等。
   • public ClueNode<T> lChild;: 左子节点的引用，指向当前节点的左子节点。
   • public ClueNode<T> rChild;: 右子节点的引用，指向当前节点的右子节点。
   • public boolean lTag;: 用于标记左子节点的类型，true 表示是线索，false 表示是真正的左子节点。
   • public boolean rTag;: 用于标记右子节点的类型，true 表示是线索，false 表示是真正的右子节点。

2. 构造函数：

   • public ClueNode(): 默认构造函数，创建一个空节点，其中数据元素和子节点均为 null，而且标记 lTag 和 rTag 均为 false。
   • public ClueNode(T data): 有参数的构造函数，用于创建带有数据元素的节点。该节点的数据元素为传入的参数 data，而子节点和标记均初始化为 null 和 false。

这个 ClueNode 类的设计是为了在构建线索二叉树时能够方便地存储节点的数据、左右子节点以及线索标记。线索标记用于标识左右子节点是指向实际的子节点，还是指向前驱或后继节点（线索）。

线索二叉树通过设置标志位（lTag 和 rTag）来表示节点的左右子节点是指向实际子节点还是线索，从而实现对二叉树的线索化和遍历。这个类的设计为实现线索二叉树提供了基础。

二叉树线索化：

public class ClueBinaryTree<T> {
    public ClueNode<T> head;  // 表示线索二叉树的头节点
    private ClueNode<T> pre;   // 用于在线索化过程中保存前一个访问的节点

    public ClueBinaryTree() {
        this.head = new ClueNode<T>();  // 创建一个空节点作为头节点
    }

    // 开始线索化
    public boolean startInThreading() {
        if (head == null) {
            return false;
        }
        head.lTag = false;
        head.rTag = true;
        head.rChild = null;  // 设置头节点的右子节点为null，表示当前为空
        if (head.lChild == null) {
            head.lChild = head;
        } else {
            pre = head;
            inThreading(head);
            pre.rChild = head;
            pre.rTag = true;
        }
        return true;
    }

    // 递归线索化方法
    public void inThreading(ClueNode<T> node) {
        if (node == null) {
            return;
        }
        inThreading(node.lChild);  // 递归处理左子树
        if (node.lChild == null) {
            node.lChild = pre;
            node.lTag = true;
        }
        if (pre.data != null && pre.rChild == null) {
            pre.rChild = node;
            pre.rTag = true;
        }
        pre = node;  // 更新前一个访问的节点
        inThreading(node.rChild);  // 递归处理右子树
    }

    // 中序遍历线索化后的二叉树
    public void inOrderTraversal() {
        ClueNode<T> current = head.lChild;  // 从最左边的节点开始
        while (current != head) {
            while (current.lTag == false) {
                current = current.lChild;  // 向左移动
            }
            System.out.print(current.data + " ");  // 输出当前节点的数据

            while (current.rTag == true && current.rChild != head) {
                current = current.rChild;  // 向右移动
                System.out.print(current.data + " ");  // 输出当前节点的数据
            }

            current = current.rChild;  // 移动到当前节点的后继节点
        }
    }

    // 主函数
    public static void main(String[] args) {
        ClueBinaryTree<String> tree = new ClueBinaryTree<String>();
        // 创建示例二叉树
        tree.head.lChild = new ClueNode<String>("A");
        tree.head.lChild.lChild = new ClueNode<String>("B");
        tree.head.lChild.rChild = new ClueNode<String>("C");
        tree.head.lChild.lChild.lChild = new ClueNode<String>("D");
        tree.head.lChild.lChild.rChild = new ClueNode<String>("E");
        tree.head.lChild.rChild.lChild = new ClueNode<String>("F");
        tree.head.lChild.rChild.rChild = new ClueNode<String>("G");
        tree.head.lChild.lChild.lChild.lChild = new ClueNode<String>("H");

        tree.startInThreading();  // 开始线索化
        tree.inOrderTraversal();   // 中序遍历并输出线索化后的结果
    }
}

这段代码实现了线索二叉树的构建和中序遍历。让我简单地讲解一下它的主要逻辑和功能：

1. ClueNode 类:

   • 定义了表示线索二叉树节点的 ClueNode 类，包含数据元素、左右子节点的引用，以及用于线索化的标记位。

2. ClueBinaryTree 类:

   • ClueBinaryTree 类包含一个 head 成员变量，表示线索二叉树的头节点。
   • 有一个默认构造函数，它在初始化时创建一个空节点作为头节点。
   • startInThreading 方法用于开始线索化。它设置头节点的标记位和右子节点，并调用 inThreading 方法完成线索化。
   • inThreading 方法是递归的，用于中序遍历并在线索化二叉树。在遍历的过程中，将节点的左子节点指向前驱节点，将前驱节点的右子节点指向后继节点，从而建立线索连接。
   • inOrderTraversal 方法用于中序遍历线索化后的二叉树，并输出节点的数据。

3. main 方法:

   • 在 main 方法中，创建了一个 ClueBinaryTree 对象 tree，并为其头节点的左子节点以及左子节点的子节点赋予一些数据。
   • 调用 startInThreading 方法开始线索化。
   • 调用 inOrderTraversal 方法进行中序遍历并输出线索化后的节点数据。

总体来说，这段代码展示了如何通过线索化实现中序遍历的效率提升。线索化的思想是在节点中添加线索，使其指向中序遍历时的前驱和后继节点，从而在遍历时不需要额外的递归或栈，提高了中序遍历的效率。