中序线索化二叉树的实现

思路分析：

在这里只做中序线索化二叉树：

package com.ran;


public class hello {

    public static void main(String[] args) {

        HeroNode root = new HeroNode(1, "qqq");
        HeroNode root2 = new HeroNode(3, "www");
        HeroNode root3 = new HeroNode(6, "eee");
        HeroNode root4 = new HeroNode(8, "rrr");
        HeroNode root5 = new HeroNode(10, "ttt");
        HeroNode root6 = new HeroNode(14, "yyy");


        //二叉树后面会递归创建
        root.setZuo(root2);
        root.setYou(root3);
        root2.setZuo(root4);
        root2.setYou(root5);
        root3.setZuo(root6);


        erchashuxiansuo qqq = new erchashuxiansuo();
        qqq.setRoot(root);
        qqq.xiansuohua();

        //测试 以10测试
        HeroNode zuodian = root5.getZuo();
        System.out.println("十号节点的前驱结点是"+ zuodian);
        System.out.println("十号节点的后继结点是"+ root5.getYou());
    }

}


//线索化二叉树
class erchashuxiansuo{
    private HeroNode root;

    //为了实现线索化，需要创建当前节点的前驱结点的引用
    //在递归进行线索化时，pre总是保留前一个节点
    private HeroNode pre=null;

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

    //重载一下
    public void xiansuohua(){
        this.xiansuohua(root);
    }


    //编写线索化的方法 node就是当前需要线索化的节点
    public void xiansuohua(HeroNode node){
        //如果node=nulll 则无法线索化
        if(node==null){
            return;
        }

        //1.先线索化我们的左子树
        xiansuohua(node.getZuo());
        //2.线索化当前节点

        //处理当前节点的前驱结点
        //以8节点来理解
        //8节点的left=null
        if(node.getZuo()==null){
            //让当前节点的左指针指向前驱结点
            node.setZuo(pre);
            //修改当前节点的左指针类型
            node.setZuotype(1);
        }

        //处理后继节点 处理后继节点的时候是在下一次遍历到3的时候处理的 在8的时候并没有处理
        if(pre!=null && pre.getYou()==null){
            //让前驱结点的右指针指向当前节点
            pre.setYou(node);
            //修改前驱结点的右指针类型
            pre.setYoutype(1);
        }

        //!!! 每处理一个节点后，让当前节点是下一个节点的前驱结点
        pre=node;

        //3.线索化右子树
        xiansuohua(node.getYou());
    }

    //前序遍历
    public void qianxu(){
        if(this.root!=null){
            this.root.qianxu();
        }else {
            System.out.println("当前二叉树为空 无法遍历");
        }
    }

    public void zhongxu(){
        if(this.root!=null){
            this.root.zhongxu();
        }else {
            System.out.println("当前二叉树为空 无法遍历");
        }
    }

    public void houxu(){
        if(this.root!=null){
            this.root.houxu();
        }else {
            System.out.println("当前二叉树为空 无法遍历");
        }
    }
}



class HeroNode{
    private int no;
    private String name;
    private HeroNode zuo;
    private HeroNode you;
    private int zuotype;   //为0表示指向的是左子树 为1表示指向前驱结点
    private int youtype;  //为0表示指向的是右子树 为1表示指向的是后继节点

    public int getZuotype() {
        return zuotype;
    }

    public void setZuotype(int zuotype) {
        this.zuotype = zuotype;
    }

    public int getYoutype() {
        return youtype;
    }

    public void setYoutype(int youtype) {
        this.youtype = youtype;
    }

    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 getZuo() {
        return zuo;
    }

    public void setZuo(HeroNode zuo) {
        this.zuo = zuo;
    }

    public HeroNode getYou() {
        return you;
    }

    public void setYou(HeroNode you) {
        this.you = you;
    }

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


    public void qianxu(){
        System.out.println(this);//先输出父节点
        //递归向左子树前序遍历
        if(this.zuo!=null){
            this.zuo.qianxu();
        }

        //递归向右子树前序遍历
        if(this.you!=null){
            this.you.qianxu();
        }
    }


    public void zhongxu(){
        //先递归向左子树中序遍历
        if(this.zuo!=null){
            this.zuo.zhongxu();
        }

        //输出父节点
        System.out.println(this);

        //递归向右子树中序遍历
        if(this.you!=null){
            this.you.zhongxu();
        }
    }


    public void houxu(){
        if(this.zuo!=null){
            this.zuo.houxu();
        }

        if(this.you!=null){
            this.you.houxu();
        }

        System.out.println(this);
    }


}

代码实现效果如下：