二叉树的各种算法
二叉树的遍历及常用算法
⼆叉树的遍历及常⽤算法⼆叉树的遍历及常⽤算法遍历的定义:按照某种次序访问⼆叉树上的所有结点,且每个节点仅被访问⼀次;遍历的重要性:当我们需要对⼀颗⼆叉树进⾏,插⼊,删除,查找等操作时,通常都需要先遍历⼆叉树,所有说:遍历是⼆叉树的基本操作;遍历思路:⼆叉树的数据结构是递归定义(每个节点都可能包含相同结构的⼦节点),所以遍历也可以使⽤递归,即结点不为空则继续递归调⽤每个节点都有三个域,数据与,左孩⼦指针和右孩⼦之指针,每次遍历只需要读取数据,递归左⼦树,递归右⼦树,这三个操作三种遍历次序:根据访问三个域的不同顺序,可以有多种不同的遍历次序,⽽通常对于⼦树的访问都按照从左往右的顺序;设: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)插入新结点(2)前序、中序、后序遍历二叉树(3)中序遍历的非递归算法(4)层次遍历二叉树(5)在二叉树中查找给定关键字(函数返回值为成功1,失败0)(6)交换各结点的左右子树(7)求二叉树的深度(8)叶子结点数Input第一行:准备建树的结点个数n第二行:输入n个整数,用空格分隔第三行:输入待查找的关键字第四行:输入待查找的关键字第五行:输入待插入的关键字Output第一行:二叉树的先序遍历序列第二行:二叉树的中序遍历序列第三行:二叉树的后序遍历序列第四行:查找结果第五行:查找结果第六行~第八行:插入新结点后的二叉树的先、中、序遍历序列第九行:插入新结点后的二叉树的中序遍历序列(非递归算法)第十行:插入新结点后的二叉树的层次遍历序列第十一行~第十三行:第一次交换各结点的左右子树后的先、中、后序遍历序列第十四行~第十六行:第二次交换各结点的左右子树后的先、中、后序遍历序列第十七行:二叉树的深度第十八行:叶子结点数*/#include ""#include ""#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int KeyType;#define STACK_INIT_SIZE 100 // 存储空间初始分配量#define STACKINCREMENT 10 // 存储空间分配增量#define MAXQSIZE 100typedef int ElemType;typedef struct BiTNode{ElemType data;struct BiTNode *lchild,*rchild;//左右孩子指针} BiTNode,*BiTree;Status SearchBST(BiTree T,KeyType key,BiTree f,BiTree &p){if(!T){p=f;return FALSE;}else if(key==T->data){p=T;return TRUE;}else if(key<T->data)return SearchBST(T->lchild,key,T,p);else return(SearchBST(T->rchild,key,T,p));}Status InsertBST(BiTree &T,ElemType e){BiTree s,p;if(!SearchBST(T,e,NULL,p)){s=(BiTree)malloc(sizeof(BiTNode));s->data=e;s->lchild=s->rchild=NULL;if(!p)T=s;else if(e<p->data)p->lchild=s;else p->rchild=s;return TRUE;}else return FALSE;}Status PrintElement( ElemType e ) { // 输出元素e的值printf("%d ", e );return OK;}// PrintElementStatus PreOrderTraverse( BiTree T, Status(*Visit)(ElemType) ) { // 前序遍历二叉树T的递归算法,对每个数据元素调用函数Visit。
实现二叉树的各种遍历算法实验报告
if(a[i]>kmax) kmax = a[i]; return kmax; } /** 求二叉树的节点个数 **/ int Nodes(BTNode *b) { if(b==NULL)
2.2:( 1 )实现二叉树的先序遍历 ( 2)实现二叉树的中序遍历 ( 3)实现二叉树的后序遍历
三 实验内容 :
3.1 树的抽象数据类型 : ADT Tree{
.专业 .整理 .
下载可编辑
数据对象 D: D 是具有相同特性的数据元素的集合 。 数据关系 R: 若 D 为空集 , 则称为空树 ;
若 D 仅含有一个数据元素 ,则 R 为空集 , 否则 R={H} , H 是如 下二元关系 :
if(b!=NULL) {
printf("%c",b->data); if(b->lchild!=NULL || b->rchild!=NULL) {
printf(" ("); DispBTNode(b->lchild); if(b->rchild != NULL)printf(" , "); DispBTNode(b->rchild); printf(" )"); } } } /** 深度 **/ int BTNodeDepth(BTNode *b)
下载可编辑
实现二叉树的各种遍历算法实验报告
一 实验题目 : 实现二叉树的各种遍历算法 二 实验要求 :
2.1:(1 ) 输出二叉树 b ( 2)输出 H 节点的左右孩子节点值 ( 3)输出二叉树 b 的深度 ( 4)输出二叉树 b 的宽度 ( 5)输出二叉树 b 的节点个数 ( 6)输出二叉树 b 的叶子节点个数 ( 7)释放二叉树 b
二叉树计算叶子节点的算法C语言版
二叉树计算叶子节点的算法C语言版二叉树是一种常见的数据结构,其中每个节点最多有两个子节点:左子节点和右子节点。
叶子节点是指没有子节点的节点。
计算二叉树的叶子节点数量可以通过递归或迭代来实现。
在本文中,我们将探讨在C语言中实现计算叶子节点的算法。
1.定义节点结构体首先,我们需要定义一个包含二叉树节点信息的结构体。
节点结构体应该至少包含一个整数值来保存节点的数据,并且需要包含指向左子节点和右子节点的指针。
```ctypedef struct TreeNodeint data;struct TreeNode* left;struct TreeNode* right;} TreeNode;```2.创建二叉树在开始计算叶子节点之前,我们需要先创建一个二叉树。
为了简化问题,我们将手动创建一个具有固定节点值的二叉树。
```cTreeNode* createBinaryTre//创建节点TreeNode* root = createNode(1); TreeNode* node2 = createNode(2); TreeNode* node3 = createNode(3); TreeNode* node4 = createNode(4); TreeNode* node5 = createNode(5); TreeNode* node6 = createNode(6); TreeNode* node7 = createNode(7); //连接节点root->left = node2;root->right = node3;node2->left = node4;node2->right = node5;node3->left = node6;node3->right = node7;return root;```在上面的代码中,我们使用`createNode`函数创建节点,并使用`->`运算符将节点连接起来形成一个二叉树。
二叉树
我们也可以把递归过程改成用栈实现的非递归过程,下面给出先序 遍历的非递归过程: procedure inorder(bt:tree); var stack:array[1..n] of tree; {栈} top:integer; {栈顶指针} p:tree; begin top:=0; while not ((bt=nil)and(top=0)) do begin
• ⑴如果i=1,则结点i为根,无父结点;如果i>1,则其 父结点编号为trunc(i/2)。 • ⑵如果2*i>n,则结点i为叶结点;否则左孩子编号为 2*i。 • ⑶如果2*i+1>n,则结点i无右孩子;否则右孩子编号 为2*i+1。
存储结构
• 二叉树的存储结构和普通树的存储结构基本相同,有链 式和顺序存储两种方法。 • ⑴链式存储结构:有单链表结构或双链表结构,基本数 据结构定义如下: type tree=^node;{单链表结构} node=record data:char;{数据域} lchild,rchild:tree;{指针域:分别指向左、右孩子} end; var bt:tree;
• 输入: • 其中第一行一个整数n,表示树的结点数。接下来的n行 每行描述了一个结点的状况,包含了三个整数,整数之 间用空格分隔,其中:第一个数为居民人口数;第二个 数为左链接,为0表示无链接;第三个数为右链接。 • 输出: • 只有一个整数,表示最小距离和。
• • • • • • • •
样例 输入: 5 13 2 3 4 0 0 12 4 5 20 0 0 40 0 0
2、删除二叉树 procedure dis(var bt:tree); begin if bt<>nil then begin dis(bt^.lchild); dis(bt^.rchild); dispose(bt); end; end;
double binary tree算法
double binary tree算法Double Binary Tree算法是一种用于处理二叉树的算法,它能够在保持原有二叉树结构不变的前提下,为每个节点添加一个指向其父节点的指针。
这个父节点指针可以让我们在二叉树中更方便地进行各种操作,从而提升算法的效率。
在传统的二叉树结构中,每个节点都有一个指向左子节点和右子节点的指针,但是没有指向父节点的指针。
这导致在进行一些操作时,我们需要使用递归或者栈等数据结构来辅助,增加了算法的复杂度。
而Double Binary Tree算法通过为每个节点添加一个指向父节点的指针,可以直接访问父节点,简化了算法的实现。
在Double Binary Tree算法中,每个节点都会新增一个指向父节点的指针,这个指针可以称为"parent"指针。
在构造这个指针时,我们需要遍历整个二叉树,并为每个节点添加一个指向其父节点的指针。
具体的构造过程可以通过递归或者迭代来实现,下面是一个使用递归的示例代码:```pythonclass Node:def __init__(self, value):self.value = valueself.left = Noneself.right = Noneself.parent = Nonedef construct_parent_pointers(root, parent=None): if root is None:returnroot.parent = parentconstruct_parent_pointers(root.left, root)construct_parent_pointers(root.right, root)# 构造一个二叉树root = Node(1)root.left = Node(2)root.right = Node(3)root.left.left = Node(4)root.left.right = Node(5)root.right.left = Node(6)root.right.right = Node(7)# 构造父节点指针construct_parent_pointers(root)# 测试node = root.left.rightprint(node.parent.value) # 输出2```在上面的示例中,我们首先定义了一个Node类来表示二叉树的节点,其中包含了value、left、right和parent四个属性。
二叉树的知识点总结
引言概述:二叉树是计算机科学中一种重要的数据结构,其特点是每个节点最多有两个子节点。
在计算机科学中,二叉树被广泛应用于搜索、排序和组织数据等领域。
本文将对二叉树的知识点进行总结和详细阐述,以帮助读者更好地理解和应用二叉树。
正文内容:一、二叉树的基本概念1.二叉树的定义:二叉树是一种特殊的树结构,每个节点最多只有两个子节点。
2.二叉树的特点:每个节点最多有两个子节点,左子节点和右子节点。
3.二叉树的性质:二叉树的左子树和右子树也是二叉树,每个节点的左子树中的所有节点都小于该节点,右子树中的所有节点都大于该节点。
二、二叉树的遍历方式1.前序遍历:先访问根节点,然后递归遍历左子树和右子树。
2.中序遍历:先递归遍历左子树,然后访问根节点,最后递归遍历右子树。
3.后序遍历:先递归遍历左子树和右子树,然后访问根节点。
4.层序遍历:按层次从上到下依次访问每个节点。
三、二叉搜索树1.二叉搜索树的定义:二叉搜索树是一种特殊的二叉树,其中的节点按一定的顺序排列。
2.二叉搜索树的性质:对于任意节点,其左子树中的所有节点都小于该节点,右子树中的所有节点都大于该节点。
3.二叉搜索树的插入操作:将待插入节点与当前节点比较,根据大小关系决定是插入左子树还是右子树。
4.二叉搜索树的删除操作:删除节点时需要考虑其子节点个数,根据不同情况分为三种情况进行处理。
5.二叉搜索树的查找操作:从根节点开始,根据节点值与目标值的大小关系,逐渐向左子树或右子树遍历,直至找到目标值或到达叶子节点。
四、平衡二叉树1.平衡二叉树的定义:平衡二叉树是一种特殊的二叉搜索树,其中的节点满足平衡条件。
2.平衡二叉树的性质:对于任意节点,其左子树和右子树的高度差不超过1。
3.平衡二叉树的实现:通过旋转操作来调整树结构,使其满足平衡条件。
4.平衡二叉树的插入操作:插入节点后,通过旋转操作保持树的平衡性。
5.平衡二叉树的删除操作:删除节点后,通过旋转操作保持树的平衡性。
数据结构实验三——二叉树基本操作及运算实验报告
《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述:实现二叉树(包括二叉排序树)的建立,并实现先序、中序、后序和按层次遍历,计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为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,失败。
出二叉树的非叶子结点个数的算法
一、概述二叉树是一种重要的数据结构,它在计算机科学中有着广泛的应用。
在二叉树中,一个节点可以有零个、一个或两个子节点,而非叶子结点指的是拥有子节点的节点。
统计出二叉树中非叶子结点的个数是一项常见的算法问题,本文将介绍几种计算二叉树非叶子结点个数的算法,并对它们进行比较和分析。
二、算法一:遍历法遍历法是一种直观的计算非叶子结点个数的方法,其基本思路是通过对二叉树进行遍历,并统计出非叶子结点的数量。
具体步骤如下:1. 从二叉树的根节点开始,采用先序、中序或后序遍历的方式依次访问每一个节点。
2. 对每个访问到的节点,判断其是否为非叶子结点,如果是,则将计数器加一。
3. 继续遍历其子节点,直至遍历完成整棵二叉树。
遍历法的时间复杂度为O(n),其中n为二叉树的节点数。
由于需要对整棵二叉树进行遍历,因此遍历法在最坏情况下需要遍历所有节点,因此其时间复杂度较高。
另外,在实现上需要使用递归或栈等数据结构来存储遍历过程中的节点信息,因此在空间复杂度上也存在一定的开销。
三、算法二:递归法递归法是一种更加简洁和精炼的计算非叶子结点个数的方法,其基本思路是通过递归的方式对整棵二叉树进行遍历,并统计出非叶子结点的数量。
具体步骤如下:1. 从二叉树的根节点开始,采用递归的方式依次访问每一个节点。
2. 对每个访问到的节点,判断其是否为非叶子结点,如果是,则将计数器加一。
3. 继续递归地访问其左右子节点,直至遍历完成整棵二叉树。
递归法的时间复杂度同样为O(n),但由于在递归的过程中不需要显式地保存遍历的状态,因此在空间复杂度上相对较低。
四、算法三:迭代法迭代法是一种基于栈的非递归实现方式,其基本思路是通过维护一个栈结构来模拟递归的过程,以达到对二叉树进行遍历和统计非叶子结点数量的目的。
具体步骤如下:1. 从二叉树的根节点开始,将其入栈。
2. 从栈中弹出一个节点,并判断其是否为非叶子结点,如果是,则将计数器加一。
3. 将该节点的子节点依次入栈,直至遍历完成整棵二叉树。
设计以先序遍历的顺序建立二叉树的二叉链表存储结构的算法
设计以先序遍历的顺序建立二叉树的二叉链表存储结构的算法一、算法简介二叉树是一种重要的树形结构,它的建立方式有多种,其中一种是按照先序遍历的顺序建立二叉树。
这种方式需要将先序遍历序列和二叉树的存储结构相结合,采用二叉链表存储结构。
具体流程是按照先序遍历序列的顺序依次创建二叉树的各个节点,同时使用二叉链表结构保存每个节点的数据和指针信息。
二、算法实现算法的实现主要包括初始化二叉树、创建节点、建立二叉树等步骤,下面对这些步骤进行详细描述。
1. 初始化二叉树初始化二叉树需要创建一个根节点,同时将根节点的左右指针指向NULL,表示二叉树为空。
2. 创建节点创建节点需要通过输入元素数据来创建,同时节点的左右指针也需要初始化为NULL。
3. 建立二叉树建立二叉树是按照先序遍历序列来实现的,具体流程如下:(1)读入当前节点的元素数据,创建节点,并将其作为当前节点。
(2)判断当前节点的元素数据是否为结束符号(这里结束符号可以指定),如果是,则返回NULL。
(3)递归创建当前节点的左子树,将左子树的根节点赋值给当前节点的左指针。
(4)递归创建当前节点的右子树,将右子树的根节点赋值给当前节点的右指针。
(5)返回当前节点。
三、算法优化虽然上述算法实现简单明了,但它有一个缺点,即无法处理空节点的情况,如果输入的先序遍历序列中存在空节点,那么该算法就无法建立正确的二叉树了。
因此,可以在输入的先序遍历序列中使用一个特殊的符号(如#)表示空节点,在建立节点时,如果遇到该符号,则将该节点的指针设置为NULL即可。
四、算法总结按照先序遍历的顺序建立二叉树是一种基于二叉链表存储结构的建树方式。
它通过递归的方式构建整个二叉树,同时为了处理空节点的情况,还需要对输入的先序遍历序列进行特殊处理。
该算法的效率较高,适用于对先序遍历序列已知的情况下建立二叉树。
树和二叉树的计算公式
树和二叉树的计算公式
树和二叉树是计算机科学中重要的数据结构,它们可以用于各种算法和数据处理应用。
在计算树和二叉树的性质和操作时,需要使用一些计算公式。
一、树的计算公式
1. 节点总数公式:假设一棵树有n个节点,那么它的节点总数
为n=1+r1+r2+...+rk,其中r1、r2、...、rk分别表示每个节点的
子节点数。
2. 叶子节点数公式:一棵树的叶子节点数等于每个非叶节点子
节点数之和加1,即l=r1+r2+...+rk+1。
3. 深度公式:一棵树的深度为从根节点到最深叶子节点的路径
长度,可以用递归的方式计算:d(T)=max{d(T1),d(T2),...,d(Tk)}+1,其中T1、T2、...、Tk是根节点的子树,d(Ti)表示第i个子树的深度。
二、二叉树的计算公式
1. 节点总数公式:假设一棵二叉树有n个节点,那么它的节点
总数为n=2^h-1,其中h为树的高度。
2. 叶子节点数公式:一棵二叉树的叶子节点数等于度数为2的
节点数加1,即l=n/2+1。
3. 深度公式:一棵二叉树的深度为从根节点到最深叶子节点的
路径长度,可以用递归的方式计算:d(T)=max{d(T1),d(T2)}+1,其
中T1、T2是根节点的左右子树,d(Ti)表示第i个子树的深度。
以上是树和二叉树的一些常用计算公式,可以用于分析和设计算法,帮助开发人员更好地理解和应用这些数据结构。
二叉树的遍历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)对一棵二叉树中序遍历时,若我们将二叉树严
格地按左子树的所有结点位于根结点的左侧,右子树的所
求解二叉树中的最大路径和算法 c语言
求解二叉树中的最大路径和算法 c语言二叉树是一种常见的数据结构,由节点组成,每个节点最多有两个子节点。
在二叉树中,每个节点都包含一个数值,并且根据特定的规则,可以通过连接节点的边来形成路径。
二叉树中的最大路径和是指一条路径上所有节点值的和最大的情况,该路径可以经过任意节点,但不能重复经过节点。
求解二叉树中的最大路径和是一个常见的算法问题,有助于我们在解决二叉树相关问题时提供思路和方法。
在解决这个问题之前,我们需要了解二叉树的基本操作和性质。
二叉树的基本操作包括插入节点、删除节点、查找节点等。
而二叉树的性质包括二叉搜索树性质、平衡二叉树性质等,这些性质对于解决二叉树中的最大路径和问题也有一定的指导意义。
接下来,我们来考虑如何求解二叉树中的最大路径和。
要解决这个问题,我们可以通过递归的方式来遍历二叉树的每个节点,并计算以每个节点为根节点的最大路径和。
具体的思路如下:1. 对于每个节点,计算以该节点为根节点的最大路径和。
可以使用递归的方式,从根节点开始,分别计算左子树和右子树的最大路径和,然后加上当前节点的值。
这里需要注意,如果左子树或右子树的最大路径和为负数,则应该将其忽略,即不加在路径和中。
2. 在计算过程中,维护一个全局变量maxPathSum,用于保存当前的最大路径和。
在递归的过程中不断更新maxPathSum的值。
递归结束后,maxPathSum中的值即为二叉树中的最大路径和。
3. 最后,返回maxPathSum的值即可。
以上就是求解二叉树中最大路径和的算法思路。
通过这个算法,我们可以找到二叉树中的一条路径,使得路径上所有节点值的和最大。
这个问题在实际应用中也有一些变种,比如可以限制路径的起始节点和结束节点等,在解决这些问题时,我们可以根据以上算法进行相应的修改和扩展。
总而言之,求解二叉树中的最大路径和是一个常见的算法问题,它不仅能够帮助我们理解二叉树的基本操作和性质,还能够提供一种解决类似问题的思路和方法。
二叉树的常考算法题目
二叉树的常考算法题目
二叉树是计算机科学中常见的数据结构,以下是几个常见的二叉树相关算法题目:
1. 二叉树的深度:给定一个二叉树,求其深度。
2. 判断二叉树是否为完全二叉树:给定一个二叉树,判断它是否是完全二叉树。
3. 查找二叉树中的最大值和最小值:给定一个二叉树,找到其中的最大值和最小值。
4. 二叉树的镜像:给定一个二叉树,将其镜像(即左右节点交换)。
5. 反转二叉树:给定一个二叉树,将其反转。
6. 二叉树的左视图:给定一个二叉树,找到其左视图。
7. 二叉树的右视图:给定一个二叉树,找到其右视图。
8. 查找二叉树中的前驱节点和后继节点:给定一个二叉树和一个节点,找到该节点的前驱节点和后继节点。
9. 二叉树的层序遍历:给定一个二叉树,使用层序遍历的方式访问其节点。
10. 二叉树的先序遍历、中序遍历和后序遍历:给定一个二叉树,分别使用先序遍历、中序遍历和后序遍历的方式访问其节点。
这些题目是常见的二叉树算法题目,对于掌握二叉树相关算法非常重要。
二叉树基本运算算法的实现
二叉树基本运算算法的实现
二叉树是一种常见的数据结构,基本运算算法包括二叉树的遍历、查找、插入、删除等操作。
下面是这些算法的实现:
1. 二叉树遍历:二叉树遍历有三种方式,分别是前序遍历、中序遍历和后序遍历。
其中,前序遍历先访问根节点,再访问左子树和右子树;中序遍历先访问左子树,再访问根节点和右子树;后序遍历先访问左子树,再访问右子树和根节点。
遍历可以使用递归算法或栈实现。
2. 二叉树查找:二叉树查找可以使用递归算法或循环算法实现。
递归算法通过比较节点值实现查找,如果查找值小于当前节点值,则在左子树中查找,否则在右子树中查找。
循环算法使用二叉树的特性,比较查找值和当前节点值的大小,根据大小关系不断移动到左子树或右子树中进行查找,直到找到目标节点或遍历到叶子节点为止。
3. 二叉树插入:二叉树插入需要先查找到插入位置,然后在该位置插入一个新节点。
插入操作可以使用递归算法或循环算法实现。
4. 二叉树删除:二叉树删除分为三种情况:删除叶子节点、删除只有一个孩子的节点和删除有两个孩子的节点。
删除叶子节点很简单,只需要将其父节点的指针设为NULL即可。
删除只有一个孩子的节点需要将父节点的指针指向该节点的
孩子节点。
删除有两个孩子的节点需要找到该节点的后继节点(或前驱节点),将后继节点的值复制到该节点中,然后删除后继节点。
上述算法的实现需要根据具体的编程语言进行调整和实现。
完全二叉树的叶子节点数计算
完全二叉树的叶子节点数计算哎呀,今天咱们聊聊“完全二叉树”的叶子节点数。
这一听,感觉像是高深莫测的数学题,实际上可没有那么复杂,咱们可以轻松搞定。
你想啊,完全二叉树就像是个整齐的花园,树上挂满了果子,每一层都饱满得不得了,下面的叶子们可都是些精灵般的存在,尤其是那些最后一层的小家伙们,简直就是“最后的倔强”。
让咱们把这个概念捋一捋。
完全二叉树的定义听上去挺学术,简单来说,它就是一种很“规矩”的树,除了最底下的那一层,其他层都是满满当当的。
底下这一层呢,可能不满,但从左到右肯定是排得整整齐齐的。
想象一下,开个派对,大家都在排队,只有最后一桌可能还有些空位,但你能想象所有人都是从左到右坐的吗?就是这么个意思。
咱们要计算叶子节点数,首先得弄清楚这树的高度。
树的高度就是从根节点到最底层的那层叶子的距离。
简单来说,树越高,叶子也就越多。
你看,第一层就一个节点,第二层俩,第三层四个,依此类推,树的层数越多,叶子们就像长得贼快的蘑菇一样,蹭蹭蹭地往上冒。
数数看,如果有 ( h ) 层,那么叶子节点的数量就是 ( 2^{(h1) )。
这公式看起来像是天书,但信我,这里边并没有什么猫腻。
如果说高的树让你觉得有点吓人,咱们来个简单的例子,想象你家旁边那颗大榕树。
你一抬头,发现它有五层。
那你心里有个谱了,五层的榕树,底下那一层,叶子节点就是 ( 2^{(51) = 16 )。
这下就明白了吧,叶子们真的是个个都抢眼。
叶子们可不是光在树上挂着那么简单。
它们其实在默默支持着树的成长,承载着整棵树的“营养”。
想象一下,每片叶子都在努力地吸收阳光,酝酿出美味的果实,绝对是一种互助的精神。
要是没有这些叶子,树又怎能长得那么壮?就像一个团队,没有每一个成员的努力,谁能顺利完成任务呢?再说,咱们完全二叉树的特性可真是让人惊讶。
它的叶子节点总是出现在最后一层,像是最受宠的小宝贝。
有人问,这些叶子节点都有什么作用呢?它们可是数据存储和处理中的重要角色。
二叉树
7.1.2
二叉树的五种基本形态
Ф
左子树
(a) (b) (c)
右子树
(d)
左子树
(e)
右子树
7.1.3
两种特殊形态的二叉树
结点拥有的子树数称为该结点的度(degree)。度为零的结点称 为叶子(leaf),其余结点称为分支结点(branch)。树中结点的最大的 度称为树的度。显然,二叉树结点的度可能为0、1或2。 根结点的层次(level)为1,其余结点的层次等于该结点的双亲结 点的层次加1。树中结点的最大层次称为该树的高度或深度。 1.满二叉树 2.完全二叉树
7.6
本章小结
本章讨论了二叉树数据类型的定义以及实现方法。二叉树是 以两个分支关系定义的层次结构,结构中的数据元素之间存在着一 对多的关系,因此它为计算机应用中出现的具有层次关系或分支关 系的数据,提供了一种自然的表示方法。 二叉树是有明确的左子树和右子树的树形结构,因此当用二 叉树来描述层次关系时,其左孩子表示下属关系,而右孩子表示的 是同一层次的关系。 二叉树的遍历算法是实现各种操作的基础。遍历的实质是按 某种规则将二叉树中的数据元素排列成一个线性序列,二叉树的线 索链表便可看成是二叉树的一种线性存储结构,在线索链表上可对 二叉树进行线性化的遍历,即不需要递归,而是从第一个元素起, 逐个访问后继元素直至后继为空止。因此,线索链表是通过遍历生 成的,即在遍历过程中保存结点之间的前驱和后继的关系。
7.1.4
二叉树的几个特性
由二叉树的定义、形态,我们很容易的得出下面二叉树的 一些特性。 性质1 在二叉树的第i 层上至多有 2i-1 个结点(i≥1)。 性质2 深度为k的二叉树中至多含有2k-1 个结点(k≥1)。 性质3 对任何一棵二叉树 T,如果其终端结点数为,度为 2的结点数为,则。 性质4 具有n个结点的完全二叉树的深度为 log2n+1。 性质5 如果对一棵有 n 个结点的完全二叉树(其深度为 log2n+1)的结点按层序(从第1层到第 log2n+1 层,每层从左到 右)从1起开始编号。
创建二叉树的三种算法
创建二叉树的三种算法1.递归算法递归算法是最直观也是最常用的创建二叉树的方法之一、递归算法通过递归地创建左子树和右子树来构建完整的二叉树。
具体步骤如下:-创建一个二叉树结构的定义,包含一个存储数据的变量和左右子节点。
-如果当前节点为空,直接将新节点插入当前位置。
-如果新节点的值小于当前节点的值,递归地将新节点插入当前节点的左子树。
-如果新节点的值大于等于当前节点的值,递归地将新节点插入当前节点的右子树。
递归算法的示例代码如下所示:```pythonclass TreeNode:def __init__(self, val):self.val = valself.left = Noneself.right = Nonedef insert(root, val):if root is None:return TreeNode(val)if val < root.val:root.left = insert(root.left, val)elif val >= root.val:root.right = insert(root.right, val)return root```2.先序遍历算法先序遍历算法通过遍历给定的节点集合,按照先序的顺序将节点逐个插入到二叉树中。
这种算法可以使用栈来实现。
具体步骤如下:-创建一个空栈,同时创建一个新节点的拷贝作为当前节点。
-依次遍历给定的节点集合,如果新节点的值小于当前节点的值,将当前节点的左子节点指向新节点,并将新节点入栈,并将新节点移动到当前节点的左子节点。
-如果新节点的值大于等于当前节点的值,重复上述过程,直到找到一个合适的位置并插入新节点。
-当遍历完所有节点后,返回二叉树的根节点。
先序遍历算法的示例代码如下所示:```pythonclass TreeNode:def __init__(self, val): self.val = valself.left = Noneself.right = Nonedef insert(root, val): if root is None:return TreeNode(val) stack = []cur = rootwhile True:if val < cur.val:if not cur.left:cur.left = TreeNode(val) breakelse:cur = cur.leftelse:if not cur.right:cur.right = TreeNode(val)breakelse:cur = cur.rightreturn root```3.层次遍历算法层次遍历算法通过逐层遍历给定的节点集合,按照从上到下、从左到右的顺序将节点逐个插入到二叉树中。
二叉树的四种遍历算法
⼆叉树的四种遍历算法⼆叉树作为⼀种重要的数据结构,它的很多算法的思想在很多地⽅都⽤到了,⽐如STL算法模板,⾥⾯的优先队列、集合等等都⽤到了⼆叉树⾥⾯的思想,先从⼆叉树的遍历开始:看⼆叉树长什么样⼦:我们可以看到这颗⼆叉树⼀共有七个节点0号节点是根节点1号节点和2号节点是0号节点的⼦节点,1号节点为0号节点的左⼦节点,2号节点为0号节点的右⼦节点同时1号节点和2号节点⼜是3号节点、四号节点和五号节点、6号节点的双亲节点五号节点和6号节点没有⼦节点(⼦树),那么他们被称为‘叶⼦节点’这就是⼀些基本的概念⼆叉树的遍历⼆叉树常⽤的遍历⽅式有:前序遍历、中序遍历、后序遍历、层序遍历四种遍历⽅式,不同的遍历算法,其思想略有不同,我们来看⼀下这四种遍历⽅法主要的算法思想:1、先序遍历⼆叉树顺序:根节点 –> 左⼦树 –> 右⼦树,即先访问根节点,然后是左⼦树,最后是右⼦树。
上图中⼆叉树的前序遍历结果为:0 -> 1 -> 3 -> 4 -> 2 -> 5 -> 62、中序遍历⼆叉树顺序:左⼦树 –> 根节点 –> 右⼦树,即先访问左⼦树,然后是根节点,最后是右⼦树。
上图中⼆叉树的中序遍历结果为:3 -> 1 -> 4 -> 0 -> 5 -> 2 -> 63、后续遍历⼆叉树顺序:左⼦树 –> 右⼦树 –> 根节点,即先访问左⼦树,然后是右⼦树,最后是根节点。
上图中⼆叉树的后序遍历结果为:3 -> 4 -> 1 -> 5 -> 6 -> 2 -> 04、层序遍历⼆叉树顺序:从最顶层的节点开始,从左往右依次遍历,之后转到第⼆层,继续从左往右遍历,持续循环,直到所有节点都遍历完成上图中⼆叉树的层序遍历结果为:0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6下⾯是四种算法的伪代码:前序遍历:preOrderParse(int n) {if(tree[n] == NULL)return ; // 如果这个节点不存在,那么结束cout << tree[n].w ; // 输出当前节点内容preOrderParse(tree[n].leftChild); // 递归输出左⼦树preOrderParse(tree[n].rightChild); // 递归输出右⼦树}中序遍历inOrderParse(int n) {if(tree[n] == NULL)return ; // 如果这个节点不存在,那么结束inOrderParse(tree[n].leftChild); // 递归输出左⼦树cout << tree[n].w ; // 输出当前节点内容inOrderParse(tree[n].rightChild); // 递归输出右⼦树}pastOrderParse(int n) {if(tree[n] == NULL)return ; // 如果这个节点不存在,那么结束pastOrderParse(tree[n].leftChild); // 递归输出左⼦树pastOrderParse(tree[n].rightChild); // 递归输出右⼦树cout << tree[n].w ; // 输出当前节点内容}可以看到前三种遍历都是直接通过递归来完成,⽤递归遍历⼆叉树简答⽅便⽽且好理解,接下来层序遍历就需要动点脑筋了,我们如何将⼆叉树⼀层⼀层的遍历输出?其实在这⾥我们要借助⼀种数据结构来完成:队列。
二叉树结点计算公式
二叉树结点计算公式一、二叉树的结点计算公式1. 结点数计算公式二叉树的结点数可以通过递归计算的方式得到。
对于一个二叉树,其结点数等于左子树的结点数加上右子树的结点数再加1(根结点)。
2. 叶子结点数计算公式叶子结点是指没有子结点的结点。
二叉树的叶子结点数可以通过递归计算的方式得到。
对于一个二叉树,如果根结点为空,则叶子结点数为0;否则,叶子结点数等于左子树的叶子结点数加上右子树的叶子结点数。
3. 二叉树的深度计算公式二叉树的深度是指从根结点到叶子结点的最长路径长度。
可以通过递归计算的方式得到二叉树的深度。
对于一个二叉树,如果根结点为空,则深度为0;否则,深度等于左子树的深度和右子树的深度中的较大值加1。
4. 二叉树的高度计算公式二叉树的高度是指从叶子结点到根结点的最长路径长度。
可以通过递归计算的方式得到二叉树的高度。
对于一个二叉树,如果根结点为空,则高度为0;否则,高度等于左子树的高度和右子树的高度中的较大值加1。
5. 二叉树的平衡因子计算公式二叉树的平衡因子是指一个结点的左子树的高度减去右子树的高度。
可以通过递归计算的方式得到二叉树的平衡因子。
对于一个二叉树,如果根结点为空,则平衡因子为0;否则,平衡因子等于左子树的高度减去右子树的高度。
1. 计算二叉树的结点数假设有一棵二叉树,根结点是A,左子树是B,右子树是C。
根据结点计算公式,结点数等于左子树的结点数加上右子树的结点数再加1,即结点数=结点数(B) + 结点数(C) + 1。
2. 计算二叉树的深度假设有一棵二叉树,根结点是A,左子树是B,右子树是C。
根据结点计算公式,深度等于左子树的深度和右子树的深度中的较大值加1,即深度=MAX(深度(B), 深度(C)) + 1。
3. 计算二叉树的平衡因子假设有一棵二叉树,根结点是A,左子树是B,右子树是C。
根据结点计算公式,平衡因子等于左子树的高度减去右子树的高度,即平衡因子=高度(B) - 高度(C)。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
二叉树的各种算法.txt男人的承诺就像80岁老太太的牙齿,很少有真的。
你嗜烟成性的时候,只有三种人会高兴,医生你的仇人和卖香烟的。
/*用函数实现如下二叉排序树算法:(1)插入新结点(2)前序、中序、后序遍历二叉树(3)中序遍历的非递归算法(4)层次遍历二叉树(5)在二叉树中查找给定关键字(函数返回值为成功1,失败0)(6)交换各结点的左右子树(7)求二叉树的深度(8)叶子结点数Input第一行:准备建树的结点个数n第二行:输入n个整数,用空格分隔第三行:输入待查找的关键字第四行:输入待查找的关键字第五行:输入待插入的关键字Output第一行:二叉树的先序遍历序列第二行:二叉树的中序遍历序列第三行:二叉树的后序遍历序列第四行:查找结果第五行:查找结果第六行~第八行:插入新结点后的二叉树的先、中、序遍历序列第九行:插入新结点后的二叉树的中序遍历序列(非递归算法)第十行:插入新结点后的二叉树的层次遍历序列第十一行~第十三行:第一次交换各结点的左右子树后的先、中、后序遍历序列第十四行~第十六行:第二次交换各结点的左右子树后的先、中、后序遍历序列第十七行:二叉树的深度第十八行:叶子结点数*/#include "stdio.h"#include "malloc.h"#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int KeyType;#define STACK_INIT_SIZE 100 // 存储空间初始分配量#define STACKINCREMENT 10 // 存储空间分配增量#define MAXQSIZE 100typedef int ElemType;typedef struct BiTNode{ElemType data;struct BiTNode *lchild,*rchild;//左右孩子指针} BiTNode,*BiTree;Status SearchBST(BiTree T,KeyType key,BiTree f,BiTree &p){if(!T){p=f;return FALSE;}else if(key==T->data){p=T;return TRUE;}else if(key<T->data)return SearchBST(T->lchild,key,T,p);else return(SearchBST(T->rchild,key,T,p));}Status InsertBST(BiTree &T,ElemType e){BiTree s,p;if(!SearchBST(T,e,NULL,p)){s=(BiTree)malloc(sizeof(BiTNode));s->data=e;s->lchild=s->rchild=NULL;if(!p)T=s;else if(e<p->data)p->lchild=s;else p->rchild=s;return TRUE;}else return FALSE;}Status PrintElement( ElemType e ) { // 输出元素e的值printf("%d ", e );return OK;}// PrintElementStatus PreOrderTraverse( BiTree T, Status(*Visit)(ElemType) ) {// 前序遍历二叉树T的递归算法,对每个数据元素调用函数Visit。
//补全代码,可用多个语句if(T){if(Visit(T->data))if(PreOrderTraverse(T->lchild,Visit))if(PreOrderTraverse(T->rchild,Visit))return OK;return ERROR;}else return OK;} // PreOrderTraverseStatus InOrderTraverse( BiTree T, Status(*Visit)(ElemType) ){// 中序遍历二叉树T的递归算法,对每个数据元素调用函数Visit。
//补全代码,可用多个语句if(T){if(InOrderTraverse(T->lchild,Visit))if(Visit(T->data))if(InOrderTraverse(T->rchild,Visit))return OK;return ERROR;}else return OK;} // InOrderTraverseStatus PostOrderTraverse( BiTree T, Status(*Visit)(ElemType) ) { // 后序遍历二叉树T的递归算法,对每个数据元素调用函数Visit。
//补全代码,可用多个语句if(T){if(PostOrderTraverse(T->lchild,Visit))if(PostOrderTraverse(T->rchild,Visit))if(Visit(T->data))return OK;return ERROR;}else return OK;} // PostOrderTraverseStatus Putout(BiTree T){PreOrderTraverse(T,PrintElement);printf("\n");InOrderTraverse(T, PrintElement);printf("\n");PostOrderTraverse(T,PrintElement);printf("\n");return OK;}//·······················非递归算法struct SqStack{BiTree *base; // 在栈构造之前和销毁之后,base的值为NULLBiTree *top; // 栈顶指针int stacksize; // 当前已分配的存储空间,以元素为单位}; // 顺序栈Status InitStack(SqStack &S){S.base=(BiTree *)malloc(STACK_INIT_SIZE*sizeof(BiTree));if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status Push(SqStack &S,BiTree e){if((S.top-S.base)>=S.stacksize){S.base=(BiTree*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(BiTree)); if(!S.base)return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,BiTree &e){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status StackEmpty(SqStack S){ // 若栈S为空栈,则返回TRUE,否则返回FALSEif(S.top-S.base==0)return TRUE;else return FALSE;}Status InOrderTraverse1(BiTree T,Status(*Visit)(ElemType e),SqStack S) {BiTree p;InitStack(S);p=T;while(p||!StackEmpty(S)){if(p){Push(S,p);p=p->lchild;}else{Pop(S,p);if(!Visit(p->data))return ERROR;p=p->rchild;}}return OK;}//···························层次遍历typedef struct{BiTree *base; // 初始化的动态分配存储空间int front; // 头指针,若队列不空,指向队列头元素int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置}SqQueue;Status InitQueue(SqQueue &Q){Q.base=(BiTree*)malloc(MAXQSIZE*sizeof(BiTree));if(!Q.base)return ERROR;Q.front=Q.rear=0;return OK;}int QueueLength(SqQueue Q){// 返回Q的元素个数// 请补全代码return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;}Status EnQueue(SqQueue &Q,BiTree e){// 插入元素e为Q的新的队尾元素// 请补全代码if((Q.rear+1)%MAXQSIZE==Q.front)return ERROR;Q.base[Q.rear]=e;Q.rear=(Q.rear+1)%MAXQSIZE;return OK;}Status DeQueue(SqQueue &Q,BiTree &e){// 若队列不空, 则删除Q的队头元素, 用e返回其值, 并返回OK; 否则返回ERROR // 请补全代码if(Q.front==Q.rear)return ERROR;e=Q.base[Q.front];Q.front=(Q.front+1)%MAXQSIZE;return OK;}Status LevelTraverse(BiTree T,SqQueue Q)//层次遍历二叉树{InitQueue(Q);BiTree p;p=T;if(T)EnQueue(Q,T);// printf("%d",QueueLength(Q));while(QueueLength(Q)!=0){DeQueue(Q,p); //根结点出队printf("%d ",p->data); //输出数据if(p->lchild)EnQueue(Q,p->lchild); //左孩子进队if(p->rchild)EnQueue(Q,p->rchild); //右孩子进队}return OK;}void Change(BiTree T){BiTNode *p;if(T){p=T->lchild;T->lchild=T->rchild;T->rchild=p;Change(T->lchild);Change(T->rchild);}// return OK;}int BTreeDepth(BiTree T)//求由BT指针指向的一棵二叉树的深度{// int dep1,dep2;if(T!=NULL){//计算左子树的深度int dep1=BTreeDepth(T->lchild); //计算右子树的深度int dep2=BTreeDepth(T->rchild); //返回树的深度if(dep1>dep2)return dep1+1;elsereturn dep2+1;}else return 0;}//`````````````叶子结点数Status yezhi(BiTree T,SqQueue Q){int i=0;InitQueue(Q);BiTree p;p=T;if(T)EnQueue(Q,T);// printf("%d",QueueLength(Q));while(QueueLength(Q)!=0){DeQueue(Q,p);if(p->lchild)EnQueue(Q,p->lchild);if(p->rchild)EnQueue(Q,p->rchild);if(!p->lchild&&!p->rchild)i++;}return i;}int main() //主函数{SqStack S;SqQueue Q,Q3;BiTree T=NULL,f,p;int i,n,e,a,b,c;scanf("%d",&n);for(i=0;i<n;i++){scanf("%d",&e);InsertBST(T,e);}scanf("%d",&a);scanf("%d",&b);scanf("%d",&c);Putout(T);printf("%d\n",SearchBST(T,a,f,p));printf("%d\n",SearchBST(T,b,f,p));InsertBST(T,c);Putout(T);InOrderTraverse1(T, PrintElement,S);printf("\n");LevelTraverse(T,Q);printf("\n");Change(T);Putout(T);Change(T);Putout(T);printf("%d",BTreeDepth(T));printf("\n");printf("%d",yezhi(T,Q3));printf("\n");return OK;}//main友情提示:本资料代表个人观点,如有帮助请下载,谢谢您的浏览!。