按层遍历二叉树

合集下载

二叉树的遍历及常用算法

⼆叉树的遍历及常⽤算法⼆叉树的遍历及常⽤算法遍历的定义:按照某种次序访问⼆叉树上的所有结点,且每个节点仅被访问⼀次;遍历的重要性:当我们需要对⼀颗⼆叉树进⾏,插⼊,删除,查找等操作时,通常都需要先遍历⼆叉树,所有说:遍历是⼆叉树的基本操作;遍历思路:⼆叉树的数据结构是递归定义(每个节点都可能包含相同结构的⼦节点),所以遍历也可以使⽤递归,即结点不为空则继续递归调⽤每个节点都有三个域,数据与,左孩⼦指针和右孩⼦之指针,每次遍历只需要读取数据,递归左⼦树,递归右⼦树,这三个操作三种遍历次序:根据访问三个域的不同顺序,可以有多种不同的遍历次序,⽽通常对于⼦树的访问都按照从左往右的顺序;设:L为遍历左⼦树,D为访问根结点,R为遍历右⼦树,且L必须位于R的前⾯可以得出以下三种不同的遍历次序:先序遍历操作次序为DLR,⾸先访问根结点，其次遍历根的左⼦树，最后遍历根右⼦树，对每棵⼦树同样按这三步(先根、后左、再右)进⾏中序遍历操作次序为LDR,⾸先遍历根的左⼦树，其次访问根结点，最后遍历根右⼦树，对每棵⼦树同样按这三步(先左、后根、再右)进⾏后序遍历操作次序为LRD,⾸先遍历根的左⼦树，其次遍历根的右⼦树，最后访问根结点，对每棵⼦树同样按这三步(先左、后右、最后根)进⾏层次遍历层次遍历即按照从上到下从左到右的顺序依次遍历所有节点,实现层次遍历通常需要借助⼀个队列,将接下来要遍历的结点依次加⼊队列中;遍历的应⽤“遍历”是⼆叉树各种操作的基础，可以在遍历过程中对结点进⾏各种操作，如:对于⼀棵已知⼆叉树求⼆叉树中结点的个数求⼆叉树中叶⼦结点的个数;求⼆叉树中度为1的结点个数求⼆叉树中度为2的结点个数5求⼆叉树中⾮终端结点个数交换结点左右孩⼦判定结点所在层次等等...C语⾔实现:#include <stdio.h>//⼆叉链表数据结构定义typedef struct TNode {char data;struct TNode *lchild;struct TNode *rchild;} *BinTree, BinNode;//初始化//传⼊⼀个指针令指针指向NULLvoid initiate(BinTree *tree) {*tree = NULL;}//创建树void create(BinTree *BT) {printf("输⼊当前结点值: (0则创建空节点)\n");char data;scanf(" %c", &data);//连续输⼊整形和字符时.字符变量会接受到换⾏,所以加空格if (data == 48) {*BT = NULL;return;} else {//创建根结点//注意开辟的空间⼤⼩是结构体的⼤⼩⽽不是结构体指针⼤⼩,写错了不会⽴马产⽣问题,但是后续在其中存储数据时极有可能出现内存访问异常(飙泪....) *BT = malloc(sizeof(struct TNode));//数据域赋值(*BT)->data = data;printf("输⼊节点 %c 的左孩⼦ \n", data);create(&((*BT)->lchild));//递归创建左⼦树printf("输⼊节点 %c 的右孩⼦ \n", data);create(&((*BT)->rchild));//递归创建右⼦树}}//求双亲结点(⽗结点)BinNode *Parent(BinTree tree, char x) {if (tree == NULL)return NULL;else if ((tree->lchild != NULL && tree->lchild->data == x) || (tree->rchild != NULL && tree->rchild->data == x))return tree;else{BinNode *node1 = Parent(tree->lchild, x);BinNode *node2 = Parent(tree->rchild, x);return node1 != NULL ? node1 : node2;}}//先序遍历void PreOrder(BinTree tree) {if (tree) {//输出数据printf("%c ", tree->data);//不为空则按顺序继续递归判断该节点的两个⼦节点PreOrder(tree->lchild);PreOrder(tree->rchild);}}//中序void InOrder(BinTree tree) {if (tree) {InOrder(tree->lchild);printf("%c ", tree->data);InOrder(tree->rchild);}}//后序void PostOrder(BinTree tree) {if (tree) {PostOrder(tree->lchild);PostOrder(tree->rchild);printf("%c ", tree->data);}}//销毁结点递归free所有节点void DestroyTree(BinTree *tree) {if (*tree != NULL) {printf("free %c \n", (*tree)->data);if ((*tree)->lchild) {DestroyTree(&((*tree)->lchild));}if ((*tree)->rchild) {DestroyTree(&((*tree)->rchild));}free(*tree);*tree = NULL;}}// 查找元素为X的结点使⽤的是层次遍历BinNode *FindNode(BinTree tree, char x) {if (tree == NULL) {return NULL;}//队列BinNode *nodes[1000] = {};//队列头尾位置int front = 0, real = 0;//将根节点插⼊到队列尾nodes[real] = tree;real += 1;//若队列不为空则继续while (front != real) {//取出队列头结点输出数据BinNode *current = nodes[front];if (current->data == x) {return current;}front++;//若当前节点还有⼦(左/右)节点则将结点加⼊队列if (current->lchild != NULL) {nodes[real] = current->lchild;real++;}if (current->rchild != NULL) {nodes[real] = current->rchild;real++;}}return NULL;}//层次遍历// 查找元素为X的结点使⽤的是层次遍历void LevelOrder(BinTree tree) {if (tree == NULL) {return;}//队列BinNode *nodes[1000] = {};//队列头尾位置int front = 0, real = 0;//将根节点插⼊到队列尾nodes[real] = tree;real += 1;//若队列不为空则继续while (front != real) {//取出队列头结点输出数据BinNode *current = nodes[front];printf("%2c", current->data);front++;//若当前节点还有⼦(左/右)节点则将结点加⼊队列if (current->lchild != NULL) {nodes[real] = current->lchild;real++;}if (current->rchild != NULL) {nodes[real] = current->rchild;real++;}}}//查找x的左孩⼦BinNode *Lchild(BinTree tree, char x) {BinTree node = FindNode(tree, x);if (node != NULL) {return node->lchild;}return NULL;}//查找x的右孩⼦BinNode *Rchild(BinTree tree, char x) {BinTree node = FindNode(tree, x);if (node != NULL) {return node->rchild;}return NULL;}//求叶⼦结点数量int leafCount(BinTree *tree) {if (*tree == NULL)return 0;//若左右⼦树都为空则该节点为叶⼦,且后续不⽤接续递归了else if (!(*tree)->lchild && !(*tree)->rchild)return 1;else//若当前结点存在⼦树,则递归左右⼦树, 结果相加return leafCount(&((*tree)->lchild)) + leafCount(&((*tree)->rchild));}//求⾮叶⼦结点数量int NotLeafCount(BinTree *tree) {if (*tree == NULL)return 0;//若该结点左右⼦树均为空,则是叶⼦,且不⽤继续递归else if (!(*tree)->lchild && !(*tree)->rchild)return 0;else//若当前结点存在左右⼦树,则是⾮叶⼦结点(数量+1),在递归获取左右⼦树中的⾮叶⼦结点,结果相加 return NotLeafCount(&((*tree)->lchild)) + NotLeafCount(&((*tree)->rchild)) + 1;}//求树的⾼度(深度)int DepthCount(BinTree *tree) {if (*tree == NULL)return 0;else{//当前节点不为空则深度+1 在加上⼦树的⾼度,int lc = DepthCount(&((*tree)->lchild)) + 1;int rc = DepthCount(&((*tree)->rchild)) + 1;return lc > rc?lc:rc;// 取两⼦树深度的最⼤值 }}//删除左⼦树void RemoveLeft(BinNode *node){if (!node)return;if (node->lchild)DestroyTree(&(node->lchild));node->lchild = NULL;}//删除右⼦树void RemoveRight(BinNode *node){if (!node)return;if (node->rchild)DestroyTree(&(node->rchild));node->rchild = NULL;}int main() {BinTree tree;create(&tree);BinNode *node = Parent(tree, 'G');printf("G的⽗结点为%c\n",node->data);BinNode *node2 = Lchild(tree, 'D');printf("D的左孩⼦结点为%c\n",node2->data);BinNode *node3 = Rchild(tree, 'D');printf("D的右孩⼦结点为%c\n",node3->data);printf("先序遍历为:");PreOrder(tree);printf("\n");printf("中序遍历为:");InOrder(tree);printf("\n");printf("后序遍历为:");PostOrder(tree);printf("\n");printf("层次遍历为:");LevelOrder(tree);printf("\n");int a = leafCount(&tree);printf("叶⼦结点数为%d\n",a);int b = NotLeafCount(&tree);printf("⾮叶⼦结点数为%d\n",b);int c = DepthCount(&tree);printf("深度为%d\n",c);//查找F节点BinNode *node4 = FindNode(tree,'C');RemoveLeft(node4);printf("删除C的左孩⼦后遍历:");LevelOrder(tree);printf("\n");RemoveRight(node4);printf("删除C的右孩⼦后遍历:");LevelOrder(tree);printf("\n");//销毁树printf("销毁树 \n");DestroyTree(&tree);printf("销毁后后遍历:");LevelOrder(tree);printf("\n");printf("Hello, World!\n");return 0;}测试:测试数据为下列⼆叉树:运⾏程序复制粘贴下列内容:ABDGHECKFIJ特别感谢:iammomo。

