线索二叉树的建立及其遍历访问操作

• 线索二叉树(中序)，建立、访问

对于线索二叉树有先序、中序、后序三种，但是只有中序线索二叉树才能获得任意节点的前驱和后继节点（实际上二叉树任意节点的访问均是访问的某一棵树的根节点），那么只有中序遍历生成的中序线索二叉树是先访问左子树，根节点，右子树，而先序线索二叉树，是先访问根节点，所以只能从先序线索二叉树中得到节点的后继结点，同理只能从后序线索二叉树得到节点的前驱结点（最后访问根节点）。

package ccnu.offer.tree;

public class Demo03 {
    static ThreadNode pre = null;

    public static void main(String[] args) {
        ThreadNode root = createBiTreeByPreIn(new int[]{1, 2, 4, 3, 5}, new int[]{2, 4, 1, 5, 3}, 0, 0, 5);
        ThreadNode inRoot = createInThreadBiTree(root);
        inOrder(inRoot);
        System.out.println();
        inOrderByReverse(inRoot);
    }

    public static ThreadNode createBiTreeByPreIn(int[] pre, int[] in, int preBegin, int inBegin, int len){
        if(pre == null || in == null || pre.length != in.length || pre.length == 0 || in.length == 0){
            return null;
        }
        if(len <= 0){
            return null;
        }
        ThreadNode root = new ThreadNode(pre[preBegin]);
        int rootIndex;
        for(rootIndex = 0; in[rootIndex] != pre[preBegin]; rootIndex++);
        root.lchild = createBiTreeByPreIn(pre, in, preBegin + 1, inBegin, rootIndex - inBegin);
        root.rchild = createBiTreeByPreIn(pre, in, preBegin + (rootIndex - inBegin) + 1, rootIndex + 1, len - (rootIndex - inBegin) - 1);
        return root;
    }

    public static ThreadNode createInThreadBiTree(ThreadNode root){
//      ThreadNode pre = null;
        if(root != null){
            inThreadBiTree(root);
            pre.rtag = 1; // pre指向中序遍历的最后一个节点
            pre.rchild = null; // 没有后继节点
        }
        return root;
    }

    public static void inThreadBiTree(ThreadNode root){
        if(root != null){
            inThreadBiTree(root.lchild); // 第一步：线索化当前root的左子树
            // 第二步：访问当前root节点,如果当前root节点的左孩子为空，那么root的lchild就应该指向其中序序列前驱结点，同时如果root的前一个访问节点(中序序列)pre的rchild为空，那么pre的rchild就应该指向当前root
            if(root.lchild == null){
                root.ltag = 1; // root的lchild指向root的中序遍历前驱结点
                root.lchild = pre; // 当前节点的中序遍历前驱结点为中序遍历中的上一个访问的节点
            }
            if(pre != null && pre.rchild == null){ // pre != null 因为第一个访问节点没有前驱
                pre.rtag = 1; // 中序遍历上一个访问的节点pre指向其中序遍历的后继节点,即当前节点root
                pre.rchild = root;
            }
            pre = root; // 将刚才访问的节点保存，注意访问最后一个节点时，pre会指向它
            inThreadBiTree(root.rchild); // 第三步：线索化当前root的右子树
        }
    }

    public static void inOrder(ThreadNode root){ // 中序线索二叉树中序遍历
        if(root == null){
            return;
        }
        ThreadNode firstNode = firstNode(root);
        ThreadNode p = firstNode;
        while(p != null){
            System.out.print(p.data + " ");
            p = nextNode(p);
        }
    }

    public static void inOrderByReverse(ThreadNode root){
        if(root == null){
            return;
        }
        ThreadNode lastNode = lastNode(root);
        ThreadNode p = lastNode;
        while(p != null){
            System.out.print(p.data + " ");
            p = previousNode(p);
        }
    }

    public static ThreadNode firstNode(ThreadNode root){ // 得到中序遍历序列(以root作为根节点的树)的第一个节点--->没有左孩子的root子树就是中序序列的第一个节点
        if(root == null){
            return null;
        }
        while(root.ltag == 0){ // 存在左孩子
            root = root.lchild;
        }
        return root;
    }

    public static ThreadNode lastNode(ThreadNode root){ // 得到中序遍历序列(以root作为根节点的树)的最后一个节点--->没有右孩子的root子树就是中序序列的最后一个节点
        if(root == null){
            return null;
        }
        while(root.rtag == 0){ // root.rtag == 0不等价于root.rchild != null(不一定存在右孩子),因为rchild可能指向其后继节点
            root = root.rchild;
        }
        return root; // 
    }

    public static ThreadNode previousNode(ThreadNode p){
        if(p == null){
            return null;
        }
        if(p.ltag == 0){ // p存在左孩子
            return lastNode(p.lchild);
        }else{ // 没有左孩子
            return p.lchild; // lchild直接指向其前驱结点
        }
    }

    public static ThreadNode nextNode(ThreadNode p){ // 得到p节点的中序遍历序列的后继节点
        if(p == null){
            return null;
        }
        if(p.rtag == 0){ // 存在右孩子,那么找到p的后继节点等价于找到p.rchild的中序遍历的第一个节点
            return firstNode(p.rchild);
        }else{ // 木有右孩子，那么p节点的rchild直接就指向其后继节点
            return p.rchild;
        }
    }

    private static class ThreadNode{
        private int data;
        private int ltag = 0; // 默认lchild指向左孩子
        private int rtag = 0; // 默认rchild指向右孩子
        private ThreadNode lchild = null;
        private ThreadNode rchild = null;

        public ThreadNode(int data){
            this.data = data;
        }
    }
}