树结构---二叉树---线索化二叉树介绍and中序遍历线索化二叉树

线索化二叉树的基本介绍：

       1) n个结点的二叉链表中含有n+1 【公式2n-(n-1)n+1】个空指针域。利用二叉链表中的空指针域,存放指向该结点在某种遍历次序下的前驱和后继结点的指针(这种附加的指针称为"线索")

       2)这种加上了线索的二叉链表称为线索链表,相应的二叉树称为线索二叉树(Threaded BinaryTree)根据线索性质的不同,线索二又树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种 

       3)一个结点的前一个结点,称为前驱结点
       4)一个结点的后一个结点,称为后继结点

    线索化二叉树的应用实例：

       应用案例说明:将下面的二叉树,进行中序线索二叉树。中序遍历的数列为(8,3, 10, 1, 14, 6)

       思路分析：中序遍历的结果：{8,3,10,1,14,6}    

                    

       说明：当线索化二叉树之后，Node节点的属性 left 和 right，有如下情况：

            1)left指向的是左子树，也可能是指向前驱节点，比如①节点left指向的左子树，而⑩节点指向的left 指向的是前驱节点

            2)right指向的是右子树，也有可能指向的是后继节点，比如①节点right指向的右子树，而⑩节点指向的right指向的是后继节点

       代码实现：

package com.alibaba.tree.threadedbinarytree;

public class TreadedBinaryTreeDemo {
    public static void main(String[] args) {
        //测试中序线索化二叉树
        HeroNode root = new HeroNode(1, "tom");
        HeroNode node2 = new HeroNode(3, "jack");
        HeroNode node3 = new HeroNode(6, "smith");
        HeroNode node4 = new HeroNode( 8, "mary");
        HeroNode node5 = new HeroNode(10, "king");
        HeroNode node6 = new HeroNode(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.threadedNodes();
        HeroNode left = node5.getLeft();
        System.out.println("10号节点的前驱节点是"+left);
        System.out.println("10号节点的后继节点是"+node5.getRight());
    }
}
//定义ThreadedBinaryTree 实现了线索化的二叉疏忽和功能翁
class ThreadedBinaryTree{
    private HeroNode root;
    //为了实现线索化，需要创建要给指向当前节点的前驱节点的指针
    //在递归线索化时，pre 总是保留前一个节点
    private HeroNode pre=null;

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


    public void threadedNodes(){
        this.threadedNodes(root);
    }
    //编写对二叉树进行中序线索化的方法
    /**
     * @param heroNode 当前需要线索化的节点
     */
     public void threadedNodes(HeroNode heroNode){
        if(heroNode==null){//为空不能线索化
            return;
        }
        //线索化左子树
         threadedNodes(heroNode.getLeft());
        //线索化当前节点
         //处理当前节点的前驱节点
         if (heroNode.getLeft()==null){
             //让当前节点的做指针指向前驱节点
             heroNode.setLeft(pre);
             //修改当前节点的左指针类型,只想前驱节点
             heroNode.setLeftType(1);
         }
         //处理后继节点
         if (pre!=null&&pre.getRight()==null){
             //让前驱节点的右指针指向当前节点
            pre.setRight(heroNode);
            //修改当前节点的右指针类型
            pre.setRightType(1);
         }

         // 每处理一个节点后，让当前节点是下一个节点的前驱节点
         pre=heroNode;
        //线索化右子树
         threadedNodes(heroNode.getRight());

     }
    //删除节点
    public void deleteNode(int no){
        if (root!=null){
            if(root.getId()==no){
                root=null;
            }else{
                root.deleteNode(no);
            }
        }else{
            System.out.println("该二叉树为空，删除失败！");
        }
    }
    //前序遍历
    public void preOrder(){
        if (this.root!=null){
            this.root.preOrder();
        }else{
            System.out.println("二叉树为空，无法遍历");
        }
    }
    //中序遍历
    public void infixOrder(){
        if (this.root!=null){
            this.root.infixOrder();
        }else{
            System.out.println("二叉树为空，无法遍历");
        }
    }
    //后序遍历
    public void afterOrder(){
        if (this.root!=null){
            this.root.afterOrder();
        }else{
            System.out.println("二叉树为空，无法遍历");
        }
    }
}

//创建节点
class HeroNode{
    private int id;
    private String name;
    private HeroNode left;
    private HeroNode right;
    //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 HeroNode(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

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

    @Override
    public String toString() {
        return "HeroNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
    //递归删除节点
    public void deleteNode(int no){
        //如果当前节点的左子节点不为空，并且左子节点就是要删除的节点，就将this.left=null，并且就返回(结果递归删除)
        if(this.left!=null && this.left.id==no){
            this.left=null;
            return;
        }
        //如果当前节点的右子节点不为空，并且右子节点就是要删除的节点，就将this.right=null，并且就返回(结果递归删除)
        if (this.right!=null&&this.right.id==no){
            this.right=null;
            return;
        }
        //向左子树进行递归删除
        if (this.left!=null){
            this.left.deleteNode(no);
        }
        //向右子树进行递归删除
        if (this.right!=null){
            this.right.deleteNode(no);
        }
    }
    //编写前序遍历的方法
    public void preOrder(){
        System.out.println(this);//先输出父节点
        //递归向左子树前序遍历
        if(this.left!=null){
            this.left.preOrder();
        }
        //递归向右子树前序遍历
        if(this.right!=null){
            this.right.preOrder();
        }
    }
    //编写中序遍历的方法
    public  void infixOrder(){
        //递归向左子树中序遍历
        if(this.left!=null){
            this.left.infixOrder();
        }
        System.out.println(this);
        //递归向右子树中序遍历
        if(this.right!=null){
            this.right.infixOrder();
        }
    }
    //编写后序遍历的方法
    public  void afterOrder(){
        //递归向左子树后序遍历
        if(this.left!=null){
            this.left.afterOrder();
        }
        //递归向右子树后序遍历
        if(this.right!=null){
            this.right.afterOrder();
        }
        System.out.println(this);
    }
}

遍历线索化二叉树：

        说明:对前面的中序线索化的二叉树,进行遍历
        分析:因为线索化后,各个结点指向有变化,因此原来的遍历方式不能使用,这时需要使用新的方式遍历线索化二叉树,各个节点可以通过线型方式遍历,因此无需使用递归方式,这样也提高了遍历的效率。遍历的次序应当和中序遍历保持一致。

         代码实现：

中序遍历线索化二叉树方法：
public void threadedList(){
        //定义一个变量存储当前遍历的节点,从root开始
        HeroNode node=root;
        while (node!=null){
            //循环找到leftType==1的节点
            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();

        }
    }