datastructure：线索化二叉树

n个结点的二叉链表中含有 n+1 ( 2n - (n-1) )个空指针域
其中空指针域存放该结点的前驱结点和后继结点的指针，称为“线索”
线索化二叉树后，Node结点的属性：left指向左子树或前驱结点；right指向右子树或后继结点
线索化二叉树后，可以通过线性方式遍历，无需使用递归方式，提高了便利的效率

public class ThreadedBinaryTreeTest {
    public static void main(String[] args) {
        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();

        HeroNode node1 = new HeroNode(1, "宋江");
        HeroNode node3 = new HeroNode(3, "吴用");
        HeroNode node6 = new HeroNode(6, "林冲");
        HeroNode node8 = new HeroNode(8, "呼延灼");
        HeroNode node10 = new HeroNode(10, "柴进");
        HeroNode node14 = new HeroNode(14, "武松");

        threadedBinaryTree.setRoot(node1);
        node1.setLeft(node3);
        node1.setRight(node6);
        node3.setLeft(node8);
        node3.setRight(node10);
        node6.setLeft(node14);

        //            1
        //        /       \
        //      3          6
        //    /   \      /
        //   8     10  14
        //
        // 前序遍历的结果是{1, 3, 8, 10, 6, 14}
        // 中序遍历的结果是{8, 3, 10, 1, 14, 6}
        // 后序遍历的结果是{8, 10, 3, 14, 6, 1}
        //
        // 中序线索化的时候，8号结点的left结点为null，left结点的类型是前驱结点，等于1
        // 中序线索化的时候，6号结点的right结点为null，right结点的类型不是后继结点，不等于1

        // 测试前序线索化
//        threadedBinaryTree.preThreadedNode();
//        System.out.println("8号结点的前驱结点是：" + node8.getLeft());
//        System.out.println("8号结点的后继结点是：" + node8.getRight());
//        System.out.println("6号结点的后继结点是：" + node6.getRight());
//        System.out.println("10号结点的前驱结点是：" + node10.getLeft());
//        System.out.println("10号结点的后继结点是：" + node10.getRight());
//
//        System.out.println("前序遍历线索化二叉树：");
//        threadedBinaryTree.preThreadedOrder();

        // 测试中序线索化
//        threadedBinaryTree.inThreadedNode();
//        System.out.println("8号结点的后继结点是：" + node8.getRight());
//        System.out.println("10号结点的前驱结点是：" + node10.getLeft());
//        System.out.println("10号结点的后继结点是：" + node10.getRight());
//        System.out.println("14号结点的前驱结点是：" + node14.getLeft());
//        System.out.println("14号结点的后继结点是：" + node14.getRight());
//
//        System.out.println("中序遍历线索化二叉树：");
//        threadedBinaryTree.inThreadedOrder();

        // 测试后序线索化
        threadedBinaryTree.postThreadedNode();
        System.out.println("8号结点的后继结点是：" + node8.getRight());
        System.out.println("10号结点的前驱结点是：" + node10.getLeft());
        System.out.println("10号结点的后继结点是：" + node10.getRight());
        System.out.println("14号结点的前驱结点是：" + node14.getLeft());
        System.out.println("14号结点的后继结点是：" + node14.getRight());
        System.out.println("6号结点的后继结点是：" + node6.getRight());

        System.out.println("后序遍历线索化二叉树：");
        threadedBinaryTree.postThreadedOrder();
    }
}

class ThreadedBinaryTree {
    private HeroNode root;

    // 为了实现线索化，需要创建指向当前结点的前驱结点的指针
    private HeroNode pre = null;

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

    // 重载inThreadedNode方法

    /**
     * 重载preThreadedNode方法、inThreadedNode方法、postThreadedNode方法
     */
    public void preThreadedNode() {
        this.preThreadedNode(root);
    }
    public void inThreadedNode() {
        this.inThreadedNode(root);
    }
    public void postThreadedNode() {
        this.postThreadedOrder(root);
    }

    /**
     * 对二叉树进行前序线索化
     * @param node 当前需要线索化的结点
     */
    public void preThreadedNode(HeroNode node) {
        if (node != null) {
            // 先线索化当前结点
            if (node.getLeft() == null) {
                node.setLeft(pre);
                node.setLeftType(1);
            }
            if (pre != null && pre.getRight() == null) {
                pre.setRight(node);
                pre.setRightType(1);
            }
            pre = node;
            // 当左、右为子树时才线索化，否则死循环
            if (node.getLeftType() == 0) {
                preThreadedNode(node.getLeft());
            }
            if (node.getRightType() == 0) {
                preThreadedNode(node.getRight());
            }
        }
    }

