线索二叉树(基于链表存储树结点)

有以下场景

如果使用中序遍历，那么得到的顺序是：HDIBEAFCG，可以得知A的前驱结点为E，后继结点为F。但是，这种关系的获得是建立在完成遍历后得到的。如果我们每次想得到某个节点的前驱或者后继，都要先遍历整棵树，未免太过于麻烦了！我们为何不在生成该树的时候，就直接将结点的前驱后后继写入结点的属性中，提高在后续寻找前驱结点和后继结点的效率？这就是线索二叉树的由来。
首先，得先明确以下概念：

1.n个结点的二叉链表中含有n+1个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结
占的指针（这种附加的指针称为"线索"）
2.这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉(ThreadedBinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种。
3.一个结点的前一个结点，称为前驱结点
4.一个结点的后一个结点，称为后继结点
5.二叉树线索化时，通常规定，若左子树为空，令其左子节点=其前驱结点，若右子树为空，令其右子结点==其后继结点。
6.指向结点得前驱后者后继指针，便称为线索。
7.将二叉树以某种次序遍历使其变为线索二叉树的过程成为线索化

图中的虚线为线索

出现问题：

上面的双向链表，与线索化之后的二叉树相比，比如节点D与后继节点I，在完成线索化之后，并没有直接线索指针，而是存在父子节点的指针；节点A与节点F，在线索化完成之后，节点A并没有直接指向后继节点F的线索指针，而是通过父子节点遍历可以找到最终的节点F，前驱节点也存在同样的问题，正因为很多节点之间不存在直接的线索，所以我将此双向链表称做“特殊的双向链表”，再使用过程中根据指针是线索指针还是子节点指针来分别处理，所以在每个节点需要标明当前的左右指针是线索指针还是子节点指针，这就需要修改节点的数据结构，增加标志位。

isLeftThread为false时，指向左孩子，为ture时指向前驱
isRightThread为false时，指向右孩子，为ture时指向后继

添加后结点结构如下：

节点类：

//节点存储结构
static class Node {
    String data;        //数据域
    Node left;          //左指针域
    Node right;         //右指针域
    Node parent;        //父节点的指针（为了后序线索化使用）
    boolean isLeftThread = false;   //左指针域类型  false：指向子节点、true：前驱
    boolean isRightThread = false;  //右指针域类型  false：指向子节点、true：后继

    Node(String data) {
        this.data = data;
    }
}

添加标志位后的二叉树：

线索树代码：

/**
 * @Title: 二叉树相关操作
 * @Description：
 * @Author： Uncle Ming
 * @Date：2017年1月6日 下午2:49:14
 * @Version V1.0
 */
public class ThreadBinaryTree {

    private Node preNode;   //线索化时记录前一个节点

    //节点存储结构
    static class Node {
        String data;        //数据域
        Node left;          //左指针域
        Node right;         //右指针域
        boolean isLeftThread = false;   //左指针域类型  false：指向子节点、true：前驱或后继线索
        boolean isRightThread = false;  //右指针域类型  false：指向子节点、true：前驱或后继线索

        Node(String data) {
            this.data = data;
        }
    }

    /**
     * 通过数组构造一个二叉树（完全二叉树）
     * @param array
     * @param index
     * @return
     */
    static Node createBinaryTree(String[] array, int index) {
        Node node = null;

        if(index < array.length) {
            node = new Node(array[index]);
            node.left = createBinaryTree(array, index * 2 + 1);
            node.right = createBinaryTree(array, index * 2 + 2);
        }

        return node;
    }

    /**
     * 中序线索化二叉树
     * @param node  节点
     */
    void inThreadOrder(Node node) {
        if(node == null) {
            return;
        }

        //处理左子树
        inThreadOrder(node.left);

        //左指针为空,将左指针指向前驱节点
        if(node.left == null) {
            node.left = preNode;
            node.isLeftThread = true;
        }

        //前一个节点的后继节点指向当前节点
        if(preNode != null && preNode.right == null) {
            preNode.right = node;
            preNode.isRightThread = true;
        }
        preNode = node;

        //处理右子树
        inThreadOrder(node.right);
    }

    /**
     * 中序遍历线索二叉树，按照后继方式遍历（思路：找到最左子节点开始）
     * @param node
     */
    void inThreadList(Node node) {
        //1、找中序遍历方式开始的节点
        while(node != null && !node.isLeftThread) {
            node = node.left;
        }

        while(node != null) {
            System.out.print(node.data + ", ");

            //如果右指针是线索
            if(node.isRightThread) {
                node = node.right;

            } else {    //如果右指针不是线索，找到右子树开始的节点
                node = node.right;
                while(node != null && !node.isLeftThread) {
                    node = node.left;
                }
            }
        }
    }

    /**
     * 中序遍历线索二叉树，按照前驱方式遍历（思路：找到最右子节点开始倒序遍历）
     * @param node
     */
    void inPreThreadList(Node node) {
        //1、找最后一个节点
        while(node.right != null && !node.isRightThread) {
            node = node.right;
        }

        while(node != null) {
            System.out.print(node.data + ", ");

            //如果左指针是线索
            if(node.isLeftThread) {
                node = node.left;

            } else {    //如果左指针不是线索，找到左子树开始的节点
                node = node.left;
                while(node.right != null && !node.isRightThread) {
                    node = node.right;
                }
            }
        }
    }

    /**
     * 前序线索化二叉树
     * @param node
     */
    void preThreadOrder(Node node) {
        if(node == null) {
            return;
        }

        //左指针为空,将左指针指向前驱节点
        if(node.left == null) {
            node.left = preNode;
            node.isLeftThread = true;
        }

        //前一个节点的后继节点指向当前节点
        if(preNode != null && preNode.right == null) {
            preNode.right = node;
            preNode.isRightThread = true;
        }

        preNode = node;

        //处理左子树
        if(!node.isLeftThread) {
            preThreadOrder(node.left);
        }

        //处理右子树
        if(!node.isRightThread) {
            preThreadOrder(node.right);
        }
    }

    /**
     * 前序遍历线索二叉树（按照后继线索遍历）
     * @param node
     */
    void preThreadList(Node node) {
        while(node != null) {

            while(!node.isLeftThread) {
                System.out.print(node.data + ", ");
                node = node.left;
            }

            System.out.print(node.data + ", ");
            node = node.right;
        }
    }

    public static void main(String[] args) {
        String[] array = {"A", "B", "C", "D", "E", "F", "G", "H"};
        Node root = createBinaryTree(array, 0);

        ThreadBinaryTree tree = new ThreadBinaryTree();
        tree.inThreadOrder(root);
        System.out.println("中序按后继节点遍历线索二叉树结果：");
        tree.inThreadList(root);
        System.out.println("\n中序按后继节点遍历线索二叉树结果：");
        tree.inPreThreadList(root);

        Node root2 = createBinaryTree(array, 0);
        ThreadBinaryTree tree2 = new ThreadBinaryTree();
        tree2.preThreadOrder(root2);
        tree2.preNode = null;
        System.out.println("\n前序按后继节点遍历线索二叉树结果：");
        tree.preThreadList(root2);
    }
}

加上头结点

有时为了方便，模仿线性表的存储结构为了便于遍历线索二叉树，我们为其添加一个头结点，头结点左孩子指向原二叉树的根结点，右孩子指针指向中序遍历的最后一个结点。同时，将第一个结点左孩子指针指向头结点，最后一个结点的右孩子指针指向头结点。这好比为二叉树建立了一个双向线索链表，既可以从第一个结点起顺后继进行遍历，又可以从最后一个结点起顺前驱进行遍历。

小结

1. 线索化的实质就是将二叉链表中的空指针改为指向前驱节点或后继节点的线索；
2. 线索化的过程就是修改二叉链表中空指针的过程，可以按照前序、中序、后序的方式进行遍历，分别生成不同的线索二叉树；
3. 有了线索二叉树之后，我们再次遍历时，就相当于操作一个双向链表。
4. 使用场景：如果我们在使用二叉树过程中经常需要遍历二叉树或者查找节点的前驱节点和后继节点，可以考虑采用线索二叉树存储结构。

本文转载于