数据结构与算法---线索化二叉树(Threaded BinaryTree)

先看一个问题

将数列 {1, 3, 6, 8, 10, 14 } 构建成一颗二叉树

问题分析:

当我们对上面的二叉树进行中序遍历时，数列为 {8, 3, 10, 1, 6, 14 }
但是 6, 8, 10, 14 这几个节点的左右指针，并没有完全的利用上.
如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点,怎么办?
解决方案-线索二叉树

线索二叉树基本介绍

1、n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）

2、这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种

3、一个结点的前一个结点，称为前驱结点

4、一个结点的后一个结点，称为后继结点

线索二叉树应用案例

应用案例说明：将下面的二叉树，进行中序线索二叉树。中序遍历的数列为 {8, 3, 10, 1, 14, 6}

思路分析: 中序遍历的结果：{8, 3, 10, 1, 14, 6}

说明: 当线索化二叉树后，Node节点的属性 left 和 right ，有如下情况:

left 指向的是左子树，也可能是指向的前驱节点. 比如 ① 节点 left 指向的左子树, 而 ⑩ 节点的 left 指向的就是前驱节点.
right指向的是右子树，也可能是指向后继节点，比如 ① 节点right 指向的是右子树，而⑩ 节点的right 指向的是后继节点.

代码实现：

 class BinaryTree {
 private HeroNode root;
 privateHeroNode pre=null;
 public void threadNodes() {
 threadNodes(root);
 }
 public void threadNodes(HeroNode node) {
 if(node==null) {
 return;
 }
 threadNodes(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;
 threadNodes(node.getRight());}}

代码

 public class BinaryTreeDemo {
 public static void main(String[] args) {
 BinaryTree binaryTree = new BinaryTree();
 HeroNode root = new HeroNode(1, "jack");
 HeroNode node1 = new HeroNode(3, "tom");
 HeroNode node2 = new HeroNode(6, "mike");
 
 root.setLeftNode(node1);
 root.setRightNode(node2);
 binaryTree.setRoot(root);
 
 HeroNode node3 = new HeroNode(8, "林冲");
 HeroNode node4 = new HeroNode(10, "关胜");
 node1.setLeftNode(node3);
 node1.setRightNode(node4);
 HeroNode node5 = new HeroNode(14, "jerry");
 node2.setLeftNode(node5);
 
 System.out.println("---中序---");
 binaryTree.infixOrder();
 //中序线索化二叉树
 binaryTree.threadNodes();
 
 HeroNode afterHeroNode10 = node4.getRight();
 System.out.println(afterHeroNode10);// no=1 name=jack ok了
 }}

测试

遍历线索化二叉树

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

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

 //遍历线索化二叉树的方法
     public void threadedList() {
         //定义一个变量，存储当前遍历的结点，从root开始
         HeroNode node = root;
         while(node != null) {
             //循环的找到leftType == 1的结点，第一个找到就是8结点
             //后面随着遍历而变化,因为当leftType==1时，说明该结点是按照线索化
             //处理后的有效结点
             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) {
         //测试一把中序线索二叉树的功能
         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);
 
         //测试中序线索化
         ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
         threadedBinaryTree.setRoot(root);
         threadedBinaryTree.threadedNodes();
 
         //测试: 以10号节点测试
         HeroNode leftNode = node5.getLeft();
         HeroNode rightNode = node5.getRight();
         System.out.println("10号结点的前驱结点是 ="  + leftNode); //
         System.out.println("10号结点的后继结点是="  + rightNode); //1
 
         //当线索化二叉树后，能在使用原来的遍历方法
         //threadedBinaryTree.infixOrder();
         System.out.println("使用线索化的方式遍历 线索化二叉树");
         threadedBinaryTree.threadedList(); // 8, 3, 10, 1, 14, 6
 
     }

测试