线索二叉树

线索二叉树

在以往介绍的二叉树的遍历中，不是用递归就是用堆栈或队列，本文将通过构建线索二叉树来简化对

二叉树遍历的实现。

1、线索二叉树的定义

按照某种遍历方式对二叉树进行遍历，可以把二叉树中所有节点排列成一个线性序列。在该序列中，

除第一个节点外，每个节点有且仅有一个直接前驱节点；除最后一个节点外，每个节点有且仅有一个

直接后继节点。但是，二叉树中每个节点在这个序列中的直接前驱节点和直接后继节点是什么，在二

叉树的存储结构中并没有反映出来，只能在对二叉树遍历的动态过程中得到这些信息。为了保留节点

在某种遍历序列中直接前驱和直接后继的位置信息，可以利用二叉树的二叉链表存储结构中的那些空

引用域来指示。这些指向直接前驱节点和指向直接后继节点的引用被称为线索（Thread），加了线索

的二叉树称为线索二叉树。线索二叉树将为二叉树的遍历提供许多方便。

2、线索二叉树的结构

一个具有n个节点的二叉树若采用二叉链表存储结构，共有2n个引用域，在2n个引用域中只有n-1个引

用域是用来存储孩子节点的引用，而另外n+1个引用域存放的都是空，因此，可以利用这些空引用域

存放线索。当节点的左孩子为空时（lchild == null）,用左引用域存储该节点在某种遍历序列中的直接

前驱节点的存储地址，当节点的右孩子为空时（rchild == null）,用右引用域存储该节点在某种遍历序

列中的直接后继节点的存储地址；对于那些非空的引用域，则仍然存放指向该节点左、右孩子的引

用，这样，就得到了一棵线索二叉树。由于序列可由不同的遍历方法得到，因此线索树有先序线索二

叉树、中序线索二叉树和后序线索二叉树三种。把二叉树改造成线索二叉树的过程称为线索化。

代码实现

package demo7;


public class ThreadedBinaryTree {

    ThreadedNode root;
    //用于临时存储前驱节点
    ThreadedNode pre=null;
    //设置根节点
    public void setRoot(ThreadedNode root){
        this.root = root;
    }

    //中序线索化二叉树
    public void threadNodes(){
        threadNodes(root);
    }

    public void threadNodes(ThreadedNode node){
        //当前节点如果为null，直接返回
        if(node==null){
            return;
        }
        //处理左子树
        threadNodes(node.leftNode);
        //处理前驱节点
        if(node.leftNode==null){
            //让当前节点的左指针指向前驱节点
            node.leftNode=pre;
            //改变当前节点左指针的类型
            node.leftType=1;
        }
        //处理前驱的右指针，如果前驱节点的右指针是null(没有指向右子树)
        if(pre!=null&&pre.rightNode==null){
            //让前驱节点的右指针指向当前节点
            pre.rightNode=node;
            //改变前驱节点的右指针类型
            pre.rightType=1;
        }

        //每处理一个节点，当前节点是下一个节点的前驱节点
        pre=node;
        //处理右子树
        threadNodes(node.rightNode);
    }

    //获取根节点
    public ThreadedNode getRoot(){
        return root;
    }

    public void frontShow() {
        if(root!=null){
            root.frontShow();
        }
    }

    public void midShow() {
        if(root!=null){
            root.midShow();
        }
    }

    public void afterShow() {
        if(root!=null){
            root.afterShow();
        }
    }


    public ThreadedNode preSearch(int i) {
        return root.preSearch(i);
    }

    public ThreadedNode midSearch(int i) {
        return root.midSearch(i);
    }

    public ThreadedNode afterSearch(int i) {
        return root.afterSearch(i);
    }

    public void delete(int i) {
        if(root.value==i){
            root = null;
        }else{
            root.delete(i);
        }
    }
}

package demo7;


public class ThreadedNode {
    //节点的权
    int value;
    //左儿子
    ThreadedNode leftNode;
    //右儿子
    ThreadedNode rightNode;
    //标识指针类型
    int leftType;
    int rightType;

    public ThreadedNode(int value){
        this.value = value;
    }

    //设置左儿子
    public void setLeftNode(ThreadedNode leftNode) {
        this.leftNode = leftNode;
    }

    //设置右儿子
    public void setRightNode(ThreadedNode rightNode) {
        this.rightNode = rightNode;
    }

    //前序遍历
    public void frontShow() {
        //先遍历当前节点的内容
        System.out.print(value+" ");
        //左节点
        if(leftNode!=null){
            leftNode.frontShow();
        }
        //右节点
        if(rightNode!=null){
            rightNode.frontShow();
        }
    }

    //中序遍历
    public void midShow() {
        //左节点
        if(leftNode!=null){
            leftNode.midShow();
        }
        //当前节点
        System.out.print(value+" ");
        //右节点
        if(rightNode!=null){
            rightNode.midShow();
        }
    }

    //后序遍历
    public void afterShow() {
        //左节点
        if(leftNode!=null){
            leftNode.afterShow();
        }
        //右节点
        if(rightNode!=null){
            rightNode.afterShow();
        }
        //当前节点
        System.out.print(value+" ");
    }

