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

Posted justbobo

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了数据结构与算法---线索化二叉树(Threaded BinaryTree)相关的知识,希望对你有一定的参考价值。

先看一个问题

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

技术图片

问题分析:

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

 线索二叉树基本介绍

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 ,有如下情况:

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

代码实现:

技术图片
 1 class BinaryTree 
 2 private HeroNode root;
 3 privateHeroNode pre=null;
 4 public void threadNodes() 
 5 threadNodes(root);
 6 
 7 public void threadNodes(HeroNode node) 
 8 if(node==null) 
 9 return;
10 
11 threadNodes(node.getLeft());
12 if(node.getLeft()==null)
13 node.setLeft(pre);
14 node.setLeftType(1);
15 
16 if(pre!=null&&pre.getRight()==null) 
17 pre.setRight(node);
18 pre.setRightType(1); 
19 pre=node;
20 threadNodes(node.getRight());
代码
技术图片
 1 public class BinaryTreeDemo 
 2 public static void main(String[] args) 
 3 BinaryTree binaryTree = new BinaryTree();
 4 HeroNode root = new HeroNode(1, "jack");
 5 HeroNode node1 = new HeroNode(3, "tom");
 6 HeroNode node2 = new HeroNode(6, "mike");
 7 
 8 root.setLeftNode(node1);
 9 root.setRightNode(node2);
10 binaryTree.setRoot(root);
11 
12 HeroNode node3 = new HeroNode(8, "林冲");
13 HeroNode node4 = new HeroNode(10, "关胜");
14 node1.setLeftNode(node3);
15 node1.setRightNode(node4);
16 HeroNode node5 = new HeroNode(14, "jerry");
17 node2.setLeftNode(node5);
18 
19 System.out.println("---中序---");
20 binaryTree.infixOrder();
21 //中序线索化二叉树
22 binaryTree.threadNodes();
23 
24 HeroNode afterHeroNode10 = node4.getRight();
25 System.out.println(afterHeroNode10);// no=1 name=jack ok了
26 
测试

遍历线索化二叉树

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

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

技术图片
 1 //遍历线索化二叉树的方法
 2     public void threadedList() 
 3         //定义一个变量,存储当前遍历的结点,从root开始
 4         HeroNode node = root;
 5         while(node != null) 
 6             //循环的找到leftType == 1的结点,第一个找到就是8结点
 7             //后面随着遍历而变化,因为当leftType==1时,说明该结点是按照线索化
 8             //处理后的有效结点
 9             while(node.getLeftType() == 0) 
10                 node = node.getLeft();
11             
12             
13             //打印当前这个结点
14             System.out.println(node);
15             //如果当前结点的右指针指向的是后继结点,就一直输出
16             while(node.getRightType() == 1) 
17                 //获取到当前结点的后继结点
18                 node = node.getRight();
19                 System.out.println(node);
20             
21             //替换这个遍历的结点
22             node = node.getRight();
23             
24         
25     
代码
技术图片
 1 public static void main(String[] args) 
 2         //测试一把中序线索二叉树的功能
 3         HeroNode root = new HeroNode(1, "tom");
 4         HeroNode node2 = new HeroNode(3, "jack");
 5         HeroNode node3 = new HeroNode(6, "smith");
 6         HeroNode node4 = new HeroNode(8, "mary");
 7         HeroNode node5 = new HeroNode(10, "king");
 8         HeroNode node6 = new HeroNode(14, "dim");
 9         
10         //二叉树,后面我们要递归创建, 现在简单处理使用手动创建
11         root.setLeft(node2);
12         root.setRight(node3);
13         node2.setLeft(node4);
14         node2.setRight(node5);
15         node3.setLeft(node6);
16         
17         //测试中序线索化
18         ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
19         threadedBinaryTree.setRoot(root);
20         threadedBinaryTree.threadedNodes();
21         
22         //测试: 以10号节点测试
23         HeroNode leftNode = node5.getLeft();
24         HeroNode rightNode = node5.getRight();
25         System.out.println("10号结点的前驱结点是 ="  + leftNode); //3
26         System.out.println("10号结点的后继结点是="  + rightNode); //1
27         
28         //当线索化二叉树后,能在使用原来的遍历方法
29         //threadedBinaryTree.infixOrder();
30         System.out.println("使用线索化的方式遍历 线索化二叉树");
31         threadedBinaryTree.threadedList(); // 8, 3, 10, 1, 14, 6
32         
33     
测试

 

以上是关于数据结构与算法---线索化二叉树(Threaded BinaryTree)的主要内容,如果未能解决你的问题,请参考以下文章

数据结构与算法:树 线索化二叉树(中,前,后序)

数据结构与算法:树 线索化二叉树(中,前,后序)

数据结构与算法__07--前序中序后序线索化二叉树,前序中序后序线索化二叉树遍历(Java语言版本)

算法系列之线索化二叉树,前序线索化中序线索化后序线索化以及遍历~

C#数据结构-线索化二叉树

数据--第37课 - 线索化二叉树