线索二叉树生成及其遍历

合集下载

数据结构实验五(二叉树的建立及遍历)题目和源程序

实验5：二叉树的建立及遍历（第十三周星期三7、8节）一、实验目的1．学会实现二叉树结点结构和对二叉树的基本操作。

2．掌握对二叉树每种操作的具体实现，学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。

二、实验要求1．认真阅读和掌握和本实验相关的教材内容。

2．编写完整程序完成下面的实验内容并上机运行。

3．整理并上交实验报告。

三、实验内容1．编写程序任意输入二叉树的结点个数和结点值，构造一棵二叉树，采用三种递归遍历算法(前序、中序、后序)对这棵二叉树进行遍历并计算出二叉树的高度。

2 .编写程序生成下面所示的二叉树，并采用中序遍历的非递归算法对此二叉树进行遍历。

四、思考与提高1．如何计算二叉链表存储的二叉树中度数为1的结点数？2．已知有—棵以二叉链表存储的二叉树，root指向根结点，p指向二叉树中任一结点，如何求从根结点到p所指结点之间的路径?/*----------------------------------------* 05-1_递归遍历二叉树.cpp -- 递归遍历二叉树的相关操作* 对递归遍历二叉树的每个基本操作都用单独的函数来实现* 水上飘2009年写----------------------------------------*/// ds05.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include <iostream>typedef char ElemType;using namespace std;typedef struct BiTNode {ElemType data;//左右孩子指针BiTNode *lchild, *rchild;}BiTNode, *BiTree;//动态输入字符按先序创建二叉树void CreateBiTree(BiTree &T) {char ch;ch = cin.get();if(ch == ' ') {T = NULL;}else {if(ch == '\n') {cout << "输入未结束前不要输入回车，""要结束分支请输入空格！" << endl;}else {//生成根结点T = (BiTNode * )malloc(sizeof(BiTNode));if(!T)cout << "内存分配失败！" << endl;T->data = ch;//构造左子树CreateBiTree(T->lchild);//构造右子树CreateBiTree(T->rchild);}}}//输出e的值ElemType PrintElement(ElemType e) { cout << e << " ";return e;}//先序遍历void PreOrderTraverse(BiTree T) { if (T != NULL) {//打印结点的值PrintElement(T->data);//遍历左孩子PreOrderTraverse(T->lchild);//遍历右孩子PreOrderTraverse(T->rchild);}}//中序遍历void InOrderTraverse(BiTree T) {if (T != NULL) {//遍历左孩子InOrderTraverse(T->lchild);//打印结点的值PrintElement(T->data);//遍历右孩子InOrderTraverse(T->rchild);}}//后序遍历void PostOrderTraverse(BiTree T) { if (T != NULL) {//遍历左孩子PostOrderTraverse(T->lchild);//遍历右孩子PostOrderTraverse(T->rchild);//打印结点的值PrintElement(T->data);}}//按任一种遍历次序输出二叉树中的所有结点void TraverseBiTree(BiTree T, int mark) {if(mark == 1) {//先序遍历PreOrderTraverse(T);cout << endl;}else if(mark == 2) {//中序遍历InOrderTraverse(T);cout << endl;}else if(mark == 3) {//后序遍历PostOrderTraverse(T);cout << endl;}else cout << "选择遍历结束！" << endl;}//输入值并执行选择遍历函数void ChoiceMark(BiTree T) {int mark = 1;cout << "请输入，先序遍历为1，中序为2，后序为3，跳过此操作为0：";cin >> mark;if(mark > 0 && mark < 4) {TraverseBiTree(T, mark);ChoiceMark(T);}else cout << "此操作已跳过！" << endl;}//求二叉树的深度int BiTreeDepth(BiTNode *T) {if (T == NULL) {//对于空树，返回0并结束递归return 0;}else {//计算左子树的深度int dep1 = BiTreeDepth(T->lchild);//计算右子树的深度int dep2 = BiTreeDepth(T->rchild);//返回树的深度if(dep1 > dep2)return dep1 + 1;elsereturn dep2 + 1;}}int _tmain(int argc, _TCHAR* argv[]){BiTNode *bt;bt = NULL; //将树根指针置空cout << "输入规则：" << endl<< "要生成新结点，输入一个字符，""不要生成新结点的左孩子，输入一个空格，""左右孩子都不要，输入两个空格，""要结束，输入多个空格（越多越好）,再回车！"<< endl << "按先序输入：";CreateBiTree(bt);cout << "树的深度为：" << BiTreeDepth(bt) << endl;ChoiceMark(bt);return 0;}/*----------------------------------------* 05-2_构造二叉树.cpp -- 构造二叉树的相关操作* 对构造二叉树的每个基本操作都用单独的函数来实现* 水上飘2009年写----------------------------------------*/// ds05-2.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include <iostream>#define STACK_INIT_SIZE 100 //栈的存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量typedef char ElemType; //元素类型using namespace std;typedef struct BiTNode {ElemType data; //结点值BiTNode *lchild, *rchild; //左右孩子指针}BiTNode, *BiTree;typedef struct {BiTree *base; //在栈构造之前和销毁之后，base的值为空BiTree *top; //栈顶指针int stacksize; //当前已分配的存储空间，以元素为单位}SqStack;//构造一个空栈void InitStack(SqStack &s) {s.base = (BiTree *)malloc(STACK_INIT_SIZE * sizeof(BiTree));if(!s.base)cout << "存储分配失败！" << endl;s.top = s.base;s.stacksize = STACK_INIT_SIZE;}//插入元素e为新的栈顶元素void Push(SqStack &s, BiTree e) {//栈满，追加存储空间if ((s.top - s.base) >= s.stacksize) {s.base = (BiTree *)malloc((STACK_INIT_SIZE+STACKINCREMENT) * sizeof(BiTree));if(!s.base)cout << "存储分配失败！" << endl;s.top = s.base + s.stacksize;s.stacksize += STACK_INIT_SIZE;}*s.top++ = e;}//若栈不空，则删除s的栈顶元素，并返回其值BiTree Pop(SqStack &s) {if(s.top == s.base)cout << "栈为空，无法删除栈顶元素！" << endl;s.top--;return *s.top;}//按先序输入字符创建二叉树void CreateBiTree(BiTree &T) {char ch;//接受输入的字符ch = cin.get();if(ch == ' ') {//分支结束T = NULL;} //if' 'endelse if(ch == '\n') {cout << "输入未结束前不要输入回车，""要结束分支请输入空格！（接着输入）" << endl;} //if'\n'endelse {//生成根结点T = (BiTNode * )malloc(sizeof(BiTree));if(!T)cout << "内存分配失败！" << endl;T->data = ch;//构造左子树CreateBiTree(T->lchild);//构造右子树CreateBiTree(T->rchild);} //Create end}//输出e的值，并返回ElemType PrintElement(ElemType e) {cout << e << " ";return e;}//中序遍历二叉树的非递归函数void InOrderTraverse(BiTree p, SqStack &S) {cout << "中序遍历结果：";while(S.top != S.base || p != NULL) {if(p != NULL) {Push(S,p);p = p->lchild;} //if NULL endelse {BiTree bi = Pop(S);if(!PrintElement(bi->data))cout << "输出其值未成功！" << endl;p = bi->rchild;} //else end} //while endcout << endl;}int _tmain(int argc, _TCHAR* argv[]){BiTNode *bt;SqStack S;InitStack(S);bt = NULL; //将树根指针置空cout << "老师要求的二叉树序列（‘空’表示空格）：""12空空346空空空5空空，再回车！"<< endl << "请按先序输入一个二叉树序列（可另输入，但要为先序），""无左右孩子则分别输入空格。

线索二叉树

6.4 线索化二叉树从前面的讨论可知，遍历二叉树就是将非线性结构的二叉树线性化，即按一定规则将二叉树中的结点排列成一个线性序列依次访问。

如图6.20(a)所示的二叉树，经中序遍历得到线性序列：BADEC，经前序遍历得到线性序列：ABCDE，经后序遍历得到线性序列：BEDCA。

在这些线性序列中，二叉树中的每个结点（除第一个和最后一个外）有且仅有唯一的一个前趋和唯一的一个后继，很容易找到各个结点的直接前驱和直接后继。

但当以二叉链表作为二叉树的存储结构时，只能找到结点的左、右孩子，而不能直接找到前驱和后继，只有在遍历的动态过程中得到这些信息。

如果将这些信息在第一次遍历时保存起来，在需要再次对二叉树进行“遍历”时就可以将二叉树视为线性结构进行访问，从而简化遍历操作。