信息学模拟试卷一

模拟试卷一一、单项选择题1．若某链表中最常用的操作是在最后一个结点之后插入一个结点和删除最后一个结点，则采用存储方式最节省运算时间。

(1)单链表 (2)双链表(3)单循环链表 (4)带头结点的双循环链表2．设一个栈的输入序列为A，B，C．，D，则借助一个栈所得到的输出序列不可能是(1)A，B，C，D (2)D，C，B，A (3)A，C，D，B (4)D，A，B，C3．串是。

(1)不少于一个字母的序列 (2)任意个字母的序列(3)不少于一个字符的序列 (4)有限个字符的序列4．链表不具有的特点是。

(1)可随机访问任一元素 (2)插入删除不需要移动元素(3)不必事先估计存储空间 (4)所需空间与线性表长度成正比5．在有n个叶子结点的哈夫曼树中，其结点总数为。

(1)不确定 (2)2n (3)2n+1 (4)2n-16．任何一个无向连通图的最小生成树(1)只有一棵 (2)有一棵或多棵 (3)一定有多棵 (4)可能不存在7．将一棵有100个结点的完全二叉树从根这一层开始，每一层上从左到右依次对结点进行编号，根结点的编号为1，则编号为49的结点的左孩子编号为。

(1)98 (2)99 (3)50 (4)488.下列序列中，是执行第一趟快速排序后得到的序列(排序的关键字类型是字符串)。

(1)[da，ax，eb，de，bb]ff[ha，gc] (2)[cd，eb，ax，da]ff[ha，gc，bb] (3)[gc，ax，eb，cd，bb]ff[da，ha] (4)[ax，bb，cd，da]ff[eb，gc，ha] 9．用n个键值构造一棵二叉排序树，最低高度为。

(1)n/2 (2)n (3)[log2n] (4)[log2n+1]10．二分查找法要求查找表中各元素的键值必须是排列。

(1)递增或递减 (2)递增 (3)递减 (4)无序11.对于键值序列(12，13，11，18，60，15，7，18，25，100)，用筛选法建堆，必须从键值为的结点开始。

