二叉树的线索化与线索二叉树的遍历（Java实现）

这里是我对线索二叉树的个人总结，第一次写博客，如果在一些定义方面有表达不清的地方，大家可以结合着专业书籍来看，这样更容易理解。

线索二叉树定义：

在二叉树的结点上加上线索的二叉树称为线索二叉树，对二叉树以某种遍历方式（如先序、中序、后序等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化。

这里的二叉树使用链表形式创建，每一个节点除了自己的权之外还存储着左右两个子节点的引用，后面会简称为左指针与右指针。

以此二叉树为例：

这里先介绍几个概念：

**1.二叉树的中序遍历：**先遍历左子节点（左子树），再遍历自己，再遍历右子节点（右子树）。称为中序遍历。上方二叉树中序遍历后的结果：8，7，3，9，10，1，14，6。
**2.二叉树的先序（前序）遍历：**先遍历自己，再遍历左子节点（左子树），再遍历右子节点（右子树）。上方二叉树前序遍历结果为：1，3，8，7，10，9，6，14。
**3.二叉树的后序遍历：**先遍历左子节点（左子树），再遍历右子节点（右子树），最后遍历自己。上方二叉树的后序遍历结果为：7，8，9，10，3，14，6，1。
**总结：**实际上三种遍历方式的名字都是以“当前节点”为基准来起名的，中序就是当前节点在遍历顺序的中间（左-自己-右），前序就是在遍历顺序的开头（自己-左-由），后序就是在遍历顺序的结尾（左-右-自己）。

还需要了解的概念：

**前驱节点：**在三种遍历方式中，按照遍历的顺序，在一个节点之前被遍历的节点成为前驱节点。
**后继节点：**在三种遍历方式中，按照遍历的顺序，在一个节点之后被遍历的节点成为后继节点。

**前序线索化二叉树：**以前序遍历的顺序来线索化二叉树。
**中序线索化二叉树：**以中序遍历的顺序来线索化二叉树。
**后序线索化二叉树：**以后序遍历的顺序来线索化二叉树。

二叉树线索化的核心思想：

如果一个节点的左指针为空，那么就把其前驱节点的引用赋值到这个节点的左指针中。同理，如果一个节点的右指针为空，那么就把其后继节点的引用赋值到这个节点的右指针中。

这样操作之后，每个节点的左指针与右指针就都存储了引用。但这样也带来了一些问题：我们如何区分左指针和右指针指向的到底是左节点和右节点，还是前驱节点与后继节点？
所以，我们需要定义一个int类型的标记，如果存储的是子节点，我们就用标记的默认值0，如果存储的是前驱、后继节点，我们就更改标记值为1。这样就可以区分指针的具体类型了。

Java实现的基本流程：

**1.定义一个节点类：**ThreadNode，其中包括节点对应的属性和方法。
**2.定义一个二叉树类：**ThreadBinaryTree，其中包括树对应的属性和方法。
**3.定义一个测试类：**Test，用于最终结果的测试。

对应的方法名称（忽略我的chinglish起名方式）：

front(); //二叉树的前序遍历
mid(); //二叉树的中序遍历
after(); //二叉树的后序遍历
frontThread(); //前序线索化二叉树
midThread(); //中序线索化二叉树
afterThread(); //后序线索化二叉树
frontIterate(); //遍历前序线索化二叉树
midIterate(); //遍历中序线索化二叉树
afterIterate(); //遍历后序线索化二叉树

在进入代码阶段之前，我们还要思考两个问题。

**1.**二叉树的子节点是不能直接找到父节点的，因为在各个节点中只存储了子节点的引用，并没有存储父节点的引用。但是在后序遍历线索化二叉树的方法中，我们需要获取父节点，所以在节点类中还定义了存储父节点的属性。在创建节点时我们需要手动给这个属性赋值。
**2.**在线索化二叉树的方法中，我们还需要存储当前节点的前驱节点，所以在节点类中，我们还需要一个存储前驱节点的静态属性，这个属性也会在后序遍历线索二叉树中使用到。之所以是静态的属性，是因为在每次递归时都要更改这个值，静态属性从属于类，这样更改后的值就可以被存储下来，以供下次使用。

这两点问题现在看可能有些不知所云，但是建议先了解一下，在看了接下来的代码之后反过来再看，就会有更深的理解。

废话了这么多，我们开始正式进入代码阶段。

**

首先是ThreadBinaryTree类：

**

import static com.ssh.test.ThreadNode.pre;

public class ThreadBinaryTree {
    //树的根节点
    private ThreadNode root;

    public ThreadNode getRoot() {
        return root;
    }