    //前序查找
    public ThreadedNode preSearch(int i) {
        ThreadedNode target = null;
        //对比当前节点的值
        if(this.value == i){
            return this;
        //当前节点的值不是要查找的节点
        }else{
            //查找左儿子
            if(leftNode!=null){
                //有可能可以查到，也可能查不到，查不到的话，target还是一个null
                target = leftNode.preSearch(i);
            }
            //如果不为空，说明在左儿子中已经找到
            if(target!=null){
                return target;
            }
            //查找右儿子
            if(rightNode!=null){
                target = rightNode.preSearch(i);
            }
        }
        return target;
    }

    //中序查找
    public ThreadedNode midSearch(int i) {
        ThreadedNode target = null;
        //查找左儿子
        if(leftNode!=null){
            //有可能可以查到，也可能查不到，查不到的话，target还是一个null
            target = leftNode.midSearch(i);
        }
        //如果不为空，说明在左儿子中已经找到
        if(target!=null){
            return target;
        }
        //对比当前节点的值
        if(this.value==i){
            return this;
        }
        //查找右儿子
        if(rightNode!=null){
            target = rightNode.midSearch(i);
        }
        return target;
    }

    //后序查找
    public ThreadedNode afterSearch(int i) {
        ThreadedNode target = null;
        //查找左儿子
        if(leftNode!=null){
            //有可能查到，有可能查不到，查不到的话，target还是一个null
            target = leftNode.afterSearch(i);
        }
        //如果不为null，说明在左儿子中已经找到
        if(target!=null){
            return target;
        }
        //查找右儿子
        if(rightNode!=null){
            target = rightNode.afterSearch(i);
        }
        //如果target不为空，说明在右儿子中已经找到
        if(target!=null){
            return target;
        }
        //对比当前节点的值
        if(this.value==i){
            return this;
        }
        return null;
    }

    //删除一个子树
    public void delete(int i) {
        ThreadedNode parent = this;
        //判断左儿子
        if(parent.leftNode!=null&&parent.leftNode.value==i){
            parent.leftNode=null;
            return;
        }
        //判断右儿子
        if(parent.rightNode!=null&&parent.rightNode.value==i){
            parent.rightNode=null;
            return;
        }
        //递归检查并删除左儿子
        parent = leftNode;
        if(parent!=null){
            parent.delete(i);
        }
        //递归检查并删除右儿子
        parent = rightNode;
        if(rightNode!=null){
            rightNode.delete(i);
        }
    }
}

package demo7;


public class TestThreadedBinaryTree {

    public static void main(String[] args) {
        //创建一棵树
        ThreadedBinaryTree threadBinaryTree = new ThreadedBinaryTree();
        //创建一个根节点
        ThreadedNode root = new ThreadedNode(1);
        //把根节点赋给树
        threadBinaryTree.setRoot(root);
        //创建一个左节点
        ThreadedNode rootL = new ThreadedNode(2);
        //把新创建的节点设置为根节点的子节点
        root.setLeftNode(rootL);
        //创建一个右节点
        ThreadedNode rootR = new ThreadedNode(3);
        //把新创建的节点设置为根节点的子节点
        root.setRightNode(rootR);
        //为第二层的左节点创建两个子节点
        rootL.setLeftNode(new ThreadedNode(4));
        ThreadedNode fiveNode = new ThreadedNode(5);
        rootL.setRightNode(fiveNode);
        //为第二层的右节点创建两个子节点
        rootR.setLeftNode(new ThreadedNode(6));
        rootR.setRightNode(new ThreadedNode(7));
//        //前序遍历树
//        System.out.print("前序遍历：");
//        threadBinaryTree.frontShow();
//        System.out.println();
//        //中序遍历树
//        System.out.print("中序遍历：");
//        threadBinaryTree.midShow();
//        System.out.println();
//        //后序遍历树
//        System.out.print("后序遍历：");
//        threadBinaryTree.afterShow();
//        System.out.println();
//        //前序查找
//        System.out.println("========================");
//        System.out.println("前序查找：");
//        ThreadedNode res1 = threadBinaryTree.preSearch(3);
//        System.out.println(res1);
//        //中序查找
//        System.out.println("中序查找：");
//        ThreadedNode res2 = threadBinaryTree.midSearch(5);
//        System.out.println(res2);
//        //后序查找
//        System.out.println("后序查找：");
//        ThreadedNode res3 = threadBinaryTree.afterSearch(3);
//        System.out.println(res3);
//        //删除一棵子树
//        System.out.println("删除节点前:");
//        threadBinaryTree.frontShow();
//        System.out.println();
//        System.out.println("删除节点后：");
//        threadBinaryTree.delete(4);
//        threadBinaryTree.frontShow();
        //中序线索化二叉树
        System.out.println();
        System.out.println("中序线索化二叉树：");
        threadBinaryTree.midShow();
        System.out.println();
        System.out.println("==============");
        threadBinaryTree.threadNodes();
        //获取5节点的后继节点
        ThreadedNode afterFive = fiveNode.rightNode;
        System.out.println(afterFive.value);
    }
}