那么，如何存储遍历中得到的结点前驱和后继的信息呢？一个简单的办法是在每个结点上增加两个指针域fwd和bkwd，分别指向存储遍历中得到的结点前驱和后继。

fwd L child data R child bkwd这是采用多重链表来表示二叉树。

这种方法虽简单易行，但这种结构的存储密度将大大降低，浪费存储空间。

另一种方法，是利用原有链域L child 和R child的空链域。

在n个结点的二叉链表中有2n个孩子链域，其中仅有n-1个链域是用来指示结点的左右孩子，而另外n+1个链域是空链域。

现在把这些空链域利用起来，使其指向结点的前驱或后继；对那些原来就不为空的链域，则仍然指向左或右孩子。

如果把指向前驱和后继的指针称为线索（Thread），那么，如何区分指向左、右孩子的指针和指向前驱、后继的线索呢？在原结点结构上增加标志域定义为：0 Lchild为左指针，指向左孩子0 Rchild为右指针，指向右孩子ltag＝rtag＝1 Lchild为左线索，指向前驱 1 Rchild为右线索，指向后继以这种结点构成的二叉链表作为二叉树的存储结构，叫做线索链表，其C语言类型说明如下：Typedef struct ThreadTNode{enum{0，1} ltag, rtag;Elem Type data;Struct ThreadTNode *Lchild, *Rchild;}ThreadTNode, *ThreadTree;为了节省内存空间，我们用C语言的位段方法将结点中的左标志域和右标志域与数据域合并在一个存储单元中（即各用一位表示左标志和右标志，其余各位表示结点值）。

实验8 线索二叉树的创建和遍历

实验八线索二叉树的创建和遍历1.实验目的（1）掌握二叉树的线索链表存储结构。

（2）能够实现二叉树的线索链表的创建、遍历等基本操作。

2.实验内容编程实现二叉树的线索链表存储表示的基本操作，包括线索二叉树的创建与遍历。

3.实验要求（1）根据实验内容编写程序，上机调试并获得运行结果（2）撰写实验报告4.准备工作本次实验将会构造此二叉树，并会对此二叉树进行遍历5.关键步骤与算法(1)构造线索二叉树算法步骤；若某节点的左孩子节点指针域（lchild）为空，就可以利用它来指出该节点在某种遍历序列中的直接前驱的存储地址；若某节点的右孩子指针域（rchild）为空，就可以利用它来指出该节点在某种遍历序列中的直接后继的存储地址。

那些非空的指针域仍存放指向该节点左、右孩子节点的指针域。

这样，就得到了一棵线索二叉树。

算法如下；1.//按先序遍历序列输入树中各节点的值，构造线索二叉树2.BiThrTree* CreateBiThrTree()3.{4. BiThrTree *s;5. DataType ch;6. scanf("%c",&ch);7.8.if(ch == '#')9. exit(0);10.if(ch == '@')11. s = NULL;12.else if (ch=='\n')13. getchar();14.15.else16. {17. s = (BiThrTree *)malloc(sizeof(BiThrTree));18.if(!s)19. exit(ERROR);20. s->data = ch;21. s->lflag = 0;22. s->rflag = 0;23. s->lchild = CreateBiThrTree();24. s->rchild = CreateBiThrTree();25. }26.return s;27.}(2) 将二叉树中序线索化现将树递归到左子树然后再判断这个树的左右子树是否为空，如果为空则把它们的标志设为1，代表线索，首先设一个current代表前驱结点，然后判断它是否为空，如果为空则进行下一次递归，如果不为空，则判断左标志和右标志如果左标志为线索，则让前驱节点的右孩子指向当前节点，如果右标志为1，则让当前节点的左孩子指向前驱结点算法如下；1.void InThreading(BiThrTree *t)2.{3.if(t != NULL)//先判断树为不为空，如果为空，则不执行函数4. {5. InThreading(t->lchild);//递归调用左子树进行线索化6.if(t->lchild == NULL)7. t->lflag = 1;8.if(t->rchild == NULL)9. t->rflag = 1;10.//以上两步是判断这个结点的左右结点是否为空，若为空，把他们对应的flag标上111.if(current != NULL)//因为要用到current所以要判断一下，且current只有当t回到倒数第二个结点时，才会不为NULL12. {13.if(current->rflag == 1)14. current->rchild = t;//前驱结点的右孩子指针指向当前节点t15.if(t->lflag == 1)16. t->lchild = current;//现结点t的左孩子指针指向前驱结点17. }18. current = t;//让前驱结点为t为下一次执行函数做准备19. InThreading(t->rchild);//递归调用右子树进行线索化20. }21.}6．源代码1.#include<malloc.h>2.#include<stdio.h>3.#include<stdlib.h>4.#include<io.h>5.#define ERROR -16.7.typedef char DataType;8.typedef struct BiThrNode//二叉树的二叉链表的存储结构9.{10. DataType data;11.struct BiThrNode *lchild,*rchild;12.int lflag,rflag;//左右标志，值为0表示指针，值为1表示线索13.}BiThrTree;14.BiThrTree *current = NULL;15.//检查if的==16.//按先序遍历序列输入树中各节点的值，构造线索二叉树17.BiThrTree* CreateBiThrTree()18.{19. BiThrTree *s;20. DataType ch;21. scanf("%c",&ch);22.23.if(ch == '#')24. exit(0);25.if(ch == '@')26. s = NULL;27.else if (ch=='\n')28. getchar();29.30.else31. {32. s = (BiThrTree *)malloc(sizeof(BiThrTree));33.if(!s)34. exit(ERROR);35. s->data = ch;36. s->lflag = 0;37. s->rflag = 0;38. s->lchild = CreateBiThrTree();39. s->rchild = CreateBiThrTree();40. }41.return s;42.}43.//将二叉树前序线索化（递归）44.void PreThreading(BiThrTree *t)45.{46.if(t != NULL)//先判断树为不为空，如果为空，则不执行函数47. {48.if(t->lchild == NULL)49. t->lflag = 1;50.if(t->rchild == NULL)51. t->rflag = 1;52.//以上两步是判断这个结点的左右结点是否为空，若为空，把他们对应的flag标上153.if(current != NULL)//因为要用到current所以要判断一下，且current只有当t回到倒数第二个结点时，才会不为NULL54. {55.if(current->rflag == 1)56. current->rchild = t;//前驱结点的右孩子指针指向当前节点t57.if(t->lflag == 1)58. t->lchild = current;//现结点t的左孩子指针指向前驱结点59. }60. current = t;//让前驱结点为t为下一次执行函数做准备61.if(t->lflag == 0)62. PreThreading(t->lchild);//递归调用右子树进行线索化63.if(t->rflag == 0)64. PreThreading(t->rchild);65. }66.}67.//遍历前序线索二叉树68.void PreVisitThrtree(BiThrTree *t)69.{70.while(t != NULL)//大循环71. {72.while(t->lflag == 0)73. {74. printf("%c\t",t->data);75. t = t->lchild;76. }77. printf("%c\t",t->data);78. t = t->rchild;79. }80.}81.82.//检查if的==83.//将二叉树中序线索化（递归）84.void InThreading(BiThrTree *t)85.{86.if(t != NULL)//先判断树为不为空，如果为空，则不执行函数87. {88. InThreading(t->lchild);//递归调用左子树进行线索化89.if(t->lchild == NULL)90. t->lflag = 1;91.if(t->rchild == NULL)92. t->rflag = 1;93.//以上两步是判断这个结点的左右结点是否为空，若为空，把他们对应的flag标上194.if(current != NULL)//因为要用到current所以要判断一下，且current只有当t回到倒数第二个结点时，才会不为NULL95. {96.if(current->rflag == 1)97. current->rchild = t;//前驱结点的右孩子指针指向当前节点t98.if(t->lflag == 1)99. t->lchild = current;//现结点t的左孩子指针指向前驱结点100. }101. current = t;//让前驱结点为t为下一次执行函数做准备102. InThreading(t->rchild);//递归调用右子树进行线索化103. }104.}105.//检查if的==106.//遍历中序线索二叉树107.void InVisitThrtree(BiThrTree *t)108.{109.while(t != NULL)//大循环110. {111.while(t->lflag == 0)//小循环1;此循环第一次进行时首先要去找到最左节点112. t = t->lchild;113.if(t == NULL)114. exit(ERROR);115. printf("%c\t",t->data);116.while(t->rflag == 1 && t->rchild != NULL)//小循环2117. {118. t = t->rchild;119. printf("%c\t",t->data);120. }121. t = t->rchild;122./*123.两种情况：124. 1.如果t的右子树为空则t直接指向t的中序后继结点.125. 2.如果t的右子树不为空，即t->rflag为0，那么退出这个小循环2回到大循环中，再到小循环1中去找t的右子树的最左下的结点.126. */127. }128.}129.130.//将二叉树后序线索化（递归）131.void PostThreading(BiThrTree *t)132.{133.if(t != NULL)//先判断树为不为空，如果为空，则不执行函数134. {135. PreThreading(t->lchild);136. PreThreading(t->rchild);137.if(t->lchild == NULL)138. t->lflag = 1;139.if(t->rchild == NULL)140. t->rflag = 1;141.//以上两步是判断这个结点的左右结点是否为空，若为空，把他们对应的flag标上1142.if(current != NULL)//因为要用到current所以要判断一下，且current只有当t回到倒数第二个结点时，才会不为NULL143. {144.if(current->rflag == 1)145. current->rchild = t;//前驱结点的右孩子指针指向当前节点t146.if(t->lflag == 1)147. t->lchild = current;//现结点t的左孩子指针指向前驱结点148. }149. current = t;//让前驱结点为t为下一次执行函数做准备150. }151.}152.//遍历后序线索二叉树153.void PostVisitThrtree(BiThrTree *t)154.{155.if(t)156. {157.while(t->lchild != NULL && t->lflag == 0)158. {159. t = t->lchild;//先遍历到最左边的节点160. }161. }162.}163.//主函数164.void main()165.{166. BiThrTree *t,*s;167. printf("\t\t请按先序序列输入二叉树(如：ABC@@DE@G@@F@@@#)\n\t\t");168. t = CreateBiThrTree();169. InThreading(t);170. printf("\t\t按中序遍历输出线索二叉树：\n\t\t");171. InVisitThrtree(t);172. printf("\n");173.//getchar();174.//getchar();175. fflush(stdin);//这个操作必须要进行，或者是进行上面注释的那两步操作，要不然176. printf("\t\t请按先序序列输入二叉树(如：ABC@@DE@G@@F@@@#)\n\t\t");177. s = CreateBiThrTree();178. PreThreading(s);179. printf("\t\t按前序遍历输出线索二叉树：\n\t\t");180. PreVisitThrtree(s);181.}7.测试图8.实验总结然对于这一节，主要是讨论线索二叉树的建立以及遍历，对于二叉树的建立，主要有五个部分构成，分别是data，lchild，rchild，lflag，rflag，而它与二叉树不同的地方就是多了lflag和rflag的判断，当当前节点的左节点为空时一定会指向它的前驱结点，当前驱节点的右节点为空时，让前驱结点的右指针域指向当前节点，这就是线索化，而对于前序中序后序的线索化本质都是一样的。

