[059] Java “线索化二叉树”

1、线索化二叉树

• 概念：上篇博文简介了顺序存储（数组）二叉树，相应的也有线索化（链表）二叉树。利用二叉树中的空指针域来存放在某种遍历次序下的前驱和后继，这种指针叫“线索”。这种加上了线索的二叉树称为线索二叉树（Threaded BinaryTree）；
• 通俗来讲：如下图的二叉树，它的中序遍历结果为 4 - 2 - 5 - 1 - 6 - 3，那 2 这个节点在中序遍历中的前驱就是4，后继节点就是5，但是单从二叉树中无法直接看出这个关系，因此，我们对原二叉树做一些小修改。我们都知道，n个节点的二叉树有2n个指针域，其中有n-1个指针域被用于指向节点的左右子节点，还有n+1个指针域为空指针，线索二叉树就是充分使用了这些空指针，让这些空指针对应地指向该节点在某种遍历顺序中的前驱或后继节点，使二叉树链接起来。例如，2节点的左右指针都为空，我们将左指针指向它的前驱节点4，右指针指向它的后继节点5，依次类推，就实现了对这棵二叉树的中序线索化；

• 作用：二叉树是一种非线性存储结构，使用时常通过遍历的方式得到线性序列，线索化二叉树能一次性保存二叉树在某种遍历顺序下的前后关系，以后在对二叉树进行某种处理时可直接使用这种关系，避免对二叉树的重复遍历。

​​​​​​​2、Java代码

// 中序遍历线索化二叉树
package DataStructures.Tree;

/**
 * @author yhx
 * @date 2020/10/15
 */
public class TreadedBinaryTreeDemo {
    public static void main(String[] args) {
        HeroNode2 root = new HeroNode2(1, "宋江");
        HeroNode2 node2 = new HeroNode2(3, "李逵");
        HeroNode2 node3 = new HeroNode2(6, "武松");
        HeroNode2 node4 = new HeroNode2(8, "吴用");
        HeroNode2 node5 = new HeroNode2(10, "林冲");
        HeroNode2 node6 = new HeroNode2(14, "关胜");

        // 手动创建二叉树
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

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

        System.out.println("使用线索化遍历的方式遍历二叉树：");
        threadedBinaryTree.threadedList();

    }
}


/**
 * 定义线索化二叉树
 */
class ThreadedBinaryTree {
    /**
     * root：根节点
     * pre指针：指向当前节点的前驱节点
     */
    private HeroNode2 root;
    private HeroNode2 pre = null;

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

    /**
     * 重载中序线索化二叉树的方法
     */
    public void midThreadedNodes() {
        this.midThreadedNodes(root);
    }

    /**
     * 对二叉树进行中序线索化的方法
     *
     * @param node 当前需要线索化的节点
     */
    public void midThreadedNodes(HeroNode2 node) {
        if (node == null) {
            return;
        }

        // 1、先线索化左子树
        midThreadedNodes(node.getLeft());

        // 2、然后线索化当前节点：当前节点左指针指向上一个节点（前驱线索化）+ 上一个节点右指针指向当前节点（后继线索化）
        if (node.getLeft() == null) {
            // 让当前节点的左指针指向前驱节点
            node.setLeft(pre);
            // 修改左指针的类型标识符
            node.setLeftType(1);
        }
        if (pre != null && pre.getRight() == null) {
            // 让前驱节点的右指针指向当前节点
            pre.setRight(node);
            // 修改右指针的类型标识符
            pre.setRightType(1);
        }
        // pre后移
        pre = node;

        // 3、最后线索化右子树
        midThreadedNodes(node.getRight());
    }

    /**
     * 遍历线索化二叉树的方法
     */
    public void threadedList() {
        // 临时变量
        HeroNode2 tempNode = root;
        while (tempNode != null) {
            // 找到线索化处理后的有效节点，即leftType == 1的节点，
            while (tempNode.getLeftType() == 0) {
                tempNode = tempNode.getLeft();
            }
            // 打印当前这个节点
            System.out.println(tempNode);
            // 如果当前节点的右指针指向的是后继节点，就一直输出
            while (tempNode.getRightType() == 1){
                tempNode = tempNode.getRight();
                System.out.println(tempNode);
            }
            // 替换遍历的节点
            tempNode = tempNode.getRight();
        }
    }
}

/**
 * 定义英雄节点 HeroNode2
 */
class HeroNode2 {
    /**
     * no：英雄编号
     * name：英雄名字
     * left right：每个英雄节点的左右指针
     * leftType rightType：表示每个英雄节点左右指针的指向类型
     * 如果 leftType == 0，则表示左指针指向的是左子树，如果 leftType == 1，则指向的是前驱节点
     * 如果 rightType == 1，则表示右指针指向的是右子树，如果 rightType == 1，则指向的是后继节点
     */
    private int no;
    private String name;
    private HeroNode2 left;
    private HeroNode2 right;
    private int leftType;
    private int rightType;

    /**
     * 构造器
     *
     * @param no   英雄编号
     * @param name 英雄名字
     */
    public HeroNode2(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public String getName() {
        return name;
    }

    public HeroNode2 getLeft() {
        return left;
    }

    public HeroNode2 getRight() {
        return right;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public void setName(String name) {
        this.name = name;
    }

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

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

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

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

    public int getLeftType() {
        return leftType;
    }

    public int getRightType() {
        return rightType;
    }

    @Override
    public String toString() {
        return "HeroNode2 [no = " + no + ",name = " + name + "]";
    }
}

3、运行结果

使用线索化遍历的方式遍历二叉树：
HeroNode2 [no = 8,name = 吴用]
HeroNode2 [no = 3,name = 李逵]
HeroNode2 [no = 10,name = 林冲]
HeroNode2 [no = 1,name = 宋江]
HeroNode2 [no = 14,name = 关胜]
HeroNode2 [no = 6,name = 武松]