《数据结构》复习题

山东大学计算机学院计算机信息管理2006级夜大专科数据结构复习题一、填空题1、数据结构可以定义为一个两元组（D，S），其中 D 是数据元素的有限集，S 是的有限集。

2、在线性表中，线性表的长度指的是。

3、栈中元素的进出原则为 ____________。

4、深度为 k 的二叉树其结点数至多有个。

5、一棵深度为6的满二叉树有______个非终端结点。

6、若一棵二叉树中有8个度为2的结点,则它有_____个叶子。

7、设数组A[1..10,1..8]的基地址为2000,每个元素占2个存储单元,若以行序8、为主序顺序存储,则元素A[4,5]的存储地址为_____；若以列序为主序顺序存储,则元素A[4,5]的存储地址为______。

9、哈希表是一种查找表，可以根据哈希函数直接获得。

10、在单链表中，删除指针 P 所指结点的后继结点的语句是：。

11、有向图 G 用邻接矩阵 A[1..n，1..n] 存储表示，其第 i 行的所有元素之和等于顶点 i 的。

12、在一个单链表p所指结点之后插入一个s所指结点时，应执行s→next=____和p→next=_____的操作。

13、设有33个值，用它们组成一棵哈夫曼树，则该哈夫曼树中共有____个结点。

14、设需将一组数据按升序排序。

在无序区中依次比较相邻两个元素a i和a i+1的值，若a i的值大于a i+1的值，则交换a i和a i+1。

如此反复，直到某一趟中没有记录需要交换为止，该排序方法被称为_________。

15、数据结构在计算机中的表示称为数据的。

16、一棵含999个结点的完全二叉树的深度为_______。

17、广义表的深度是指_______。

18、称算法的时间复杂度为O(f(n))，其含义是指算法的执行时间和_______的数量级相同。

19、在一个长度为n的单链表L中，删除链表中*p的前驱结点的时间复杂度为_________。

20、在队列中，允许插入元素的一端称为_________。

二叉树遍历（前序、中序、后序、层次、广度优先、深度优先遍历）

⼆叉树遍历（前序、中序、后序、层次、⼴度优先、深度优先遍历）⽬录转载：⼆叉树概念⼆叉树是⼀种⾮常重要的数据结构，⾮常多其他数据结构都是基于⼆叉树的基础演变⽽来的。

对于⼆叉树，有深度遍历和⼴度遍历，深度遍历有前序、中序以及后序三种遍历⽅法，⼴度遍历即我们寻常所说的层次遍历。

由于树的定义本⾝就是递归定义，因此採⽤递归的⽅法去实现树的三种遍历不仅easy理解并且代码⾮常简洁，⽽对于⼴度遍历来说，须要其他数据结构的⽀撑。

⽐⽅堆了。

所以。

对于⼀段代码来说，可读性有时候要⽐代码本⾝的效率要重要的多。

四种基本的遍历思想前序遍历：根结点 ---> 左⼦树 ---> 右⼦树中序遍历：左⼦树---> 根结点 ---> 右⼦树后序遍历：左⼦树 ---> 右⼦树 ---> 根结点层次遍历：仅仅需按层次遍历就可以⽐如。

求以下⼆叉树的各种遍历前序遍历：1 2 4 5 7 8 3 6中序遍历：4 2 7 5 8 1 3 6后序遍历：4 7 8 5 2 6 3 1层次遍历：1 2 3 4 5 6 7 8⼀、前序遍历1）依据上⽂提到的遍历思路：根结点 ---> 左⼦树 ---> 右⼦树，⾮常easy写出递归版本号：public void preOrderTraverse1(TreeNode root) {if (root != null) {System.out.print(root.val+" ");preOrderTraverse1(root.left);preOrderTraverse1(root.right);}}2）如今讨论⾮递归的版本号：依据前序遍历的顺序，优先訪问根结点。

然后在訪问左⼦树和右⼦树。

所以。

对于随意结点node。

第⼀部分即直接訪问之，之后在推断左⼦树是否为空，不为空时即反复上⾯的步骤，直到其为空。

若为空。

则须要訪问右⼦树。

注意。

在訪问过左孩⼦之后。

二叉树求每个结点高度算法

二叉树求每个结点高度算法二叉树是一种非常常见的数据结构，它由一个根结点和最多两个子结点组成。

在解决二叉树相关问题时，经常需要求每个结点的高度，也就是树的深度。

本文将介绍常见的二叉树求每个结点高度的算法。

在介绍求每个结点高度的算法之前，首先需要了解二叉树的定义和性质。

二叉树是一种树的特殊形式，它的每个结点最多只有两个子结点。

二叉树的高度定义为从根结点到叶子结点的最长路径上的结点数，即树中结点的最大深度。

在求解每个结点高度时，需要遍历整个二叉树，计算每个结点距离根结点的深度。

一种常见的求每个结点高度的算法是通过递归实现的。

其基本思想是，对于每个结点，其高度等于其左子树和右子树的高度中较大的那个值加一，再加上该结点本身的高度（1）。

具体实现递归算法的伪代码如下：```function getHeight(node):if node is null:return 0leftHeight = getHeight(node.left)rightHeight = getHeight(node.right)return max(leftHeight, rightHeight) + 1```通过递归算法，可以方便地求出每个结点的高度。

递归算法的停止条件是当结点为空时，返回0作为高度。

在使用递归算法时，需要注意避免重复计算。

可以通过在每个结点处保存其高度，避免重复计算。

在算法的实现中，可以使用一个哈希表或者结构体来保存每个结点的高度。

除了递归算法外，还可以使用层次遍历的方法求每个结点的高度。

层次遍历是一种广度优先搜索的算法，可以按层次遍历二叉树。

在层次遍历的过程中，可以对每个结点进行标记，记录其所在的层数。