线索二叉树

遍历线索二叉树非
{
while(p->ltag==0) p=p->left; /*从根往下找到"最左"的结
点，即中序序列的开始结点*/
do
{
递归算法
printf("%c",p->date);/*访问结点*/
p=succ(p);
}while(p!=NULL); }
返回
}
树
数据结构
在中序遍历线索树过程中，按下述两条原则即可找到后继结点：
– 1) 如果某结点的右线索标志域为1，说明其右指针域是线索，这个线索所指的即是该结点的后继结点；
– 2) 如果某结点的右线索标志为0，则其右指针域是指向右儿子结点的指针，由此结点的右儿子结点起按左指针域指针逐结点向左查找，一直找到左线索标志域为1的结点，即是该结点的后继结点。
{
中
if(p!=NULL)
序
{ inthread(p->left,pre); /*左子树线索化*/
线
if(p->left==NULL)
索
/*若当前结点的左子树为空，则建立指向其前趋结点的前趋线索*/
化
{
算
p->ltag=1;
法
p->left=pre; }
else
p->ltag=0树;
if (pre!=NULL && pre->right==NULL)
这种结点类型和相应结点的指针类型定义如下：
typedef struct tnode {
ElemType data; int ltag,rtag; /*ltag和rtag只能取值为0或1*/ struct tnode *left,*right; }tbtree;

线索二叉树

0 A0 0 B1
0 C0
1 D0
1 E1
1F1
1 G1
(b) root
0
1
ห้องสมุดไป่ตู้
0 A0
0 B1
0 C0
0 A0
0 B1
0 C0
1 D0
1 E1
1F1
1 D0
1 E1
1F1
1 G1
1 G1
(c)
(d)
线索二叉树 b—中序 c—前序 d—后序
一旦建立了某种方式的线索二叉树后，用户程序就可以像操作双向链表一样操作该线索二叉树。
if(tree->current == tree->root) tree->nextComplete = 1;
}
int EndOfNext(ThreadBiTree *tree) //判断是否已到中序线索二叉树的最后一个结点 { return tree->nextComplete; }
例8-3 编写一个程序，首先建立如图8-10（a）所示的不带头结点的二叉树，然后中序线索化该二叉树，最后用循环结构输出该中序线索化二叉树各结点的序列信息。
这种算法设计要求分别设计三个函数： First()：定位在第一个结点位置； Next()：移动到下一个结点位置； End()：是否已经到最后下一个结点位置；当然，还需要一个根据二叉树构造线索二叉树的函数。
typedef struct { ThreadBiNode *root;
ThreadBiNode *current; int nextComplete; }ThreadBiTree;
规定：当某结点的左指针为空时，令该指针指向按某种方法遍历二叉树时得到的该结点的前驱结点；当某结点的右指针为空时，令该指针指向按某种方法遍历二叉树时得到的该结点的后继结点。仅仅这样做会使我们不能区分左指针指向的结点到底是左孩子结点还是前驱结点，右指针指向的结点到底是右孩子结点还是后继结点。因此我们再在结点中增加两个线索标志位来区分这两种情况。

线索二叉树的创建及遍历

实验九线索二叉树的创建及遍历实验目的：掌握二叉树的线索链表存储结构，能够实现二叉树的线索链表的创建、遍历等基本操作实验要求：1、认真阅读和掌握教材上和本实验相关的内容及算法2、上机将线索二叉树的线索链表存储表示的创建和遍历算法实现。

3、进行简单的输入输出验证。

实验内容：编程实现二叉树的线索链表存储表示的基本操作，这些基本操作包括：线索二叉树的创建、线索二叉树的中序遍历算法的实现。

要求对程序中的一些关键语句要有注释，并能够进行简单的输入输出验证。

参考代码#include <stdlib.h>#include <stdio.h>#define OVERFLOW 0//线索二叉树的二叉链表存储定义typedef enum PointerTag {LINK=0,THREAD=1};struct BiThrNode{char data;struct BiThrNode * lchild, * rchild;PointerTag LTag, RTag;};typedef struct BiThrNode BiThrNode;typedef BiThrNode * BiThrTree;/*****************************************************************\** 按先序次序输入二叉树中的结点的值（一个字符）构造二叉链表表示的二叉树，* 字符'#'表示空树。

** 例如，一棵二叉树的三种遍历次序为：* 先序：-+a*b-cd/ef 中序：a+b*c-d-e/f 后序：abcd-*+ef/* 程序中应该输入：-+a##*b##-c##d##/e##f##** 又如，一棵二叉树的三种遍历次序为：* 先序：ABDFGCEH 中序：BFDGACHE 后序：FGDBHECA* 程序中应该输入：AB#DF##G##C#EH###*\******************************************************************/ void CreateBiTree(BiThrTree &T){char ch;ch = getchar();if (ch=='#') T=NULL;else{if (!(T = (BiThrNode *)malloc(sizeof(BiThrNode)))) exit(OVERFLOW);T->data = ch;T->LTag = LINK;T->RTag = LINK;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}return;}//CreateBiTreevoid PrintBiTree(BiThrTree T){//按中序遍历次序输出二叉树T中的结点的值（一个字符），二叉树T用二叉链表存储。

莫里斯算法

莫里斯算法莫里斯算法（Morris Traversal）是一种二叉树遍历的算法，通过只使用一个指针和利用线索二叉树的思想，实现对二叉树的中序遍历，时间复杂度为O(n)，空间复杂度为O(1)。

1. 线索二叉树线索二叉树是指将一颗二叉树中所有的空指针域指向该节点的直接前驱节点或直接后继节点的二叉树。

线索化后，原本空闲的指针域存储前驱或后继的指针，可以方便地实现对二叉树的遍历。

在递归遍历的过程中，需要记录每个节点是否已经被遍历。

线索二叉树分为前序线索二叉树、中序线索二叉树、后序线索二叉树。

其中，利用中序线索二叉树可以实现对二叉树的中序遍历。

2. Morris遍历算法Morris遍历算法是一种利用线索二叉树对二叉树进行中序遍历的算法，它的核心思想是在遍历节点的过程中，利用空闲的指针域存储前驱或后继的指针，从而实现对二叉树的遍历。

Morris遍历算法对于空间的要求比较严格，它只需要使用一个指针来实现对二叉树的遍历，因此空间复杂度为O(1)，非常适合解决空间限制的问题。

在时间复杂度方面，Morris遍历算法需要在遍历每个节点和寻找其前驱节点时，都需要遍历部分节点，因此时间复杂度为O(n)。

具体而言，Morris遍历算法利用线索化指针判断节点是否被访问过，从而实现对二叉树的遍历。

Morris遍历算法的具体流程如下：1）初始化当前节点为根节点2）重复以下操作，直到当前节点为空a. 如果当前节点没有左孩子节点，则输出当前节点，将其右孩子节点作为下一次要访问的节点，更新当前节点为右孩子节点b. 如果当前节点存在左孩子节点，则寻找当前节点的左子树中的最右侧节点，该节点为当前节点的直接前驱节点i. 如果该节点的右孩子指向当前节点，则说明当前节点是第二次访问该节点，将其右孩子设为null，输出该节点，更新当前节点为右孩子节点ii. 如果该节点的右孩子指向null，则说明当前节点为第一次访问该节点，将其右孩子设为当前节点，更新当前节点为左孩子节点Morris遍历算法的特点是利用空闲的指针域存储前驱或后继的指针，实现对二叉树的遍历。

二叉树的生成与遍历

#include <alloc.h>#include "btree.h"#include "sstack.h"typedef struct stack_tag{elemtype *elem;int top;int size;}SQSTACK;int InitSqstack(SQSTACK *S,int n);void DestroySqstack(SQSTACK *S);int IsSqstackEmpty(SQSTACK S);int IsSqstackFull(SQSTACK S);int Push(SQSTACK *S,elemtype e);int Pop(SQSTACK *S,elemtype *e);int InitSqstack(SQSTACK *S, int n){S->elem=(elemtype *)malloc(n*sizeof(elemtype)); if(S->elem==NULL)return 0;S->size=n;S->top=-1;return 1;}void DestroySqstack(SQSTACK *S){free(S->elem);S->elem=NULL;S->top=-1;S->size=0;}int IsSqstackEmpty(SQSTACK S){return S.top==-1;}int IsSqstackFull(SQSTACK S){return S.top==S.size-1;}int Push(SQSTACK *S,elemtype e){if(IsSqstackFull(*S))return 0;S->top++;S->elem[S->top]=e;return 1;}int Pop(SQSTACK *S,elemtype *e){if(IsSqstackEmpty(*S)) return 0;*e=S->elem[S->top];S->top--;return 1;}typedef struct thrbtreenode{char data;int ltag,rtag;struct thrbtreenode *lchild,*rchild;} THRBTREENODE, *THRBTREENODEPTR,*THRBTREE; typedef THRBTREENODEPTR elemtype;typedef struct{int x,y;}BTREENODEPOS;#define MAXCOUNT 32void InitBtreeNodePos();THRBTREE CreateBtree2(char *str);void DestroyBtree(THRBTREE root);void ShowBtree(THRBTREE root,int index);void PreOrderThr(THRBTREE p);THRBTREE InOrderThread(THRBTREE root);void InOrderThr(THRBTREE p);THRBTREE PreOrderThread(THRBTREE root);#include <stdio.h>#include <conio.h>#include <graphics.h>#include <alloc.h>#include <string.h>#include "btree.h"#include "sstack.h"THRBTREENODEPTR pre;BTREENODEPOS btnpos[MAXCOUNT];void InitBtreeNodePos(void){int i;for(i=0;i<16;i++){btnpos[16+i].x=20+i*40;btnpos[16+i].y=480-30;}for(i=15;i>=1;i--){btnpos[i].x=(btnpos[2*i].x+btnpos[2*i+1].x)/2;btnpos[i].y=btnpos[2*i].y-80;}}THRBTREE CreateBtree1(char *str){THRBTREE root=NULL;THRBTREENODEPTR p;int tag,i,len;int mark;/* 1--characters,2--(,3--,4--) */SQSTACK s;if(str[0]==0)return root;root=(THRBTREENODEPTR)malloc(sizeof(THRBTREENODE)); if(root==NULL)return root;root->data=str[0];root->lchild=root->rchild=NULL;root->ltag=root->rtag=0;len=strlen(str);InitSqstack(&s,len);p=root;mark=1;for(i=1;str[i]!=0;i++)switch(str[i]){case '(':if(mark==2){DestroyBtree(root);printf("illegal global list!");return NULL;}mark=2;Push(&s,p);tag=0;break;case ')':mark=4;if(!Pop(&s,&p)){DestroyBtree(root);printf("illegal global list!");return NULL;}break;case ',':if(mark==3){DestroyBtree(root);printf("illegal global list!");return NULL;}mark=3;tag=1;break;default:if(mark==1){DestroyBtree(root);printf("illegal global list!");return NULL;}mark=1;if(IsSqstackEmpty(s)){DestroyBtree(root);printf("illegal global list!");return NULL;}p=(THRBTREENODEPTR)malloc(sizeof(THRBTREENODE)); if(p==NULL){DestroyBtree(root);return NULL;}p->data=str[i];p->lchild=p->rchild=NULL;p->ltag=p->rtag=0;if(tag==0)s.elem[s.top]->lchild=p;elses.elem[s.top]->rchild=p;break;}return root;}void DestroyBtree(THRBTREE root){if(root==NULL)return;if(root->ltag==0)DestroyBtree(root->lchild);if(root->rtag==0)DestroyBtree(root->rchild);root->lchild=NULL;root->rchild=NULL;free(root);}void ShowBtree(THRBTREE root,int index){int i,j,len;char str[10];if(root==NULL)return;i=index*2;j=index*2+1;setcolor(YELLOW);if(i<MAXCOUNT&&root->ltag==0&&root->lchild!=NULL) line(btnpos[index].x,btnpos[index].y,btnpos[i].x,btnpos[i].y); if(j<MAXCOUNT&&root->rtag==0&&root->rchild!=NULL) line(btnpos[index].x,btnpos[index].y,btnpos[j].x,btnpos[j].y); setfillstyle(SOLID_FILL,BLACK);setcolor(WHITE);fillellipse(btnpos[index].x,btnpos[index].y,15,15);sprintf(str,"%c",root->data);len=strlen(str);outtextxy(btnpos[index].x-len*8/2,btnpos[index].y-4,str); setcolor(YELLOW);if(root->ltag==1&&root->lchild!=NULL){sprintf(str,"%c",root->lchild->data);len=strlen(str);outtextxy(btnpos[index].x-len*8/2-8,btnpos[index].y,str);}if(root->rtag==1&&root->rchild!=NULL){sprintf(str,"%c",root->rchild->data);len=strlen(str);outtextxy(btnpos[index].x-len*8/2+8,btnpos[index].y,str);}if(i<MAXCOUNT&&root->ltag==0) ShowBtree(root->lchild,i);if(j<MAXCOUNT&&root->rtag==0) ShowBtree(root->rchild,j);}void InOrder(THRBTREE root,char *str){char tmpstr[10];if(root==NULL)return;InOrder(root->lchild,str);sprintf(tmpstr,"%c ",root->data);strcat(str,tmpstr);InOrder(root->rchild,str);}void InOrderThr(THRBTREE p){}THRBTREE InOrderThread(THRBTREE root){THRBTREE head;head=(THRBTREENODEPTR)malloc(sizeof(THRBTREENODE)); if(head==NULL)return NULL;head->lchild=NULL;return head;}void TraverseInOrderThr(THRBTREE root,char *str){return;}void main(){char *gstr="A(B(C,),E(F(G,H),))"; char trastr[80];THRBTREE root,thrt;int gdriver=DETECT,gmode;int i;InitBtreeNodePos();root=CreateBtree1(gstr);registerbgidriver(EGA VGA_driver); initgraph(&gdriver,&gmode,"");trastr[0]=0;InOrder(root,trastr);setcolor(WHITE);outtextxy(10,10,trastr);thrt=InOrderThread(root);trastr[0]=0; TraverseInOrderThr(root,trastr); setcolor(YELLOW);outtextxy(10,20,trastr); ShowBtree(thrt->lchild,1);getch();closegraph();DestroyBtree(root);}。

线索二叉树

6·4 线索二叉树1、线索二叉树的结点结构二叉树的遍历本质上是将一个复杂的非线性结构转换为线性结构，使每个结点都有了唯一前驱和后继（第一个结点无前驱，最后一个结点无后继）。

对于二叉树的一个结点，查找其左右子女是方便的，其前驱后继只有在遍历中得到。

为了容易找到前驱和后继，有两种方法。

一是在结点结构中增加向前和向后的指针fwd和bkd，这种方法增加了存储开销，不可取；二是利用二叉树的空链指针。

现将二叉树的结点结构重新定义如下：其中：ltag=0 时ltag=1 时lchild指向前驱；rtag=0 时rchild指向左子女；rtag=1 时rchild指向后继；以这种结点结构构成的二叉链表作为二叉树的存储结构，叫做线索链表，指向前驱和后继的指针叫线索，加上线索的二叉树叫线索二叉树，对二叉树进行某种形式遍历使其变为线索二叉树的过程叫线索化。

学习线索化时，有三点必须注意：一是何种“序”的线索化，是先序、中序还是后序；二是要“前驱”线索化、“后继”线索化还是“全”线索化（前驱后继都要）；三是只有空指针处才能加线索。

2、对二叉树进行中序线索化的算法bithptr *pre; /* 全程变量*/void INTHREAD(bithptr *p){if(p!=NULL){ INTHREAD(p->lchild); /* 左子树线索化*/if(p->lchild==NULL) { p->ltag=1;p->lchild=pre;}if(p->rchild==NULL) p->rtag=1;if(pre!=NULL && pre->rtag==1) pre->rchild=p;pre=p; /* 前驱指向当前结点*/INTHREAD(p->rchild); /* 右子树线索化*/}3、在线索二叉树上查找前驱和后继（1）中序线索二叉树：若结点的ltag=1，lchild指向其前驱；否则，该结点的前驱是以该结点为根的左子树上按中序遍历的最后一个结点。

二叉树遍历讲课教案ppt课件

I；中序遍历序列：D，C，B，E，H，A，G， I，F，试画出二叉树，并写出该二叉树的前序遍历序列和中序遍历序列。
资金是运动的价值，资金的价值是随时间变化而变化的，是时间的函数，随时间的推移而增值，其增值的这部分资金就是原有资金的时间价值
6.5 线索二叉树
§ 何谓线索二叉树？ § 线索链表的遍历算法 § 如何建立线索链表？
一、问题的提出
顺着某一条搜索路径巡访二叉树中的结点，使得每个结点均被访问一次，而且仅被访问一次。
“访问”的含义可以很是随时间变化而变化的，是时间的函数，随时间的推移而增值，其增值的这部分资金就是原有资金的时间价值
if (T) {
visit(T->data);
// 访问结点
Preorder(T->lchild, visit); // 遍历左子树
Preorder(T->rchild, visit);// 遍历右子树 }
}
资金是运动的价值，资金的价值是随时间变化而变化的，是时间的函数，随时间的推移而增值，其增值的这部分资金就是原有资金的时间价值
资金是运动的价值，资金的价值是随时间变化而变化的，是时间的函数，随时间的推移而增值，其增值的这部分资金就是原有资金的时间价值
二、先左后右的遍历算法
先（根）序的遍历算法中（根）序的遍历算法后（根）序的遍历算法
资金是运动的价值，资金的价值是随时间变化而变化的，是时间的函数，随时间的推移而增值，其增值的这部分资金就是原有资金的时间价值
先（根）序的遍历算法：
若二叉树为空树，则空操作；否则，（1）访问根结点；（2）先序遍历左子树；（3）先序遍历右子树。

二叉树的遍历PPT-课件

4 、二叉树的创建算法
利用二叉树前序遍历的结果可以非常方便地生成给定的
二叉树，具体做法是：将第一个输入的结点作为二叉树的根结点，后继输入的结点序列是二叉树左子树前序遍历的结果，由它们生成二叉树的左子树；再接下来输入的结点序列为二叉树右子树前序遍历的结果，应该由它们生成二叉树的右子树；而由二叉树左子树前序遍历的结果生成二叉树的左子树和由二叉树右子树前序遍历的结果生成二叉树的右子树的过程均与由整棵二叉树的前序遍历结果生成该二叉树的过程完全相同，只是所处理的对象范围不同，于是完全可以使用递归方式加以实现。
void createbintree(bintree *t) { char ch; if ((ch=getchar())==' ') *t=NULL; else { *t=(bintnode *)malloc(sizeof(bintnode)); /*生成二叉树的根结点*/ (*t)->data=ch; createbintree(&(*t)->lchild); /*递归实现左子树的建立*/ createbintree(&(*t)->rchild); /*递归实现右子树的建立*/ }
if (s.top>-1) { t=s.data[s.top]; s.tag[s.top]=1; t=t->rchild; }
else t=NULL; }
}
7．5 二叉树其它运算的实现
由于二叉树本身的定义是递归的，因此关于二叉树的许多问题或运算采用递归方式实现非常地简单和自然。 1、二叉树的查找locate(t,x)
（1）对一棵二叉树中序遍历时，若我们将二叉树严
格地按左子树的所有结点位于根结点的左侧，右子树的所

线索化二叉树详解

线索化⼆叉树详解线索化⼆叉树详解说明1. 线索化⼆叉树，由字⾯意思，就是将⼆叉树的节点拿线索连接起来2. 实质上，也就是将⼆叉树的叶⼦节点左右指针域彼此连接⼀个节点3. ⼆叉树的⾮叶⼦节点的左右指针域都各⾃连接了⼀个节点，但是叶⼦节点的左右指针域是空的，因此考虑将叶⼦节点的左右指针域按照某种遍历次序连接起来4. 按照⼆叉树的遍历⽅式，有前序中序后续三种遍历⽅式，因此可以形成三种链式结构5. 每个叶⼦节点前⼀个节点称为前驱节点，后⼀个节点称为后继节点，如果当前节点没有前驱或者后继节点，则直接置为空6. 以中序线索化⼆叉树为例，编写中序线索化⼆叉树的⽅法7. 先判断当前节点是否为空，如果为空，则直接返回8. 否则先向左递归线索化⼆叉树的左⼦树9. 然后再线索化当前节点，定义属性pre保存当前节点的前⼀个节点，因此当前节点的前⼀个节点置为pre10. 注意当前节点的后⼀个节点，需要⽤pre保存当前节点，然后遍历到后⼀个节点，然后⽤pre指向11. 注意第⼀个节点和最后⼀个节点12. 中序线索化如下，前序和后续类似源码及分析节点类//创建节点class HeroNode{//编号private int no;//姓名private String name;//左⼦树private HeroNode left;//右⼦树private HeroNode right;//线索化的前驱节点类型，是节点还是树，假定 0 为树， 1 为节点private int leftType;//线索化的后继节点类型private int rightType;public int getLeftType() {return leftType;}public void setLeftType(int leftType) {this.leftType = leftType;}public int getRightType() {return rightType;}public void setRightType(int rightType) {this.rightType = rightType;}//构造器，左⼦树和右⼦树默认为空public HeroNode(int no, String name) {this.no = no; = name;}public int getNo() {return no;}public void setNo(int no) {this.no = no;}public String getName() {return name;}public void setName(String name) { = name;}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;}@Overridepublic String toString() {return "HeroNode{" +"no=" + no +", name='" + name + '\'' +'}';}//删除节点/**** @param no 要删除的节点编号*/public void delNode(int no){//判断当前节点的左⼦树是否为空，如果不为空，再判断是否为要删除的节点if (this.left != null && this.left.no == no){this.left = null;}//判断当前节点的右⼦树是否为空，如果不为空，再判断是否为要删除的节点if (this.right != null && this.right.no == no){this.right = null;}//否则向左向右递归if (this.left != null){this.left.delNode(no);}if (this.right != null){this.right.delNode(no);}}//前序中序后序遍历主要区别在于⽗节点的输出位置不同，/*** 前序遍历先输出⽗节点信息，然后判断左⼦树是否为空，如果不为空，则递归前序遍历 * 然后再判断右⼦树是否为空，如果不为空，则递归遍历前序遍历*///前序遍历public void preOrder(){//先输⼊当前节点信息System.out.println(this);//然后判断当前节点的左⼦树是否为空if (this.left != null){this.left.preOrder();}//再判断当前节点的右⼦树是否为空if (this.right != null){this.right.preOrder();}}//中序遍历public void infixOrder(){//先判断当前节点的左⼦树是否为空if (this.left != null){this.left.infixOrder();}//再输出当前节点的信息System.out.println(this);//然后再判断当前节点的右⼦树是否为空if (this.right != null){this.right.infixOrder();}}//后序遍历public void postOrder(){//先判断当前节点的左⼦树是否为空if (this.left != null){this.left.postOrder();}//再判断当前节点的右⼦树是否为空if (this.right != null){this.right.postOrder();}//最后输出当前节点的信息System.out.println(this);}//前序查找/*** 前序遍历查找* @param no 要查找的节点编号* @return 返回查找的结果*/public HeroNode preOrderSearch(int no){//先判断当前节点是不是要查找的节点if (this.no == no){return this;}//如果当前节点不是要查找的节点，则判断左⼦树是否为空，若不为空，则递归前序查找 HeroNode resNode = null;if (this.left != null){resNode = this.left.preOrderSearch(no);}//如果在左⼦树找到，则直接返回if (resNode != null){return resNode;}//如果左⼦树也没有找到，则判断右⼦树是否为空，并递归if (this.right != null){resNode = this.right.preOrderSearch(no);}return resNode;}//中序查找/*** 中序遍历查找* @param no 要查找的节点编号* @return 返回查找的结果*/public HeroNode infixOrderSearch(int no){//先判断当前节点左⼦树是否为空，如果不为空则递归中序查找//定义变量保存查找的结果HeroNode resNode = null;if (this.left != null){resNode = this.left.preOrderSearch(no);}//如果查找到，则直接返回if (resNode != null){return resNode;}//如果没有找到，判断当前节点是不是要查找的节点if (this.no == no){return this;}//如果还没有找到，则判断右⼦树是否为空，不为空则递归中序查找if (this.right != null){resNode = this.right.infixOrderSearch(no);}return resNode;}//后序查找/*** 后续遍历查找* @param no 要查找的节点编号* @return 返回查找的结果*/public HeroNode postOrderSearch(int no){//判断当前节点的左⼦树是否为空，如果不为空，则递归后续查找HeroNode resNode = null;if (this.left != null){resNode = this.left.postOrderSearch(no);}if (resNode != null){return resNode;}if (this.right != null){resNode = this.right.postOrderSearch(no);}if (resNode != null){return resNode;}if (this.no == no){return this;}return resNode;}}线索化⼆叉树类//创建⼀颗线索化⼆叉树class ThreaderBinaryTree{//⼆叉树必有根节点private HeroNode root;//定义变量指向前驱节点,默认为空private HeroNode pre = null;public void setRoot(HeroNode root) {this.root = root;}//编写中序线索化⼆叉树的⽅法/**** @param node node为当前要中序线索化的节点*/public void infixThreadedBinaryTree(HeroNode node){//先判断当前节点是否为空if (node == null){return;}//如果不为空，先线索化左⼦树infixThreadedBinaryTree(node.getLeft());//再线索化当前节点//当前节点的前驱节点为pre,后继节点需要在下⼀个节点连通，因为是单向的 //设置当前节点的前驱节点，并设置前驱节点类型if (node.getLeft() == null){node.setLeft(pre);node.setLeftType(1);}//设置当前节点的后继节点及其类型if (pre != null && pre.getRight() == null){pre.setRight(node);pre.setRightType(1);}//让pre指向当前节点pre = node;//最后再线索化右⼦树infixThreadedBinaryTree(node.getRight());}//重载线索化的⽅法public void infixThreadedBinaryTree(){this.infixThreadedBinaryTree(root);}//删除节点/**** @param no 要删除的节点编号*/public void delNode(int no){//先判断⼆叉树是否为空if (this.root != null){//再判断当前root节点是不是要删除的节点if (this.root.getNo() == no){root = null;}else {this.root.delNode(no);}}else {System.out.println("⼆叉树为空，不能删除...");}}//前序遍历public void preOrder(){if (this.root != null){this.root.preOrder();}else {System.out.println("⼆叉树为空...");}}//中序遍历public void infixOrder(){if (this.root != null){this.root.infixOrder();}else {System.out.println("⼆叉树为空...");}}//后续遍历public void postOrder(){if (this.root != null){this.root.postOrder();}else {System.out.println("⼆叉树为空...");}}//前序查找public HeroNode preOrderSearch(int no){if (this.root != null){return this.root.preOrderSearch(no);}else {return null;}}//中序查找public HeroNode infixOrderSearch(int no){if (this.root != null){return this.root.infixOrderSearch(no);}else {return null;}}//后续查找public HeroNode postOrderSearch(int no){if (this.root != null){return this.root.postOrderSearch(no);}else {return null;}}}测试类public static void main(String[] args) {ThreaderBinaryTree threaderBinaryTree = new ThreaderBinaryTree(); HeroNode root = new HeroNode(1,"tom");HeroNode node2 = new HeroNode(3,"jack");HeroNode node3 = new HeroNode(6,"smith");HeroNode node4 = new HeroNode(8,"king");HeroNode node5 = new HeroNode(10,"mary");HeroNode node6 = new HeroNode(14,"dop");root.setLeft(node2);root.setRight(node3);node2.setLeft(node4);node2.setRight(node5);node3.setLeft(node6);threaderBinaryTree.setRoot(root);//进⾏线索化threaderBinaryTree.infixThreadedBinaryTree();//测试线索化的结果System.out.println("node5的前⼀个节点 = " + node5.getLeft());System.out.println("node5的后⼀个节点 = " + node5.getRight());}。

线索二叉树(图)

线索二叉树：遍历二叉树：实际上是对二叉树（非线性结构）进行的线性化操作，即以一定规则将二叉树中的结点排列成一个线性序列（先序序列、中序序列和后序序列）。

举例：图6.9所示的二叉树中的结点，按中序遍历可得到中序序列：a+b*c-d-e/f，其中‘c’的前驱为‘*’，后继为‘-’。

当以二叉链表作为二叉树的存储结构时，只能找到结点的左右孩子信息，而不能直接得到结点在任一线性序列中的前驱和后继信息，因为这种信息只有在遍历的动态过程中才能得到。

如何保存这种在遍历过程中得到的结点的前驱和后继信息呢？方法一：在二叉链表的每个结点上增加两个指针域fwd和bkwd，分别指向在依任一次序遍历时得到的前驱和后继信息。

（大大影响存储密度）方法二：利用二叉链表中的空链域来存放结点的前驱和后继信息。

（在有n个结点的二叉链表中必定存在n+1个空链域！）（不影响存储密度）为此，可以将二叉链表中的结点结构作如下修改：lchild LTag data RTag rchild其中：Ltag = 0 lchild域指示结点的左孩子1 lchild域指示结点的前驱Rtag = 0 rchild域指示结点的右孩子1 rchild域指示结点的后继我们把如此修改后的二叉链表称为二叉树的线索链表，其中指向结点前驱和后继的指针称为线索。

相应地，把添加线索后的二叉树称为线索二叉树(Threaded Binary Tree)。

对二叉树以某种次序遍历使其变为线索二叉树的过程叫做线索化。

举例：图6.11(a)所示为中序线索二叉树，与其对应的中序线索链表如图 6.11(b)所示。

其中实线为指针（指向左、右子树），虚线为线索（指向前驱和后继）。

在线索树上进行遍历，只要找到序列中的第一个结点，然后依次找结点的后继直到其后继为空时而停止。

关键是如何在线索树中找结点的后继？二叉树的二叉线索存储表示：（p133-134）线索二叉树的遍历：（以中序线索二叉树为例，即中序遍历二叉线索树）算法6.5二叉树的线索化：（以中序线索化为例，即通过中序遍历建立中序线索链表）算法6.6，算法6.7。

浅谈线索二叉树

浅谈线索二叉树摘要：数据结构中二叉树有很多的遍历算法，但本质都是将属性结构转换为线性序列，简化问题。

在遍历序列中，每个节点都有自己的前驱和后去，但在二叉树遍历过程中寻求答案却因为时间复杂度等因素使操作效率低下。

线索二叉树很好地解决了这一问题，本文是在二叉树的基础上加入线索二又树实现数据的快速可操作性。

关键词：数据结构；线索二叉树；应用前言为了实现在遍历序列中快速查找节点的前驱、后继，利用二叉链表中空的指针域，指向结点在遍历序列中的前驱、后继，这些指向前驱、后继的指针就是线索。

1、数据结构数据结构起源于程序设计，主要是电脑中数据的组织方式、存储结构和处理方法。

在程序的编程中，写一个“好”的程序，就是要选择一个合理的数据结构和算法。

数据的逻辑结构常用结构图来描述，将每一个数据元素看做一个结点，在计算处理数据的时候，算法同样很关键。

一种算法的有穷性，必须对任何合法的输入在执行有穷之后结束，并且每 1 步都在有穷时间内完成。

树形结构就是用于有层次关系的数据表示，表达大多数问题求解的思路，而二叉树的结点数和深度，为二叉树存储结构的选择提供了预备知识和思考线索。

线索二又树借助二又树遍历的程序框架建立，通过函数将整个二叉树的线索化分解，求后继、前驱结点的算法增加数据操作的效率，缩短时间，提高数据的操作性。

2、树的结构定义树形结构是信息的重要组织形式之一，树是一种数据结构，它是由n(n>=1)个有限结点组成一个具有层次关系的集合。

把它叫做“树”是因为它看起来像1棵倒挂的树，也就是说它是根朝上，而叶朝下的。

它具有以下的特点：(1)每个结点有零个或多个子结点；(2)每一个子结点只有一个父结点；(3)没有前驱的结点为根结点；(4)除了根结点外，每个子结点可以分为多个不相交的子树。

树的应用非常广泛，在程序设计中实现通用树的基本功能需要考虑很多功能，比方内存分配，添加节点，修改节点，删除节点，移动节点，遍历，查询，保存，读取问题。

浅谈二叉树线索化及利用线索进行遍历

“数据结构 ”在计算机科学中是一门综合性的专业基础课。它的研究不仅涉及到计算机硬件的范围，而且和计算机软件有着更密切的关系．无论是编译程序还是操作系统。都涉及到数据元素在存储器中的分配问题。在研究信息检索时也必须考虑如何组织数据，以便查找和存取数据元素更为方便。数据结构和算法是程序设计的基础，可以用该式来表示：
程序＝算法＋数据结构遍历二叉树是以一定规则将二叉树中结点排列成一个线性序列，得￣ｍｌ＿－叉树中结点的先序或中序序列或后序序列。这实质上是对一个非线性结构进行线性化操作，使每个结点（除第一个和最后一个外）在这些线性序列中有且仅有一个直接前驱和直接后继。但是．当以二叉链表作为存储结构时．只能找到结点的左、右孩子信息，而不能直接得到结点在任一序列中的前驱和后继信息，这种信息只有在遍历的动态过程中才能得到。如果对这种二叉树进行线索化，就能够直接得到结点的前驱和后继信息。
ＺＨＯＵＭｉｎ，ＹＵＹｉｎｇ－ｊａｎ
（ＨｅｉｌｏｎｇｊｉａｎｇＡｇｒｉｃｕｌｔｕｒａｌＥｃｏｎｏｍｙＶｏｃａｔｉｏｎａｌＣｏｌｌｅｇｅ，Ｍｕｄａｎｇｊｉａｎｇ１５７０４１，Ｃｈｉｎａ）

二叉树的遍历

T->rchild= CreatBiTree(); /*构造右子树*/ 扩展先序遍历序列
}
2021/2/21
return (T) ;}
A B Φ D Φ Φ C Φ 17Φ
T
T
T
ch=B
ch=Φ
Λ
T
T= Λ, Creat(T)
ch=A T
A
B creat(T L)
ΛB 返回
creat(T L)
creat(T R)
A
p=p->RChild;
}
2021/2/21
}
top
A
B
C
D
top
B
top
A
A
top
D
A
top
A
top
C
13
top
中序遍历二叉树的非递归算法：
A
void InOrder(BiTree T)
{ InitStack(&S); 相当于top=-1;
p=T;
B
C
while(p!=NULL | | !IsEmpty(S)) 相当于top==-1;
}
后序遍历二叉树的递归算法：
void PostOrder (BiTree T)
{ if(T!=NULL)
{ PostOrder (T->lchild);
PostOrder (T->rchild);
printf(T->data); }
2021/2/21
15
}
先序遍历二叉树的递归算法： void PreOder (BiTree T) { if(T! =NULL){ printf (T->data); PreOrder (T->lchild); PreOrder (T->rchild); } }

