中序线索化二叉树数据结构
数据结构(Java版)_郑州大学中国大学mooc课后章节答案期末考试题库2023年
数据结构（Java版）_郑州大学中国大学mooc课后章节答案期末考试题库2023年1.对不含相同元素的同一输入序列进行两组不同的、合法的入栈和出栈组合操作，所得的输出序列一定相同。
参考答案:错误2.在链队列中，即使不设置尾指针，也能进行入队操作。
参考答案:正确3.循环顺序队列和循环链队列都存在空间一处问题。
参考答案:错误4.直接选择排序的时间复杂度与关键字的初始排列无关。
参考答案:正确5.一个循环链表可以由给定的头指针或尾指针来唯一标识。
参考答案:正确6.所谓随机存取，就是通过首地址和元素的序号可以在O(1)的时间内找到指定的元素。
参考答案:正确7.快速排序在最坏情况下的时间复杂度是O(【图片】)。
参考答案:正确8.哈夫曼树是带权路径长度最短的树，路径上权值较大的结点离根较近（）参考答案:正确9.在队列中存取数据元素的原则是（）。
参考答案:先进先出10.将整数1、2、3、4依次进栈，则不可能得到的出栈序列是（）。
参考答案:142311.完全二叉树的存储结构通常采用顺序存储结构（）。
参考答案:正确12.在中序线索二叉树中，每一非空的线索均指向其祖先结点（）参考答案:正确13.二叉树中序线索化后，不存在空指针域（）参考答案:错误14.二叉树的层次遍历需要栈结构的支持。
参考答案:错误15.下列关于AOE网的叙述中，不正确的是（）参考答案:任何一个关键活动提前完成，那么整个工程将会提前完成16.一棵非空的二叉树的先序遍历序列与后序遍历序列正好相反，则该二叉树一定满足（）参考答案:只有一个叶子结点17.引入二叉线索树的目的是（）参考答案:加快查找结点的前驱或后继的速度18.单源最短路径算法的时间复杂度为（）参考答案:O()19.对6个不同的数据元素进行直接插入排序，最多需要进行（）次关键字的比较。
参考答案:1520.完全二叉树中，若一个结点没有左孩子，则它必是树叶（）。
参考答案:正确21.已知循环队列存储在一维数组A[0【图片】n]中，且队列非空时front和rear分别指向队首元素和队尾元素。
2016年考研核心题型【数据结构部分】【第4章 树与二叉树】
其余的 b 和 c 结点都各有一个前驱结点和后继结点。
那么，将 d 右指针域（初始为空）调整并指向其后继结点 b。将 b 结点的左指针域调整
指向其前驱结点 d，因为 b 的右指针域不为空，所以线索化过程中不需要调整。c 的左右指
针域都为空，令其左指针域指向其前驱结点 b，右指针域指向其后继结点 a。
有在已知前序遍历序列或者后序遍历序列的情况下，又知道中序遍历序列，才能唯一确定
一棵二叉树。
遍历一棵二叉树，要使得前序遍历序列和后序遍历序列刚好相反，那么必须保证每一
个结点都只有一个孩子结点。故而，二叉树的高度为 4。那么，在前序遍历序列为 1、2、3、
4，后序遍历序列为 4、3、2、1 的情况下，该二叉树第 1、2、3、4 层的结点依次为 1、2、
【解析】对于某一种遍历顺序对应的线索化，只需写出对应的遍历序列，然后修改空
指针域分别指向该遍历序列的前驱和后继即可。例如，本题中的二叉树的后序遍历可得到
序列 d、b、c、a。那么，d 是第一个元素，没有前驱，所以其左指针域原来为空，线索化时
亦为空；a 是最后一个元素，但是其左右孩子都不为空，所以不需要考虑该结点的线索化；
24
13
53
37
90
48
图 4.4 插入新的结点 48 之后，我们沿着叶子结点 48 往根节点的路径上，查找第一个不平衡 的结点。显然，24 是第一个不平衡的结点，其左子树的高度为 1，右子树的高度为 3。图中 的粗线部分，即需要旋转的部分。 那么，造成了什么类型的不平衡呢？我们这样判断：53 是 24 右孩子（R），37 是 24 的左孩子（L），所以是 RL 型不平衡。于是，先把结点 24 的右孩子 53 的左孩子 37 向右上 方旋转到原来 53 的位置，再将 37 向左上旋转到 24 的位置，24 被旋转下来。成了如图 4.5 所示的样子。
第6章_数据结构习题题目及答案_树和二叉树_参考答案
一、基础知识题6.1设树T的度为4，其中度为1，2，3和4的结点个数分别为4，2，1，1，求树T中的叶子数。
【解答】设度为m的树中度为0,1,2,…,m的结点数分别为n0, n1, n2,…, nm，结点总数为n，分枝数为B，则下面二式成立n= n0+n1+n2+…+nm (1)n=B+1= n1+2n2 +…+mnm+1 (2)由(1)和(2)得叶子结点数n0=1+即： n0=1+(1-1)*4+(2-1)*2+(3-1)*1+(4-1)*1=86.2一棵完全二叉树上有1001个结点，求叶子结点的个数。
【解答】因为在任意二叉树中度为2 的结点数n2和叶子结点数n0有如下关系：n2=n0-1,所以设二叉树的结点数为n, 度为1的结点数为n1，则n= n0+ n1+ n2n=2n0+n1-11002=2n0+n1由于在完全二叉树中，度为1的结点数n1至多为1，叶子数n0是整数。
本题中度为1的结点数n1只能是0，故叶子结点的个数n0为501.注：解本题时要使用以上公式，不要先判断完全二叉树高10，前9层是满二叉树，第10层都是叶子，……。
虽然解法也对，但步骤多且复杂，极易出错。
6.3 一棵124个叶结点的完全二叉树，最多有多少个结点。
【解答】由公式n=2n0+n1-1,当n1为1时，结点数达到最多248个。
6.4．一棵完全二叉树有500个结点，请问该完全二叉树有多少个叶子结点？有多少个度为1的结点？有多少个度为2的结点？如果完全二叉树有501个结点，结果如何？请写出推导过程。
【解答】由公式n=2n0+n1-1，带入具体数得，500=2n0+n1-1，叶子数是整数，度为1的结点数只能为1，故叶子数为250，度为2的结点数是249。
若完全二叉树有501个结点，则叶子数251，度为2的结点数是250，度为1的结点数为0。
6.5 某二叉树有20个叶子结点，有30个结点仅有一个孩子，则该二叉树的总结点数是多少。
线索二叉树
遍历 线索 二叉 树非
{
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;
中序线索树的理解
教材178页
pre是全局变量，他的初值是NULL，始终指向刚访问的结点
在程序中，假设所要线索化的二叉树如下：
A
/ \
B E
/ \ / \
C D F G
当我们把C访问完后递归退层到B,然后执行加线索操作，第一if条件因为B有右孩子而不满足，
程序到第二个if，因为pre上次已经指向了C,所以满足条件，所以，执行第二个if里面的语句，将
C的右孩子指针指向了当前访问的结点B，即，为C设置了后继结点，其它步骤依次类推。
总结：
ห้องสมุดไป่ตู้
（中序）线索化树的加线索操作过程中，每次只是为当前访问的结点设置了它的前驱，并没有
不满足条件if（pre！=NULL&&pre->Rchild==NULL）,所以直接执行第三步，让pre指向刚被访问过的
的C结点，到这里，我们发现，C的前驱已经确定了（不存在），但是C的后继并没有确定，
是怎么回事呢？别着急，其实，C的后继是在访问下一个结点时确定的，即在访问B结点时确定的，
如下分析：
那么依次递归调用，首先要访问的便是C结点，因为当Inthread（C->Lchild）时，
不满足条件，递归退回到C，所以从C开始，第一，if（root（即就是C）->lchild==null）
满足，所以C的左孩子指针便被设置为指向其前驱，但是由于C是第一个被访问的，所以没有前驱，
所以C->Lchild便为pre的初值，为空，第二，因为pre为空，
线索二叉树
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指向其前驱；否则，该结点的前驱是以该结点为根的左子树上按中序遍历的最后一个结点。
线索二叉树
void InThreading(BiThrTree p) { if ( p ) { InThreading ( p -> lchild ); //左子树中序线索化 左子树中序线索化 if ( p->lchild = = NULL ) { p->LTag=Thread; p->lchild= pre; } //左线索为 ; 左线索为pre 左线索为 if ( pre->rchild == NULL ) { pre->RTag=Thread; pre->rchild= p ;} //后继线索 后继线索 pre = p; //保持 指向 的前驱 保持pre指向 保持 指向p的前驱 InThreading(p -> rchild ); //右子树中序线索化 右子树中序线索化 } }//InThreading
指向该线性序列中的“前驱”和 “后继” 的指针 指针，称作“线索” 线索” 指针 线索
A B C D E F G H K
^B
C^ E^
^D^
包含 “线索” 的存储 结构，称作 “线索链 线索链 表” 与其相应的二叉树， 线索二叉树” 称作 “线索二叉树 线索二叉树中序线索二叉树源自A0 1B
C
NULL
Status InOrderThreading (BiThrTree &Thrt , BiThrTree T ) { //将二叉树 改变为其中序线索二叉树 将二叉树T改变为其中序线索二叉树 if ( !Thrt = (BiThrTree ) malloc (sizeof(BiThrNode))) exit ( OVERFLOW ); Thrt-> LTag = Link ; Thrt ->RTag = Thread; Thrt -> rchild = Thrt; if ( !T ) Thrt -> lchild = Thrt; //空树 空树 else { Thrt -> lchild = T ; pre = Thrt ; InTreading( T ); //中序遍历进行中序线索化 中序遍历进行中序线索化 pre-> rchild = Thrt; pre->RTag= Thread; Thrt -> rchild = pre; } return OK; }
若x是二叉树中序线索树中一个有左孩子的结点
若x是二叉树中序线索树中一个有左孩子的结点1二叉树中序线索树二叉树中序线索树（Threaded Binary Tree）是指用线索把二叉树的空缺指针打上标记，使其成为双链表，以便让二叉树具有更强的访问能力，同时节省存储空间。
2特点线索标识：对于空链接而言，我们给其添加一个特殊标记，来标识空链接，用来控制遍历时循环跳出。
数据结构：在线索树中，将每一个节点结构体特殊定义为线索化节点结构体，用tag标记左右孩子的指针是否为空，及其空时的处理方式。
3操作中序线索树的操作主要是遍历二叉树，即中序遍历和前序遍历。
中序遍历：中序遍历的核心在于只有当结点的左子树遍历完了才能继续遍历右子树，所以用线索树以后，其中序遍历可以沿所有指向前驱结点的线索一路返回根结点，即访问根结点之前访问它的前驱，然后从根结点出发，依次访问所有后继结点。
前序遍历：前序遍历的核心在于无论根节点在哪里，都要先访问它，然后访问左孩子，最后访问右孩子。
因此采用线索树以后，只要沿着指向父结点的线索一路回退根结点，即可访问所有的先序顺序访问。
4具体应用二叉树中序线索树和树结构在很多应用程序中都有广泛的应用，其中最常用的两个应用分别是树查询和语法分析。
树查询：用线索树具有快速查询的特性，可以大大提高查询的速度，尤其是在复杂的树结构中使用线索树，查询的速度会更快。
语法分析：用于自动处理语言，是对源代码中的符号进行分析的过程，以构建出一棵源程序的语法树节点，可以用线索树这种数据结构来实现快速的访问和查找。
5若x是二叉树中序线索树中一个有左孩子的结点若节点x具有左孩子，那么该节点x通过线索把左孩子结点加上标记，以便于后续遍历，当访问x时，可通过线索遍历该左节点，并与其他节点信息进行交互，而不必从根结点开始重复遍历。
同时，如果该节点x的右节点不是叶子结点，那么可以借助线索快速找到x的右节点，不需要通过先找到x的左节点才能找到右节点。
简述二叉树的五种形态
简述二叉树的五种形态二叉树是一种常用的数据结构，它由节点组成，每个节点最多有两个子节点。
根据节点的分布情况，二叉树可以分为五种形态，分别是满二叉树、完全二叉树、平衡二叉树、搜索二叉树和线索二叉树。
一、满二叉树满二叉树是指除了叶子节点外，每个节点都有两个子节点的二叉树。
也就是说，满二叉树的所有层都是满的，并且最后一层的叶子节点都靠左排列。
满二叉树的节点数可以通过公式计算得到，假设树的高度为h，则节点数为2^h - 1。
满二叉树的特点是结构简单，查找速度快。
在满二叉树中，任意两个节点的路径长度都相同。
二、完全二叉树完全二叉树是指除了最后一层之外，其他层都是满的，并且最后一层的叶子节点都靠左排列的二叉树。
完全二叉树的特点是节点数较少，结构相对简单。
完全二叉树通常用数组来表示，因为它的节点之间的关系可以通过数组的下标来表示。
在完全二叉树中，任意一个节点的左子节点的下标为2i，右子节点的下标为2i+1。
三、平衡二叉树平衡二叉树是指左右子树的高度差不超过1的二叉树。
平衡二叉树的特点是查找、插入和删除的时间复杂度都为O(logn)，其中n是节点的数量。
平衡二叉树的高度可以通过节点的平衡因子来计算，平衡因子定义为左子树的高度减去右子树的高度。
平衡因子的取值范围为-1、0和1，当平衡因子的绝对值大于1时，需要通过旋转操作来调整树的平衡性。
四、搜索二叉树搜索二叉树，也称为二叉搜索树或排序二叉树，是一种特殊的二叉树。
它的特点是对于树中的任意一个节点，其左子树中的所有节点都小于它，右子树中的所有节点都大于它。
搜索二叉树的中序遍历结果是一个递增的有序序列。
搜索二叉树的特点是可以快速地查找某个节点，时间复杂度为O(logn)，其中n是节点的数量。
但是，如果搜索二叉树不平衡，即左子树或右子树过深，则会导致查找的时间复杂度退化为O(n)。
五、线索二叉树线索二叉树是对二叉树进行了优化的数据结构，它通过添加指向前驱和后继节点的线索，使得遍历操作更加高效。
画出中序线索二叉树简单例题
画出中序线索二叉树简单例题
假设有一个二叉树如下：
A
/ \
B C
/ \ / \
D E F G
根据中序遍历的顺序，节点的访问顺序应该为 D -> B -> E -> A -> F -> C -> G。
我们可以通过添加线索化标记，将每个节点的左右空指针改为指向其前驱和后继节点。
这样，递归遍历中序线索二叉树时不再需要通过递归调用访问左右子树，而可以直接跳转到前驱或后继节点。
线索化后的二叉树如下：
D
\
B
/ \
E A
\
F
/ \
G C
在中序线索二叉树中，对于每个节点，其指向前驱节点的指针称为"前驱线索"，指向后继节点
的指针称为"后继线索"。
这样，我们可以通过线索化标记快速找到任意节点的前驱和后继节点，而不需要遍历整棵树。
例如，节点 A 的后继节点为 F，前驱节点为空。
节点 C 的后继节点为尚未线索化的节点 G，
前驱节点为节点 A。
节点 D 的后继节点为节点 B，前驱节点为尚未线索化的节点 E。
通过线索化，我们可以利用中序线索二叉树实现快速查找任意节点的前驱和后继节点，而不需要进行递归遍历。
这样，我们可以在时间复杂度为O(1) 的情况下完成前驱和后继节点的查找，大大提高了效率。
总结起来，中序线索二叉树可以在原有二叉树的基础上添加线索化标记，从而实现快速查找任意节点的前驱和后继节点。
这一特性在某些需要频繁查找节点前驱和后继的应用场景中具有重要意义。
计算机数据结构知识点梳理 线索二叉树的基本概念和构造
[题2] 一棵左子树为空的二叉树在先序线索化后，其中空链域的个数是（ ）。
A．不确定 B．0
C．1
D．2
分析：左子树为空的二叉树的根结点的左线索为空（无前驱），先序序列的最后 结点的右线索为空（无后继），共2个空链域。
解答：D。
这样，在线索二叉树（特别是中序线索二叉树）上遍历就消除了递归，也不使用栈（其 中后序线索二叉树中查找后继仍需要栈）。
2、由于序列可由不同的遍历方法得到，因此，线索树有先序线索二叉树、中 序线索二叉树和后序线索二叉树三种。在先序、中序和后序线索二叉树中所位取值也完全 相同，只是当标志位取1时，不同的线索二叉树将用不同的虚线表示，即不 同的线索树中线索指向的前驱结点和后继结点不同。
知识点7： 线索二叉树的基本概念和构造
1、在二叉链表表示的二叉树中，引入线索的目的主要是便于查找结点的前驱和后继。因 为若知道各结点的后继，二叉树的遍历就变得非常简单。
二叉链表结构查找结点的左、右孩子非常方便，但其前驱和后继是在遍历中形成的。为 了将非线性结构二叉树的结点排成线性序列，利用具有n个结点的二叉树的二叉链表中 的n＋1个空指针域，可以利用某结点空的左指针域（lchild）指出该结点在某种遍历序 列中的直接前驱结点的存储地址，利用结点空的右指针域（rchild）指出该结点在某种 遍历序列中的直接后继结点的存储地址；对于那些非空的指针域，则仍然存放指向该结 点左、右孩子的指针。
C．线索二叉树是利用二叉树的n+1个空指针来存放结点前驱和后继信息的
D．每个结点通过线索都可以直接找到它的前驱和后继
分析：不是每个结点通过线索都可以直接找到它的前驱和后继。在先序线索 二叉树中查找一个结点的先序后继很简单，而查找先序前驱必须知道该结 点的双亲结点。同样，在后序线索二叉树中查找一个结点的后序前驱也很 简单，而查找后序后继也必须知道该结点的双亲结点。二叉链表中没有存 放双亲的指针。
数据结构C语言版_线索二叉树
int InOrderTraverse_Thr(BiThrTree T,int(*Visit)(TElemType))
{
BiThrTree p;
p=T->lchild; // p指向根结点
while(p!=T)
{ // 空树或遍历结束时,p==T
// 空格(字符型)表示空结点
int CreateBiThrTree(BiThrTree *T)
{
TElemType h;
scanf("%c",&h);
if(h==Nil)
*T=NULL;
else
{
*T=(BiThrTree)malloc(sizeof(BiThrNode));
if(!p->lchild) // 没有左孩子
{ Biblioteka p->LTag=Thread; // 前驱线索
p->lchild=pre; // 左孩子指针指向前驱
}
if(!pre->rchild) // 前驱没有右孩子
{
pre->RTag=Thread; // 后继线索
"b为左子树的二叉树)\n");
CreateBiThrTree(&T); // 按先序产生二叉树
InOrderThreading(&H,T); // 中序遍历，并中序线索化二叉树
printf("中序遍历(输出)二叉线索树:\n");
InOrderTraverse_Thr(H,vi); // 中序遍历(输出)二叉线索树
数据结构(树)习题与答案
一、单选题1、树最适合用来表示（）。
A.元素之间具有分支层次关系的数据B.有序数据元素C.元素之间无联系的数据D.无序数据元素正确答案：A2、在树结构中，若结点A有三个兄弟，且B是A的双亲，则B的度是（）。
A.5B.4C.3D.2正确答案：B3、下列陈述中正确的是（）。
A.二叉树是度为2的有序树B.二叉树中结点只有一个孩子时无左右之分C.二叉树中每个结点最多只有两棵子树，并且有左右之分D.二叉树中必有度为2的结点正确答案：C4、设深度为h的二叉树中只有度为0和度为2的结点，则此类二叉树中所包含结点数至少为（）。
A.2h-1B.2h+1C.h+1D.2h正确答案：A解析： A、除根之外，每层只有两个结点，且互为兄弟。
5、设深度为h的二叉树中只有度为0和度为2的结点，则此类二叉树中所包含结点数至多为（）。
A.2h-1B. 2h+1-1C. 2h-1-1D. 2h+1正确答案：A解析： A、构成完全二叉树。
6、具有n(n>0)个结点的完全二叉树的深度为（）。
A.⌊ log2(n)⌋ +1B.⌈log2(n)⌉C.⌊ log2(n)⌋D.⌈log2(n)+1⌉正确答案：A7、具有32个结点的完全二叉树有（）个叶子结点。
A.16B.14C.15D.17正确答案：A解析： A、对结点按层序编号，32号结点的双亲结点编号为16，则17至32号结点都为叶子，共16个。
8、一棵完全二叉树的第6层上有23个叶子结点，则此二叉树最多有（）结点。
A.81B.78C.80D.79正确答案：A解析： A、完全二叉树的叶子结点只能在最下两层，要使结点最多，这棵二叉树深度为7，前6层结点数共为63，第6层有32个结点，其中叶子为23个，非叶子为9个，它们的度都为2，第7层只有18个结点，故整棵二叉树结点数为81.9、具有3个结点的二叉树有（）种。
A.6B.3C.5D.4正确答案：C10、若一棵二叉树有9个度为2的结点，5个度为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．以下说法错误的是 ( )A．树形结构的特点是一个结点可以有多个直接前趋B．线性结构中的一个结点至多只有一个直接后继C．树形结构可以表达(组织)更复杂的数据D．树(及一切树形结构)是一种"分支层次"结构E．任何只含一个结点的集合是一棵树2．下列说法中正确的是 ( )A．任何一棵二叉树中至少有一个结点的度为2B．任何一棵二叉树中每个结点的度都为2C．任何一棵二叉树中的度肯定等于2D．任何一棵二叉树中的度可以小于23．讨论树、森林和二叉树的关系，目的是为了（）A．借助二叉树上的运算方法去实现对树的一些运算B．将树、森林按二叉树的存储方式进行存储C．将树、森林转换成二叉树D．体现一种技巧，没有什么实际意义4．树最适合用来表示 ( )A．有序数据元素 B．无序数据元素C．元素之间具有分支层次关系的数据 D．元素之间无联系的数据5．若一棵二叉树具有10个度为2的结点，5个度为1的结点，则度为0的结点个数是（）A．9 B．11 C．15 D．不确定6．设森林F中有三棵树，第一，第二，第三棵树的结点个数分别为M1，M2和M3。
与森林F 对应的二叉树根结点的右子树上的结点个数是（）。
A．M1 B．M1+M2 C．M3 D．M2+M37．一棵完全二叉树上有1001个结点，其中叶子结点的个数是（）A． 250 B． 500 C．254 D．505 E．以上答案都不对8. 设给定权值总数有n 个，其哈夫曼树的结点总数为( )A．不确定 B．2n C．2n+1 D．2n-19．二叉树的第I层上最多含有结点数为（）A．2I B． 2I-1-1 C． 2I-1 D．2I -110．一棵二叉树高度为h,所有结点的度或为0，或为2，则这棵二叉树最少有( )结点A．2h B．2h-1 C．2h+1 D．h+111. 利用二叉链表存储树，则根结点的右指针是（）。
A．指向最左孩子 B．指向最右孩子 C．空 D．非空12．已知一棵二叉树的前序遍历结果为ABCDEF,中序遍历结果为CBAEDF,则后序遍历的结果为（）。
浅谈线索二叉树
浅谈线索二叉树摘要：数据结构中二叉树有很多的遍历算法，但本质都是将属性结构转换为线性序列，简化问题。
在遍历序列中，每个节点都有自己的前驱和后去，但在二叉树遍历过程中寻求答案却因为时间复杂度等因素使操作效率低下。
线索二叉树很好地解决了这一问题，本文是在二叉树的基础上加入线索二又树实现数据的快速可操作性。
关键词：数据结构；线索二叉树；应用前言为了实现在遍历序列中快速查找节点的前驱、后继，利用二叉链表中空的指针域，指向结点在遍历序列中的前驱、后继，这些指向前驱、后继的指针就是线索。
1、数据结构数据结构起源于程序设计，主要是电脑中数据的组织方式、存储结构和处理方法。
在程序的编程中，写一个“好”的程序，就是要选择一个合理的数据结构和算法。
数据的逻辑结构常用结构图来描述，将每一个数据元素看做一个结点，在计算处理数据的时候，算法同样很关键。
一种算法的有穷性，必须对任何合法的输入在执行有穷之后结束，并且每 1 步都在有穷时间内完成。
树形结构就是用于有层次关系的数据表示，表达大多数问题求解的思路，而二叉树的结点数和深度，为二叉树存储结构的选择提供了预备知识和思考线索。
线索二又树借助二又树遍历的程序框架建立，通过函数将整个二叉树的线索化分解，求后继、前驱结点的算法增加数据操作的效率，缩短时间，提高数据的操作性。
2、树的结构定义树形结构是信息的重要组织形式之一，树是一种数据结构，它是由n(n>=1)个有限结点组成一个具有层次关系的集合。
把它叫做“树”是因为它看起来像1棵倒挂的树，也就是说它是根朝上，而叶朝下的。
它具有以下的特点：(1)每个结点有零个或多个子结点；(2)每一个子结点只有一个父结点；(3)没有前驱的结点为根结点；(4)除了根结点外，每个子结点可以分为多个不相交的子树。
树的应用非常广泛，在程序设计中实现通用树的基本功能需要考虑很多功能，比方内存分配，添加节点，修改节点，删除节点，移动节点，遍历，查询，保存，读取问题。
数据结构详细教案——树与二叉树
数据结构教案第六章树与二叉树目录6.1树的定义和基本术语 (1)6.2二叉树 (2)6.2.1 二叉树的定义 (2)6.2.2 二叉树的性质 (4)6.2.3 二叉树的存储结构 (5)6.3树和森林 (6)6.4二叉树的先|中|后序遍历算法 (7)6.5先|后|中序遍历的应用扩展 (9)6.5.1 基于先序遍历的二叉树(二叉链)的创建 (9)6.5.2 统计二叉树中叶子结点的数目 (9)6.5.3 求二叉树的高度 (10)6.5.4 释放二叉树的所有结点空间 (11)6.5.5 删除并释放二叉树中以元素值为x的结点作为根的各子树 (12)6.5.6 求位于二叉树先序序列中第k个位置的结点的值 (12)6.5.7 线索二叉树 (13)6.5.8 树和森林的遍历 (14)6.6二叉树的层次遍历 (16)6.7判断一棵二叉树是否为完全二叉树 (16)6.8哈夫曼树及其应用 (18)6.8.1 最优二叉树(哈夫曼树) (18)6.8.2 哈夫曼编码 (19)6.9遍历二叉树的非递归算法 (19)6.9.1 先序非递归算法 (19)6.9.2 中序非递归算法 (20)6.9.3 后序非递归算法 (21)第6章二叉树和树6.1 树的定义和基本术语1、树的递归定义1）结点数n=0时，是空树2）结点数n>0时有且仅有一个根结点、m个互不相交的有限结点集——m棵子树2、基本术语结点：叶子(终端结点)、根、内部结点（非终端结点、分支结点）；树的规模：结点的度、树的度、结点的层次、树的高度(深度)结点间的关系：双亲(1)—孩子(m)，祖先—子孙，兄弟，堂兄弟兄弟间是否存在次序：无序树、有序树去掉根结点非空树森林引入一个根结点3、树的抽象数据类型定义树特有的操作：查找：双亲、最左的孩子、右兄弟结点的度不定，给出这两种操作可以查找到一个结点的全部孩子插入、删除：孩子遍历：存在一对多的关系，给出一种有规律的方法遍历(有且仅访问一次)树中的结点ADT Tree{数据对象：D={a i | a i∈ElemSet, i=1,2,…,n, n≥0}数据关系：若D为空集，则称为空树；若D仅含一个数据元素，则R为空集，否则R={H}，H是如下二元关系：(1) 在D中存在唯一的称为根的数据元素root，它在关系H下无前驱；(2) 若D-{root}≠Ф，则存在D-{root}的一个划分D1, D2, …, D m (m>0)（D i 表示构成第i棵子树的结点集），对任意j≠k (1≤j, k≤m) 有D j∩D k=Ф，且对任意的i (1≤i≤m)，唯一存在数据元素x i∈D i, 有<root,x i>∈H（H表示结点之间的父子关系）；(3) 对应于D-{root}的划分，H-{<root, x1>,…, <root, x m>}有唯一的一个划分H1, H2, …, H m(m>0)（H i表示第i棵子树中的父子关系），对任意j≠k(1≤j,k≤m)有H j∩H k=Ф，且对任意i(1≤i≤m)，H i是D i上的二元关系，(D i, {H i})是一棵符合本定义的树，称为根root的子树。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
中序线索化二叉树数据结构.当用二叉链表作为二叉树的存储结构时，因为每个结点中只有指向其左、右孩子结点的指针，所以从任一结点出发只能直接找到该结点的左、右孩子。
在一般情况下靠它无法直接找到该结点在某种遍历次序下的前驱和后继结点。
如果在每个结点中增加指向其前驱和后继结点的指针，将降低存储空间的效率。
与此同时，我们可以证明：在n个结点的二叉链表中含有n+1个空指针。
因为含n个结点的二叉链表中含有2n个指针，除了根结点，每个结点都有一个从父结点指向该结点的指针，因此一共使用了n-1个指针，所以在n个结点的二叉链表中含有2n-(n-1)=n+1个空指针。
因此，可以利用这些空指针，存放指向结点在某种遍历次序下的前驱和后继结点的指针。
这种附加的指针称为线索，加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树。
为了区分一个结点的指针是指向其孩子的指针，还是指向其前驱或后继结点的线索，可在每个结点中增加两个线索标志。
这样，线索二叉树结点类型定义为：LchildLtagDataRtagRchild其中：1. Ltag=0时，表示Lchild指向该结点的左孩子；2. Ltag=1时，表示Lchild指向该结点的线性前驱结点；3. Rtag=0时，表示Rchild指向该结点的右孩子；4. Rtag=1时，表示Rchild指向该结点的线性后继结点；以二叉链表结点数据结构所构成的二叉链表作为二叉树的存储结构，叫做线索二叉链表；指向结点的线性前驱或者线性后继结点的指针叫做线索；加上线索的二叉树称为线索二叉树；对二叉树以某种次序遍历将其变为线索二叉树的过程叫做线索化。
中序线索化是指用二叉链表结点数据结构建立二叉树的二叉链表，然后按照中序遍历的方法访问结点时建立线索。
例如有如上图所示二叉树，则中序遍历的顺序是：O / J * I + H A G【参考程序】#include <stdio.h>#include <malloc.h>typedef enum{Link,Thread} PointerTag; /*指针标志*/typedef char DataType;typedef struct BiThreTree{ /*定义结点元素*/PointerTag LTag,RTag;DataType data;struct BiThreTree *lchild,*rchild;}BiThreTree;BiThreTree *pre; /*全局变量，用于二叉树的线索化*/ BiThreTree *CreateTree() /*按前序输入建立二叉树*/{BiThreTree *T;DataType ch;scanf("%c",&ch);if(ch==’#’)T=NULL;else{T=(BiThreTree *)malloc(sizeof(BiThreTree));T->data=ch;T->LTag=Link; /*初始化时指针标志均为Link*/ T->RTag=Link;T->lchild=CreateTree();T->rchild=CreateTree();}return T;}void InThread(BiThreTree *T){BiThreTree *p;p=T;if(p){InThread(p->lchild);if(!p->lchild){ p->LTag=Thread;p->lchild=pre;}if(!pre->rchild){ pre->RTag=Thread;pre->rchild=p;}pre=p;InThread(p->rchild);}}BiThreTree *InOrderThrTree(BiThreTree *T) /*中序线索化二叉树*/ {BiThreTree *Thre; /*Thre为头结点的指针*/ Thre=(BiThreTree *)malloc(sizeof(BiThreTree));Thre->lchild=T;Thre->rchild=Thre;pre=Thre;InThread(T);pre->RTag=Thread;pre->rchild=Thre;Thre->rchild=pre;return Thre;}void InThrTravel(BiThreTree *Thre) /*中序遍历二叉树*/{BiThreTree *p;p=Thre->lchild;while(p!=Thre) /*指针回指向头结点时结束*/ {while(p->LTag==Link)p=p->lchild;printf("%4c",p->data);while(p->RTag==Thread&&p->rchild!=Thre){p=p->rchild;printf("%4c",p->data);}p=p->rchild;}}void main(){BiThreTree *T,*Thre;printf(“PreOrder Create Binary Tree:\n”);T=CreateTree();Thre=InOrderThrTree(T);printf(“InOrder Traverse Binary Tree:\n”);InThrTravel(Thre);system("pause");}【调试举例】（1）建立二叉树时，按先序遍历方式输入：“ABD##EH##I##CF##G##”，其中“#”表示空指针。
（2）建立的二叉树为： AB CD E F GH I（3）程序输出为中序遍历线索化二叉树的结果：DBHEIAFCG已知A、B和C为三个递增有序的线性表，现要求对A表作如下操作：删除那些既在B表中出现又在C表中出现的元素。
【实验步骤】1.试对顺序表编写实现上述操作的算法并上机编写代码，要求算法尽可能高效。
在实验报告中分析你的算法的时间复杂度。
2.A表中要删除的元素实际上就是在三个表中都存在的元素。
注意这三个线性表都是递增有序的线性表！可以利用这一性质减少对线性表“扫描”的趟数。
3.改用单链表作为存储结构编写算法，请释放A表中无用的结点空间，并上机编程实现。
【算法思想】先从B和C中找出共有元素same，再从A中从当前位置开始，凡小于same的元素均保留，等于same的就跳过，大于same时就再找下一个same。
【顺序存储结构算法描述】void SqList_Delete(SqList&A, SqList B, SqList C){i=0;j=0;m=0;/*i指示A中元素原来的位置，m为移动后的位置*/while(i<A.length&&j<B.length&&k<C.length){if(B.elem[j]<C.elem[k]) j++;else if(B.elem[j]>C.elem[k])k++;else{same= B.elem[j];/*找到了相同元素same*/while(B.elem[j]==same)j++;while(C.elem[k])==same)k++;/*j,k后移到新的元素*/while(i<A.length&&A.elem[i]<same)A.elem[m++]=A.elem[i++];/*需要保留的元素移动到新位置*/while( i<A.length&&A.elem[i]==same)i++;}/*else*/}/*while*/while(i<A.length)A.elem[m++]=A.elem[i++];/*A的剩余元素重新存储*/A.length=m;}/*SqList_Delete*/【顺序存储结构参考程序】#include<stdio.h>main(){#define N 3/*宏定义,代表数组维数*/#define M 4#define T 5int i,j,k,r,m,same;/*定义变量分别指向数组a,b,c*/int a[N],b[M],c[T];printf(“please input numbers:\n”);for (i=0;i<N;i++) scanf("%d",&a[i]);for (j=0;j<M;j++) scanf("%d",&b[j]);for (k=0;k<T;k++) scanf("%d",&c[k]);i=0;j=0;m=0;k=0;/*分别赋值为0，即指向数组的第一元素*/ while(i<N&&j<M&&k<T){if(b[j]<c[k])j++;else if(b[j]>c[k]) k++;else{same=b[j];while(b[j]==same)j++;while(c[k]==same)k++;while(i<N&&a[i]<same)a[m++]=a[i++];while(i<N&&a[i]==same) i++;}}while(i<N)a[m++]=a[i++];printf("a[%d]={",m);/*输出删除元素后的数组a/*for (r=0;r<m-1;r++)printf("%d,",a[r]);printf("%d",a[m-1]);printf("}\n");return;}【程序调试】程序运行是屏幕显示：please input numbers: 此时输入三组测试数据，数据间用空格隔开：2 3 4回车3 4 5 6 回车4 5 6 7 8 回车程序输出结果：a[3]={2,3}，即删除了数组a中即在b和c中都出现的元素。
【单链表存储结构参考程序】# include <stdio.h># include <stdlib.h>Typedef struct LNode{int data;struct LNode *next;}Lnode,*LinkList;/*定义链表节点的结构*/void main ( ){/*功能：建立单链表A,B,C，并且删除A中均在B和C中出现的数据。