线索化二叉树笔记

线索化二叉树介绍
1.n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）。
2.这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种。
3.一个结点的前一个结点，称为前驱结点。
4.一个结点的后一个结点，称为后继结点。
案例应用
将下面的二叉树，进行中序线索二叉树。中序遍历的数列为 {8, 3, 10, 1, 14, 6}

代码

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Hero root=new Hero(1,"tom");
        Hero node2=new Hero(3,"jack");
        Hero node3=new Hero(6,"smith");
        Hero node4=new Hero(8,"mary");
        Hero node5=new Hero(10,"king");
        Hero node6=new Hero(14,"dim");

        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

        ThreadedBinaryTree threadedBinaryTree=new ThreadedBinaryTree();
        threadedBinaryTree.setRoot(root);
        threadedBinaryTree.threadedNotes();

        //测试：以10号节点测试
        Hero leftNode=node5.getLeft();
        Hero rightNode=node5.getRight();
        System.out.println("10号节点的前驱节点为："+leftNode);
        System.out.println("10号节点的前驱节点为："+rightNode);
        //打印线索化二叉树
        threadedBinaryTree.threadedIndixOrder(root);

    }

//定义ThreadedBinaryTree实现了线索化功能的二叉树
class ThreadedBinaryTree{
    private Hero root;
    //为了实现线索化，需要创建要给指向当前节点的前驱节点的指针
    //在递归进行线索化时，pre总是保留前一个节点
    private Hero pre=null;
    public void setRoot(Hero root) {
        this.root = root;
    }

    //重载
    public void threadedNotes(){
        this.threadedNotes(root);
    }
    //编写对二叉树进行中序线索化的方法

    /**
     *
     * @param node 就是当前需要线索化的节点
     */
    public void threadedNotes(Hero node){
        //如果node==null,不能线索化
        if(node==null){
            return;
        }
        //（一）先线索化左子树
        threadedNotes(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;
        //(三）线索化右子树
        threadedNotes(node.getRight());
    }
    //线索化二叉树的遍历
    public void threadedIndixOrder(Hero node){
        while(node!=null){
            while(node.getLeftType()==0){
                node=node.getLeft();
            }
            System.out.println(node);
            while (node.getRightType()==1){
                node=node.getRight();
                System.out.println(node);
            }

           node= node.getRight();
        }


    }

}

//英雄类
class Hero{
    private int namuber;
    private String name;
    private Hero left;
    private Hero right;

    /**
     * 说明：
     * 1.如果leftType==0表示指向的是左子树，如果1则表示指向前驱节点
     * 2.如果rightType==0表示指向的是右子树，如果1则表示指向后继节点
     */
    private int leftType;
    private int rightType;

    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 Hero(int namuber, String name) {
        this.namuber = namuber;
        this.name = name;
    }

    public int getNamuber() {
        return namuber;
    }

    public void setNamuber(int namuber) {
        this.namuber = namuber;
    }

    public String getName() {
        return name;
    }

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

    public Hero getLeft() {
        return left;
    }

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

    public Hero getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "Hero{" +
                "namuber=" + namuber +
                ", name='" + name + '\'' +
                '}';
    }

}

运行结果