数据结构中二叉树的生成及遍历非递归算法浅析

及运算都较为简练，因此，二叉树在数据结构课程中显得特别ｃａｄｔ；ｈｒａａｓｕｔｔｏｅｃｉ，ｈｄｔｃｂｎｄｈｄｒｉ；ｒｌｌｃｌ二叉树是由结点的有限集合构成，这个有限集合或者为空｝ｔｅＢｒ；ｅ集，或者是由一个根节点及两棵互不相交的分别称之为这个根Ｂｒｅ［ａｓｅｔＱｍｘｉ］ｅｚ；
一
、
引言
＃ｃｄ “ａｏｈｉｌｅｍ１・ｎｕ］ ” ｃ
ｔｅｅ。ｃｂｏｅｙｄｔｔｔｄ｛ｐｎ
、
二叉树是一种重要的树形结构，其结构规整。许多实际问＃ｅｎＵＬ０ｄｆｅＬｉＮ
题抽象出来的数据结构往往是二叉树的形式，而且其存储结构重要，这里我们先了解一下二叉树。
，
立二叉链表。一般的二对于叉树，必须添加一些虚结点，使其成 ‘ ～’ ：一、
队列是一个指针类型的数组，保存已输入的结点＿… 、
… ～ … 一 ’
，
＃ｅｎｘｉ０ｄｆｅｍａｓｚ１０ｉｅ衔ｎｌｄｓｄｏｈ” ｃｕｅ“ ｔｉ．
ｓ＞一
ｌ＝Ｌ；ｄＵＬ
ｒａ＋；ｅｒ＋
Ｑｒａ１ｓｒ；ｅ＝
。
３办公自动化杂志ｏ。
ｉｒａ－１Ｔｓｆｅｒ＝）＝：（＝
ｅｓｌｅ
ｆ＝ｔｋｔ］Ｔｓｃ［ｐ；ａｏ
近＞ｉ＝ｐ卜ｒ＝）曲ｔ
ｆｒｆ“ ＂－ｄｔ；ｐｉ（％ｃ，＞ａａｎＴ）
递归算法，故有关二叉树的试题通常要求采用非递归算法，这就Ｂｒ，；ｔｅｅｓ使得掌握二叉树的生成及遍历的非递归算法成为必要。ｔＮＩ；＝ｕＪＬ

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