具体实现层次遍历的伪代码如下：```function getHeight(root):if root is null:return 0queue = new Queue()queue.enqueue(root)root.level = 1while queue is not empty:node = queue.dequeue()if node.left is not null:queue.enqueue(node.left)node.left.level = node.level + 1if node.right is not null:queue.enqueue(node.right)node.right.level = node.level + 1return max(node.level for node in tree)```通过层次遍历的方法，可以按层次遍历二叉树，同时记录每个结点的层数。

数据结构答案第5章

第 5 章树和二叉树1970-01-01第 5 章树和二叉树课后习题讲解1. 填空题⑴树是n（n≥0）结点的有限集合，在一棵非空树中，有（）个根结点，其余的结点分成m（m＞0）个（）的集合，每个集合都是根结点的子树。

【解答】有且仅有一个，互不相交⑵树中某结点的子树的个数称为该结点的（），子树的根结点称为该结点的（），该结点称为其子树根结点的（）。

【解答】度，孩子，双亲⑶一棵二叉树的第i（i≥1）层最多有（）个结点；一棵有n（n>0）个结点的满二叉树共有（）个叶子结点和（）个非终端结点。

【解答】2i-1，(n+1)/2，(n-1)/2【分析】设满二叉树中叶子结点的个数为n0，度为2的结点个数为n2，由于满二叉树中不存在度为1的结点，所以n=n0+n2；由二叉树的性质n0=n2+1，得n0=(n+1)/2，n2=(n-1)/2。

⑷设高度为h的二叉树上只有度为0和度为2的结点，该二叉树的结点数可能达到的最大值是（），最小值是（）。

【解答】2h -1，2h-1【分析】最小结点个数的情况是第1层有1个结点，其他层上都只有2个结点。

⑸深度为k的二叉树中，所含叶子的个数最多为（）。

【解答】2k-1【分析】在满二叉树中叶子结点的个数达到最多。

⑹具有100个结点的完全二叉树的叶子结点数为（）。

【解答】50【分析】100个结点的完全二叉树中最后一个结点的编号为100，其双亲即最后一个分支结点的编号为50，也就是说，从编号51开始均为叶子。

⑺已知一棵度为3的树有2个度为1的结点，3个度为2的结点，4个度为3的结点。

则该树中有（）个叶子结点。

【解答】12【分析】根据二叉树性质3的证明过程，有n0=n2+2n3+1（n0、n2、n3分别为叶子结点、度为2的结点和度为3的结点的个数）。

⑻某二叉树的前序遍历序列是ABCDEFG，中序遍历序列是CBDAFGE，则其后序遍历序列是（）。

【解答】CDBGFEA【分析】根据前序遍历序列和后序遍历序列将该二叉树构造出来。

数据结构课后习题(第6章)

【课后习题】第6章树和二叉树网络工程2010级（）班学号：姓名：一、填空题（每空1分，共16分)1.从逻辑结构看，树是典型的。

2.设一棵完全二叉树具有999个结点，则此完全二叉树有个叶子结点，有个度为2的结点，有个度为1的结点。

3.由n个权值构成的哈夫曼树共有个结点。

4.在线索化二叉树中，T所指结点没有左子树的充要条件是。

5.在非空树上，_____没有直接前趋。

6.深度为k的二叉树最多有结点，最少有个结点。

7.若按层次顺序将一棵有n个结点的完全二叉树的所有结点从1到n编号，那么当i为且小于n时，结点i的右兄弟是结点，否则结点i没有右兄弟。

8.N个结点的二叉树采用二叉链表存放，共有空链域个数为。

9.一棵深度为7的满二叉树有___ ___个非终端结点。

10.将一棵树转换为二叉树表示后,该二叉树的根结点没有。

11.采用二叉树来表示树时，树的先根次序遍历结果与其对应的二叉树的遍历结果是一样的。

12.一棵Huffman树是带权路径长度最短的二叉树，权值的外结点离根较远。

二、判断题（如果正确，在对应位置打“√”，否则打“⨯”。

每题0.5分，共5分)1.对于一棵非空二叉树，它的根结点作为第一层，则它的第i层上最多能有2i-1个结点。

2.二叉树的前序遍历并不能唯一确定这棵树，但是，如果我们还知道该二叉树的根结点是那一个，则可以确定这棵二叉树。

3.一棵树中的叶子结点数一定等于与其对应的二叉树中的叶子结点数。

4.度≤2的树就是二叉树。

5.一棵Huffman树是带权路径长度最短的二叉树，权值较大的外结点离根较远。

6.采用二叉树来表示树时，树的先根次序遍历结果与其对应的二叉树的前序遍历结果是一样的。

7.不存在有偶数个结点的满二叉树。

8.满二叉树一定是完全二叉树，而完全二叉树不一定是满二叉树。

9.已知二叉树的前序遍历顺序和中序遍历顺序，可以惟一确定一棵二叉树；10.已知二叉树的前序遍历顺序和后序遍历顺序，不能惟一确定一棵二叉树；三、单项选择（请将正确答案的代号填写在下表对应题号下面。

数据结构二叉树习题含答案

第 6 章树和二叉树1．选择题（ 1）把一棵树变换为二叉树后，这棵二叉树的形态是（）。

A．独一的Ｂ．有多种C．有多种，但根结点都没有左孩子Ｄ．有多种，但根结点都没有右孩子（ 2）由 3 个结点能够结构出多少种不一样的二叉树？（）A． 2 B ． 3 C ． 4 D． 5（ 3）一棵完整二叉树上有1001 个结点，此中叶子结点的个数是（）。

A． 250 B ． 500 C ． 254 D． 501（ 4）一个拥有 1025 个结点的二叉树的高h 为（）。

A． 11 B ． 10 C．11 至 1025 之间 D ．10 至 1024 之间（ 5）深度为 h 的满 m叉树的第 k 层有（）个结点。