    /**
     * 对二叉树进行中序线索化
     * @param node 当前需要线索化的结点
     */
    public void inThreadedNode(HeroNode node) {
        if (node != null) {
            // 先线索化左子树
            inThreadedNode(node.getLeft());

            // 再线索化当前结点
            // 处理当前结点的前驱结点
            if (node.getLeft() == null) {
                // 让当前结点的左指针指向前驱结点
                node.setLeft(pre);
                // 修改当前结点的左指针的类型
                node.setLeftType(1);
            }
            // 处理当前结点的后继结点
            if (pre != null && pre.getRight() == null) {
                // 让前驱结点的右指针指向当前结点
                pre.setRight(node);
                // 修改前驱结点的右指针的类型
                pre.setRightType(1);
            }
            // 处理一个结点后，让当前结点作为下一个结点的前驱结点
            pre = node;

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

    /**
     * 对二叉树进行后序线索化
     * @param node 当前需要线索化的结点
     */
    public void postThreadedOrder(HeroNode node) {
        if (node != null) {
            // 先线索化左子树
            postThreadedOrder(node.getLeft());
            // 再线索化右子树
            postThreadedOrder(node.getRight());
            // 最后线索化当前结点
            // 处理当前结点的前驱结点
            if (node.getLeft() == null) {
                // 让当前结点的左指针指向前驱结点
                node.setLeft(pre);
                // 修改当前结点的左指针的类型
                node.setLeftType(1);
            }
            // 处理当前结点的后继结点
            if (pre != null && pre.getRight() == null) {
                // 让前驱结点的右指针指向当前结点
                pre.setRight(node);
                // 修改前驱结点的右指针的类型
                pre.setRightType(1);
            } else if (pre != null && pre.getRight() != null) {
                pre.setChild(node);
            }
            // 处理一个结点后，让当前结点作为下一个结点的前驱结点
            pre = node;
        }
    }

    /**
     * 前序遍历线索化二叉树
     */
    public void preThreadedOrder() {
        HeroNode temp = root;
        while (temp != null) {
            // 如果当前结点的left不是前驱结点，继续找下一个
            while (temp.getLeftType() == 0) {
                //打印当前结点
                System.out.println(temp);
                temp = temp.getLeft();
            }
            while (temp.getRightType() == 1){
                //打印当前结点
                System.out.println(temp);
                //获取到当前结点的后继结点
                temp = temp.getRight();
            }
            System.out.println(temp);
            //替换这个遍历的结点
            temp  = temp.getRight();
        }
    }

    /**
     * 中序遍历线索化二叉树
     */
    public void inThreadedOrder() {
        HeroNode temp = root;
        while (temp != null) {
            // 如果当前结点的left不是前驱结点，继续找下一个
            while (temp.getLeftType() == 0) {
                temp = temp.getLeft();
            }
            // while结束，表示leftType=1，打印该结点
            System.out.println(temp);
            // 如果当前结点的right是后继结点，输出后继结点
            while (temp.getRightType() == 1) {
                temp = temp.getRight();
                System.out.println(temp);
            }
            // while结束，表示rightType=0，替换遍历的结点
            temp = temp.getRight();
        }
    }

    public void postThreadedOrder() {
        HeroNode temp = root;
        HeroNode pre = null;
        while (temp != null) {
            // 如果当前结点的left不是前驱结点，继续找下一个
            while (temp.getLeftType() == 0) {
                temp = temp.getLeft();
            }
            // 如果当前结点的right是后继结点，输出后继结点
            while (temp.getRightType() == 1) {
                //打印当前结点
                System.out.println(temp);
                pre = temp;
                temp = temp.getRight();
            }
            if (temp == root) {
                System.out.println(temp);
                return;
            }
            while (temp != null && temp.getRight() == pre) {
                System.out.println(temp);
                pre = temp;
                temp = temp.getChild();
            }
            if (temp != null && temp.getRightType() == 0) {
                temp = temp.getRight();
            }
        }
    }
}

class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;
    private HeroNode child;

    // leftType为0表示指向左子树，为1表示指向前驱结点
    private int leftType;
    // rightType为0表示指向右子树，为1表示指向后继结点
    private int rightType;

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

    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 HeroNode getChild() {
        return child;
    }

    public void setChild(HeroNode child) {
        this.child = child;
    }

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