数据结构课程设计题目: 线索二叉树的生成及其遍历学院：理学院班级：数学13-2班学生姓名：孙晴、张炳赫、张美娜、董自鹏学生学号： 8、12、13、22 指导教师：张太发2014 年 12月 24日课程设计任务书目录摘要................................. 错误!未定义书签。

1 题目分析.......................... 错误!未定义书签。

1.1相关思想及概念介绍 (1)1.2线索二叉树的结构 (1)1.3需求分析 (2)2 概要设计 (2)2.1抽象数据类型的定义 (3)2.2主程序的流程 (3)2.3各程序模块之间的层次(调用)关系 (5)3 详细设计 (6)4 调试分析 (10)5 用户使用说明 (10)6 测试结果 (11)7 课程设计体会 (12)8 参考文献 (12)9 源程序 (13)摘要针对以二叉链表作为存储结构时，只能找到结点的左、右孩子的信息，而得不到结点的前驱与后继信息，为了使这种信息只有在遍历的动态过程中才能得到。

增设两个指针分别指示其前驱和后继，并且利用结点的空链域存放（线索链表）。

同时为了记下遍历过程中访问结点的先后关系，附设一个指针pre始终指向刚刚访问过的结点，若指针 p 指向当前访问的结点，则 pre指向它的前驱。

