韩顺平 数据结构与算法 （11_3） 树结构基础部分_线索化二叉树

线索化二叉树

1.引出：

Ps：中序遍历应该是{8，3，10，1，14，6}

2.基本介绍

注释：

​ 1） 例如二叉链表中的8节点，指向3或者1或者6…都是在该节点下的指针，也就是线索

​ 2）按照前序遍历方式加指针叫前序线索二叉树，同理中序线索二叉树、后序线索二叉树

​ 3）比如在{8，3，10，1，14，6}中，3的前驱是8，8没有前驱

​ 4）比如在{8，3，10，1，14，6}中，14的后继是6，6没有后继

3. 【建立】线索化二叉树

案例

建立线索化二叉树思路分析

4.【遍历】线索化二叉树

说明：对前面的中序线索化的二叉树进行遍历

思路分析：

​ 因为线索化后，各个节点的指向有所改变，所以原来的遍历方式不能使用，这时需要使用新的方式遍历线索化二叉树，各个节点可以通过线性方式遍历，因此无需使用递归方式，这样也提高了遍历的效率。遍历的次序应当和中序遍历保持一致

5.代码实现

package DataStructures.Tree.threadedbinaryTree;

public class ThreadedBinaryTree {
    public static void main(String[] args) {
        //测试中序线索二叉树的功能
        HeroNode root = new HeroNode(1, "Tom");
        HeroNode node2 = new HeroNode(3, "jack");
        HeroNode node3 = new HeroNode(6, "smith");
        HeroNode node4 = new HeroNode(8, "mary");
        HeroNode node5 = new HeroNode(10, "king");
        HeroNode node6 = new HeroNode(14, "dim");
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

        //测试线索化
        BinaryTree binaryTree = new BinaryTree();
        binaryTree.setRoot(root);
        binaryTree.threadedNodes();

        //以10号节点为例
        HeroNode leftNode = node5.getLeft();
        HeroNode rightNode = node5.getRight();
        System.out.println("10号节点的前驱节点是=" + leftNode);
        System.out.println("10号节点的后继节点是=" + rightNode);

        //线索化的方式遍历线索化二叉树
        System.out.println("线索化的方式遍历线索化二叉树");
        binaryTree.threadedList();//8->3->10->1->14->6
    }
}

//定义ThreadedBinaryTree实现了线索化功能的二叉树
class BinaryTree {
    private HeroNode root;
    //再递归进行线索化时，这个pre总是保留前一个节点
    private HeroNode pre = null;

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

    //重载
    public void threadedNodes() {
        this.threadedNodes(root);
    }

    //遍历线索化二叉树的方法
    public void threadedList() {
        //定义临时存储变量node
        HeroNode node = root;
        while (node != null) {
            //循环的找到leftType==1的节点，第一个找到的应该是8
            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();
        }
    }

    //建立中序线索化二叉树方法
    /**
     * @param node 当前需要线索化的节点
     */
    public void threadedNodes(HeroNode node) {
        //如果当前节点为空
        if (node == null) {
            return;
        }

        //(1)先线索化左子树
        threadedNodes(node.getLeft());
        //(2)线索化当前节点[有难度]
        /*先处理当前节点的前驱节点*/
        /*以8节点为例:8.left = null;8.letfType = 1*/
        if (node.getLeft() == null) {
            //让当前节点的左指针指向前驱节点
            node.setLeft(pre);
            //并且修改当前节点的左指针的类型,指向前驱节点
            node.setLeftType(1);
        }
        /*再处理后继节点*/
        if (pre != null && pre.getRight() == null) {
            pre.setRight(node);
            pre.setRightType(1);
        }
        //每处理一个节点后，让当前节点是下一个节点的前驱节点
        pre = node;
        //(3)再线索化右子树
        threadedNodes(node.getRight());
    }
}

//创建HeroNode
class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;
    //New
    //1. if(leftType==0),表示指向左子树，if(leftType==1)责表示指向前驱节点
    //2. if(rightType==0),表示指向右子树，if(righType==1)则表示指向后继节点
    private int leftType;
    private int rightType;

    public int getLeftType() {
        return leftType;
    }

    public int getRightType() {
        return rightType;
    }

    public void setLeftType(int leftType) {
        this.leftType = leftType;
    }

    public void setRightType(int rightType) {
        this.rightType = rightType;
    }

    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 HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

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