    public void setRoot(ThreadNode root) {
        this.root = root;
    }
    //中序线索化方法的重载
    public void midThread(){
        root.midThread();
    }
    //前序线索化方法的重载
    public void frontThread(){
        root.frontThread();
    }
    //后序线索化方法的重载
    public void afterThread(){
        root.afterThread();
    }
    //中序线索遍历
    public void midIterate(){

        //定义一个变量，用于储存当前节点
        ThreadNode node = root;
        while(node!=null){
            //循环找到左节点类型为0的节点
            while(node.getLeftNode()!=null&&node.getLeftType()==0){
                node = node.getLeftNode();
            }
            //打印当前节点
            System.out.println(node.getValue());
            //判断，如果右节点类型为1，说明右节点为后继节点，替换并直接打印
            while(node.getRightNode()!=null&&node.getRightType()==1){
                node = node.getRightNode();
                System.out.println(node.getValue());
            }
            //如果右节点类型为0，说明右节点为子节点，直接替换node为右节点，进行下一次的循环判断
            node = node.getRightNode();
        }
    }
    //前序线索遍历
    public void frontIterate(){
        //定义一个变量，用于存储当前节点
        ThreadNode node = root;
        while(node!=null){
            //当前节点的左子节点类型为0时，循环打印当前节点信息，并替换node为当前节点的下一个节点
            while(node!=null){
                System.out.println(node.getValue());
                if(node.getLeftType()==0){
                    node = node.getLeftNode();
                }else {  //如果当前节点的左指针类型不为0，则跳出循环
                    break;
                }
            }
            //找到并打印完最左边的节点以后，开始处理右节点
            node = node.getRightNode();
        }
    }
    //前序线索化遍历的优化方法
    public void test(){
        //定义一个变量，存储当前遍历的节点，从root开始
        ThreadNode node = root;
        while ( node != null ) {
            while ( node.getLeftType() == 0 ) {
                //如果是叶子节点，非前驱节点，打印当前这个结点
                System.out.print(node + ",");
                node = node.getLeftNode();
            }
            System.out.print(node + ",");
            //找到并打印完最左边的节点以后，开始处理右节点
            node = node.getRightNode();
        }
    }

    //后序线索化遍历
    public void afterIterate(){
        //先把ThreadNode中的静态变量pre赋值为空
        ThreadNode.pre = null;
        //定义一个变量，存储当前遍历的节点，从root开始
        ThreadNode node = root;
        //找到最左边的点
        while(node!=null&&node.getLeftType()==0){
            node = node.getLeftNode();
        }
        while(node!=null){
            //如果右节点类型为1
            if(node.getRightType()==1){
                System.out.println(node.getValue());
                pre = node;
                node = node.getRightNode();
            }else{
                //如果上一个打印的节点是当前节点的右节点
                if(pre == node.getRightNode()){
                    System.out.println(node.getValue());
                    pre = node;
                    node = node.getParent();

                }else{
                    //如果从左节点进入或者一开始就是右节点，找到最左边的节点
                    node = node.getRightNode();
                    while(node!=null&&node.getLeftType()==0&&node.getLeftNode()!=null){
                        node = node.getLeftNode();
                    }
                }
            }
        }
    }

    //中序遍历的重载方法
    public void mid(){
        root.mid();
    }
    //前序遍历的重载方法
    public void front(){
        root.front();
    }
    //后序遍历的重载方法
    public void after(){
        root.after();
    }

}

其次是ThreadNode类：

public class ThreadNode {
    private int value;//节点的权
    private ThreadNode leftNode;//左节点
    private ThreadNode rightNode;//右节点
    private int leftType;//左指针（节点）类型
    private int rightType;//右指针（节点）类型
    public static ThreadNode pre;//节点的前驱节点
    private ThreadNode parent;//节点的父节点

    public ThreadNode getParent() {
        return parent;
    }

    public void setParent(ThreadNode parent) {
        this.parent = parent;
    }