由此得到中序遍历建立中序线索化链表的算法本文通过建立二叉树，实现二叉树的中序线索化并实现中序线索二叉树的遍历。

实现对已生成的二叉树进行中序线索化并利用中序线索实现对二叉树的遍历的效果。

关键词：二叉树，中序线索二叉树，中序线索二叉树的遍历1 题目分析1.1 相关思想及概念介绍（1）二叉树遍历二叉树的遍历是指按照某种顺序访问二叉树中的每个结点，使每个结点被访问一次且仅被访问一次。

遍历二叉树中经常要用到的一种操作。

因为在实际应用问题中，常常需要按一定顺序对二叉树中的每个结点逐个进行访问，查找具有某一特点的结点，然后对这些满足条件的结点进行处理。

通过一次完整的遍历，可使二叉树中结点信息由非线性排列变为某种意义上的线性序列。

也就是说，遍历操作使非线性结构线性化。

由二叉树的定义可知，一棵二叉树由根结点、根结点的左子树和根结点的右子树三部分组成。

因此，只要依次遍历这三部分，就可以遍历整个二叉树。

若以D、L、R分别表示访问根结点、遍历根结点的左子树、遍历根结点的右子树，则二叉树的遍历方式有6种：DLR、LDR、LRD、DRL、RDL、和RLD。