(1=<k=<h)k-1B kCh-1 hA． m ． m-1 ． m D．m-1（ 6）利用二叉链表储存树，则根结点的右指针是（）。

A．指向最左孩子 B ．指向最右孩子 C ．空 D ．非空（ 7）对二叉树的结点从 1 开始进行连续编号，要求每个结点的编号大于其左、右孩子的编号，同一结点的左右孩子中，其左孩子的编号小于其右孩子的编号，可采纳（）遍历实现编号。

A．先序 B. 中序 C. 后序 D.从根开始按层次遍历（8）若二叉树采纳二叉链表储存结构，要互换其全部分支结点左、右子树的地点，利用（）遍历方法最适合。

A．前序B．中序C．后序D．按层次（9）在以下储存形式中，（）不是树的储存形式？A．双亲表示法 B ．孩子链表表示法 C ．孩子兄弟表示法D．次序储存表示法（ 10）一棵非空的二叉树的先序遍历序列与后序遍历序列正好相反，则该二叉树必定满足（）。

A．全部的结点均无左孩子B．全部的结点均无右孩子C．只有一个叶子结点D．是随意一棵二叉树（ 11）某二叉树的前序序列和后序序列正好相反，则该二叉树必定是（）的二叉树。

A．空或只有一个结点B．任一结点无左子树C．高度等于其结点数 D ．任一结点无右子树（ 12）若 X 是二叉中序线索树中一个有左孩子的结点，且 X 不为根，则 X 的前驱为（）。

计算机考研408 数据结构算法总结及二叉树三种遍历算法的源码背诵版

数据结构算法背诵一、线性表1.逆转顺序表中的所有元素算法思想：第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，……，依此类推。

void Reverse(int A[], int n){int i, t;for (i=0; i < n/2; i++){t = A[i];A[i] = A[n-i-1];A[n-i-1] = t;}}2.删除线性链表中数据域为item的所有结点算法思想：先从链表的第2个结点开始，从前往后依次判断链表中的所有结点是否满足条件，若某个结点的数据域为item，则删除该结点。

最后再回过头来判断链表中的第1个结点是否满足条件，若满足则将其删除。