    @Override
    public String toString() {
        return "ThreadNode{" +
                "value=" + value +
                '}';
    }

    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 ThreadNode(int value){
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public ThreadNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(ThreadNode leftNode) {
        this.leftNode = leftNode;
    }

    public ThreadNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(ThreadNode rightNode) {
        this.rightNode = rightNode;
    }

    //中序线索化二叉树
    public void midThread() {

        //处理左子树
        if(leftNode!=null){
            leftNode.midThread();
        }
        if(pre!=null)
        //System.out.println(pre.value+"kkk");
        //处理前驱节点
        if(pre!=null&&pre.rightNode==null){
            pre.rightNode = this;
            pre.rightType = 1;
        }
        //处理自己
        if(pre!=null&&this.leftNode==null){
            this.leftNode = pre;
            this.leftType = 1;
        }
        pre = this;
        //System.out.println(pre.value);
        //处理右子树
        if(rightNode!=null){
            rightNode.midThread();
        }

    }
    //前序线索化二叉树
    public void frontThread() {
        //处理自己
        if(pre!=null&&this.leftNode==null){
            this.leftNode = pre;
            this.leftType = 1;
        }
        if(pre!=null&&pre.rightNode == null){
            pre.rightNode = this;
            pre.rightType = 1;
        }
        pre = this;
        //处理左节点
        if(this.leftNode!=null&&leftType==0){
            leftNode.frontThread();
        }
        //处理右节点
        if(this.rightNode!=null&&rightType==0){
            rightNode.frontThread();
        }
    }
    //后序线索化二叉树
    public void afterThread() {
        //处理左子树
        if(this.leftNode!=null){
            leftNode.afterThread();
        }
        //处理右子树
        if(this.rightNode!=null){
            rightNode.afterThread();
        }
        //处理自己
        if(pre!=null&&this.leftNode == null){
            this.leftNode = pre;
            this.leftType = 1;
        }
        if(pre!=null&&pre.rightNode==null){
            pre.rightNode = this;
            pre.rightType = 1;
        }
        pre = this;
    }
    //中序遍历二叉树
    public void mid() {
        //先处理左边
        if(this.leftNode!=null){
            leftNode.mid();
        }
        //再处理中间
        System.out.println(this.getValue());
        //再处理右边
        if(this.rightNode!=null){
            rightNode.mid();
        }
    }
    //前序遍历二叉树
    public void front() {
        //先处理自己
        System.out.println(this.getValue());
        //处理左边
        if(this.leftNode!=null){
            leftNode.front();
        }
        //处理右边
        if(this.rightNode!=null){
            rightNode.front();
        }
    }
    //后序遍历二叉树
    public void after() {
        //处理左边
        if(this.getLeftNode()!=null){
            leftNode.after();
        }
        //处理右边
        if(this.getRightNode()!=null){
            rightNode.after();
        }
        //处理自己
        System.out.println(this.getValue());
    }
}

最后是Test类以及运行的结果：

public class Test {
    public static void main(String[] args) {
        ThreadBinaryTree tree = new ThreadBinaryTree();
        //创建根节点
        ThreadNode root = new ThreadNode(1);
        tree.setRoot(root);
        //创建一些子节点，这里节点起名的方式为：n+节点的权
        ThreadNode n3 = new ThreadNode(3);
        ThreadNode n6 = new ThreadNode(6);
        ThreadNode n8 = new ThreadNode(8);
        ThreadNode n10 = new ThreadNode(10);
        ThreadNode n14 = new ThreadNode(14);
        ThreadNode n7 = new ThreadNode(7);
        ThreadNode n9 = new ThreadNode(9);
        //追加子节点
        root.setLeftNode(n3);
        root.setRightNode(n6);
        n3.setLeftNode(n8);
        n3.setRightNode(n10);
        n8.setRightNode(n7);
        n10.setLeftNode(n9);
        n6.setLeftNode(n14);
        //给节点追加父节点
        n3.setParent(root);
        n6.setParent(root);
        n8.setParent(n3);
        n10.setParent(n3);
        n7.setParent(n8);
        n9.setParent(n10);
        n14.setParent(n6);



        //测试中序线索化
        tree.mid(); //8，7，3，9，10，1，14，6。
        tree.midThread();
        tree.midIterate();//8，7，3，9，10，1，14，6。

        //测试前序线索化
        tree.front();//1，3，8，7，10，9，6，14。
        tree.frontThread();
        tree.frontIterate();//1，3，8，7，10，9，6，14。
        tree.test();//1，3，8，7，10，9，6，14。

        //测试后序线索化
        tree.after();//7，8，9，10，3，14，6，1。
        tree.afterThread();
        tree.afterIterate();//7，8，9，10，3，14，6，1。


    }
}

二叉树的前、中、后序遍历没有什么好说的。但是在二叉树的线索化中，由于用到了递归，所以要注意递归的结束条件，还有在线索化二叉树时，每一次要处理当前节点的左节点与上一个节点的右节点，这点并不容易理解，需要细心的留意，可以用debug一步一步的观察。
在遍历线索化二叉树时，前序、中序遍历相对好理解，但是在后序遍历时，之所以同时用到了存储前驱节点的属性pre以及存储父节点的属性parent，是因为后序遍历的特殊性，在遍历右节点（右子树）时需要分成两种情况：第一种是当前节点的前驱节点刚好是右节点；一种是从左子树来到了当前节点，再遍历右节点。
这就是个人在学习线索二叉树之后的总结，如果有不对的或者有争议的地方，还请大家指出，我们共同进步！