如果限定先左后右，则只有前三种方式，即DLR（先序遍历）、LDR（中序遍历）和LRD（后序遍历）。

（1）线索二叉树按照某种遍历方式对二叉树进行遍历，可以把二叉树中所有结点排列为一个线性序列。

在该序列中，除第一个结点外，每个结点有且仅有一个直接前驱结点；除最后一个结点外，每个结点有且仅有一个直接后继结点。

但是，二叉树中每个结点在这个序列中的直接前驱结点和直接后继结点是什么，二叉树的存储结构中并没有反映出来，只能在对二叉树遍历的动态过程中得到这些信息，可以利用二叉树的二叉链表存储结构中的那些空指针域来指示。

这些指向直接前驱结点和指向直接后继结点的指针被称为线索，借了线索的二叉树成为线索二叉树。

线索二叉树将为二叉树的遍历提供许多方便。

1.2 线索二叉树的结构1、n个结点有n-1个前驱和n-1个后继；一共有2n个链域，其中：n+1个空链域，n-1个指针域；因此, 可以用空链域来存放结点的前驱和后继。

线索二叉树就是利用n+1个空链域来存放结点的前驱和后继结点的信息。

2、线索：有效利用二叉链表中空的存储空间，指定原有的孩子指针为空的域来存放指向前驱和后继的信息，这样的指针被称为“线索”。

