码迷,mamicode.com
首页 > 其他好文 > 详细

树——二叉树的线索化

时间:2019-05-26 15:50:13      阅读:109      评论:0      收藏:0      [点我收藏+]

标签:一起   pre   方式   顺序   推荐   ima   ret   dash   线性   

1,什么是线索化二叉树?

       1,将二叉树转换为双向链表的过程(非线性 ==> 线性);

              1,实际工程开发中,很大一部分情况下,二叉树一旦建立之后,就不会轻易改动,一般的用于遍历,并且这种操作一般执行很多;

              2,先中后序遍历都是递归完成的,实际工程开发中,对一棵已经建立的二叉树反复执行先序遍历,效率低,所以不推荐反复的递归的遍历;

              3,直接将遍历后的结果保存下来,下一次遍历直接用这个结果就可以;

              4,工程开发中还有一种常见情况,就是要反复的知道某个结点在中序遍历下,前驱结点是谁、后继结点是谁,需要这三个结点一起来判断是否要执行后续的操作,这个时候也需要遍历、反复多次;

              5,因此线性化二叉树就被创建出来,高效访问;

       2,能够反映某种二叉树的遍历次序(结点的先后访问次序):

              1,利用结点的 right 指针指向遍历(某种遍历)中的后继结点;

              2,利用结点的 left 指针指向遍历(某种遍历)中的前驱结点;

             

2,如何对二叉树进行线索化?

       1,思维过程:

 技术图片

 

3,二叉树的线索化:

技术图片 

       1,用traversal() 函数把树结点放到队列中,然后通过connect() 函数将right 指针指向后继,left 指针指向前驱;

             

4,课程目标:

       1,新增(在“树——二叉树的先序、中序和后续中”已经重构并存在了)功能函数 traversal(order, queue);

              1,按照某种方式对二叉树进行遍历,并将遍历时结点访问的先后次序保存在 queue 中;

       2,新增遍历方式 BTTraversal::LevelOrder;

              1,在 traversal(order, queue)中新增层次遍历;

       3,新增共有函数 BTreeNode<T>* thread(BTTraversal order);

              1,用于根据遍历次序 order 执行线索化,线索化后结果为指向双向链表首元素的指针;

       4,消除遍历和线索化的代码冗余(代码重构);

 

5,遍历功能函数代码实现:

 1    /* 遍历的功能函数,第二个参数用于保存访问时,结点的先后顺序 */
 2     void traversal(BTTraversal order, LinkQueue<BTreeNode<T>*>& queue)
 3     {
 4         switch(order)
 5         {
 6             case PreOrder:
 7                 PreOrderTraversal(root(), queue);
 8                 break;
 9             case InOrder:
10                 inOrderTraversal(root(), queue);
11                 break;
12             case PostOrder:
13                 postOrderTraversal(root(), queue);
14                 break;
15             case LevelOrder:
16                 levelOrderTraversal(root(), queue);
17                 break;
18             default:
19                 THROW_EXCEPTION(InvalidParameterException, "Parameter order is invalid ...");
20                 break;
21         }
22     }

 

6,层次遍历算法小结:

       1,将根结点压入队列中;

       2,访问队头元素指向的二叉树结点;

       3,队头元素弹出,将队头元素的孩子压入队列中;

       4,判断队列是否为空(非空:转 2,空:结束);

      

7,层次遍历算法示例:

技术图片

 

8,层次遍历算法流程:

 技术图片

 

9,实现见代码;

 1    /* 实现层次遍历算法 */
 2     void levelOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue)
 3     {
 4         if( node != NULL )  // 树不为空
 5         {
 6             LinkQueue<BTreeNode<T>*> tmp;  // 创造辅助队列
 7             tmp.add(node);  // 先将根结点压入队列
 8 
 9             while( tmp.length() > 0 )
10             {
11                 BTreeNode<T>* n = tmp.front();  // 拿到 tmp 头部结点
12 
13                 if( n->left != NULL )
14                 {
15                     tmp.add(n->left);
16                 }
17 
18                 if( n->right != NULL )
19                 {
20                     tmp.add(n->right);
21                 }
22 
23                 tmp.remove();  // 移动 tmp 头部的结点
24 
25                 queue.add(n);  // 保存遍历结果
26             }
27         }
28     }

 

10,函数接口设计:

       1,BTreeNode<T>* thread(BTTraversal order)

              1,根据参数 order 选择线索化的次序(先序,中序,后序,层次);

              2,返回值线索化之后指向链表首结点的指针;

                     1,既然要不停地访问,为何不用顺序表而要用链表?

              3,线索化执行结束后对应的二叉树变为空树;

                     1,二叉树中的结点已经被从排列为一个线性链表了,二叉树也就不存在了,所以要变为空树;

                    

11,线索化流程:

 技术图片

 

12,队列中结点的连接算法(connect(queue)):

技术图片 

 

13,连接算法的代码实现:

 
 1    /* 将 queue 队列中结点连接成双向链表,并返回双向链表首地址 */
 2     BTreeNode<T>* connect(LinkQueue<BTreeNode<T>*>& queue)
 3     {
 4         BTreeNode<T>* ret = NULL;
 5         if( queue.length() > 0 )  // 对列不为空
 6         {
 7             ret = queue.front();  // 返回头结点
 8             BTreeNode<T>* slider = queue.front();  // 辅助指针指向对列头结点
 9             queue.remove();  // 被指向后头结点出队列
10             slider->left = NULL;  // 链表头结点指向空
11             while( queue.length() > 0 )  // 链接所有结点,就像树一样、将指针重新指定好后,就能够完成相应的容器设计了;
12             {
13                 slider->right = queue.front();
14                 queue.front()->left = slider;
15                 slider = queue.front();  // 移动 slider 指针,指向头结点;要不然就最后只有首尾两个结点了,这点很重要;
16                 queue.remove();  // 被指向后头结点出队列
17             }
18             slider->right = NULL;  // 双向链表最后一个结点指向空,不然这个双向链表就是有问题的;
19         }
20         return ret;
21     }

 

14,二叉树的线索化:

 1    /* 线索化,二叉树变为线性链表 */
 2     BTreeNode<T>* thread(BTTraversal order)
 3     {
 4         BTreeNode<T>* ret = NULL;  // 定义返回值
 5         LinkQueue<BTreeNode<T>*> queue;  // 先定义对列
 6         traversal(order, queue);  // 遍历,后将结果放在 queue 对列中
 7         ret = connect(queue);  // 将对列中的结点链接,并返回链表首结点
 8         this->m_root = NULL;  // 结点变为链表了,树不存在了,直接置为空树;每一个成员函数后,都要考虑成员变量的属性值,这很重要!
 9         m_queue.clear();  // 上面的树发生了变化,则清空树,否则组合函数执行的有问题
10         return ret;
11     }

 

15,小结:

       1,线索化是将二叉树转换为双向链表的过程;

       2,线索化之后结点间的先后次序符合某种遍历次序;

       3,线索化操作将破坏原二叉树结点间的父子关系;

              1,重新组织结点,使结点间的非线性关系变为线性关系;

       4,线索化之后二叉树将不在管理结点的生命期;

              1,二叉树已经不存在了,成为空树了;

              2,对线索化之后的双向链表进行生命期管理,比如不需要的时候对双向链表进行释放,每个结点都释放,摧毁它;

树——二叉树的线索化

标签:一起   pre   方式   顺序   推荐   ima   ret   dash   线性   

原文地址:https://www.cnblogs.com/dishengAndziyu/p/10926140.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!