线索化二叉树（Java）

一、引入

       1、线索二叉树： 在二叉树的结点上加上线索的二叉树

        2、二叉树线索化：对二叉树以某种遍历方式（如先序、中序、后序或层次等）进行遍历，使其变为线索二叉树的过程。

        3、为什么要进行线索化：在进行中序遍历的时候不需要采用堆栈处理，节约空间，而且数度比一般二叉树较快，缺点就是插入和删除较为复杂且数度也较慢。

---

二、线索化二叉树的原理

中序线索化的过程

        中序线索化的关键在于调整二叉树节点的指针，使其能够形成一个线性的结构。以下是中序线索化的过程：

1. 初始化： 从根节点开始，中序线索化的初始状态是空树。
2. 递归处理左子树： 递归对左子树进行线索化。
3. 处理当前节点： 如果当前节点的左子树为空，将左指针指向前驱节点；如果右子树为空，将右指针指向后继节点。
4. 递归处理右子树： 递归对右子树进行线索化。

前驱和后继关系的建立

        在线索化的过程中，需要注意建立前驱和后继关系。前驱是指中序遍历时，当前节点的前一个节点；后继是指当前节点的后一个节点。

---

三、图例及思路

        中序线索化过程：遍历一颗二叉树过程中将节点的左空指针指向前驱节点，右空指针指向后继节点

---

四、代码实现

1、中序线索化二叉树（常用）

class TreeNode {
    int data;
    TreeNode left, right;
    boolean isThreaded;

    public TreeNode(int data) {
        this.data = data;
        this.left = this.right = null;
        this.isThreaded = false;
    }
}

public class ThreadedBinaryTree {
    private TreeNode root, prev;

    public ThreadedBinaryTree() {
        this.root = null;
        this.prev = null;
    }

    // 中序线索化二叉树
    private void threadedInOrder(TreeNode node) {
        if (node != null) {
            threadedInOrder(node.left);

            if (node.left == null) {
                node.left = prev;
                node.isThreaded = true;
            }

            if (prev != null && prev.right == null) {
                prev.right = node;
                prev.isThreaded = true;
            }

            prev = node;

            threadedInOrder(node.right);
        }
    }

    // 中序遍历线索化二叉树
    public void inOrder() {
        TreeNode current = leftmost(root);

        while (current != null) {
            System.out.print(current.data + " ");

            if (current.isThreaded)
                current = current.right;
            else
                current = leftmost(current.right);
        }
    }

    // 找到以当前节点为根的子树的最左节点
    private TreeNode leftmost(TreeNode node) {
        while (node != null && node.left != null)
            node = node.left;
        return node;
    }

    // 主方法，用于调用线索化和遍历
    public static void main(String[] args) {
        ThreadedBinaryTree tree = new ThreadedBinaryTree();
        // 构建二叉树...

        // 线索化
        tree.threadedInOrder(tree.root);

        // 遍历
        tree.inOrder();
    }
}

2、先序线索化二叉树

        相较于中序线索化二叉树的实现稍显复杂，因为在先序遍历中，需要考虑前驱和后继关系的建立。以下是一个简单的Java代码演示先序线索化二叉树的过程：

class TreeNode {
    int data;
    TreeNode left, right;
    boolean isThreaded;

    public TreeNode(int data) {
        this.data = data;
        this.left = this.right = null;
        this.isThreaded = false;
    }
}

public class PreorderThreadedBinaryTree {
    private TreeNode root, prev;

    public PreorderThreadedBinaryTree() {
        this.root = null;
        this.prev = null;
    }

    // 先序线索化二叉树
    private void threadedPreOrder(TreeNode node) {
        if (node != null) {
            if (node.left == null) {
                node.left = prev;
                node.isThreaded = true;
            }

            if (prev != null && prev.right == null) {
                prev.right = node;
                prev.isThreaded = true;
            }

            prev = node;

            // 如果当前节点不是线索化的节点，递归处理左右子树
            if (!node.isThreaded) {
                threadedPreOrder(node.left);
                threadedPreOrder(node.right);
            }
        }
    }

    // 先序遍历线索化二叉树
    public void preOrder() {
        TreeNode current = root;

        while (current != null) {
            System.out.print(current.data + " ");

            if (current.isThreaded)
                current = current.right;
            else if (current.left != null)
                current = current.left;
            else
                current = current.right;
        }
    }

    // 主方法，用于调用线索化和遍历
    public static void main(String[] args) {
        PreorderThreadedBinaryTree tree = new PreorderThreadedBinaryTree();
        // 构建二叉树...

        // 线索化
        tree.threadedPreOrder(tree.root);

        // 遍历
        tree.preOrder();
    }
}

3、后序线索化二叉树

        序线索化二叉树的实现稍显复杂，因为需要考虑到后序遍历中节点的后继关系。以下是一个简单的Java代码演示后序线索化二叉树的过程：

class TreeNode {
    int data;
    TreeNode left, right;
    boolean isThreaded;

    public TreeNode(int data) {
        this.data = data;
        this.left = this.right = null;
        this.isThreaded = false;
    }
}

public class PostorderThreadedBinaryTree {
    private TreeNode root, prev;

    public PostorderThreadedBinaryTree() {
        this.root = null;
        this.prev = null;
    }

    // 后序线索化二叉树
    private void threadedPostOrder(TreeNode node) {
        if (node != null) {
            threadedPostOrder(node.left);
            threadedPostOrder(node.right);

            if (node.left == null) {
                node.left = prev;
                node.isThreaded = true;
            }

            if (prev != null && prev.right == null) {
                prev.right = node;
                prev.isThreaded = true;
            }

            prev = node;
        }
    }

    // 后序遍历线索化二叉树
    public void postOrder() {
        TreeNode current = leftmost(root);

        while (current != null) {
            System.out.print(current.data + " ");

            if (current.isThreaded) {
                current = current.right;
            } else {
                if (isThreadedNode(current)) {
                    current = current.left;
                } else {
                    current = leftmost(current.right);
                }
            }
        }
    }

    // 找到以当前节点为根的子树的最左节点
    private TreeNode leftmost(TreeNode node) {
        while (node != null && node.left != null)
            node = node.left;
        return node;
    }

    // 判断节点是否为线索化节点
    private boolean isThreadedNode(TreeNode node) {
        return node.left == null && node.isThreaded;
    }

    // 主方法，用于调用线索化和遍历
    public static void main(String[] args) {
        PostorderThreadedBinaryTree tree = new PostorderThreadedBinaryTree();
        // 构建二叉树...

        // 线索化
        tree.threadedPostOrder(tree.root);

        // 遍历
        tree.postOrder();
    }
}

五、总结

        通过本文，我们深入研究了线索化二叉树的原理，特别关注了中序线索二叉树的实现过程，并通过Java语言进行了演示。线索化二叉树通过引入前驱和后继关系，提高了中序遍历的效率，特别适用于需要频繁中序遍历的场景。通过实际的Java代码，读者可以更好地理解和运用线索化二叉树这一数据结构。