加线索的过程称为线索化，由此得到的二叉树称作线索二叉树。

若结点有左子树，则左链域lchild指示其左孩子（ltag=0）；否则，令左链域指示其前驱（ltag=1）；若结点有右子树，则右链域rchild指示其右孩子（rtag=0）；否则，令右链域指示其后继（rtag=1）；增设一个头结点，令其lchild指向二叉树的根结点，ltag=0、rtag=1；并将该结点作为遍历访问的第一个结点的前驱和最后一个结点的后继；最后用头指针指示该头结点。

其rchild域的指针指向中序遍历时访问的最后一个结点；反之，令二叉树中序序列中的第一个结点的lchild域指针和最后一个结点rchild 域的指针均指向头结点，这好比为二叉树建立了一个双向线索链表，既可以从第一个结点起顺后继进行遍历，也可以从最后一个结点起顺前驱进行遍历。

3、例子：如下图a示的二叉树，其中序线索二叉树为图b所示：1.3 需求分析以二叉链表作为存储结构时，只能找到结点的左、右孩子的信息，而得不到结点的前驱与后继信息，为了使这种信息只有在遍历的动态过程中才能得到。

增设两个指针分别指示其前驱和后继，并且利用结点的空链域存放（线索链表）。

同时为了记下遍历过程中访问结点的先后关系，附设一个指针pre始终指向刚刚访问过的结点，若指针 p 指向当前访问的结点，则 pre指向它的前驱。

由此得到中序遍历建立中序线索化链表的算法本文通过建立二叉树，实现二叉树的中序线索化并实现中序线索二叉树的遍历。

实现对已生成的二叉树进行中序线索化并利用中序线索实现对二叉树的遍历的效果。

主要任务：1.建立二叉树；2.将二叉树进行中序线索化；3.编写程序，运行并修改；4.利用中序线索遍历二叉树5.书写课程设计论文并将所编写的程序完善。

2 概要设计2.1抽象数据类型的定义二叉树的存储结构struct node{ ElemenType data; //数据域int ltag; //左标志域int rtag; //右标志域struct node *lchild; //左指针域struct node *rchild; //右指针域}BTree;2.2主程序的流程3 详细设计（一）算法的C语言实现#include "stdio.h"#include "stdlib.h"#define OK 1typedef char TElemType;typedef int Status;typedef enum PointerTag {Link,Thread};//link==0:pointer,Thread==1:threadtypedef struct BiThrNode{TElemType data;struct BiThrNode *lchild,*rchild;PointerTag LTag,RTag;}BiThrNode,*BiThrTree;BiThrTree pre; // 全局变量,始终指向刚刚访问过的结点void InThreading(BiThrTree p){if(p){InThreading(p->lchild);//左子树线索化if(!p->lchild){p->LTag=Thread;p->lchild=pre;}//前驱线索if(!pre->rchild){pre->RTag=Thread;pre->rchild=p;}//后续线索 pre=p; //保持pre指向p的前驱InThreading(p->rchild);//右子树线索化}//if}//InThreadingStatus InOrderThreading(BiThrTree &Thrt,BiThrTree T){//中序遍历二叉树，并将其中序线索化，Thrt指向头结点//BiThrTree Thrt;if(!(Thrt=(BiThrTree)malloc(sizeof(BiThrNode)))) exit(-1); Thrt->LTag=Link; //建立头结点Thrt->RTag=Thread; //右指针回指Thrt->rchild=Thrt;if(!T) Thrt->rchild=Thrt; //若二叉树为空，则左指针回指else {Thrt->lchild=T;pre=Thrt;InThreading(T); //中序遍历进行中序线索化pre->rchild=Thrt;//最后一个结点线索化pre->RTag=Thread;Thrt->rchild=pre;}return OK;}//InOrderThreadingStatus InOrderTraverse_Thr(BiThrTree T){//T指向头结点，头结点的左链lchild指向根结点，非递归算法BiThrTree p;p=T->lchild;while(p!=T) //空树或遍历结束时，T＝＝p{while(p->LTag==Link) p=p->lchild;printf("%c\n",p->data); //访问其左子树为空的结点while(p->RTag==Thread&&p->rchild!=T){p=p->rchild;printf("%c\n",p->data); //访问后续结点}//whilep=p->rchild;}//whilereturn OK;}//InOrderT_ThrStatus CreateBitree(BiThrTree &T){//按先序次序输入二叉树char ch,enter;scanf("%c%c",&ch,&enter);if(ch==' ') T=NULL;else{if(!(T=(BiThrTree)malloc(sizeof(BiThrNode)))) exit(1);T->data=ch;CreateBitree(T->lchild);CreateBitree(T->rchild);}//elsereturn OK;}//CreateBitreeint main(){BiThrTree T,Thrt;CreateBitree(T);//创建InOrderThreading(Thrt,T);//线索化InOrderTraverse_Thr(Thrt);//遍历访问return OK;}注意点：在输入字符创立二叉树时，要注意叶子结点的输入形式，即叶子结点的左右空指针也要输入，在我们这里输入空格。

（二）建立中序二叉树的递归算法，其中pre为全局变量。

BiThrNodeType *pre;BiThrTree InOrderThr(BiThrTree T){ /*中序遍历二叉树T，并将其中序线索化，pre为全局变量*/BiThrTree head;head=(BitThrNodeType *)malloc（sizeof（BiThrType））;/*设申请头结点成功*/head->ltag=0;head->rtag=1;/*建立头结点*/head->rchild=head;/*右指针回指*/if(！T)head->lchild=head;/*若二叉树为空，则左指针回指*/ else{head->lchild=T;pre=head;InThreading(T);/*中序遍历进行中序线索化*/pre->rchild=head;pre->rtag=1;/*最后一个结点线索化*/head->rchild=pre;};return head;}void InThreading(BiThrTree p){/*通过中序遍历进行中序线索化*/if(p){InThreading(p->lchild);/*左子树线索化*/if(p->lchild==NULL)/*前驱线索*/{p->ltag=1;p->lchild=pre;}if(p->rchild==NULL)p->rtag=1;/*后驱线索*/if(pre!=NULL && pre->rtag==1) pre->rchild=p;pre=p;InThreading(p->rchild);/*右子树线索化*/}}进行中序线索化的算法：bithptr*pre; /* 全程变量*/voidINTHREAD(bithptr *p){if(p!=NULL){ INTHREAD(p->lchild); /* 左子树线索化*/if(p->lchild==NULL) {p->ltag=1;p->lchild=pre;}if(p->rchild==NULL) p->rtag=1;if(pre!=NULL && pre->rtag==1)pre->rchild=p;pre=p; /* 前驱指向当前结点*/INTHREAD(p->rchild); /* 右子树线索化*/}4 调试分析该程序在调试过程中遇到的问题是：对已学知识运用能力欠缺，尤其是在编程方面，由于C语言等计算机基础课程知识没有很好的掌握同时在学习数据结构时也没有真正弄懂导致编程时小错误不断，而且在遇到许多小的错误时靠自己很难再调整过来，但整体上是一次对所学知识的运用巩固，特别是对二叉树的建立以及对它进行线索方面，翻阅大量的书籍及搜集资料并求教于计算机系的同学，才找到一些解决问题的方法，在用中序遍历线索二叉树时总是搞混不过也因此让我对前序，中序，后序遍历更加理解。