void PurgeItem(LinkList &list){LinkList p, q = list;p = list->next;while (p != NULL){if (p->data == item) {q->next = p->next;free(p);p = q->next;} else {q = p;p = p->next;}}if (list->data == item){q = list;list = list->next;free(q);}}3.逆转线性链表void Reverse(LinkList &list){LinkList p, q, r;p = list;q = NULL;while (p != NULL){r = q;q = p;p = p->next;q->next = r;}list = q;}4.复制线性链表（递归）LinkList Copy(LinkList lista){LinkList listb;if (lista == NULL)return NULL;else {listb = (LinkList)malloc(sizeof(LNode));listb->data = lista->data;listb->next = Copy(lista->next);return listb;}}5.将两个按值有序排列的非空线性链表合并为一个按值有序的线性链表LinkList MergeList(LinkList lista, LinkList listb){LinkList listc, p = lista, q = listb, r;// listc 指向 lista 和 listb 所指结点中较小者if (lista->data <= listb->data) {listc = lista;r = lista;p = lista->next;} else {listc = listb;r = listb;q = listb->next;}while (p != NULL && q != NULL){if (p->data <= q->data) {r->next = p;r = p;p = p->next;} else {r->next = q;r = q;q = q->next;}}// 将剩余结点（即未参加比较的且已按升序排列的结点）链接到整个链表后面 r->next = (p != NULL) ? p : q;return listc;}二、树1.二叉树的先序遍历（非递归算法）算法思想：若p所指结点不为空，则访问该结点，然后将该结点的地址入栈，然后再将p指向其左孩子结点；若p所指向的结点为空，则从堆栈中退出栈顶元素（某个结点的地址），将p指向其右孩子结点。

数据结构自考题-2

数据结构自考题-2(总分：105.00，做题时间：90分钟)一、单项选择题(总题数：15，分数：30.00)1.用二分查找法对具有n个结点的线性表查找一个结点所需的平均比较次数为( )A．O(n2) B．O(nlog2n) C．O(n) D．O(log2n)（分数：2.00）A.B. √C.D. √解析：2.如果我们采用二分查找法查找一个长度为n的有序表，则查找每个元素的平均比较次数( )对应的判定树的高度(假设树高h≥2)。

A．大于 B．小于 C．等于 D．无法确定（分数：2.00）A.B. √C.D.解析：3.对一棵非空二叉树进行中序遍历，则根结点的左边( )A．只有左子树上的所有结点 B．只有右子树上的所有结点C．只有左子树上的部分结点 D．只有右子树上的部分结点（分数：2.00）A. √B.C.D.解析：4.在按层次遍历二叉树的算法中，需要借助的辅助数据结构是 ( )A．队列 B．栈 C．线性表 D．有序表（分数：2.00）A. √B.C.D.解析：5.从具有n个结点的单链表中查找值等于x的结点时，在查找成功的情况下，平均需比较( )个结点。

A．n B．n/2 C．(n-1)/2 D．(n+1)/2（分数：2.00）A.B.C.D. √解析：6.设二叉树根结点的层次为0，一棵高度为h的满二叉树中的结点个数是( )A．2h B．2h-1 C．2h-1 D．2h+1-1（分数：2.00）A.B.C.D. √解析：7.下面的查找方式中，可以对无序表进行查找的是( )A．顺序查找 B．二分查找 C．二叉排序树 D．B-树上的查找（分数：2.00）A. √B.C.D.解析：8.具有12个记录的序列，采用冒泡排序最少的比较次数是( )A．1 B．144 C．11 D．66（分数：2.00）A.B.C. √D.解析：9.线性结构中的一个结点代表一个数据元素，通常要求同一线性结构的所有结点所代表的数据元素具有相同的特性，这意味着( )A．每个结点所代表的数据元素都一样B．每个结点所代表的数据元素包含的数据项的个数要相等C．不仅数据元素所包含的数据项的个数要相同，而且对应数据项的类型要一致D．结点所代表的数据元素有同一特点（分数：2.00）A.B.C. √D.解析：10.下列排序算法中，其时间复杂度和记录的初始排列无关的是 ( ) A．插入排序 B．堆排序 C．快速排序 D．冒泡排序（分数：2.00）A.B. √C.D.解析：11.若用邻接矩阵表示一个有向图，则其中每一列包含的"1"的个数为 ( ) A．图中每个顶点的入度 B．图中每个顶点的出度C．图中弧的条数 D．图中连通分量的数目（分数：2.00）A. √B.C.D.解析：12.具有24个记录的序列，采用冒泡排序最少的比较次数是( )A．1 B．23 C．24 D．529（分数：2.00）A.B. √C.D.解析：13.邻接表存储结构下图的深度优先遍历算法结构类似于于叉树的( ) A．先序遍历 B．中序遍历 C．后序遍历 D．按层遍历（分数：2.00）A. √B.C.D.解析：14.树最适合用来表示( )A．有序数据元素 B．无序数据元素C．元素之间具有分支层次关系的数据 D．元素之间无联系的数据（分数：2.00）A.B.C. √D.解析：15.若用冒泡排序法对序列18,14,6,27,8,12,16,52,10,26,47,29,41,24从小到大进行排序，共要进行( )次比较。

中序序列与层次遍历序列相同的二叉树

中序序列与层次遍历序列相同的二叉树中序遍历（Inorder Traversal）是二叉树遍历的一种方式，它按照访问左子树、访问根节点、访问右子树的顺序遍历二叉树。

层次遍历（Level Order Traversal）是另一种二叉树遍历方式，它从上到下逐层遍历二叉树。

现在假设有一棵二叉树，它的中序遍历序列与层次遍历序列相同。

我们需要证明这样的二叉树是存在的，并且给出构造这样二叉树的方法。

首先，让我们来分析一棵二叉树的中序遍历和层次遍历序列有什么特点。

中序遍历序列的特点是根节点在中间，左子树在根节点的左边，右子树在根节点的右边。

而层次遍历序列的特点是根节点在最上面，每一层的节点从左到右依次排列。

由于中序遍历和层次遍历序列相同，我们可以确定的是根节点一定在层次遍历序列的最上面，而且中序遍历序列中根节点的左侧一定是左子树的节点，根节点的右侧一定是右子树的节点。

接下来，我们需要找出根节点的左子树和右子树在中序遍历序列和层次遍历序列中的位置。

对于中序遍历序列，根节点左边的节点一定是左子树的节点，根节点右边的节点一定是右子树的节点。

而对于层次遍历序列，我们可以通过根节点的位置来确定其左子树和右子树的节点。

由于中序遍历序列和层次遍历序列相同，根节点在层次遍历序列的最上面，那么根节点的左子树一定在层次遍历序列的左侧（可能有多个节点），根节点的右子树一定在层次遍历序列的右侧（可能有多个节点）。

我们可以通过上述分析得到以下结论：1.中序遍历序列和层次遍历序列相同的二叉树一定存在；2.根节点在层次遍历序列的最上面；3.根节点的左子树在层次遍历序列的左侧；4.根节点的右子树在层次遍历序列的右侧。

接下来，我们可以通过递归的方式来构造满足条件的二叉树。

首先，我们选取层次遍历序列的第一个节点作为根节点，并在中序遍历序列中找到该节点的位置。

根据该位置，我们可以确定根节点的左子树和右子树在中序遍历序列和层次遍历序列中的位置。

然后，我们可以对左子树和右子树的中序遍历序列和层次遍历序列进行递归构造。

二叉树的建立和遍历的实验报告

竭诚为您提供优质文档/双击可除二叉树的建立和遍历的实验报告篇一：二叉树遍历实验报告数据结构实验报告报告题目：二叉树的基本操作学生班级：学生姓名：学号：一．实验目的1、基本要求：深刻理解二叉树性质和各种存储结构的特点及适用范围；掌握用指针类型描述、访问和处理二叉树的运算；熟练掌握二叉树的遍历算法；。

2、较高要求:在遍历算法的基础上设计二叉树更复杂操作算法；认识哈夫曼树、哈夫曼编码的作用和意义;掌握树与森林的存储与便利。

二.实验学时：课内实验学时：3学时课外实验学时：6学时三．实验题目1．以二叉链表为存储结构，实现二叉树的创建、遍历（实验类型：验证型）1）问题描述：在主程序中设计一个简单的菜单，分别调用相应的函数功能：1…建立树2…前序遍历树3…中序遍历树4…后序遍历树5…求二叉树的高度6…求二叉树的叶子节点7…非递归中序遍历树0…结束2）实验要求：在程序中定义下述函数，并实现要求的函数功能：createbinTree(binTreestructnode*lchild,*rchild;}binTnode;元素类型：intcreatebinTree(binTreevoidpreorder(binTreevoidInorder(binTreevoidpostorder(binTreevoidInordern(binTreeintleaf(bi nTreeintpostTreeDepth(binTree2、编写算法实现二叉树的非递归中序遍历和求二叉树高度。

1）问题描述：实现二叉树的非递归中序遍历和求二叉树高度2）实验要求：以二叉链表作为存储结构3)实现过程：1、实现非递归中序遍历代码：voidcbiTree::Inordern(binTreeinttop=0;p=T;do{while(p!=nuLL){stack[top]=p;;top=top+1;p=p->lchild;};if(top>0){top=top-1;p=stack[top];printf("%3c",p->data);p=p->rchild;}}while(p!=nuLL||top!=0);}2、求二叉树高度：intcbiTree::postTreeDepth(binTreeif(T!=nuLL){l=postTreeDepth(T->lchild);r=postTreeDepth(T->rchil d);max=l>r?l:r;return(max+1);}elsereturn(0);}实验步骤：1）新建一个基于consoleApplication的工程，工程名称biTreeTest；2）新建一个类cbiTree二叉树类。

二叉树节点数与形态数

二叉树节点数与形态数1.引言1.1 概述引言是文章的开端，用来介绍文章的主题和目的。

在这篇文章中，我们将讨论二叉树的节点数和形态数，并探讨它们之间的关系。

二叉树是一种常见的树形结构，具有丰富的应用场景。

节点数是指二叉树中节点的总数，而形态数则是指二叉树的不同形态的总数。

在本文中，我们将首先介绍二叉树节点数的定义和计算方法。

节点数是指二叉树中所有节点的总数，包括根节点、内部节点和叶子节点。

我们将详细介绍如何计算不同类型的二叉树的节点数，并讨论其复杂度和算法特点。

接下来，我们将介绍二叉树形态数的定义和计算方法。

形态数是指二叉树的不同形态的总数，也可以理解为二叉树的种类数量。

我们将探讨如何计算二叉树的形态数，并分析影响形态数的因素，如节点的数量、结构和顺序等。

最后，我们将研究二叉树节点数和形态数之间的关系。

我们将讨论节点数对形态数的影响，以及通过增加或删除节点如何改变二叉树的形态数。

我们还将总结文章的主要观点和结论，以及对进一步研究的建议。

通过对二叉树节点数和形态数的深入研究，我们可以更好地理解和分析二叉树的特性和应用。

本文的目的是为读者提供一个全面的了解，并激发更多关于二叉树的研究和应用的思考。

让我们开始这个有趣而挑战性的探索之旅吧。

1.2文章结构1.2 文章结构本文将详细讨论二叉树节点数与形态数的定义、计算方法以及它们之间的关系。

整篇文章分为以下几个部分：2.1 二叉树节点数的定义和计算方法在这一部分，我们将首先对二叉树节点数的定义进行介绍。

然后，我们将详细说明如何计算给定二叉树的节点数。

我们将讨论两种主要的计算方法：递归计算和迭代计算。

我们将对每种方法进行分析，并比较它们的优缺点。

最后，我们将通过一些例子来说明如何应用这些计算方法。

2.2 二叉树形态数的定义和计算方法在这一部分，我们将对二叉树形态数的定义进行介绍。

形态数指的是不同形态的二叉树的数量。

我们将详细说明如何计算给定节点数的二叉树的形态数。

二叉树的各种遍历及直观打印

目录一．引言-----------------------------------------------------------------------21. 摘要---------------------------------------------------------------------------22. 关键字------------------------------------------------------------------------2 二．正文1. 需求分析-------------------------------------------------------------------------------------------22. 数据结构---------------------------------------------------------------------23. 算法设计---------------------------------------------------------------------3 3.1概要设计---------------------------------------------------------------------------------------------33.2详细设计--------------------------------------------------------------------------------------------44. 调试分析----------------------------------------------------------------------65. 测试结果----------------------------------------------------------------------66.源程序---------------------------------------------------------------------------97. 不足之处----------------------------------------------------------------------158.设计体会-----------------------------------------------------------------------16 四．参考文献-------------------------------------------------------------------16一. 引言二叉树是树形结构的一个重要类型，许多实际问题抽象出来的数据结构往往是二叉树的形式，即使是一般的树也能简单地转换为二叉树，因此，二叉树显得特别重要。

数据结构实验三——二叉树基本操作及运算实验报告

《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述：实现二叉树（包括二叉排序树）的建立，并实现先序、中序、后序和按层次遍历，计算叶子结点数、树的深度、树的宽度，求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目，以及二叉树常用运算。

问题分析：二叉树树型结构是一类重要的非线性数据结构，对它的熟练掌握是学习数据结构的基本要求。

由于二叉树的定义本身就是一种递归定义，所以二叉树的一些基本操作也可采用递归调用的方法。

处理本问题，我觉得应该：1、建立二叉树；2、通过递归方法来遍历（先序、中序和后序）二叉树；3、通过队列应用来实现对二叉树的层次遍历；4、借用递归方法对二叉树进行一些基本操作，如：求叶子数、树的深度宽度等；5、运用广义表对二叉树进行广义表形式的打印。

算法规定：输入形式：为了方便操作，规定二叉树的元素类型都为字符型，允许各种字符类型的输入，没有元素的结点以空格输入表示，并且本实验是以先序顺序输入的。

输出形式：通过先序、中序和后序遍历的方法对树的各字符型元素进行遍历打印，再以广义表形式进行打印。

对二叉树的一些运算结果以整型输出。

程序功能：实现对二叉树的先序、中序和后序遍历，层次遍历。

计算叶子结点数、树的深度、树的宽度，求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目。

对二叉树的某个元素进行查找，对二叉树的某个结点进行删除。

测试数据：输入一：ABC□□DE□G□□F□□□（以□表示空格）,查找5,删除E预测结果：先序遍历ABCDEGF中序遍历CBEGDFA后序遍历CGEFDBA层次遍历ABCDEFG广义表打印A（B（C,D（E（,G）,F）））叶子数3 深度5 宽度2 非空子孙数6 度为2的数目2 度为1的数目2查找5，成功，查找的元素为E删除E后，以广义表形式打印A（B（C,D（,F）））输入二：ABD□□EH□□□CF□G□□□（以□表示空格）,查找10,删除B预测结果：先序遍历ABDEHCFG中序遍历DBHEAGFC后序遍历DHEBGFCA层次遍历ABCDEFHG广义表打印A（B(D,E(H)),C(F(,G))）叶子数3 深度4 宽度3 非空子孙数7 度为2的数目2 度为1的数目3查找10，失败。

第六章树与二叉树2-1遍历二叉树

?
先序序列: A, B, D, E, J, C, F, I, G 中序序列: D, B, J, E, A, F, I, C, G
先序序列: A, B, D, E, J, C, F, I, G 中序序列: D, B, J, E, A, F, I, C, G
A
D,B,J, E F,I,C,G
A B D J, E F,I,C,G
viod PreOrderTraverse(BiTree T, Status(*Visit)(TElemType e)) { if (T) { Visit(T->data)； PreOrderTraverse(T->lchild, Visit); PreOrderTraverse(T->rchild, Visit); }//if }//PreOrderTraverse void leaf(BiTree T) { if(T) { if (T->lchild==NULL&&T->rchild==NULL) n=n+1; leaf(T->lchild); leaf(T->rchild); }//if }//leaf
先序序列：A
B D C
printf(C); pre(T L); pre(T R);
T
返回
二、遍历的算法描述先序遍历非递归算法
算法的关键：在前序遍历过某结点的整个左子树后，如何找到该结点的右子树的根指针。解决办法：在访问完该结点后，将该结点的指针保存在栈中，以便以后能通过它找到该结点的右子树。在前序遍历中，设要遍历二叉树的根指针为T，则有两种可能： ⑴ 若T!=NULL，则表明？如何处理？ ⑵ 若T=NULL，则表明？如何处理？

广州大学松田学院7数据结构复习题-树-参考答案

7数据结构复习题（二叉树）一．判断题（下列各题，正确的请在前面的括号内打√；错误的打╳）（√）（1）树结构中每个结点最多只有一个直接前驱。

（ㄨ）（2）完全二叉树一定是满二查树。

（ㄨ）（3）在中序线索二叉树中，右线索若不为空，则一定指向其双亲。

（√）（4）一棵二叉树中序遍历序列的最后一个结点，必定是该二叉树前序遍历的最后一个结点。

（√）（5）二叉树的前序遍历中，任意一个结点均处于其子女结点的前面。

（√）（6）由二叉树的前序遍历序列和中序遍历序列，可以推导出后序遍历的序列。

（√）（7）在完全二叉树中，若一个结点没有左孩子，则它必然是叶子结点。

（ㄨ）（8）在哈夫曼编码中，当两个字符出现的频率相同，其编码也相同，对于这种情况应该做特殊处理。

（ㄨ）（9）含多于两棵树的森林转换的二叉树，其根结点一定无右孩子。

（√）（10）具有n个叶子结点的哈夫曼树共有2n-1个结点。

二．填空题（1）在树中，一个结点所拥有的子树数称为该结点的度。

（2）度为零的结点称为叶（或叶子，或终端）结点。

（3）树中结点的最大层次称为树的深度（或高度）。

（4）对于二叉树来说，第i层上至多有2i-1个结点。

（5）深度为h的二叉树至多有2h-1 个结点。

（6）由一棵二叉树的前序序列和中序序列可唯一确定这棵二叉树。

（7）有20个结点的完全二叉树，编号为10的结点的父结点的编号是 5 。

（8）哈夫曼树是带权路径长度最小的二叉树。

（9）由二叉树的后序和中序遍历序列，可以唯一确定一棵二叉树。

（10）某二叉树的中序遍历序列为: DEBAC，后序遍历序列为：EBCAD。

则前序遍历序列为：DABEC 。

（11）设一棵二叉树结点的先序遍历序历为：ABDECFGH，中序遍历序历为：DEBAFCHG，则二叉树中叶结点是：E、F、H 。

（12）已知完全二叉树的第8层有8个结点，则其叶结点数是68 。

（13）由树转换成二叉树时，其根结点无右子树。

（14）采用二叉链表存储的n个结点的二叉树，一共有2n 个指针域。

二叉树的遍历及例题

⼆叉树的遍历及例题⼆叉树的遍历及例题前序遍历就是根在前，中序是根在根在中，前序遍历根 --> 左 --> 右中序遍历左 --> 根 --> 右后序遍历左 --> 右 --> 根如图是⼀颗⼆叉树前序(根左右)，中序(左根右)，后序(左右根)它的前序遍历结果为： A B D F G H I E C 代表的含义为A( B ( D ( F ,G( H ,I ) ) ,E ) , C )所以第⼀个点⼀定是根节点它的中序遍历结果为： F D H G I B E A C它代表的含义，A（已知它不是叶⼦节点）在中间说明A的左边是左⼉⼦，A的右边是他的右⼉⼦它的后序遍历结果为：F H I G D E B C A解题：如果有前序和中序或者中序和后序可以得到⼆叉树，从⽽得到后序。

如果有前序和后序⽆法的得到⼆叉树。

1.已知前序、中序遍历求后序遍历例：前序遍历：A B G D E C F H中序遍历：G B E D A F C H构建⼆叉树的步骤：1.根据前序遍历特点，得到根节点A2.观察中序遍历结果：根节点左边节点为G B E D，根节点的右边节点为 F C H。

同时，两段也是左右⼦树的中序遍历的结果。

B G D E也是左⼦树前序遍历的结果。

C F H也是右⼦树前序遍历的结果。

3.重复 1 2的步骤，直到找到叶⼦结点就可以得到最后的⼆叉树。

例题：题意：给出中序遍历和前序遍历，让你找到后序遍历的结果。

#include <iostream>using namespace std;const int maxn = 105;int pre[maxn],in[maxn],pos[maxn];int infind(int root,int l,int r){//在中序遍历中找到当前根节点的位置for(int i=l;i<r;i++){if(in[i]==root){return i;}}}int cnt;void posorder(int prel,int prer,int inl,int inr){if(prel==prer) return ;int root=infind(pre[prel],inl,inr);//找当前的根的位置int len=root-inl;posorder(prel+1,prel+1+len,inl,inl+len);//prel的位置是root的位置，删去posorder(prel+1+len,prer,inl+1+len,inr);//inl+len+1的位置是root的位置，删去//进⾏完左边和右边的遍历之后，进⾏赋值。