java实现线索二叉树

1、节点

public class Node {
    private int id;
    private Node left;
    private Node right;
    //0-表示指向左子树，1-表示指向前驱节点
    private int leftType;
    //0-表示指向左子树，1-表示指向前驱节点
    private int rightType;
}

2、前序线索二叉树

public class PreThreadedBinaryTree {
    private Node root;  //根节点
    private Node pre;   //前驱节点

    /**
     * 前序线索化
     *
     * @param node
     */
    public void createThreadedBinaryTree(Node node) {
        //无法进行线索化，结束
        if (node == null)
            return;
        if (node.getLeft() == null) {
            //如果当前节点的左子树为空，将左子节点指向前驱节点
            node.setLeft(pre);
            node.setLeftType(1);
        }
        if (pre != null && pre.getRight() == null) {
            //如果前驱节点不为空，并且前驱节点的右子树为空，则将前驱节点的右子节点指向当前节点
            pre.setRight(node);
            pre.setRightType(1);
        }
        pre = node;
        if (node.getLeft() != null && node.getLeftType() == 0)
            //左子节点不为空，并且左子节点不是指向前驱节点
            createThreadedBinaryTree(node.getLeft());
        if (node.getRight() != null && node.getRightType() == 0)
            //右子节点不为空，并且右子节点不是指向后继节点
            createThreadedBinaryTree(node.getRight());
    }

    /**
     * 遍历线索化二叉树
     */
    public void preOder() {
        Node node = root;
        while (node != null) {
            System.out.println(node);
            while (node.getLeftType() == 0) {
                node = node.getLeft();
                System.out.println(node);
            }
            while (node.getRightType() == 1) {
                node = node.getRight();
                System.out.println(node);
            }
            if (node.getLeftType() == 0)
                node = node.getLeft();
            else
                node = node.getRight();
        }
    }
}

public static void main(String[] args) {
        Node node = new Node(1);
        Node node1 = new Node(2);
        Node node2 = new Node(3);
        Node node3 = new Node(4);
        Node node4 = new Node(5);
        Node node5 = new Node(6);
        Node node6 = new Node(7);
        PreThreadedBinaryTree pre = new PreThreadedBinaryTree();
        pre.root = node;
        node.setLeft(node1);
        node.setRight(node2);
        node1.setLeft(node3);
        node1.setRight(node4);
        node2.setLeft(node5);
        node2.setRight(node6);
        pre.createThreadedBinaryTree(pre.root);
        pre.preOder();
    }

3、中序线索二叉树

public class InThreadedBinaryTree {
    private Node root;  //根节点
    private Node pre;   //前驱节点

    /**
     * 中序线索化
     *
     * @param node
     */
    public void createThreadedBinaryTree(Node node) {
        //无法进行线索化，结束
        if (node == null)
            return;
        createThreadedBinaryTree(node.getLeft());
        if (node.getLeft() == null) {
            //如果当前节点的左子树为空，将左子节点指向前驱节点
            node.setLeft(pre);
            node.setLeftType(1);
        }
        if (pre != null && pre.getRight() == null) {
            //如果前驱节点不为空，并且前驱节点的右子树为空，则将前驱节点的右子节点指向当前节点
            pre.setRight(node);
            pre.setRightType(1);
        }
        pre = node;
        createThreadedBinaryTree(node.getRight());
    }

    /**
     * 遍历线索化二叉树
     */
    public void inOder() {
        Node node = root;
        while (node != null) {
            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();
        }
    }

    public static void main(String[] args) {
        Node node = new Node(1);
        Node node1 = new Node(2);
        Node node2 = new Node(3);
        Node node3 = new Node(4);
        Node node4 = new Node(5);
        Node node5 = new Node(6);
        Node node6 = new Node(7);
        InThreadedBinaryTree in = new InThreadedBinaryTree();
        in.root = node;
        node.setLeft(node1);
        node.setRight(node2);
        node1.setLeft(node3);
        node1.setRight(node4);
        node2.setLeft(node5);
        node2.setRight(node6);
        in.createThreadedBinaryTree(in.root);
        in.inOder();
    }
}

4、后序线索二叉树

public class PostThreadedBinaryTree {
    private Node root;  //根节点
    private Node pre;   //前驱节点

    /**
     * 后序线索化
     *
     * @param node
     */
    public void createThreadedBinaryTree(Node node) {
        //无法进行线索化，结束
        if (node == null)
            return;
        createThreadedBinaryTree(node.getLeft());
        createThreadedBinaryTree(node.getRight());
        if (node.getLeft() == null) {
            //如果当前节点的左子树为空，将左子节点指向前驱节点
            node.setLeft(pre);
            node.setLeftType(1);
        }
        if (pre != null && pre.getRight() == null) {
            //如果前驱节点不为空，并且前驱节点的右子树为空，则将前驱节点的右子节点指向当前节点
            pre.setRight(node);
            pre.setRightType(1);
        }
        pre = node;
    }

    public static void main(String[] args) {
        Node node = new Node(1);
        Node node1 = new Node(2);
        Node node2 = new Node(3);
        Node node3 = new Node(4);
        Node node4 = new Node(5);
        Node node5 = new Node(6);
        Node node6 = new Node(7);
        PostThreadedBinaryTree post = new PostThreadedBinaryTree();
        post.root = node;
        node.setLeft(node1);
        node.setRight(node2);
        node1.setLeft(node3);
        node1.setRight(node4);
        node2.setLeft(node5);
        node2.setRight(node6);
        post.createThreadedBinaryTree(post.root);
    }
}