鱼C论坛

 找回密码
 立即注册
查看: 288|回复: 1

[学习笔记] 中序穿线二叉树

[复制链接]
最佳答案
11 
发表于 2018-5-10 16:29:51 | 显示全部楼层 |阅读模式

马上注册加入鱼C,享用更多服务吧^_^

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
《数据结构C++描述》 清华大学出版社    任燕编著
小弟学习一下中序穿线二叉树,发现里面有很多的方法都和普通的二叉树有所不同,
比如遍历,删除结点等方法都和普通二叉树的方法有较大差异,同时小弟也是改正了书上类模板程序中一个方法的bug
还请大神指教,加油!!!
  1. #include <iostream>
  2. #include <cstdlib>
  3. #include <assert.h>
  4. #include <cstdbool>
  5. using namespace std;

  6. typedef enum PointerTag{ LINK, THREAD };                                //相当于LINK = 0,THREAD = 1

  7. template <typename elemtype>
  8. class ThreadTree{
  9. public:
  10.         //中序穿线二叉树(二叉链表存储)结点的数据结构C++类定义
  11.         class ThreadTNode{
  12.         public:
  13.                 //这里的构造函数已经给赋值ltag = LINK和rtag = LINK,所以接下来
  14.                 //线索话操作只管THREAD赋值即可
  15.                 ThreadTNode() :ltag(LINK), left(NULL), rtag(LINK), right(NULL){};
  16.                 ~ThreadTNode(){};
  17.         public:
  18.                 elemtype data;                                                                        //数据域
  19.                 class ThreadTNode *left, *right;                                //左右指针域
  20.                 PointerTag ltag, rtag;                                                        //左右指针标记
  21.         };
  22.         typedef ThreadTNode* NodePointer;                                        //指向结点的指针类型声明

  23. public:
  24.         //中序穿线二叉树置空
  25.         void clear();
  26.         //中序穿线二叉树置空辅助函数
  27.         void clear_aux(NodePointer p);


  28.         //递归求中序穿线二叉树的深度
  29.         int depth();
  30.         //递归求中序穿线二叉树的深度的辅助函数
  31.         int depth_aux(NodePointer p);


  32.         //取中序穿线二叉树的根指针
  33.         NodePointer getRoot();


  34.         //中序遍历中序穿线二叉树
  35.         void inOrderTraverse_ThreadTree();
  36.         //中序遍历中序穿线二叉树的辅助函数
  37.         void inOrderTraverse_ThreadTree_aux(NodePointer p);


  38.         //判断是否为空
  39.         bool isEmpty();


  40.         //生成中序穿线二叉树
  41.         void CreateThreadTree();
  42.         //生成中序穿线二叉树的辅助函数
  43.         void CreateThreadTree_aux(NodePointer &p);


  44.         //中序穿线二叉树穿线操作
  45.         void seqToThreadTree();
  46.         //中序穿线二叉树穿线操作的辅助函数
  47.         void seqToThreadTree_aux(NodePointer &p);


  48.         //找指定结点中序的前驱
  49.         bool searchPriorNode(elemtype key, elemtype& prior);


  50.         //找指定结点中序的后继
  51.         bool searchNextNode(elemtype key, elemtype& next);


  52.         //找指定结点
  53.         bool searchNode(elemtype key, NodePointer &p);

  54.         //中序穿线二叉树构造函数重载
  55.         ThreadTree();

  56.         //析构函数
  57.         ~ThreadTree();
  58. private:
  59.         NodePointer root;
  60. };

  61. //取二叉树的根指针
  62. template <typename elemtype>
  63. typename ThreadTree<elemtype>::NodePointer ThreadTree<elemtype>::getRoot(){
  64.         return root;
  65. }



  66. //中序穿线二叉树构造函数重载
  67. template <typename elemtype>
  68. ThreadTree<elemtype>::ThreadTree(){
  69.         root = NULL;
  70. }


  71. //创建中序穿线二叉树
  72. template <typename elemtype>
  73. void ThreadTree<elemtype>::CreateThreadTree(){
  74.         CreateThreadTree_aux(root);
  75. }

  76. //创建中序穿线二叉树的辅助函数
  77. template <typename elemtype>
  78. void ThreadTree<elemtype>::CreateThreadTree_aux(NodePointer &p){
  79.         elemtype value;
  80.         cout << "请输入结点的值(输入零代表叶子的终结):";
  81.         cin >> value;
  82.         if (value == 0){
  83.                 p = NULL;
  84.         }
  85.         else{
  86.                 p = new ThreadTNode;
  87.                 assert(p != 0);
  88.                 p->data = value;
  89.                 CreateThreadTree_aux(p->left);
  90.                 CreateThreadTree_aux(p->right);
  91.         }
  92. }


  93. //删除中序穿线二叉树
  94. template <typename elemtype>
  95. void ThreadTree<elemtype>::clear(){
  96.         clear_aux(root);
  97. }

  98. //删除中序穿线二叉树的辅助函数
  99. template <typename elemtype>
  100. void ThreadTree<elemtype>::clear_aux(NodePointer p){
  101.         if (p){
  102.                 if (p->ltag == LINK){
  103.                         clear_aux(p->left);
  104.                 }
  105.                 if (p->rtag == LINK){
  106.                         clear_aux(p->right);
  107.                 }
  108.                 delete p;
  109.                 cout << "删除结点..." << endl;
  110.         }
  111. }

  112. //析构函数
  113. template <typename elemtype>
  114. ThreadTree<elemtype>::~ThreadTree(){
  115.         clear();
  116.         root = NULL;                                //根指针置空
  117. }


  118. //中序遍历中序穿线二叉树
  119. template <typename elemtype>
  120. void ThreadTree<elemtype>::inOrderTraverse_ThreadTree(){
  121.         inOrderTraverse_ThreadTree_aux(root);
  122. }

  123. //中序遍历中序穿线二叉树操作
  124. template <typename elemtype>
  125. void ThreadTree<elemtype>::inOrderTraverse_ThreadTree_aux(NodePointer p){
  126.         while (p){
  127.                 //首先沿着其左子树的左指针向下滑动,直到某结点有左线索为止
  128.                 while (p->ltag == LINK){
  129.                         p = p->left;
  130.                 }
  131.                 //访问该结点
  132.                 cout << p->data << "\t";
  133.                 //如果该结点有右线索,那么沿着右线索一直往上爬,访问右线索上的每一个结点
  134.                 //直到某结点不再是右线索,而有右指针为止
  135.                 while (p->rtag == THREAD && p->right){
  136.                         p = p->right;
  137.                         cout << p->data << "\t";
  138.                 }
  139.                 //进入右子树
  140.                 p = p->right;
  141.         }
  142. }




  143. //递归求二叉树深度
  144. template <typename elemtype>
  145. int ThreadTree<elemtype>::depth(){
  146.         return depth_aux(root);
  147. }

  148. //求二叉树深度的辅助函数
  149. template <typename elemtype>
  150. int ThreadTree<elemtype>::depth_aux(NodePointer p){
  151.         int lDep, rDep;                                //预存放左右子树的深度
  152.         if (!p){
  153.                 return 0;
  154.         }
  155.         else{
  156.                 if (p->ltag == LINK){                                                //如果指针p不为空且所指向的结点有左指针
  157.                         lDep = depth_aux(p->left);                                //那么用左指针自递归求左子树的深度
  158.                 }
  159.                 else{                                                                                //如果指针p不为空且所指结点有左线索
  160.                         lDep = 0;                                                                //其左子树的深度为0
  161.                 }
  162.                 if (p->rtag == LINK){                                                //如果指针p不为空且所指向的结点有右指针
  163.                         rDep = depth_aux(p->right);                                //那么用右指针自递归求左子树的深度
  164.                 }
  165.                 else{                                                                                //如果指针p不为空且所指结点有右线索
  166.                         rDep = 0;                                                                //其右子树的深度为0
  167.                 }

  168.                 return (lDep > rDep ? lDep : rDep) + 1;
  169.         }
  170. }



  171. //中序穿线二叉树的穿线操作
  172. template <typename elemtype>
  173. void ThreadTree<elemtype>::seqToThreadTree(){
  174.         seqToThreadTree_aux(root);
  175. }

  176. //中序穿线二叉树穿线操作的辅助函数
  177. template <typename elemtype>
  178. void ThreadTree<elemtype>::seqToThreadTree_aux(NodePointer &p){
  179.         //当前结点按中序遍历的前驱的指针,初始化为空
  180.         static NodePointer pre = NULL;

  181.         if (p){
  182.                 //如果当前结点不为空,那么对以其为根的子树进行中序穿线
  183.                 //用当前结点的left自递归,完成左子树的线索化
  184.                 seqToThreadTree_aux(p->left);
  185.                 if (!p->left){
  186.                         //如果当前结点的left为空,那将其作为中序的前驱线索
  187.                         p->ltag = THREAD;
  188.                         p->left = pre;
  189.                 }
  190.                 if (pre&&!pre->right){
  191.                         //如果当前结点按中序遍历的前驱的right为空,那么将其用作中序的后继线索
  192.                         pre->rtag = THREAD;
  193.                         pre->right = p;
  194.                 }
  195.                 pre = p;                                //更新当前结点按照中序遍历的前驱指针

  196.                 //用当前结点的right自递归,完成右子树的线索化
  197.                 seqToThreadTree_aux(p->right);

  198.         }
  199.         if (p == root){
  200.                 //如果当前结点等于根节点,那么完成了所有结点的中序穿线
  201.                 //最后一个结点的右标记标注为线索,且右线索设置为空
  202.                 //当前结点按照中序遍历前驱的指针置空,以便再次调用此函数做线索化
  203.                 if (pre){
  204.                         pre->rtag = THREAD;
  205.                         pre->right = NULL;
  206.                 }
  207.                 pre = NULL;
  208.         }
  209. }

  210. //找指定结点
  211. template <typename elemtype>
  212. bool ThreadTree<elemtype>::searchNode(elemtype key, NodePointer &p){
  213.         p = root;
  214.         while (p){
  215.                 while (p->ltag == LINK){
  216.                         p = p->left;
  217.                 }
  218.                 //判断该结点的数据域是否等于要查找的值
  219.                 if (p->data == key){
  220.                         return true;
  221.                 }
  222.                 //如果该节点有右线索,则沿着右线索一直向上爬,知道某节点出现右指针为止
  223.                 //判断右结点上每个结点的数据域是否和key值相等
  224.                 while (p->rtag == THREAD && p->right){
  225.                         p = p->right;
  226.                         if (p->data == key){
  227.                                 return true;
  228.                         }
  229.                 }
  230.                 //进入右子树
  231.                 p = p->right;
  232.         }

  233.         return false;
  234. }

  235. //找指定结点的前驱
  236. template <typename elemtype>
  237. bool ThreadTree<elemtype>::searchPriorNode(elemtype key, elemtype &prior){
  238.         NodePointer p;                                                        //预指向待查节点的指针
  239.         if (searchNode(key, p)){                                //此时这里已经有p的地址了
  240.                 if (p->ltag == THREAD){                       
  241.                         if (!p->left){
  242.                                 return false;
  243.                         }
  244.                         else{
  245.                                 prior = p->left->data;
  246.                         }
  247.                 }
  248.                 else{
  249.                         p = p->left;
  250.                         while (p->rtag == LINK){
  251.                                 p = p->right;
  252.                         }
  253.                         prior = p->data;
  254.                 }
  255.         }
  256.         return true;
  257. }


  258. //找指定结点中序的后继
  259. template <typename elemtype>
  260. bool ThreadTree<elemtype>::searchNextNode(elemtype key, elemtype& next){
  261.         NodePointer p;
  262.         if (searchNode(key, p)){
  263.                 if (p->rtag == THREAD){
  264.                         if (!p->right){
  265.                                 return false;
  266.                         }
  267.                         else{
  268.                                 next = p->right->data;
  269.                         }
  270.                 }
  271.                 else{
  272.                         p = p->right;
  273.                         while (p->ltag == LINK){
  274.                                 p = p->left;
  275.                         }
  276.                         next = p->data;
  277.                 }
  278.         }
  279.         return true;
  280. }



  281. int main(void){
  282.         ThreadTree<int> tt1;
  283.         tt1.CreateThreadTree();                                //创建中序穿线二叉树框架
  284.         tt1.seqToThreadTree();                                //穿线操作
  285.         tt1.inOrderTraverse_ThreadTree();
  286.         cout << endl;
  287.         cout << "深度为:" << endl;
  288.         cout << tt1.depth() << endl;

  289.         cout << "请输入要查找的指定结点的值:";
  290.         int key;
  291.         cin >> key;

  292.         ThreadTree<int>::NodePointer p = tt1.getRoot();                //获取root指针

  293.         if (tt1.searchNode(key, p)){
  294.                 cout << "有这个结点" << endl;
  295.                 cout << "其中序前驱的值是:";
  296.                 int prior;
  297.                 tt1.searchPriorNode(key, prior);
  298.                 cout << prior << endl;

  299.                 cout << "其中序后继的值是:";
  300.                 int next;
  301.                 tt1.searchNextNode(key, next);
  302.                 cout << next << endl;
  303.         }

  304.         return 0;
  305. }
复制代码
最佳答案
11 
 楼主| 发表于 2018-5-10 21:01:29 | 显示全部楼层
中序穿线二叉树原来在线索化过程中结点指针指向变了,所以进行中序遍历的时候要用线索来循环遍历,在删除结点的时候也要用线索,线索化完成后二叉树全部指针域只有两个是空,一个是中序遍历开始结点左指针区域指向为空,另一个是中序遍历最后一个结点右指针域为空,怪不得要是线索化完成后按照普通的二叉树中序自递归遍历会无限递归爆栈
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

关闭

小甲鱼强烈推荐上一条 /1 下一条

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号

GMT+8, 2018-8-20 13:21

Powered by Discuz! X3.4

© 2001-2017 Comsenz Inc.

快速回复 返回顶部 返回列表