二叉树的各种算法

合集下载

二叉树的遍历及常用算法

二叉树的遍历及常用算法

⼆叉树的遍历及常⽤算法⼆叉树的遍历及常⽤算法遍历的定义:按照某种次序访问⼆叉树上的所有结点,且每个节点仅被访问⼀次;遍历的重要性:当我们需要对⼀颗⼆叉树进⾏,插⼊,删除,查找等操作时,通常都需要先遍历⼆叉树,所有说:遍历是⼆叉树的基本操作;遍历思路:⼆叉树的数据结构是递归定义(每个节点都可能包含相同结构的⼦节点),所以遍历也可以使⽤递归,即结点不为空则继续递归调⽤每个节点都有三个域,数据与,左孩⼦指针和右孩⼦之指针,每次遍历只需要读取数据,递归左⼦树,递归右⼦树,这三个操作三种遍历次序:根据访问三个域的不同顺序,可以有多种不同的遍历次序,⽽通常对于⼦树的访问都按照从左往右的顺序;设: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。

实现二叉树的各种遍历算法实验报告

实现二叉树的各种遍历算法实验报告
a[i] = 0; int k = 0; search(b,a,k); for(i = 0;i < maxx; ++i)
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语言版二叉树是一种常见的数据结构,其中每个节点最多有两个子节点:左子节点和右子节点。

叶子节点是指没有子节点的节点。

计算二叉树的叶子节点数量可以通过递归或迭代来实现。

在本文中,我们将探讨在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算法通过为每个节点添加一个指向父节点的指针,可以直接访问父节点,简化了算法的实现。

在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. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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友情提示:本资料代表个人观点,如有帮助请下载,谢谢您的浏览!。

相关文档
最新文档