后序遍历的非递归算法.doc
二叉树后序遍历的递归和非递归算法
安 徽电气工 程 职 业 技术学 院学报
：薹６ Ｍ２ ａ ｒ ０ ｃ ｈ ０
．
－Ｘ树后序遍历的递归和非递归算法
孙泽宇， 赵国增 ， 舒云星・
（ 洛阳工业高等专科学校计算机系 ， 河南 洛阳 ４ １０ ） ７０３
［ 要 ］ 论述了二又树后序遍历的递归算法和非递归算法， 摘 对递归算法中的工作栈 的执行过程做 了
Ｓｒｃｂｔ ｅ ｔ ｔ ｉｅ ｛ ｕ ｒ
● 收稿 日期 ：０ ５—１ ０ ７０ ． ２— ２
作者筒介： 孙泽字（９７ ． 吉林长春人． １７ 一） 男。 洛阳工业高等专科学校计算机秉麓师。研究方向： 人工智能。 趟 目增 （９７ ． 河南越壁人 。 阳工业高等专科 学校计算机 秉麓师 。研究方 向： １ 一） 男。 ７ 洛 人工智能。
ｓ ｃ ｂｒ 木ｅ ， ｒ ｈ；｝ ｔ ｔ ｉｅ ｌｔ 木 ｉ ｔ ｍ ｔｅ ｆ ｇ
后序遍历二叉树的递归算法如下 ：
Ｔ ｐ ｄ ｆｓ ｕ ｔＢＴ ｏ ｅ ｙ ｅ ｅ ｒ ｃ ｉｎ ｄ ｔ
法及执行时栈 的变化情况 ， 可设计 出较好 的非递归化算法 ， 本文讨论了二叉树后序遍历的递归和非递归
算法。 ２ 后序遍历二叉树的递归算法
１ 后序遍历左子树（ ） 若左子树不为空 ） ２ 后序遍历右子树（ ） 若右子树不为空 ） ３ 访问根结点 （ ） 若存在根结点）
二叉树数据结构如下 ：
二叉树是数据结构 中最常见 的存储形式 ， 在算法与数据结构中经常使用。树与森林都可以转换为 二叉树 ， 而遍历算法则是二叉树最重要的操作 。所谓遍历二叉树 ， 就是遵从某种次序 ， 遍访二叉树 中的
所有结点， 使得每个结点被访问一次 ， 而且仅一次。在遍历算法中， 递归算法是最普遍 的， 弄清 了递归算
后序遍历的非递归算法(C详细)
后序遍历的非递归算法（C详细）后序遍历是二叉树遍历的一种方式，它的顺序是先遍历左子树，然后遍历右子树，最后访问根节点。
非递归实现后序遍历的算法可以使用栈来辅助实现。
首先，我们需要定义一个树节点的数据结构，例如：```cstruct TreeNodeint val;struct TreeNode* left;struct TreeNode* right;};```接下来，我们使用一个辅助栈来进行非递归后序遍历。
首先需要创建一个空栈，并将根节点入栈。
然后开始循环，直到栈为空为止。
在循环中，首先取出栈顶节点，如果该节点没有左子树且没有右子树，说明该节点是叶子节点，可以直接输出该节点的值。
如果该节点有左子树或者右子树，需要判断是否已经遍历过该节点的子节点。
为了实现后序遍历的顺序，我们需要一个标记变量来记录上次访问的节点。
如果上次访问的节点是该节点的右子树，说明该节点的左右子节点都已经访问过了，可以直接输出该节点的值。
反之，如果上次访问的节点不是该节点的右子树，将该节点重新入栈，并以右、左、中的顺序将其右子树、左子树入栈。
下面给出完整的代码实现：```c#include <stdio.h>#include <stdlib.h>struct TreeNodeint val;struct TreeNode* left;struct TreeNode* right;};void postOrderTraversal(struct TreeNode* root)if (root == NULL)return;}struct TreeNode* lastVisited = NULL; // 上次访问的节点struct TreeNode* node = root; // 当前遍历的节点struct TreeNode* stack[100]; // 栈int top = -1; // 栈顶指针while (node != NULL ， top != -1)if (node != NULL)stack[++top] = node; // 入栈node = node->left; // 访问左子树} elsestruct TreeNode* temp = stack[top]; // 取出栈顶节点if (temp->right == NULL ， temp->right == lastVisited) printf("%d ", temp->val);top--; // 出栈lastVisited = temp; // 记录上次访问的节点} elsenode = temp->right; // 访问右子树}}}struct TreeNode* createNode(int val)struct TreeNode* node = (structTreeNode*)malloc(sizeof(struct TreeNode));if (node != NULL)node->val = val;node->left = NULL;node->right = NULL;}return node;int mai//创建一个二叉树struct TreeNode* root = createNode(1); root->left = createNode(2);root->right = createNode(3);root->left->left = createNode(4);root->left->right = createNode(5); root->right->left = createNode(6); root->right->right = createNode(7);//后序遍历二叉树printf("后序遍历结果："); postOrderTraversal(root);printf("\n");return 0;```以上代码中，我们使用了一个辅助数组作为栈来实现非递归遍历。
二叉树的遍历
二叉树的遍历算法1 先序遍历（T、p、S（）、top）\*先序遍历的非递归算法，T为根指针，p为指针，指向当前结点。
使用一个栈S（）、top为栈顶指针*\1．if（T=NULL）2．Printf( “这是一棵空二叉树”);3．else｛△△p=T;top=0;4． While(top≠0)||(p≠NULL)｛△while(p≠NULL)｛﹡Visit(p→data); \﹡访问结点﹡\top=top+1;if (top＞n) 调用栈满else｛S(top)=p→rchild;P=P→lchild;｝｝﹡if (top≠0)｛p= S(top);top--;｝｝△｝△△｛算法结束｝算法2 中序遍历（T、p、S()、top）\*｛中序遍历的非递归算法，使用栈S（），top为栈顶指针，T指向根，p为指针，指向当前结点*\top=0,p=TWhile(top≠0)||(P≠NULL)｛While(P≠NULL)｛Top=top+1if (top＞n) 调用栈满else｛S(top)=p, p=p→lchied;｝｝If (top≠null)｛p=S(top);top=top-1;Visit(p→data); \﹡访问结点﹡\p=p→rchild;｝｝｛算法结束｝算法3 后序遍历（T、p、S()、top）\*后序遍历的非递归算法，T指向根，P为指标指向当前结点，使用堆栈S（），栈顶指针为top，*\1、if (t=NIL)2、then { 输出“这是一棵空树”go 22 \* 结束 *\3、else { p=t;top=0;4、 while (top≠0)||(p≠NIL) {5、 while (p≠NIL){6、 top=top+1;7、 if (top﹥n)8、调用栈满9、 else{S(top)=p;10、 p=p→lchild;}11、 }12、 if (top≠0){13、 p=S(top);top=top-114、 if (p﹤0){15、 p=-p;16、 Visit(p→data); \﹡访问结点﹡\17、 p=NIL;〕18、 else {top=top+1;19、 S(top)=-P;20、 p=p→rchild;}21、 }22、｛算法结束｝算法4 二叉树后序遍历（t、p、S()、top、h）\*后序遍历的非递归算法，T指向根，使用堆栈S（），top为栈顶指针，P为指针，指向当前结点，h为指针，指向刚被访问结点*\1、if (T=Nil）{ 输出“这是一棵空树”go 20}2、else{﹡p=t,top=03、 if (p→lchild=Nil)&&(P→rchild=Nil)4、 then go 125、 else{△△top=top+1;S(top)=p;6、 if (p→lchild=Nil)7、 {p= p→rchild; go 3;}8、 else {△if (p→rchild=Nil)9、 go 1110、 else {top=top+1; S(top)= p→rchild;}11、 P=p→lchil; go 3}△}△△12、 Visit(p→data); \﹡访问结点﹡\13、 h=p14、 if (top=0){15、输出“栈空” go 20;}16、 else {p= S(top);top=top-1;17、 if(p→Lchild=h)OR(p→rchild=h)18、 then go 12;19、 else go 3;}}﹡20、｛算法结束｝。
二叉树遍历的通用非递归算法
右子 树还未访 问）（ 序访 问 Ａ的左子树 的根结点 Ｂ ， 和 ｌ ，先 ）Ｂ 进 栈 ． 于 Ｂ的左 子 树 为 空 ， 以 Ｂ 和 １出 栈 ，中 序 访 问 Ｂ）Ｂ 由 所 （ ， 和 Ｏ进栈 （ Ｏ表 示 开 始 遍 历 结 点 Ｂ 的 右 子 树 ） 由 于 Ｂ 的 右 子树 ． 为空 。 Ｂ和 Ｏ出栈 ，后 序访 问 Ｂ ． 和 １出 栈 。 中序 访 问 Ａ）Ａ （ ）Ａ （ ， 和 Ｏ进栈 ．先 序 访 Ａ的 右 子 树 的 根 结 点 Ｃ ， （ ）Ｃ和 １进 栈 ， 由 于 Ｃ的左子树为空 ， Ｃ和 ｌ出栈 ．中序 访问 Ｃ 。 （ ）Ｃ和 Ｏ进栈 ， 由 于 Ｃ 的 右 子 树 为 空 。 和 ０出 栈 ． 后 序 访 问 Ｃ）Ａ 和 Ｏ出 栈 ， Ｃ （ ． （ 序 访 问 Ａ）此 时 栈 已 空 ， 历 过 程 结 束 。 后 ， 遍 从 上 面可 知 ， 每个 结 点 进栈 、 出栈 都 是 两 次 。若 进 栈 前 访 问 该结点 ， 则得 到先 序 序 列 Ａ Ｃ； 在 第 一 次 出栈 时 济 问 该结 点 ， Ｂ 若 则得 到 中序 序 列 Ｂ Ｃ： 在 第 二 次 出栈 时访 问 该 结 点 ， Ａ 若 则得 到 后 序 序 列 Ｂ Ａ。 此 ． Ｃ 因 只需 对 二 叉树 遍 历 一 次 即 可 得 到 三 种 遍 历序 列 这里的关键是设置了一个标志位 ． 用来 说明该结点的右子树 是 否 已访 问 ． 以此 表 示 该 结 点 是第 一 次 出栈 还 是 第 二 次 出栈 。
维普资讯
２０ ０ ６年 第 ６期
福
建 电
脑
１１ ２
二叉树遍历的通用非递归算 法
徐凤生 １ 李立群 ２ 马夕荣 ２
（ ． 州 学 院 计算 机 系 。 东 德 州 ２ ３２ ２ 山 东省 农 业 管 理 干部 学 院 ， 东 济 南 ２ ０ ０ ） １德 山 ５０３ ． 山 ５ １０
(完整word版)数据结构-树练习题
数据结构－树练习题一、选择题1、二叉树的深度为k，则二叉树最多有（ C ）个结点。
A. 2kB. 2k-1C. 2k-1D. 2k-12、用顺序存储的方法，将完全二叉树中所有结点按层逐个从左到右的顺序存放在一维数组R[1..N]中，若结点R[i]有右孩子，则其右孩子是（ B ）。
A. R[2i-1]B. R[2i+1]C. R[2i]D. R[2/i]3、设a,b为一棵二叉树上的两个结点，在中序遍历时，a在b前面的条件是（ B ）。
A. a在b的右方B. a在b的左方C. a是b的祖先D. a是b的子孙4、设一棵二叉树的中序遍历序列：badce，后序遍历序列：bdeca，则二叉树先序遍历序列为（）。
A. adbceB. decabC. debacD. abcde5、在一棵具有5层的满二叉树中结点总数为（ A ）。
A. 31B. 32C. 33D. 166、由二叉树的前序和后序遍历序列（ B ）惟一确定这棵二叉树。
A. 能B. 不能7、某二叉树的中序序列为ABCDEFG，后序序列为BDCAFGE，则其左子树中结点数目为（C ）。
A. 3B. 2C. 4D. 58、若以{4,5,6,7,8}作为权值构造哈夫曼树，则该树的带权路径长度为（C ）。
A. 67B. 68C. 69D. 709、将一棵有100个结点的完全二叉树从根这一层开始，每一层上从左到右依次对结点进行编号，根结点的编号为1，则编号为49的结点的左孩子编号为（A ）。
A. 98B. 99C. 50D. 4810、表达式a*(b+c)-d的后缀表达式是（ B ）。
A. abcd+-B. abc+*d-C. abc*+d-D. -+*abcd11、对某二叉树进行先序遍历的结果为ABDEFC，中序遍历的结果为DBFEAC，则后序遍历的结果是（ B ）。
A. DBFEACB. DFEBCAC. BDFECAD. BDEFAC12、树最适合用来表示（ C ）。
数据结构期末试题及答案
计算机科学与技术、网络工程本科《数据结构》期末考试试卷一、选择题〔单选题，每小题3分，共33分〕1．已知某二叉树的中序、层序序列分别为DBAFCE、FDEBCA，则该二叉树的后序序列为。
A．BCDEAF B．ABDCEF C．DBACEF D．DABECF 2．在11个元素的有序表A[1…11]中进行折半查找〔⎣⎦2/)low+〕，查找元素(highA[11]时，被比较的元素的下标依次是。
A．6，8，10，11 B．6，9，10，11 C．6，7，9，11 D．6，8，9，113．由元素序列〔27，16，75，38，51〕构造平衡二叉树，则首次出现的最小不平衡子树的根〔即离插入结点最近且平衡因子的绝对值为2的结点〕为。
A．27 B．38 C．51 D．754．利用逐点插入法建立序列〔50，72，43，85，75，20，35，45，65，30〕对应的二叉排序树以后，查找元素30要进行次元素间的比较。
A．4 B．5 C．6 D．75．循环链表的主要优点是。
A．不再需要头指针了B．已知某个结点的位置后，很容易找到它的直接前驱结点C．在进行删除后，能保证链表不断开D．从表中任一结点出发都能遍历整个链表6．已知一个线性表〔38，25，74，63，52，48〕，假定采用散列函数h〔key〕=key%7计算散列地址，并散列存储在散列表A[0…6]中，若采用线性探测方法解决冲突，则在该散列表上进行等概率查找时查找成功的平均查找长度为。
A．1．5 B．1．7 C．2．0 D．2．37．由权值为9，2，5，7的四个叶子结点构造一棵哈夫曼树，该树的带权路径长度为。
A．23 B．37 C．44 D．468．在最好和最坏情况下的时间复杂度均为O〔nlogn〕且稳定的排序方法是。
A．基数排序B．快速排序C．堆排序D．归并排序9．无向图G=(V，E)，其中V={a，b，c，d，e，f}，E={(a，b)，〔a，e〕，(a，c)，〔b，e〕，〔c，f〕，(f，d)，〔e，d〕}。
二叉树后序遍历的非递归算法
二叉树后序遍历的非递归算法
二叉树后序遍历是指按照左子树、右子树、根节点的顺序遍历二叉树的过程。
与前序遍历和中序遍历不同，后序遍历需要考虑根节点的位置，因此需要使用栈来存储节点信息。
非递归算法一般使用栈来实现，因为后序遍历的过程中需要先遍历左子树和右子树，最后才遍历根节点，所以存储节点信息的栈需要进行一些特殊处理。
下面是二叉树后序遍历的非递归算法：
1. 创建一个空栈，并将根节点入栈。
2. 创建一个辅助变量pre表示上一个被遍历的节点。
3. 当栈不为空时，取出栈顶元素top，判断它是否为叶子节点或者它的左右子节点都被遍历过了（被遍历过的节点可以通过辅助变量pre来判断）。
4. 如果top为叶子节点或者它的左右子节点都被遍历过了，则将top出栈，并将它的值输出。
5. 如果不满足条件3，判断top的右子节点是否为pre，如果是，则说明右子树已经遍历完了，此时可以直接输出top的值，并将top出栈；如果不是，则将top的右子节点入栈。
6. 将top的左子节点入栈。
7. 将上一个被遍历的节点pre更新为top。
根据这个算法，我们可以分别对左子树和右子树进行遍历，并保证根节点最后被遍历到，从而实现二叉树的后序遍历。
这个算法的时间复杂度为O(n)，空间复杂度为O(n)。
总的来说，二叉树的后序遍历是一种比较复杂的遍历方式，需要使用栈保存节点信息，并且需要特殊处理根节点的位置。
使用非递归算法实现后序遍历可以优化空间复杂度和避免栈溢出的问题。
数据结构-1_真题-无答案
数据结构-1(总分100,考试时间90分钟)一、单项选择题在每小题列出的四个选项中只有一个选项是符合题目要求的1. 设数组data[0..m]作为循环队列SQ的存储空间，front为队头指针，rear为队尾指针，则执行出队操作的语句为( )A. front:=front+1B. front:=(front+1)mod mC. rear:=(rear+1)mod mD. front:=(front+1)mod(m+1)2. 在Hash函数H(k)=k MOD m中，一般来讲，m应取( )A. 奇数B. 偶数C. 素数D. 充分大的数3. 实现任意二叉树的后序遍历的非递归算法而不使用栈结构，最佳方案是二叉树采用( )存储结构。
A. 二叉链表B. 广义表C. 三叉链表D. 顺序4. 向一个栈顶指针为Top的链栈中插入一个s所指结点时，其操作步骤为( )A. Top—＞next=s;B. s—＞next=Top—＞next;Top—＞next=s;C. s—＞next=Top;top=s;D. s—＞next=Top; Top=Top—＞next;5. 快速排序在最坏情况下的时间复杂度是( )A. O(nlogB. O(n2)C. O(n3)D. 都不对6. 内部排序的方法有许多种，( )方法是从未排序序列中依次取出元素，与已排序序列中的元素作比较，将其放入已排序序列的正确位置上。
A. 归并排序B. 插入排序C. 快速排序D. 选择排序7. 对于一个具有N个顶点的图，如果我们采用邻接矩阵法表示，则此矩阵的维数应该是( )A. (N-1)×(N-1)B. N×NC. (N+1)×(N+1)D. 不确定8. 在一个长度为n的顺序表(顺序存储的线性表)中，向第i个元素(1≤i≤n+1)之前插入一个新元素时，需向后移动( )个元素。
A. n-iB. n-i+1C. n-i-1D. i9. 下面四种排序方法中，平均查找长度最小的是( )A. 插入排序B. 选择排序C. 快速排序D. 归并排序10. 如果我们采用二分查找法查找一个长度为n的有序表，则查找每个元素的平均比较次数( )对应的判定树的高度(假设树高h≥2)。
三叉链表存储结构及其非递归遍历算法
数据结构实验报告知识范畴：树实验题目：二叉树的基本算法二(三叉链表的建立、非递归遍历)实验内容及要求：设二叉树采用三叉链表存储结构，结点数据域为字符类型，从键盘输入先序遍历字符序列（用#字符表示NULL指针域）建立三叉链表存储结构。
对先序、中序、后序遍历分别定义各自的求第一访问结点地址first(bt)以及下一访问结点地址next(p)函数，然后用三种遍历的first(bt)和next(p)函数实现非递归遍历。
实验目的：掌握二叉树的三叉链表存储结构及其非递归遍历算法。
数据结构设计简要描述：采用双向链表，每个结点包括字符类型的数据域和一个指针域。
链表结点结构如下：typedef struct node{ElemTp data; //字符数据域struct node *lchild; //左儿子指针struct node *rchild; //右儿子指针struct node *parent; //双亲指针}算法设计简要描述：采用三叉链表的存储结构，双亲指针指向根结点，左右指针指向左右儿子构造双向链表的二叉树。
每一次遍历时先用该遍历的first函数获取第一个访问的结点地址，调用next函数获取下一个访问的结点地址，当结点为空为循环的结束条件。
获取下一个访问的结点地址时需要判断是否需要回溯，需要回溯时通过双亲指针获取根节点地址，再判断是否需要再回溯。
回溯的结束条件为根节点地址为空。
输入/输出设计简要描述：从键盘输入二叉树的数据域，用#表示空。
按先序遍历的顺序依次构建二叉树。
输出三种遍历的遍历结果，并有文字提示。
编程语言说明：使用Visual C++编程。
主要代码采用C语言实现；动态存储分配采用C的malloc操作符实现；输入与输出采用C的printf和scanf流；程序注释采用C/C++规范。
主要函数说明：void InitTrT(TrT bt) //初始化二叉树void crtTrT(TrT *bt) //创建三叉结构的二叉树void destroyTrT(TrT *bt) //销毁二叉树Status emptyTrT(TrT bt) //判断二叉树是否为空int depthTrT(TrT bt) //求二叉树的深度TrT prefirst(TrT bt) //找出先序遍历的第一个结点TrT prenext(TrT bt) //找出先序遍历的下一结点void preorder(TrT bt) //先序非递归遍历TrT midfirst(TrT bt,int &mark) //查找中序遍历的第一个结点TrT midnext(TrT bt,int &mark) //查找中序遍历的下一个结点void midorder(TrT bt) //中序非递归遍历TrT lastfirst(TrT bt,int &mark) //查找后序遍历的第一个结点TrT lastnext(TrT bt,int &mark) //查找后序遍历的下一个结点void lasorder(TrT bt) //后序非递归遍历程序测试简要报告：输入：ABC#F##D##E##输出：程序输出结果与期望输出结果相符。
后序遍历非递归算法
后序遍历非递归算法后序遍历是二叉树遍历中的一种，它的遍历顺序是先访问左子树、再访问右子树、最后访问根节点。
在非递归算法中，我们需要借助栈来实现后序遍历。
具体步骤如下：1. 新建一个栈，并将根节点入栈2. 定义两个节点变量pre和cur，初始化pre为null3. 当栈不为空时，循环执行以下操作：- 将栈顶元素cur赋值为栈顶元素，但不弹出该元素- 如果当前节点没有左右子节点，或者左右子节点已经被访问过了，那么弹出当前节点，并将其值打印输出，并将pre赋值为当前节点- 否则，若当前节点有右子节点，就将其右子节点入栈。
若当前节点有左子节点，则将其左子节点入栈4. 循环结束可以看到，后序遍历的算法和前序遍历、中序遍历都有所区别。
与前序遍历的主要区别在于，在访问节点前，需要判断该节点的左右子节点是否已经被访问过。
而与中序遍历的主要区别在于，在访问节点后，需要将该节点的值打印输出。
此外，后序遍历还需要维护一个pre节点变量，用于记录上一个被访问过的节点。
那么，后序遍历的非递归算法有什么优点呢？相比递归算法，它的空间复杂度更低，因为递归算法需要维护函数调用栈。
而非递归算法中使用的栈只需要在遍历过程中存储节点，不需要再维护函数调用栈。
此外，非递归算法在一些嵌入式系统、服务器等资源受限的环境下表现更优秀。
总体而言，后序遍历非递归算法是一种非常实用的二叉树遍历算法，它可以帮助我们更加高效地对二叉树进行遍历，尤其是在空间限制较大的情况下。
需要注意的是，该算法的具体实现过程可能会因为树结构的复杂性而略有差异，建议大家在编写代码时用心梳理整个算法过程。
后序遍历的非递归算法
后序遍历非递归算法typedef enum{L,R} tagtype;typedef struct{Bitree ptr;tagtype tag;}stacknode;typedef struct{stacknode Elem[maxsize];int top;}SqStack;void PostOrderUnrec(Bitree t){SqStack s;stacknode x;StackInit(s);p=t;do{while (p!=null) //遍历左子树{x.ptr = p;x.tag = L; //标记为左子树push(s,x);p=p->lchild;}while (!StackEmpty(s) && s.Elem[s.top].tag==R){x = pop(s);p = x.ptr;visite(p->data); //tag为R，表示右子树访问完毕，故访问根结点}if (!StackEmpty(s)){s.Elem[s.top].tag =R; //遍历右子树p=s.Elem[s.top].ptr->rchild;}}while (!StackEmpty(s));}//PostOrderUnrec后序算法之二void BT_PostOrderNoRec(pTreeT root){stack<treeT *> s;pTreeT pre=NULL;while ((NULL != root) || !s.empty()){if (NULL != root){s.push(root);root = root->left;}else{root = s.top();if (root->right!=NULL && pre!=root->right){root=root->right;}else{root=pre=s.top();visit(root);s.pop();root=NULL;}}}}一个比较容易理解的后序遍历:void PostOrder(Bitree *t){TreeNode *node = NULL,*last = NULL;Stack s;s,Init();s.push(t);while(!s.IsEmpty()){node = s.pop();if(last == node->left || last == node->right)//左右子树已经访问完了，该访问根节点了{visit(node);last = node;}else if(node->left || node->right) //左右子树未访问，当前节点入栈，左右节点入栈{s.push(node);if(node->right)s.push(node->right);if(node->left)s.push(node->left);}else //当前节点为叶节点，访问{visit(node);last = node;}}}。
树的后序遍历非递归算法
树的后序遍历非递归算法
树的后序遍历是一种常用的算法，它可以让我们遍历树结构的所有
节点，并按照一定的顺序进行处理。
而非递归算法则是解决树的遍历
问题的一种常用方法。
下面就为大家介绍一下树的后序遍历的非递归算法：
1. 首先我们需要创建一个堆栈，用于保存遍历过程中的节点。
同时，
我们需要定义一个指针指向当前操作的节点，初始值为根节点。
2. 然后我们开始遍历树，先将根节点入栈。
接下来进入一个循环：
3. 在循环中，我们将指针向左移动，直到遇到一个没有左子节点的节
点为止。
在这个移动的过程中，我们需要将每个遍历过的节点都入栈。
4. 如果当前节点没有右子节点，或者当前节点的右子节点已经入栈，
那么就可以对当前节点进行操作（例如打印出当前节点的值，或者将
其从堆栈中弹出），并将指针指向堆栈中的下一个节点。
5. 如果当前节点存在右子节点，并且其右子节点还没有入栈，则将其
右子节点入栈。
6. 重复步骤3~5，直到堆栈为空为止。
这就完成了一次树的后序遍历。
通过上述非递归算法，我们可以很容易地遍历整棵树，并进行各种自定义操作。
同时，由于使用了堆栈的存储方式，算法复杂度相比递归算法也有了一定程度的优化。
树的三种遍历方式
树的三种遍历方式树是一种非常重要的数据结构，它在计算机科学中应用广泛。
树可以用于搜索、排序、数据表、文件系统等诸多领域。
而树的遍历方式，则是在树中搜索数据的一种方法。
树的遍历方式有三种，分别是前序遍历、中序遍历和后序遍历。
这三种遍历方式在树的数据结构中有着重要的作用，它们可以用来检索所有节点的信息。
下面我们将对它们一一进行介绍。
1.前序遍历前序遍历也称为先序遍历，它的顺序是根节点->左子树->右子树。
它的算法描述如下：前序遍历的递归算法实现：void PreOrderTraversal(TraversalNode T){ if (T) { visit(T); PreOrderTraversal(T->left); PreOrderTraversal(T->right); } }前序遍历的非递归算法实现：void PreOrderTraversal(TraversalNode T){ while (T || !StackIsEmpty(S)) { while (T) { visit(T); push(Stack,T); T = T->left; } if(!StackIsEmpty(S)) { T = pop(Stack);T = T->right; } } }2.中序遍历中序遍历的顺序是左子树->根节点->右子树。
它的算法描述如下：中序遍历的递归算法实现：void InOrderTraversal(TraversalNode T) { if(T) { InOrderTraversal(T->left);visit(T);InOrderTraversal(T->right); } }中序遍历的非递归算法实现：void InOrderTraversal(TraversalNode T){ while (T || !StackIsEmpty(S)) { while(T) { push(Stack, T); T =T->left; } if (!StackIsEmpty(S)){ T = pop(Stack); visit(T); T = T->right; } } }3.后序遍历后序遍历的顺序是左子树->右子树->根节点。
浅析一种二叉树非递归遍历算法的C语言实现论文.doc
浅析一种二叉树非递归遍历算法的C语言实现论文一种二叉树非递归遍历算法的C语言实现论文导读：本论文是一篇关于一种二叉树非递归遍历算法的C语言实现的优秀论文范文,对正在写有关于递归论文的写有一定的参考和指导作用,摘要：针对二叉树的链式存储结构，分析了二叉树的各种遍历算法，探讨了递归算法的递推消除理由，提出了一种改善的非递归遍历算法并用C语言予以实现。
关键词：二叉树；遍历算法；非递归；C语言实现1009-3044（2014）01-0223-031 概述树形结构是一种非常常见的数据结构，而二叉树又是其中最重要的一种树形结构。
二叉树的遍历是指按照一定的规则和次序将二叉树中的每一个结点都访问一次，既不能重复，也不能漏掉。
一般而言，对二叉树的遍历有前序遍历、中序遍历、后序遍历和按层遍历等几种方式。
在具体的算法设计上，以上遍历方式一般采取递归算法来实现，该文将探讨采用非递归算法来实现二叉树的遍历。
2 二叉树的数据结构描述二叉树作为一种非线性结构，每个结点最多有一个双亲结点和两个子结点。
二叉树可以采用顺序存储结构和链式存储结构。
对于完全二叉树而言，采用顺序存储是非常方便并且节省空间的，但是对于大部分的非完全二叉树而言，采用顺序存储将导致空间浪费严重且结构混乱、效率低下。
因此，更多的时候，大家都更愿意用链式存储结构来表示二叉树，这样结构更加清晰，尤其是对于一种二叉树非递归遍历算法的C语言实现由写论文的好帮手.zbjy.提供,.左右子树的描述和双亲节点的描述更加方便。
该文中拟采用链式结构来表示二叉树。
用链式存储结构来表示二叉树，一个结点至少由3个域组成，即数据域、左子结点域和右子结点域（如图1所示）。
3 二叉树的遍历及递归算法实现3.1 二叉树的遍历二叉树的遍历就是一个不漏的访问树中的每个结点，同时也不能重复。
所谓“访问”，就是指对结点的数据域进行某种操作，比如说读取、删除、更新、求该节点深度等等。
对于二叉树中的任意一个部分，都可以把它看作三部分，根节点、左子树、右子树，我们用D表示访问跟结点，用L表示遍历左子树，用R表示遍历右子树，则共有以下6种遍历方式[1]。
c语言中序非递归遍历求树的高度
C语言是一种广泛应用于系统程序设计和应用软件开发的高级编程语言。
在C语言中，常常需要对树进行遍历操作，以求取树的高度。
其中，序非递归遍历是一种常用的遍历方式。
本文将针对C语言中对树进行序非递归遍历求树的高度进行详细的讲解。
一、序非递归遍历1.序非递归遍历是一种在树的遍历过程中不使用递归的方式。
通过借助栈这一数据结构来完成遍历操作。
2.在序非递归遍历中，我们首先将树的根节点入栈，然后循环执行以下步骤：a.将栈顶节点弹出，并输出该节点的值；b.将该节点的右子节点入栈（如果存在的话）；c.将该节点的左子节点入栈（如果存在的话）。
3.直到栈为空为止，遍历结束。
二、求树的高度1.树的高度是指树中从根节点到叶节点的最长路径的节点数。
求树的高度是树的常见操作之一。
2.在进行序非递归遍历的过程中，我们可以借助一个变量来记录树的高度。
具体做法如下：a.在栈中入栈的使用一个额外的变量记录当前节点的高度；b.每次遇到叶子节点时，将该节点的高度与之前记录的最大高度进行比较，并更新最大高度。
3.遍历结束后，最大高度即为树的高度。
三、C语言实现以下是C语言实现序非递归遍历求树高度的示例代码：```c#include <stdio.h>#include <stdlib.h>// 树的节点结构typedef struct Node {int data;struct Node* left;struct Node* right;} Node;// 栈的结构typedef struct Stack {Node* data[100]; // 假设栈的最大容量为100 int top;} Stack;// 初始化栈void init(Stack* s) {s->top = -1;}// 入栈void push(Stack* s, Node* node) {s->data[++(s->top)] = node;}// 出栈Node* pop(Stack* s) {return s->data[(s->top)--];}// 判断栈是否为空int isEmpty(Stack* s) {return s->top == -1;}// 求树高度int getHeight(Node* root) {Stack s;init(s);int maxHeight = 0;Node* curr = root;Node* prev = NULL;while (curr != NULL || !isEmpty(s)) { if (curr != NULL) {push(s, curr);if (s.top + 1 > maxHeight) { maxHeight = s.top + 1;}curr = curr->left;} else {curr = pop(s);curr = curr->right;}}return maxHeight;}// 主函数int m本人n() {// 构建一棵树（这里用简单的示例，实际情况中树的构建可能更加复杂）Node* root = (Node*)malloc(sizeof(Node));root->data = 1;root->left = (Node*)malloc(sizeof(Node));root->left->data = 2;root->left->left = NULL;root->left->right = NULL;root->right = (Node*)malloc(sizeof(Node));root->right->data = 3;root->right->left = NULL;root->right->right = NULL;printf("树的高度为：d\n", getHeight(root));return 0;}四、总结通过以上的讲解和示例代码，我们详细地介绍了C语言中如何利用序非递归遍历求树的高度。
非递归后序遍历求带权路径长度
非递归后序遍历求带权路径长度1.引言在计算机科学和算法领域中，树是一种常见的数据结构，而树的遍历是对树中所有节点进行访问的一种重要操作。
后序遍历是一种常见的树遍历方式，它的应用场景非常广泛。
今天我们将着重讨论非递归后序遍历，并探讨如何利用非递归后序遍历来求解树中带权路径长度的问题。
2.非递归后序遍历非递归后序遍历是指在遍历树的过程中，不使用递归的方式来实现后序遍历的操作。
它通常借助栈来实现。
我们可以通过模拟递归的过程，在栈的帮助下，实现非递归后序遍历。
这种方式能够有效地降低递归带来的空间开销，提高算法的效率。
3.树的带权路径长度树的带权路径长度是指树中所有节点的路径长度之和。
路径长度是指从根节点到叶子节点的路径上边的权值之和。
带权路径长度可以用来衡量树的结构以及节点之间的关系，它在树的相关问题中有着重要的作用。
4.求解带权路径长度的算法利用非递归后序遍历，我们可以求解树中的带权路径长度。
具体的算法思路如下：•我们使用非递归后序遍历来遍历树的所有节点。
•在遍历的过程中，我们维护一个变量来记录当前节点到根节点的路径长度之和。
•当遍历到叶子节点时，我们将当前节点的路径长度加到带权路径长度中。
•我们就可以得到树的带权路径长度。
5.个人观点和理解在我看来，非递归后序遍历求解带权路径长度是一种非常巧妙的算法设计。
它充分利用了树的特点和后序遍历的思想，通过栈来模拟递归的过程，实现了高效的算法。
而带权路径长度作为一种重要的树的指标，可以帮助我们更好地理解树的结构和特性。
这种算法不仅能够提高我们对树的认识，还能够在实际问题中得到应用。
6.总结通过本文的讨论，我们深入探讨了非递归后序遍历求解带权路径长度的算法。
我们首先介绍了非递归后序遍历的基本概念，然后讨论了树的带权路径长度以及如何利用非递归后序遍历来求解。
我分享了自己的观点和理解。
我相信通过本文的阅读，你不仅对非递归后序遍历有了更深入的理解，也对树的带权路径长度有了更全面的认识。
二叉树后序遍历非递归算法的改进研究
算法提供了一种思路．
２ ． １ 利用 “ 先序遍 历 ” 思想 进行 二叉树 后序遍 历
二叉树 的后序 遍历操 作定 义 为先访 问左子 树 ， 再访 问右 子 树 ， 最 后 访 问根 …． 根据该定义 ， 可 以
很容易设计 出后序遍历的递归算法 ， 而其非递归算
法 的设计则 比较 麻烦 ． 因 为在 后 序 遍 历过 程 中 ， 要
保证 左孩子 和右孩 子都 已被访 问 ， 并 且左 孩子 在右
二叉树 先序 遍历 的思 想是先 访 问根 结点 ， 再访
问左孩 子 ， 最 后访 问右 孩 子 ． 对 于 二叉 树 中的任 一 结点 ， 都 可看 做是 根结 点 ， 因此可 以直接 访 问 ， 访 问
孩 子前访 问才能访 问根结 点 ， 这就 为算法 的设计 带
操作的基础． 二叉树 的遍历主要有先序遍历 、 中序 遍 历和后 序遍历 三种 ． 由于二 叉树 的定 义本身 就是
递 归定义 ， 因此 采 用 递 归 的 方 法 实 现 二 叉 树 的先 序、 中序和 后序三 种遍历 不仅 容易 理解 而且代 码很 简 洁． 而对 于二叉 树 的遍 历若 采 用 非 递 归 的方 法 ，
动， 最后 回到根结 点的 曲线来访 问每个 结点 ， 按 照结
２ ＝叉 捌后序遍历非递归算法的改进思路
二 叉树后 序遍 历 操 作 要 求 访 问 的 顺 序 是 “ 左
①
收稿 日期 ： ２ ０ １ ３—１ ０—１ ７ 作者简 介： 章晓勤 ， 女， 安徽 安庆太湖人 ， 安徽电子信 息职业技术学院 ， 讲师 ， 工程硕士 ， 研究方 向： 软件工程．
来 了难 题 】 ． 为 了解 决 这一 难 题 ， 研 究 人员 提 出 了
三种遍历方法
三种遍历方法一、前序遍历前序遍历是二叉树遍历的一种方法，也是最常见的遍历方式之一。
在前序遍历中，首先访问根节点，然后递归地遍历左子树，最后递归地遍历右子树。
前序遍历的应用非常广泛，例如在二叉树的构建和重建、树的深度优先搜索等问题中都会用到前序遍历。
在进行前序遍历时，可以采用递归或者非递归的方式。
1. 递归实现前序遍历：递归实现前序遍历非常简单，具体步骤如下：- 首先判断当前节点是否为空，若为空则返回；- 访问当前节点；- 递归遍历左子树；- 递归遍历右子树。
2. 非递归实现前序遍历：非递归实现前序遍历需要借助栈来实现，具体步骤如下：- 将根节点入栈；- 循环执行以下步骤，直到栈为空：- 弹出栈顶节点，并访问该节点；- 若该节点的右子节点不为空，则将右子节点入栈；- 若该节点的左子节点不为空，则将左子节点入栈。
二、中序遍历中序遍历是二叉树遍历的另一种方法，同样也是一种常用的遍历方式。
在中序遍历中，首先递归地遍历左子树，然后访问根节点，最后递归地遍历右子树。
中序遍历的应用也非常广泛，例如在二叉搜索树的操作中，中序遍历可以按照升序输出所有节点的值。
1. 递归实现中序遍历：递归实现中序遍历的步骤如下：- 首先判断当前节点是否为空，若为空则返回；- 递归遍历左子树；- 访问当前节点；- 递归遍历右子树。
2. 非递归实现中序遍历：非递归实现中序遍历同样需要借助栈来实现，具体步骤如下：- 将根节点入栈；- 循环执行以下步骤，直到栈为空：- 若当前节点不为空，则将当前节点入栈，并将当前节点指向其左子节点；- 若当前节点为空，则弹出栈顶节点，并访问该节点，然后将当前节点指向其右子节点。
三、后序遍历后序遍历是二叉树遍历的另一种方式，也是最后一种常见的遍历方式。
在后序遍历中，首先递归地遍历左子树，然后递归地遍历右子树，最后访问根节点。
后序遍历的应用也非常广泛，例如在二叉树的删除操作中，需要先删除子节点，再删除根节点。
数据结构中二叉树的生成及遍历非递归算法浅析
及运算 都较为简练 ， 因此 ， 二叉树 在数据结构课 程 中显得 特别 ｃ ａ ｄｔ； ｈｒ ａａ ｓ ｕｔ ｔｏ ｅｃｉ ， ｈｄ ｔ ｃ ｂｎｄ ｈ ｄｒ ｉ ； ｒ ｌ ｌ ｃｌ 二叉树是 由结点的有 限集合构成 ，这个有限集合或者为空 ｝ｔ ｅ Ｂｒ ； ｅ 集 ，或者是 由一个根节点及两棵互不相交的分别称之为这个根 Ｂｒｅ ［ ａｓ ｅ ｔ Ｑ ｍ ｘｉ ］ ｅ ｚ；
一
、
引言
＃ ｃ ｄ “ａｏｈ ｉｌ ｅ ｍ１ ・ ｎｕ ］ ” ｃ
ｔ ｅｅ。 ｃ ｂ ｏｅ ｙ ｄ ｔ ｔ ｔ ｄ｛ ｐ ｎ
、
二叉树是一种重要 的树形结构 ， 其结构规整。许多实际问 ＃ ｅｎ Ｕ Ｌ０ ｄｆ ｅ Ｌ ｉ Ｎ
题抽象 出来 的数据结构往往是二叉树 的形式 ， 而且其存储结构 重要 ， 这里 我们先 了解一下二叉树 。
，
立二 叉链表。 一般的二 对于 叉树， 必须添加一些 虚结点， 使其成 ‘ ～’ ： 一 、
队列是一个指针类型 的数组 ， 保存已输入 的结点 ＿… 、
… ～ … 一 ’
，
＃ ｅ ｎ ｘ ｉ ０ ｄ ｆ ｅｍａ ｓｚ １ ０ ｉ ｅ 衔ｎ ｌ ｄ ｓｄｏｈ” ｃｕ ｅ“ ｔ ｉ．
ｓ＞ 一
ｌ＝ Ｌ ； ｄ Ｕ Ｌ
ｒ ａ＋ ； ｅ ｒ ＋
Ｑｒａ１ｓ ｒ ； ｅ ＝
。
３ 办公 自动化杂志 ｏ。
ｉ ｒａ－ １Ｔ ｓ ｆ ｅｒ＝ ）＝ ： （ ＝
ｅｓ ｌｅ
ｆ＝ｔ ｋｔ ］ Ｔ ｓ ｃ ［ｐ； ａ ｏ
近 ＞ｉ ＝ ｐ 卜 ｒ ＝） 曲ｔ
ｆｒ ｆ“ ＂ － ｄｔ ； ｐｉ （％ｃ ， ＞ ａａ ｎ Ｔ ）
递归算法 ， 故有关二叉树的试题通 常要求采用非递归算 法， 这就 Ｂｒ ， ； ｔｅ ｅ ｓ 使得掌握二叉树的生成及遍历的非递归算法成为必要 。 ｔＮ Ｉ ； ＝ ｕＪ Ｌ
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第六章树二叉树后序遍历的非递归算法。
在对二叉树进行后序遍历的过程中，当指针p 指向某一个结点时，不能马上对它进行访问，而要先遍历它的左子树，因而要将此结点的地址进栈保存。
当其左子树遍历完毕之后，再次搜索到该结点时(该结点的地址通过退栈得到) ，还不能对它进行访问，还需要遍历它的右子树，所以，再一次将此结点的地址进栈保存。
为了区别同一结点的两次进栈，引入一个标志变量nae,有0 表示该结点暂不访问 1 表示该结点可以访问标志flag 的值随同进栈结点的地址一起进栈和出栈。
因此，算法中设置两个空间足够的堆栈,其中, STACKlCM] 存放进栈结点的地址, STACK2[M] 存放相应的标志n 昭的值, 两个堆栈使用同一栈顶指针top , top 的初值为— 1 。
具体算法如下：#defineH 100 /•定义二叉树中结点最大数目。
/voidPOSTOiRDER(BTREET){/ *T 为二叉树根结点所在链结点的地址。
/BTREESTACKl[H] , p=T ；intSTACK2[M] , flag,top= —1；if(T!=NULL)d0{while(p!=NULL){STACK/[++top]=p ; /•当前p所指结点的地址进栈•/STACK2[top]= 0 ; /,标志0 进栈•/p=p->lchild ；/•将p 移到其左孩子结点x/}p=STACKl[top) ；flag=STACK2[top--] ；if(flag==0){ STACKl[++top]=p ; /,当前p所指结点的地址进栈。
/STACK2[toP]=1 ; /•标志1 进栈•/p=p->rchild ; /x将p移到其右孩子结点o/}else{VISIT(p) ; /x访问当前p所指的结点x/p=NULL ；}}while(p!=NULLtttop!=-1) ；} 不难分析,上述算法的时间复杂度同样为O(n)7．6．3 二叉树的线索化算法对--X 树的线索化,就是把二叉树的二叉链表存储结构中结点的所有空指针域改造成指向某结点在某种遍历序列中的直接前驱或直接后继的过程, 因此, 二叉树的线索化过程只能在对二叉树的遍历过程中进行。
下面给出二叉树的中序线索化的递归算法。
算法中设有指针pre,用来指向中序遍历过程中当前访问的结点的直接前驱结点，pre的初值为头结点的指针；T初始时指向头结点，但在算法执行过程中，T总是指向当前访问的结点。
voldlNTHREAD(TBTREET) { TBTREE pre ；if(T!=Null){INTHREAD(T —>lchild)；if(T —>rchild==NULL)T—>rbit=O ；if(T —>lchild==NUll)；T—>lchild=pre ；T—>lbit=0 ；}if(pre —>rbitc==0)pre—>rchild=T ；pre=T ；inthread(T->rchild)；} }平均查找长度(AverageSearchLength):确定一个元素在树中的位置所需要进行的比较次数的期望值。
二叉树的内路径长度(InternalPathLength):从二叉树根结点到某结点所经过的分支数目定义为该结点的路径长度。
二叉树中所有结点的路径长度之和定义为该二叉树的内路径长度IPL。
图7。
25(h)给出的二叉排序树的内路径长度为IPL : 1X2+2X2+3X1+4X2=17二叉树的外路径长度(ExternalPathLength):为了分析查找失败时的查找长度，在二叉树中出现空子树时，增加新的空叶结点来代表这些空子树，从而得到一棵扩充后的二叉树。
为了与扩充前的二叉树相区别，这些新增添的空的叶结点用小方块代表，称之为外部结点，树中原有的结点为内部结点。
图7. 27给出了一棵扩充后的二叉树，其外路径长度EPL是二叉树中所有外部结点的路径长度之和，即习题7.1判断题(在你认为正确的题后的括号中打"，否则打X)。
(1) 在树型结构中，每一个结点最多只有一个前驱结点，但可以有多个后继结点。
( )(2) 在树型结构中，每—个结点不能没有前驱结点。
( )(3) 在度为k 的树中，至少有一个度为k 的结点。
( )(4) 在度为k 的树中，每个结点最多有k—1 个兄弟结点。
( )(5) 度为2 的树是二叉树。
( )(6) 二叉树的度一定为2。
( )(7) 在非空完全二叉树中，只有最下面一层的结点为叶结点。
( )(8) 在完全-y .树中，没有左孩子的结点一定是叶结点。
()(9) 在完全二叉树中，没有右孩子的结点一定是叶结点。
( )(10) 在结点数目一定的前提下，各种形态的二叉树中，完全二叉树具有最小深度。
( )(11) 满二叉树一定是完全二叉树。
( )(12) 满二叉树中的每个结点的度不是0 就是2。
( )(13) 在所有深度相同的二叉树中，满二叉树具有最大结点数目。
( )(14) 具有n 个结点的非空二叉树一定有n—1 个分支。
( )(15) n 个结点的二叉树采用二叉链表结构，链表中有n—1 个存放NULL 的指针域。
( )(16) “退化二叉树”不宜采用顺序存储结构的主要原因是空间浪费较大。
( )(17) 由二叉树的前序序列和中序序列可以惟一地确定一棵二叉树。
( )(18) 由二叉树的中序序列和后序序列可以惟一地确定一棵二叉树。
( )(19) 由二叉树的前序序列和后序序列可以惟一地确定一棵二叉树。
( )(20) 实现二叉树的按层次遍历算法时需要用到队列结构。
( )(21) 实现二叉树的遍历算法时不需要用到堆栈结构。
( )(22) 线索二叉树对应的二叉链表中不存在空的指针域。
( )(23) 二叉排序树中的任何一棵子树也是二叉排序树。
( )(24) 一个序列对应的二叉排序树是惟一的。
( )(25) 按照“逐点插入法”建立的二叉排序树的深度与结点的插入顺序无关。
( )(26) 在二叉排序树中进行查找的效率与二叉排序树的深度有关。
( )(27) 在二叉排序树中查找一个结点，查找长度不会超过二叉树的深度。
( )(28) 给定一组权值，构造出来的哈夫曼树是惟一的。
( )(29) 哈夫曼树中不存在度为 1 的结点。
( )(30) 在哈夫曼树中，权值相同的叶结点都在同一层上。
( )7. 2 单项选择题。
(1) 树型结构最适合用来描述——。
A •有序的数据元素B•无序的数据元素C.数据元素之间具有层次关系的数据 D .数据元素之间没有关系的数据(2) 对于一棵具有n 个结点、度为4的树而言，——。
A .树的深度最多是n-4B .树的深度最多是n-3C.第i层上最多有4x(i-1)个结点D.最少在某一层上正好有4个结点(3) “二叉树为空”意味着二叉树————。
A •由一些未赋值的空结点组成B.根结点无子树巳不存在D.没有结点(4) 按照二叉树的定义，具有3个结点的二叉树有——种形态(不考虑数据信息的组合情况)。
A. 2B. 3C. 4D. 5(5) 若一棵度为7 的树有8 个度为1 的结点，有7 个度为2 的结点，有6 个度为3 的结点，有5个度为4的结点，有4 个度为5的结点，有3个度为6的结点，有 2 个度为7的结点，则该树一共有——个叶结点。
A ．35 B．28 C．77 D．78(6) 若一棵二叉树有10 个度为2 的结点，则该二叉树的叶结点的个数是——。
A ．9 B．11 C．12 D ．不确定(7) 若一棵满二叉树有2047 个结点，则该二叉树中叶结点的个数为——。
A．512 B．1024C．2048 D．4096(8) 深度为h的满二叉树的第i层有一一个结点。
(i < h)A．2(i)—1 B．2(i)-1 C．2(h)—1 D．2(h)-1(9) 深度为h 的完全二叉树的第i 层有——个结点。
(i<h)A ．2(i-1) B．2(i)-1 C．2(h-1) D ．2(h)-1(10) 具有n 个结点的非空完全二叉树的深度为——。
A．n-1 B．n C．Llog2(n) 』D．Llog2(n) 』+1(11) 具有2000 个结点的非空二叉树的最小深度为——。
A ．9 B．10 C．11 D．12(12) 若某完全二叉树的深度为h，则该完全二叉树中至少有一一个结点。
A．2(h) B．2(h)-1 c．2(h)+1 D．2(h—1)(13) 若二叉树的前序序列与后序序列的次序正好相反，则该二叉树一定是——的二叉树。
A •空或仅有一个结点B •其分支结点无左子树C.其分支结点无右子树 D .其分支结点的度都为1(14) 任何一棵非空二叉树中的叶结点在前序遍历、中序遍历与后序遍历中的相对位置—A •都会发生改变B •不会发生改变C.有可能会发生改变 D •部分会发生改变(15) 对于一个数据元素序列，按照逐点插入方法建立一棵二叉排序树，该二叉排序树的形状取决于——。
A .该序列的存储结构B.序列中数据元素的取值范围C,数据元素的输人次序 D •使用的计算机的软、硬件条件(16) 对一棵二叉排序树进行——遍历，可以得到该二叉树的所有结点按值从小到大排列的序列。
A .前序B .中序C.后序 D .按层次(17) 除了前序遍历(DLR)、中序遍历(LDR)与后序遍历(LRD)夕卜，二叉树的遍历方法还可以有DRL 、RDL 和RLD 三种。
对于一棵二叉排序树，采用——遍历方法可以得到该二叉排序树的所有结点按值从大到小排列的序列。
A ．LDRB ．LRD C．RLD D．RDL(18) 在二叉排序树中进行查找的效率与——有关。
A。
二叉排序树的深度 B .二叉排序树的结点的个数C.被查找结点的度 D .二叉排序树的存储结构(19) 在具有n 个结点的二叉排序树中查找一个结点的过程的时间复杂度约为——。
A ．O(1)B ．O(n)C ．O(nz)D ．O(10gan)(20) 下列名词术语中，与数据的存储结构有关系的仅是——。
A .完全二叉树B .满二叉树C.线索二叉树D .二叉排序树(21) 平衡二叉树中任意结点的平衡因子只能是——之一。
A．0，1，2 B．0，1 C．-1，+1 D．0，-1，+1 7．3 填空题。
(1) 任何非空树中有且仅有一个结点没有前驱结点，该结点就是树的——。
(2) 树的层次定义为——。
(3) 度为k的树中第i层最多有一一个结点(i > 1)。
(4) 深度为h的k叉树最多有——个结点。
(5) 非空二叉树一共有——种基本形态。
(6) 非空二叉树中第i 层最多有——个结点。
(7) 深度为h 的二叉树最多有————个结点。