数据结构课程设计-二叉树的基本操作

合集下载

二叉树的基本操作

二叉树的基本操作

二叉树的基本操作二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点。

二叉树在计算机领域中得到广泛应用,它的基本操作包括插入、删除、查找、遍历等。

1.插入操作:二叉树的插入操作是将一个新的节点添加到已有的二叉树中的过程。

插入操作会按照一定规则将新节点放置在正确的位置上。

插入操作的具体步骤如下:-首先,从根节点开始,比较新节点的值与当前节点的值的大小关系。

-如果新节点的值小于当前节点的值,则将新节点插入到当前节点的左子树中。

-如果新节点的值大于当前节点的值,则将新节点插入到当前节点的右子树中。

-如果当前节点的左子树或右子树为空,则直接将新节点插入到该位置上。

-如果当前节点的左子树和右子树都不为空,则递归地对左子树或右子树进行插入操作。

2.删除操作:二叉树的删除操作是将指定节点从二叉树中删除的过程。

删除操作有以下几种情况需要考虑:-如果待删除节点是叶子节点,则直接将其从二叉树中删除即可。

-如果待删除节点只有一个子节点,则将其子节点替换为待删除节点的位置即可。

-如果待删除节点有两个子节点,则需要找到其左子树或右子树中的最大节点或最小节点,将其值替换为待删除节点的值,然后再删除最大节点或最小节点。

3.查找操作:二叉树的查找操作是在二叉树中查找指定值的节点的过程。

查找操作的具体步骤如下:-从根节点开始,将待查找值与当前节点的值进行比较。

-如果待查找值等于当前节点的值,则返回该节点。

-如果待查找值小于当前节点的值,则在当前节点的左子树中继续查找。

-如果待查找值大于当前节点的值,则在当前节点的右子树中继续查找。

-如果左子树或右子树为空,则说明在二叉树中找不到该值。

4.遍历操作:二叉树的遍历操作是按照一定规则依次访问二叉树中的每个节点。

有三种常用的遍历方式:- 前序遍历(Preorder Traversal):先访问根节点,然后递归地前序遍历左子树和右子树。

- 中序遍历(Inorder Traversal):先递归地中序遍历左子树,然后访问根节点,最后递归地中序遍历右子树。

二叉树的存储结构及基本操作

二叉树的存储结构及基本操作

二叉树的存储结构及基本操作二叉树是一种常见的数据结构,广泛应用于计算机科学领域。

二叉树具有其独特的存储结构和基本操作,下面将详细介绍。

一、二叉树的存储结构二叉树的存储结构通常有两种形式:顺序存储和链式存储。

1. 顺序存储顺序存储是将二叉树中的所有元素按照一定的顺序存储在一段连续的内存单元中,通常采用数组来表示。

对于任意一个节点i,其左孩子节点的位置为2*i+1,右孩子节点的位置为2*i+2。

这种存储方式的优点是访问速度快,但需要预先确定节点总数,且不易于插入和删除操作。

2. 链式存储链式存储是采用指针的方式将二叉树的节点链接起来。

每个节点包含数据元素以及指向左孩子节点和右孩子节点的指针。

链式存储方式的优点是易于插入和删除操作,但访问速度较慢。

二、二叉树的基本操作1. 创建二叉树创建二叉树的过程就是将数据元素按照一定的顺序插入到二叉树中。

对于顺序存储的二叉树,需要预先分配内存空间;对于链式存储的二叉树,可以直接创建节点对象并链接起来。

2. 遍历二叉树遍历二叉树是指按照某种规律访问二叉树中的所有节点,通常有前序遍历、中序遍历和后序遍历三种方式。

前序遍历的顺序是根节点-左孩子节点-右孩子节点;中序遍历的顺序是左孩子节点-根节点-右孩子节点;后序遍历的顺序是左孩子节点-右孩子节点-根节点。

对于顺序存储的二叉树,可以采用循环结构实现遍历;对于链式存储的二叉树,需要使用指针逐个访问节点。

3. 查找元素在二叉树中查找元素,需要根据一定的规则搜索所有节点,直到找到目标元素或搜索范围为空。

对于顺序存储的二叉树,可以采用线性查找算法;对于链式存储的二叉树,可以采用深度优先搜索或广度优先搜索算法。

4. 插入元素在二叉树中插入元素需要遵循一定的规则,保证二叉树的性质。

对于顺序存储的二叉树,插入操作需要移动大量元素;对于链式存储的二叉树,插入操作相对简单,只需修改指针即可。

5. 删除元素在二叉树中删除元素同样需要遵循一定的规则,保证二叉树的性质。

实验三--二叉树的基本运算

实验三--二叉树的基本运算

实验三二叉树的基本运算一、实验目的1、使学生熟练掌握二叉树的逻辑结构和存储结构。

2、熟练掌握二叉树的各种遍历算法。

二、实验内容1、问题描述建立一棵二叉树,试编程实现二叉树的如下基本操作:(1). 按先序序列构造一棵二叉链表表示的二叉树T;(2). 对这棵二叉树进行遍历:先序、中序、后序以及层次遍历,分别输出结点的遍历序列;(3). 求二叉树的深度/结点数目/叶结点数目;(选做)(4). 将二叉树每个结点的左右子树交换位置。

(选做)2、基本要求从键盘接受输入(先序),以二叉链表作为存储结构,建立二叉树(以先序来建立)。

3、测试数据如输入:abc00de0g00f000(其中ф表示空格字符)则输出结果为:先序:a->b->c->d->e->g->f中序:a->b->c->d->e->g->f后序:a->b->c->d->e->g->f三、程序代码#include<malloc.h>#include<iostream.h>#define OK 1#define ERROR -1typedef char TElemType;int i;typedef struct BiTNode{TElemType data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;int CreateBiTree(BiTree&T) //创建二叉树{char a;cin>>a;if(a=='0') T=NULL;else{if(!(T=(BiTNode*)malloc(sizeof(BiTNode)))) {return ERROR;}T->data=a;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}return OK;}int PreOrderTraverse(BiTree&T) //先序遍历二叉树{if(T){//cout<<"此为先序遍历"<<endl;cout<<T->data<<"->";if(PreOrderTraverse(T->lchild))if(PreOrderTraverse(T->rchild))return OK;return ERROR;}else return OK;}int InOrderTraverse(BiTree&T) //中序遍历二叉树{if(T){//cout<<"此为中序遍历"<<endl;if(InOrderTraverse(T->lchild)){cout<<T->data<<"->";if(InOrderTraverse(T->rchild))return OK;}return ERROR;}else return OK;}int PostOrderTraverse(BiTree&T) //后序遍历二叉树{if(T){//cout<<"此为后序遍历"<<endl;if (PostOrderTraverse(T->lchild))if(PostOrderTraverse(T->rchild)){cout<<T->data<<"->";i++;return (OK);}return (ERROR);}elsereturn (OK);}int CountDepth(BiTree&T) //计算二叉树的深度{if(T==NULL){return 0;}else{int depl=CountDepth(T->lchild);int depr=CountDepth(T->lchild);if(depl>depr){return depl+1;}else{return depr+1;}}}void main() //主函数{BiTree T;cout<<"请输入二叉树节点的值以创建树"<<endl;CreateBiTree(T);cout<<"此为先序遍历";PreOrderTraverse(T);cout<<"end"<<endl;cout<<"此为中序遍历";InOrderTraverse(T);cout<<"end"<<endl;cout<<"此为后序遍历";PostOrderTraverse(T);cout<<"end"<<endl<<"此树节点数是"<<i<<endl<<"此树深度是"<<CountDepth(T)<<endl;}四、调试结果及运行界面:五、实验心得通过这次程序上机实验让我认识到了以前还不太了解的二叉树的性质和作用,这次实验的的确确的加深了我对它的理解。

二叉树及二叉树的基本操作(基础篇)

二叉树及二叉树的基本操作(基础篇)

⼆叉树及⼆叉树的基本操作(基础篇)⼀、相关概念树是n( n>=0)个有限个数据的元素集合,它的数据的存储结构形状像⼀颗倒过来的树。

根在上,叶在下:如图所⽰1.⼀个独⽴的节点也可看作⼀棵树,它既为根节点,⼜为叶⼦节点;2.⼀个节点也没有称作空树;3.这是⼀颗典型的树,根节点为A;4.⼀个节点只有唯⼀⽗节点。

节点:结点包含数据和指向其它节点的指针。

根节点:树第⼀个结点称为根节点。

结点的度:结点拥有的⼦节点个数。

叶节点:没有⼦节点的节点(度为0)。

⽗⼦节点:⼀个节点father指向另⼀个节点child,则child为孩⼦节点, father为⽗亲节点。

兄弟节点:具有相同⽗节点的节点互为兄弟节点。

节点的祖先:从根节点开始到该节点所经的所有节点都可以称为该节点的祖先。

⼦孙:以某节点为根的⼦树中任⼀节点都称为该节点的⼦孙。

树的⾼度:树中距离根节点最远节点的路径长度。

如图⽰:5.树的存储结构1 struct TreeNode2 {3 DataType data; //节点值4 TreeNode* _firistchild; //第⼀个孩⼦5 TreeMode* _nextchild; //第⼆个孩⼦6 ...7 };有时候根据需要还会加⼊⽗节点,结构如下:1 struct TreeNode2 {3 DataType data; //节点值4 TreeNode* _parent;5 TreeNode* _firistchild; //第⼀个孩⼦6 TreeMode* _nextchild; //第⼆个孩⼦7 ...8 };⼆、⼆叉树1.⼆叉树:⼆叉树是⼀棵特殊的树,⼆叉树每个节点最多有两个孩⼦结点,分别称为左孩⼦和右孩⼦。

如图:2.存储结构1 template <class T>2 struct TreeNode //定义⼆叉树结点3 {5 TreeNode<T>* _left; //指向左⼦树的指针6 TreeNode<T>* _right; //指向右⼦树的指针7 T _data; //节点数据8 TreeNode(const T& n)9 :_left(NULL)10 ,_right(NULL)11 ,_data(n)12 {}13 };有时候根据需要还会加⼊⽗节点,结构如下:1 template <class T>2 struct TreeNode //定义⼆叉树结点3 {4 TreeNode<T>* _parent; //指向⽗节点的指针5 TreeNode<T>* _left; //指向左⼦树的指针6 TreeNode<T>* _right; //指向右⼦树的指针7 T _data; //节点数据8 TreeNode(const T& n)9 :_left(NULL)10 ,_right(NULL)11 ,_data(n)12 {}13 };3.特殊的⼆叉树满⼆叉树:⾼度为N的满⼆叉树有2^N - 1个节点的⼆叉树。

c语言二叉树的基本操作

c语言二叉树的基本操作

c语言二叉树的基本操作一、概念二叉树是一种数据结构,它由节点组成,每个节点都有0个或2个子节点,左子节点的关键字小于或等于该节点的关键字,右子节点的关键字大于该节点的关键字。

二、基本操作1、创建二叉树(1)结构体定义typedef struct node{int data; // 数据struct node *left; // 左子节点struct node *right; // 右子节点}Node, *pNode;(2)创建节点return p;}// 创建根节点*pTree = create_node(arr[0]);// 寻找合适的位置插入节点while (p != NULL){q = p;if (arr[i] < p->data)p = p->left;elsep = p->right;}2、遍历二叉树遍历二叉树有三种方法,分别是前序遍历、中序遍历和后序遍历。

(1)前序遍历void pre_order(pNode pTree){if (pTree != NULL){printf("%d ", pTree->data);pre_order(pTree->left);pre_order(pTree->right);}}3、查找节点找到关键字为data的节点,返回指向该节点的指针。

pNode search_node(pNode pTree, int data){if (pTree == NULL)return NULL;4、计算深度计算二叉树的深度,即为根节点到叶子节点的最长路径所包含的节点个数。

return left_depth > right_depth ? left_depth + 1 : right_depth + 1; }5、计算叶子节点数return leaf_count(pTree->left) + leaf_count(pTree->right);}6、删除节点删除节点分为两种情况:(1)被删除节点为叶子节点直接将其父节点指向该节点的指针设置为NULL即可。

数据结构二叉树的基本操作

数据结构二叉树的基本操作

数据结构与算法课程实验报告实验四:二叉树的基本操作姓名:沈靖雯班级:14信息与计算科学(2)班学号:2014326601094实验四二叉树的基本操作【实验内容】实现创建和遍历二叉树的基本操作【实验目的】掌握二叉树的定义和存储表示,学会建立一棵特定二叉树的方法;掌握二叉树的遍历算法(先序、中序、后序遍历算法)的思想,并学会遍历算法的递归实现和非递归实现。

【问题描述】(1)编程实现构造一棵二叉树的算法,适合任意合法输入的二叉树的建立,并进行相应异常处理。

(2)编程实现在二叉链表这种存储方式下,实现二叉的遍历,可采用递归或者非递归实现,遍历算法可在先序、中序和后序遍历算法中任选其一。

【问题实现】一、实现链队列基本运算(1)抽象数据类型ADT BTree {数据对象D: D是具有相同特性的数据元素的集合。

基本操作:CreatBiTree(*T)操作结果:构造二叉树T。

PreOrderTraverse(T)初始条件:二叉树T已存在。

操作结果:先序遍历T。

InOrderTraverse(T)初始条件:二叉树T已存在。

操作结果:中序遍历T。

PostOrderTraverse(T)初始条件:二叉树T已存在。

操作结果:后序遍历T。

} ADT BTree(2)主要实现思路与主要程序代码:1).首先定义二叉树结点结构;typedef struct Node{char data;struct Node *lchild,*rchild; //左右孩子指针}BiTNode,*BTree;2).其次定义一个二叉树构造函数int CreatBiTree(BTree *T);采用递归先序法构造二叉树;scanf("%c",&ch);if(ch==' ')*T=NULL;//T为空二叉树else{if(!(*T=(BTree)malloc(sizeof(BiTNode)))) return (OVERFLOW);(*T)->data=ch;CreatBiTree(&((*T)->lchild));CreatBiTree(&((*T)->rchild));}3).定义遍历函数(递归先序为例);//先序遍历二叉树,递归实现void PreOrderTraverse(BTree T){if(T){ printf("%c ",T->data);PreOrderTraverse (T->lchild);PreOrderTraverse (T->rchild);}}这里用printf代替visit(),简化程序代码;4).定义主函数,总体完成以上所有函数功能的实现(构建二叉树与遍历二叉树)。

c语言数据结构二叉树的基本操作 -回复

c语言数据结构二叉树的基本操作 -回复

c语言数据结构二叉树的基本操作-回复C语言数据结构:二叉树的基本操作概述:二叉树是一种常用的数据结构,在计算机科学中广泛应用于各种算法和问题的解决方案中。

它的特点是每个节点至多有两个子节点,即左子节点和右子节点,且子节点的顺序不能颠倒。

本文将介绍常见的二叉树基本操作,包括创建二叉树、插入节点、删除节点、查找节点、遍历等。

1. 创建二叉树:创建一个二叉树的方法是从根节点开始,逐个插入子节点。

首先定义一个二叉树的结构体,包含一个值和指向左右子节点的指针。

然后使用malloc 函数分配内存空间,并将值赋给根节点的指针。

接着创建左子节点和右子节点,将子节点的指针分别赋给根节点的左右指针。

这样就完成了一个简单的二叉树的创建。

2. 插入节点:插入节点是在现有的二叉树上新增一个节点。

首先找到插入节点的位置,可以从根节点开始逐级比较。

如果插入节点的值小于当前节点,则向左子树查找,否则向右子树查找,直到找到合适的位置。

然后创建一个新节点,并将新节点的指针赋给找到位置的节点的左或右指针。

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,失败。

c语言数据结构二叉树的基本操作

c语言数据结构二叉树的基本操作

c语言数据结构二叉树的基本操作在 C 语言中,二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点。

以下是二叉树的一些基本操作的示例:1. 创建二叉树:```c#include <stdio.h>#include <stdlib.h>// 定义二叉树节点结构体struct TreeNode {int data;struct TreeNode* left;struct TreeNode* right;};// 创建二叉树struct TreeNode* createTree(int data) {struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));if (newNode == NULL) {printf("内存分配失败\n");exit(1);}newNode->data = data;newNode->left = NULL;newNode->right = NULL;return newNode;}```在上述示例中,我们定义了一个二叉树节点结构体 `TreeNode`,它包含一个整数类型的数据成员 `data`,以及两个指向左右子节点的指针成员 `left` 和 `right`。

然后,我们使用 `malloc` 函数分配一个 `TreeNode` 结构体的内存空间,并将其赋值给 `newNode` 变量。

如果内存分配失败,我们输出错误信息并终止程序。

最后,我们初始化 `newNode` 的数据成员,并将左右子节点设置为 `NULL`,表示它们还没有被赋值。

2. 插入节点:```c// 在二叉树中插入节点void insertNode(struct TreeNode* root, int data) {if (root == NULL) {root = createTree(data);return;}if (data < root->data) {insertNode(root->left, data);} else if (data > root->data) {insertNode(root->right, data);}}```在上述示例中,我们定义了一个函数 `insertNode`,用于在二叉树中插入节点。

二叉树的基本操作与实现实验报告

二叉树的基本操作与实现实验报告

二叉树的基本操作与实现实验报告二叉树是一种重要的数据结构,在计算机科学领域中被广泛应用。

本实验将介绍二叉树的基本操作与实现,并给出相应的实验报告。

一、引言二叉树是一种特殊的树状结构,每个节点至多有两个子节点。

二叉树有许多重要的特性,如平衡二叉树、二叉树等,应用广泛。

在本实验中,我们将介绍二叉树的基本操作和实现。

二、实验目的1.掌握二叉树的基本概念和特性;2.熟悉二叉树的基本操作,包括创建、插入、删除、遍历等;3.学会使用编程语言实现二叉树的基本操作。

三、实验内容本实验主要包括以下内容:1.二叉树的定义和基本概念;2.二叉树的基本操作,包括创建、插入、删除、遍历等;3.使用编程语言实现二叉树的基本操作;4.测试和验证二叉树的基本操作的正确性。

四、实验步骤1.二叉树的定义和基本概念二叉树是一种树状结构,每个节点至多有两个子节点。

二叉树的每个节点包含一个数据项和指向左子树和右子树的指针。

二叉树的特性有很多,如完全二叉树、平衡二叉树、二叉树等。

2.二叉树的基本操作(1)创建二叉树:可以通过手动输入节点数据来创建二叉树,也可以通过读取文件中的数据来创建二叉树。

(2)插入节点:在指定位置插入一个新节点。

(3)删除节点:删除指定位置的节点。

(4)遍历二叉树:有前序遍历、中序遍历和后序遍历三种遍历方式。

3.使用编程语言实现二叉树的基本操作实现二叉树的基本操作可以使用编程语言来完成。

我们可以定义一个二叉树的结构体,包含节点数据和指向左右子树的指针。

然后根据具体的需求,实现相应的操作函数。

4.测试和验证二叉树的基本操作的正确性在完成二叉树的基本操作后,我们可以编写测试代码来验证操作的正确性。

通过创建二叉树,并进行插入、删除和遍历操作,观察输出结果是否符合预期。

五、实验结果与分析在完成二叉树的基本操作后,我们可以进行测试和验证。

通过输出二叉树的遍历结果,比对预期结果来判断操作是否正确。

同时,我们还可以观察二叉树的结构和特性,如是否满足平衡二叉树或二叉树的条件。

数据结构课程设计(二叉树的基本操作)资料

数据结构课程设计(二叉树的基本操作)资料

重庆大学城市科技学院课程设计报告二叉树的基本操作学院:电气信息学院专业:软件工程年级: 2011 姓名:班级: 01 学号: 20110286 成绩:完成时间: 2013年1月2日指导教师:目录一、需求分析 (3)二、概要设计 (3)三、详细设计 (4)四、调试结果 (11)五、课程设计总结 (11)一、需求分析二叉树形象地说即树中每个节点最多只有两个分支,它是一种重要的数据类型。

可以运用于建立家谱,公司所有的员工的职位图,以及各种事物的分类和各种机构的职位图表等。

二叉树是通过建立一个链式存储结构,达到能够实现前序遍历,中序遍历,后序遍历。

以及能够从输入的数据中得知二叉树的叶子结点的个数,二叉树的深度。

在此,二叉树的每一个结点中必须包括:值域,左指针域,右指针域。

演示程序以用户与计算机对话的方式进行,即在计算机终端上显示提示信息后,由用户在键盘上输入相应动作的序号和相应的输入数据。

1.1课程设计任务及要求(1)按先序次序输入二叉树中结点的值,构造二叉链表表示的二叉树t;(2)对二叉树t作先序、中序、后序遍历的递归算法,输出结果;(3)计算二叉树t的深度,输出结果;(4)计算二叉树t的叶子结点个数1.2课程设计思想本次课程设计中,用到的主要知识就是递归思想,着重体会递归的思想。

建立二叉树采用先序次序插入的方式。

对二叉树进行遍历时采用递归函数的方式。

求二叉树的深度及叶子结点个数均采用递归方式。

二、概要设计2.1对程序中定义的核心数据结构及对其说明:typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;在开头定义了二叉树的链式存储结构,此处采用了每个结点中设置三个域,即值域,左指针域和右指针域。

2.2 程序模块及其功能:本程序分为:7大模块。

二叉树的建立链式存储结构、前序遍历、中序遍历、后序遍历、求叶子结点的个数计算、中序遍历、后序遍历、深度、主函数。

二叉树的建立与基本操作

二叉树的建立与基本操作

二叉树的建立与基本操作二叉树是一种重要的数据结构,它由节点以及节点之间的链接组成。

每个节点最多有两个子节点,被称为左子节点和右子节点。

二叉树的建立和操作是学习数据结构的基础内容,对于计算机科学和算法设计非常重要。

本文将介绍二叉树的建立和一些基本操作,包括插入节点、删除节点、查找节点以及遍历二叉树。

一、二叉树的建立要建立一个二叉树,我们需要先定义一个节点类,并指定节点的左子节点和右子节点。

节点类一般包含一个值以及左子节点和右子节点的指针。

下面是一个示例的节点类的定义:class Nodepublic:int value;Node* left;Node* right;};接下来,我们可以通过创建节点对象并将它们连接起来来构建一棵二叉树。

下面是一个示例的建立二叉树的函数:Node* buildTreNode* root = new Node(;root->value = 1;Node* node1 = new Node(;node1->value = 2;Node* node2 = new Node(;node2->value = 3;Node* node3 = new Node(;node3->value = 4;Node* node4 = new Node(;node4->value = 5;root->left = node1;root->right = node2;node1->left = node3;node1->right = node4;return root;在这个示例中,我们创建了一个根节点root,然后创建了四个子节点node1、node2、node3和node4,并将它们连接到正确的位置上。

二、二叉树的基本操作1.插入节点要插入一个节点,我们首先需要找到插入的位置。

如果节点要插入的位置为null,则直接将节点赋值给该位置;否则,继续找到合适的位置插入节点。

二叉树的基本操作

二叉树的基本操作

二叉树的基本操作二叉树是一种常见的数据结构,它由节点组成,每个节点最多连接两个子节点,分别称为左子节点和右子节点。

二叉树的基本操作包括创建、插入、删除、查找和遍历,下面将对这些操作进行详细介绍。

一、创建二叉树创建二叉树的方法有多种,其中最常用的是使用递归的方式。

递归创建二叉树时,可以先创建根节点,然后递归创建左子树和右子树。

如果子树为空,则使用特殊字符表示。

二、插入节点插入节点是向二叉树中添加新节点的操作。

插入节点的位置通常由二叉树的特性决定,左子节点小于父节点,右子节点大于父节点。

插入节点时,需要先找到插入位置,然后创建新节点,并将其连接到对应的位置。

三、删除节点删除节点是从二叉树中移除指定节点的操作。

删除节点的方式取决于节点的位置和子节点的情况。

如果要删除的节点是叶子节点,则直接将其删除即可。

如果要删除的节点有一个子节点,则将其子节点连接到父节点。

如果要删除的节点有两个子节点,则需要找到替代节点,将替代节点的值复制到当前位置,并将替代节点删除。

四、查找节点查找节点是在二叉树中寻找特定节点的操作。

常用的方式有深度优先(DFS)和广度优先(BFS)。

深度优先通常使用递归实现,分为前序遍历、中序遍历和后序遍历三种方式。

广度优先通常使用队列实现,先访问根节点,然后访问其所有子节点,再逐层访问下去,直到找到目标节点或遍历完整棵树。

五、遍历二叉树遍历二叉树是指按照一定顺序访问二叉树中的所有节点,常用的方式有前序遍历、中序遍历和后序遍历。

前序遍历先访问根节点,然后递归遍历左子树和右子树;中序遍历先递归遍历左子树,然后访问根节点,再遍历右子树;后序遍历先递归遍历左子树和右子树,然后访问根节点。

以上是二叉树的基本操作,通过这些操作可以有效地管理和处理二叉树数据结构。

在实际应用中,二叉树常用于、排序和表达等方面,因为它具有较高的查询效率和灵活性。

对于使用二叉树的相关算法和数据结构,理解和掌握其基本操作是非常重要的。

数据结构课程设计-二叉树的基本操作

数据结构课程设计-二叉树的基本操作

二叉树的基本操作摘要:本次课程设计通过对二叉树的一系列操作主要练习了二叉树的建立、四种遍历方式:先序遍历、中序遍历、后序遍历和层序遍历以及节点数和深度的统计等算法。

增加了对二叉树这一数据结构的理解,掌握了使用c语言对二叉树进行一些基本的操作。

关键字:递归、二叉树、层序遍历、子树交换一、程序简介本程序名为“二叉树基本操作的实现”,其主要为练习二叉树的基本操作而开发,其中包含了建立、遍历、统计叶子结点和深度等一系列操作。

其中定义二叉链表来表示二叉树,用一个字符类型的数据来表示每一个节点中存储的数据。

由于没有进行图形界面的设计,用户可以通过程序中的遍历二叉树一功能来查看操作的二叉树。

二、功能模块2.1功能模块图2.2功能模块详解2.2.1建立二叉树输入要建立的二叉树的扩展二叉树的先序遍历序列,来建立二叉树,建立成功会给出提示。

2.2.2遍历二叉树执行操作之后会有四个选项可供选择:先序遍历、中序遍历、后序遍历、层序遍历。

输入对应的序号即可调动相关函数输出相应的遍历序列。

2.2.3统计叶子节点树执行之后输出叶子结点的个数。

2.2.4求二叉树深度执行之后输出二叉树的深度。

2.2.5子树交换交换成功则会给出提示,用户可通过遍历二叉树来观察子树交换之后的二叉树。

三、数据结构和算法设计3.1二叉链表的设计1.typedef struct BiNode {2.char data;3.struct BiNode* lchild; //左孩子4.struct BiNode* rchild; //右孩子5.}BiTree;用一个字符型保存节点数据,分别定义两个struct BiNode类型的指针来指向左孩子和右孩子。

在BiTree.h中实现相关的功能。

3.2队列的实现1.typedef struct {2. ElemType* data;3.int head;//队头指针4.int tail;//队尾指针5.} SqQueue;队列主要用于二叉树遍历过程中的层序遍历,从根节点开始分别将左右孩子放入队列,然后从对头开始输出。

数据结构课程设计_二叉树操作

数据结构课程设计_二叉树操作

数据结构课程设计_⼆叉树操作数据结构课程设计题⽬:⼆叉树的操作学⽣姓名:学号:系部名称:计算机科学与技术系专业班级:指导教师:课程设计任务书第⼀章程序要求1)完成⼆叉树的基本操作。

2)建⽴以⼆叉链表为存储结构的⼆叉树;3)实现⼆叉树的先序、中序和后序遍历;4)求⼆叉树的结点总数、叶⼦结点个数及⼆叉树的深度。

第⼆章算法分析建⽴以⼆叉链表为存储结构的⼆叉树,在次⼆叉树上进⾏操作;1先序遍历⼆叉树的操作定义为:若⼆叉树唯恐则为空操作;否则(1)访问根节点;(2)先序遍历做字数和;(3)先序遍历有⼦树;2中序遍历⼆叉树的操作定义为:若⼆叉树为空,则空操作;否则(1)中序遍历做⼦树;(2)访问根节点;(3)中序遍历有⼦树;3后续遍历⼆叉树的操作定义为:若⼆叉树为空则为空操作;否则(1)后序遍历左⼦树;(2)后序遍历右⼦树;(3)访问根节点;⼆叉树的结点总数、叶⼦结点个数及⼆叉树的深度。

第三章⼆叉树的基本操作和算法实现⼆叉树是⼀种重要的⾮线性数据结构,是另⼀种树形结构,它的特点是每个节点之多有两棵⼦树(即⼆叉树中不存在度⼤于2的结点),并且⼆叉树的结点有左右之分,其次序不能随便颠倒。

1.1⼆叉树创建⼆叉树的很多操作都是基于遍历实现的。

⼆叉树的遍历是采⽤某种策略使得采⽤树形结构组织的若⼲年借点对应于⼀个线性序列。

⼆叉树的遍历策略有四种:先序遍历中续遍历后续遍历和层次遍历。

基本要求1 从键盘接受输⼊数据(先序),以⼆叉链表作为存储结构,建⽴⼆叉树。

2 输出⼆叉树。

3 对⼆叉树进⾏遍历(先序,中序,后序和层次遍历)4 将⼆叉树的遍历打印出来。

⼀.问题描述⼆叉树的很多操作都是基于遍历实现的。

⼆叉树的遍历是采⽤某种策略使得采⽤树型结构组织的若⼲结点对应于⼀个线性序列。

⼆叉树的遍历策略有四种:先序遍历、中序遍历、后序遍历和层次遍历。

⼆.基本要求1.从键盘接受输⼊数据(先序),以⼆叉链表作为存储结构,建⽴⼆叉树。

2.输出⼆叉树。

二叉树基本操作

二叉树基本操作

二叉树基本操作二叉树基本操作一、实验目的1.熟悉二叉树结点的结构和对二叉树的基本操作。

2.掌握对二叉树每一种操作的具体实现。

3.学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。

4.在二叉树基本操作的基础上掌握对二叉树的一些其它操作的具体实现方法。

5.掌握构造哈夫曼树以及哈夫曼编码的方法。

二、实验内容(必做1)程序 1该程序的功能是实现二叉树结点的类型定义和对二叉树的基本操作。

该程序包括二叉树结构类型以及每一种操作的具体的函数定义和主函数。

/* 定义 DataType 为char类型 */typedef char DataType;/* 二叉树的结点类型 */typedef struct BitNode{DataType data;struct BitNode *lchild,*rchild;}BitNode,*BitTree;/* 初始化二叉树,即把树根指针置空 */void BinTreeInit(BitTree *BT)/* 按先序次序建立一个二叉树*/void BinTreeCreat(BitTree *BT)/* 检查二叉树是否为空 */int BinTreeEmpty(BitTree *BT)/* 按任一种遍历次序(包括按先序、中序、后序、按层次)输出二叉树中的所有结点 */void BinTraverse(BitTree *BT)/* 求二叉树的深度 */int BinTreeDepth(BitTree BT)/* 求二叉树中所有结点数 */int BinTreeCount(BitTree BT)/* 清除二叉树,使之变为空树 */void BinTreeClear(BitTree *BT)程序2 二叉树采用二叉链表存储,设计按层次遍历二叉树的算法。

设计要求:在程序中构造两个子程序分别为void BinTreeCreat(BitTree *BT) /* 按前序次序建立一个二叉树*/ void layorder(BitTree T) /*按层次遍历二叉树 */程序 3哈夫曼树和哈夫曼编码:从终端输入若干个字符,统计字符出现的频率,将字符出现的频率作为结点的权值,建立哈夫曼树,然后对各字符进行哈夫曼编码。

二叉树的基本操作完整版,包含二叉树的所有操作,凡是你想要的都在里面--数据结构版

二叉树的基本操作完整版,包含二叉树的所有操作,凡是你想要的都在里面--数据结构版

#include "stdio.h"#include "stdlib.h"#include "string.h"#include "math.h"typedef char TElemType; //定义结点数据为字符型typedef int Status; //定义函数类型为int型#define ERROR 0#define OK 1typedef struct BiTNode{ //定义结构体TElemType data; //结点数值struct BiTNode *lchild; //左孩子指针struct BiTNode *rchild; //右孩子指针struct BiTNode *next; //下一结点指针}BiTNode, *BiTree;Status NumJudge(char ch[20]){//限制输入数据必须为大于零的整形char ch1[20];int num;while(1){scanf("%s",ch);num=atoi(ch); //将字符串转换为整型itoa(num,ch1,10); //将整型转换为字符串型if(strcmp(ch,ch1)==0&&num>0)break;else{printf("请输入一个大于零的整数: ");}}return num;}//NumJudgeStatus InitBiTree(BiTree &T){//构造空二叉树Tif(!(T=(BiTree)malloc(sizeof(BiTNode))))exit(ERROR); //若申请空间失败则退出T->next=NULL;printf("\n\t空二叉树构建成功!\n\n");return OK;}//InitBiTreeStatus DestroyTree(BiTree &T,BiTree t){//销毁二叉树if(T){free(T);T=NULL;printf("\t二叉树销毁成功!\n");}if(t){DestroyTree(T,t->lchild);DestroyTree(T,t->rchild);free(t);}return OK;}//DestroyTreeStatus ClearBiTree(BiTree &T,int sum,int &i){//清空二叉树if(T){ClearBiTree(T->lchild,sum,i);ClearBiTree(T->rchild,sum,i);free(T);i++;}if(i==sum){printf("\t二叉树清空成功!\n");T=NULL;}return OK;}//ClearBiTreeStatus CreateBiTree(BiTree &T,int i,int j,TElemType ch){//按先序次序输入二叉树中结点的值(一个字符),空格字符表示该结点为空//构造二叉链表示的二叉树TTElemType ch1;int k;char str[20];if(i==0){printf("\n 按先序顺序建立二叉树:请按提示输入相应的数据(一个字符),若提示结点数值为空,\n 请输入空格\n\n");printf("%5s请输入树根: "," ");}if(i!=0&&i>=j){printf("%5s请输入%c的左孩子: "," ",ch);}if(j!=0&&j>i){printf("%5s请输入%c的右孩子: "," ",ch);}while(1){ //限制输入数据必须为字符型,否则重新输入fflush(stdin);for(k=0;k<20;k++){str[k]=getchar();if(str[k]=='\n')break;}if(k==0)printf("%5s请输入一个字符后再按Enter键: "," ");if(k==1)break;if(k>1)printf("%5s您只能输入一个字符: "," ");}ch1=str[0]; //获取输入的准确字符型数据if(ch1==' '){T=NULL;return ERROR;} //输入空格则为根结点为空if(ch1!=' '){if(!(T=(BiTree)malloc(sizeof(BiTNode)))) exit(ERROR);T->data=ch1; //生成根结点ch=T->data;i++;CreateBiTree(T->lchild,i,j,ch); //构造左子树j=i;j++;CreateBiTree(T->rchild,i,j,ch); //构造右子树}i=0;j=0;return OK;}//CreateBitreeStatus TreeDepth(BiTree T,int l,int &h){//若二叉树存在,返回其深度if(T){l=l+1;if(l>h)h=l;TreeDepth(T->lchild,l,h);TreeDepth(T->rchild,l,h);}return h;}//TreeDepthStatus GetRootElem(BiTree T){//获取根结点值printf("该二叉树的根结点值为: %c\n\n",T->data);return OK;}//GetRootElemStatus SaveElem(BiTree T,BiTree *Q,int i){//根据完全二叉树中,若本节点位置序号为i,则其左孩子结点为2i,右孩子为2i+1的方法//保存二叉树的有效结点至指针数组Q特定的位置if(T){Q[i]=T;SaveElem(T->lchild,Q,2*i);SaveElem(T->rchild,Q,2*i+1);}return OK;}//SaveElemStatus Lev_Traverse(BiTree T,int h){//按层次从上到下,每层从左到右的顺序显示树状二叉树if(T==NULL){printf("\n\t\t二叉树目前为空树\n\n");return ERROR;}BiTree *Q;if(!(Q=(BiTree *)malloc(int(pow(2,h)+1) * sizeof(BiTNode))))exit(ERROR);int i,j,n=1,k=h;for(i=1;i<=int(pow(2,h)+1);i++){Q[i]=NULL;}SaveElem(T,Q,n); //将目前有效结点按照满二叉树的序号存储printf(" 提示:规定下图中的有效结点的位置序号从1开始按从上到下,从左到右的顺序依次递增\n");for(i=1;i<=(pow(2,h)+1);i++){ //树形显示二叉树if(int(pow(2,h))%i==0){printf("\n");printf("\t\t");for(j=0;j<pow(2,k-1)-1;j++){printf(" ");}k--;}if(Q[i])printf("%c",Q[i]->data);if(!Q[i])printf(" ");for(j=0;j<pow(2,k+1)-1;j++){printf(" ");}}printf("\n\n");i=0;j=0;return OK;}//Lev_TraverseStatus FirstPrint(BiTree T,int i){//按先序次序(递归)访问二叉树if(i==0)printf("\n先序(递归)遍历结果如下:\n");if(T){i++;printf("%-5c",T->data); //访问TFirstPrint(T->lchild,i); //递归遍历左子树FirstPrint(T->rchild,i); //递归遍历右子树}i=0;return OK;}//FirstPrintBiTreeStatus MiddlePrint(BiTree T,int i){//按中序次序(递归)访问二叉树if(i==0)printf("\n中序(递归)遍历结果如下:\n");if(T){i++;MiddlePrint(T->lchild,i); //递归遍历左子树printf("%-5c",T->data); //访问TMiddlePrint(T->rchild,i); //递归遍历右子树}i=0;return OK;}//MiddlePrintStatus LastPrint(BiTree T,int i){//按后序次序(递归)访问二叉树if(i==0)printf("\n后序(递归)遍历结果如下:\n");if(T){i++;LastPrint(T->lchild,i); //递归遍历左子树LastPrint(T->rchild,i); //递归遍历右子树printf("%-5c",T->data); //访问T}i=0;return OK;}//LastPrintStatus PreOrderTraverse(BiTree T){//按先序(非递归)遍历二叉树TBiTree p,S,q;int flag=0;if(!(S=(BiTree)malloc(sizeof(BiTNode))))exit(ERROR);S->next=NULL; //建立空栈Sp=T;printf("\n先序(非递归)遍历结果如下:\n");while(1){while(1){ //遍历存储并访问左子树直到根结点左孩子不存在printf("%-5c",p->data);q=S->next;S->next=p;p->next=q; //当前结点进栈if(p->lchild)p=p->lchild;else{break;}}while(1){ //栈顶指针出栈,如果当前栈顶指针的右孩子存在则跳出循环p=S->next;S->next=p->next;if(!S->next&&!p->rchild){flag=1;break;} //如果栈空并且当前结点右孩子不存在则遍历结束if(p->rchild){p=p->rchild;break;}}if(flag==1)break;}printf("\n\n");return OK;}//PreOrderTraverseStatus InOrderTraverse(BiTree T){// 中序遍历(非递归)二叉树TBiTree p,S,q;if(!(S=(BiTree)malloc(sizeof(BiTNode))))exit(ERROR);S->next=NULL; //建立空栈Sp=T;printf("\n中序(非递归)遍历结果如下:\n");while(p||S->next){if(p){q=S->next;S->next=p;p->next=q;p=p->lchild;} //左孩子进栈else{p=S->next;S->next=p->next;if(p)printf("%-5c",p->data); //输出栈中元素else{return ERROR;}p=p->rchild;}}printf("\n\n");return OK;}//InOrderTraverseStatus PostOrderTraverse(BiTree T){//后序遍历(非递归)二叉树TBiTree p,S,q;if(!(S=(BiTree)malloc(sizeof(BiTNode))))exit(ERROR);S->next=NULL; //建立空栈Sp=T;printf("\n后序(非递归)遍历结果如下:\n");while(1){while(1){ //遍历左子树,若当前结点左右孩子都不存在则跳出q=S->next;S->next=p;p->next=q; //当前结点进栈if(p->lchild)p=p->lchild;else{if(p->rchild)p=p->rchild;else{break;}}}while(S->next){p=S->next;S->next=p->next; //栈顶指针出栈并访问printf("%-5c",p->data);if(!S->next)break; //若栈空则跳出if(p==S->next->rchild)p=S->next; //若当前结点为栈顶指针的右孩子,则继续出栈else{if(S->next->rchild){ //栈顶指针右孩存在,指针移至栈顶指针的右孩子后跳出循环p=S->next->rchild;break;}}}if(!S->next)break; //若栈空则跳出循环}printf("\n\n");return OK;}//PostOrderTraverseStatus GetElemSum(BiTree T){//计算二叉树中总结点的个数BiTree p,*q;int l=0,h=0;if(!(q=(BiTree *)malloc(int(pow(2,TreeDepth(T,l,h))+1) * sizeof(BiTNode))))exit(ERROR);int head=1,tail=2;q[1]=T;while(head<tail){p=q[head++];if(p->lchild)q[tail++]=p->lchild;if(p->rchild)q[tail++]=p->rchild;}return head-1;}//GetElemSumStatus LevelOrderPrint(BiTree T){//二叉树T存在,层序遍历二叉树//将二叉树中的结点按从上到下,从左到右的顺序存至指针数组q,然后按次序输出BiTree p,*q;if(!(q=(BiTree *)malloc(GetElemSum(T) * sizeof(BiTNode))))exit(ERROR);int head=1,tail=2;q[1]=T;printf("\n层序(非递归)遍历结果如下:\n");while(head<tail){p=q[head++];printf("%-5c",p->data);if(p->lchild)q[tail++]=p->lchild;if(p->rchild)q[tail++]=p->rchild;}printf("\n\n");return OK;}//LevelOrderPrintStatus GetElemNum(BiTree T,TElemType e){//查找元素e在二叉树T中的个数及位置int j,i=0,num=0,*a;BiTree p,*q;if(!(q=(BiTree *)malloc(GetElemSum(T) * sizeof(BiTNode))))exit(ERROR);if(!(a=(int *)malloc(GetElemSum(T) * sizeof(int))))exit(ERROR);int head=1,tail=2;q[1]=T;while(head<tail){p=q[head++];if(p->data==e){num++;a[i]=head-1;i++;}if(p->lchild)q[tail++]=p->lchild;if(p->rchild)q[tail++]=p->rchild;}printf("\n元素%c在二叉树中的个数为: %d\n",e,num);printf("元素%c在二叉树中的位置序号为:",e);for(j=0;j<i;j++){printf("%-4d",a[j]);}printf("\n");return num;}//GetElemNumStatus GetLeafNum(BiTree T){//计算二叉树T中叶子个数BiTree p,*q;if(!(q=(BiTree *)malloc(GetElemSum(T) * sizeof(BiTNode))))exit(ERROR);int num=0,head=1,tail=2;q[1]=T;while(head<tail){p=q[head++];if(!p->lchild&&!p->rchild)num++;if(p->lchild)q[tail++]=p->lchild;if(p->rchild)q[tail++]=p->rchild;}return num;}//GetLeafNumStatus LBrother(BiTree T,int sum){//求第num个结点的左兄弟BiTree p,*q;if(!(q=(BiTree *)malloc(GetElemSum(T) * sizeof(BiTNode))))exit(ERROR);int i,num,head=1,tail=2;char str[20];q[1]=T;printf("请输入要查找的位置序号: ");num=NumJudge(str);if(num>sum){printf("您输入的位置序号大于有效结点个数\n");return ERROR;};while(head<tail){p=q[head++];if(num==tail-2)break;if(p->lchild)q[tail++]=p->lchild;if(p->rchild)q[tail++]=p->rchild;}if(num==1)printf("位置%d的%c没有左兄弟\n",num,q[num]->data);else{for(i=1;i<num;i++){if(q[i]->lchild==q[num]||q[i]->rchild==q[num])break;}if(q[i]->lchild==q[num])printf("位置%d的%c没有左兄弟\n",num,q[num]->data);if(q[i]->rchild==q[num])printf("位置%d的%c的左兄弟为: %c\n",num,q[num]->data,q[i]->lchild->data);}return OK;}//LBrotherStatus RBrother(BiTree T,int sum){//求第num个结点的右兄弟BiTree p,*q;if(!(q=(BiTree *)malloc(GetElemSum(T) * sizeof(BiTNode))))exit(ERROR);int i,num,head=1,tail=2;char str[20];q[1]=T;printf("请输入要查找的位置序号: ");num=NumJudge(str);if(num>sum){printf("您输入的位置序号大于有效结点个数\n");return ERROR;};while(head<tail){p=q[head++];if(num==tail-2)break;if(p->lchild)q[tail++]=p->lchild;if(p->rchild)q[tail++]=p->rchild;}if(num==1)printf("位置%d的%c没有右兄弟\n",num,q[num]->data);else{for(i=1;i<num;i++){if(q[i]->lchild==q[num]||q[i]->rchild==q[num])break;}if(!q[i]->rchild||q[i]->rchild==q[num])printf("位置%d的%c没有右兄弟\n",num,q[num]->data);if(q[i]->rchild&&q[i]->lchild==q[num])printf("位置%d的%c的右兄弟为: %c\n",num,q[num]->data,q[i]->rchild->data);}return OK;}//RBrotherStatus Lchild(BiTree T,int sum){//求第num个结点的左孩子BiTree p,*q;if(!(q=(BiTree *)malloc(GetElemSum(T) * sizeof(BiTNode))))exit(ERROR);int num,head=1,tail=2;char str[20];q[1]=T;printf("请输入要查找的位置序号: ");num=NumJudge(str);if(num>sum){printf("您输入的位置序号大于有效结点个数\n");return ERROR;}while(head<tail){p=q[head++];if(num==tail-2)break;if(p->lchild)q[tail++]=p->lchild;if(p->rchild)q[tail++]=p->rchild;}if(q[num]->lchild)printf("位置%d的%c的左孩子为: %c\n",num,q[num]->data,q[num]->lchild->data);else{printf("位置%d的%c的左孩子不存在\n",num,q[num]->data);}return OK;}//LchildStatus Rchild(BiTree T,int sum){//求第num个结点的右孩子BiTree p,*q;if(!(q=(BiTree *)malloc(GetElemSum(T) * sizeof(BiTNode))))exit(ERROR);int num,head=1,tail=2;char str[20];q[1]=T;printf("请输入要查找的位置序号: ");num=NumJudge(str);if(num>sum){printf("您输入的位置序号大于有效结点个数\n");return ERROR;}while(head<tail){p=q[head++];if(num==tail-2)break;if(p->lchild)q[tail++]=p->lchild;if(p->rchild)q[tail++]=p->rchild;}if(q[num]->rchild)printf("位置%d的%c的右孩子为: %c\n",num,q[num]->data,q[num]->rchild->data);else{printf("位置%d的%c的右孩子不存在\n",num,q[num]->data);}return OK;}//RchildStatus Partents(BiTree T,int sum){//求第num个结点的双亲BiTree p,*q;if(!(q=(BiTree *)malloc(GetElemSum(T) * sizeof(BiTNode))))exit(ERROR);int i,num,head=1,tail=2;char str[20];q[1]=T;printf("请输入要查找的位置序号: ");num=NumJudge(str);if(num>sum){printf("您输入的位置序号大于有效结点个数\n");return ERROR;}while(head<tail){p=q[head++];if(num==tail-2)break;if(p->lchild)q[tail++]=p->lchild;if(p->rchild)q[tail++]=p->rchild;}if(num==1)printf("位置%d的%c没有双亲\n",num,q[num]->data);else{for(i=1;i<num;i++){if(q[i]->lchild==q[num]||q[i]->rchild==q[num])break;}printf("位置%d的%c的双亲为: %c\n",num,q[num]->data,q[i]->data);}return OK;}//PartentsStatus TreeDelete(BiTree &T,int sum){//删除第num个结点BiTree p,p1,*q;if(!(q=(BiTree *)malloc(GetElemSum(T) * sizeof(BiTNode))))exit(ERROR);int i,num,head=1,tail=2,a=0,b=0;char str[20];q[1]=T;printf("请输入要删除结点的位置序号: ");num=NumJudge(str);if(num>sum){printf("\n您输入的位置序号大于有效结点个数\n\n");return ERROR;}if(num==1){printf("\t对不起,您不能删除根结点,若想删除根结点,请选择销毁树\n\n");return ERROR;};while(head<tail){p=q[head++];if(num==tail-2)break;if(p->lchild)q[tail++]=p->lchild;if(p->rchild)q[tail++]=p->rchild;}for(i=1;i<num;i++){if(q[i]->lchild==q[num]||q[i]->rchild==q[num])break;}printf("\n您删除了如下子树:\n\n");Lev_Traverse(q[num],TreeDepth(q[num],a,b));if(q[i]->lchild==q[num])q[i]->lchild=NULL;if(q[i]->rchild==q[num])q[i]->rchild=NULL;p1=NULL;DestroyTree(p1,q[num]);printf("\n删除结点成功\n");return OK;}//TreeDeleteStatus TreeInsert(BiTree &T,int sum){//在第num个生成子树BiTree p,p1,*q;if(!(q=(BiTree *)malloc(GetElemSum(T) * sizeof(BiTNode))))exit(ERROR);int num,head=1,tail=2,a=0,b=0;char ch=' ',str[20];q[1]=T;printf("请输入要插入结点的位置序号: ");num=NumJudge(str);if(num>sum){printf("\n您输入的位置序号大于有效结点个数\n\n");return ERROR;}while(head<tail){p=q[head++];if(num==tail-2)break;if(p->lchild)q[tail++]=p->lchild;if(p->rchild)q[tail++]=p->rchild;}if(q[num]->lchild&&q[num]->rchild){printf("您输入的位置序号已有左子树和右子树,无法再此位置插入\n\n");return ERROR;}if(q[num]->lchild&&!q[num]->rchild){printf("位置%d的%c处只能生成右子树,确定插入/退出(y/n): ",num,q[num]->data);while(1){scanf("%s",str);if(strcmp(str,"y")==0||strcmp(str,"n")==0)break;else{printf("选择错误,请重新输入: ");}}if(strcmp(str,"y")==0){printf("请输入插入子树的信息: \n");CreateBiTree(p1,a,b,ch);if(p1){q[num]->rchild=p1;}}if(strcmp(str,"n")==0)return ERROR;}if(!q[num]->lchild&&q[num]->rchild){printf("位置%d的%c处只能生成左子树,确定插入/退出(y/n): ",num,q[num]->data);while(1){scanf("%s",str);if(strcmp(str,"y")==0||strcmp(str,"n")==0)break;else{printf("选择错误,请重新输入: ");}}if(strcmp(str,"y")==0){printf("请输入插入子树的信息: \n");CreateBiTree(p1,a,b,ch);if(p1){q[num]->lchild=p1;}}if(strcmp(str,"n")==0)return ERROR;}if(!q[num]->lchild&&!q[num]->rchild){printf("请输入插入子树的信息: \n");CreateBiTree(p1,a,b,ch);printf("\t\t你想把新建的树作为位置%d的%c处的: \n",num,q[num]->data);printf("\t\t [1]左子树[2]右子树\n");printf("\n\t\t请输入你的选择: ");while(1){scanf("%s",str);if(strcmp(str,"1")==0||strcmp(str,"2")==0)break;else{printf("选择错误,请重新输入: ");}}if(strcmp(str,"1")==0){if(p1){q[num]->lchild=p1;}}if(strcmp(str,"2")==0){if(p1){q[num]->rchild=p1;}}}printf("插入子树成功\n");return OK;}//TreeInsertStatus Modify(BiTree T,int sum,int &n){//修改二叉树第num个结点的值BiTree p,*q;if(!(q=(BiTree *)malloc(GetElemSum(T) * sizeof(BiTNode))))exit(ERROR);int k,num,head=1,tail=2;char str[20];q[1]=T;n=0;printf("请输入要修改结点的位置序号: ");num=NumJudge(str);if(num>sum){printf("\n您输入的位置序号大于有效结点个数\n\n");return ERROR;} while(head<tail){p=q[head++];if(num==tail-2)break;if(p->lchild)q[tail++]=p->lchild;if(p->rchild)q[tail++]=p->rchild;}printf("%5s请输入新的结点值: "," ");while(1){fflush(stdin);for(k=0;k<20;k++){str[k]=getchar();if(str[k]=='\n')break;}if(k==0)printf("%5s请输入一个字符后再按Enter键: "," ");if(k==1)break;if(k>1)printf("%5s您只能输入一个字符: "," ");}q[num]->data=str[0];printf("\n 修改成功\n");n=1;return OK;}//Modifyint MainMenu(){ //主菜单函数system("cls");int choose;char str[20];printf("\n\t\t\t*=*=*=*=*=*=*=**=*=*=**=*=*=**=*=*=**=*=*=*");printf("\n\t\t\t 计本102 卢荣盼1018014052");printf("\n\t\t\t*=*=*=*=*=*=*=**=*=*=**=*=*=**=*=*=**=*=*=*");printf("\n\t\t\t [1]建立空树\n");printf("\n\t\t\t [2]构造二叉树\n");printf("\n\t\t\t [3]显示树状二叉树\n");printf("\n\t\t\t [4]遍历二叉树->>进入子菜单\n");printf("\n\t\t\t [5]查看二叉树信息->>进入子菜单\n");printf("\n\t\t\t [6]对二叉树进行操作->>进入子菜单\n");printf("\n\t\t\t [0]退出程序");printf("\n\t\t\t*=*=*=*=*=*=*=**=*=*=**=*=*=**=*=*=**=*=*=*");printf("\n\t\t\t请输入你的选择: ");while(1){scanf("%s",str);if(strcmp(str,"0")==0||strcmp(str,"1")==0||strcmp(str,"2")==0||strcmp(str,"3")==0 ||strcmp(str,"4")==0||strcmp(str,"5")==0||strcmp(str,"6")==0){choose=atoi(str);break;}else{printf("\t\t\t选择错误请重新输入: ");}}if(choose==0){printf("\n\n\t…~~~…~~~谢谢使用本程序~~~…~~~…\n\n");} return choose;}//MainMenu()int Menu(){ //主菜单函数system("cls");int choose;char str[20];printf("\n\t\t\t*=*=*=*=*=*=*=**=*=*=**=*=*=**=*=*=**=*=*=*");printf("\n\t\t\t 请选择对应的选项按对应的方式遍历二叉树");printf("\n\t\t\t*=*=*=*=*=*=*=**=*=*=**=*=*=**=*=*=**=*=*=*");printf("\n\t\t\t\t[1]按先序(递归)遍历二叉树\n");printf("\n\t\t\t\t[2]按中序(递归)遍历二叉树\n");printf("\n\t\t\t\t[3]按后序(递归)遍历二叉树\n");printf("\n\t\t\t\t[4]按先序(非递归)遍历二叉树\n");printf("\n\t\t\t\t[5]按中序(非递归)遍历二叉树\n");printf("\n\t\t\t\t[6]按后序(非递归)遍历二叉树\n");printf("\n\t\t\t\t[7]按层次(非递归)遍历二叉树\n");printf("\n\t\t\t\t[0]返回主菜单");printf("\n\t\t\t*=*=*=*=*=*=*=**=*=*=**=*=*=**=*=*=**=*=*=*\n");printf("\t\t\t请输入你的选择: ");while(1){scanf("%s",str);if(strcmp(str,"0")==0||strcmp(str,"1")==0||strcmp(str,"2")==0||strcmp(str,"3")==0 ||strcmp(str,"4")==0||strcmp(str,"5")==0||strcmp(str,"6")==0||strcmp(str,"7")==0) {choose=atoi(str);break;}else{printf("\t\t\t选择错误请重新输入: ");}}return choose;}//Menu()int Menu1(){ //查看二叉树信息菜单system("cls");int choose;char str[20],str1[20];printf("\n\t*=*=*=*=*=*=*=**=*=*=**=*=*=**=*=*=**=*=*=**=*=*=**=*=*=**=*=* =*=*=*=*");printf("\n\t 请选择对应的选项查看当前二叉树的信息");printf("\n\t*=*=*=*=*=*=*=**=*=*=**=*=*=**=*=*=**=*=*=**=*=*=**=*=*=**=*=* =*=*=*=*");printf("\n\t [1]返回根结点值[2]二叉树的深度\n");printf("\n\t [3]二叉树的总结点个数[4]二叉树中度为2的结点个数\n");printf("\n\t [5]二叉树中度为1的结点个数[6]二叉树中叶子结点个数\n");printf("\n\t [7]某一值的结点个数及位置[8]二叉树中某结点的左孩子\n");printf("\n\t [9]二叉树中某结点的右孩子[10]二叉树中某结点的左兄弟\n");printf("\n\t [11]二叉树中某结点的右兄弟[12]二叉树中某结点的双亲\n");printf("\n\t [0]返回主菜单\n");printf("\t*=*=*=*=*=*=*=**=*=*=**=*=*=**=*=*=**=*=*=**=*=*=**=**=*=*=**=*= *=*=*=*=*\n");printf("\t\t请输入你的选择: ");while(1){scanf("%s",str);choose=atoi(str);itoa(choose,str1,10);if(choose>0&&choose<=12&&strcmp(str,str1)==0||strcmp(str,"0")==0)break;else{printf("\t\t选择错误请重新输入: ");}}return choose;}//Menu1()int Menu2(){ //主菜单函数system("cls");int choose;char str[20];printf("\n\t\t\t*=*=*=*=*=*=*=**=*=*=**=*=*=**=*=*=*");;printf("\n\t\t\t 请选择对应的选项对二叉树进行操作");printf("\n\t\t\t*=*=*=*=*=*=*=**=*=*=**=*=*=**=*=*=*");printf("\n\t\t\t\t[1]删除某一结点\n");printf("\n\t\t\t\t[2]对某一结点生成子树\n");printf("\n\t\t\t\t[3]修改某一结点值\n");printf("\n\t\t\t\t[4]清空二叉树\n");printf("\n\t\t\t\t[5]销毁二叉树\n");printf("\n\t\t\t\t[0]返回主菜单");printf("\n\t\t\t*=*=*=*=*=*=*=**=*=*=**=*=*=**=*=*=*");printf("\n\t\t\t请输入你的选择: ");while(1){scanf("%s",str);if(strcmp(str,"0")==0||strcmp(str,"1")==0||strcmp(str,"2")==0||strcmp(str,"3")==0 ||strcmp(str,"4")==0||strcmp(str,"5")==0){choose=atoi(str);break;}else{printf("\t\t\t选择错误请重新输入: ");}}return choose;}//Menu2()void main(){system("color e0");BiTree T=NULL;int num,l,h,choose,flag=0,i=0,j=0,n;TElemType ch;while((choose=MainMenu())!=0){switch(choose){case 1:if(flag==2){printf("您已清空了之前的二叉树,目前为空树,无须再建立空树!\n\n");} else{if(flag==0){InitBiTree(T);flag=1;}else{printf("您之前已经建过空树,若想重建,请先销毁当前的树!\n\n");}} system("pause");break;case 2:if(!T)printf("您还没有建树,请先建树!\n\n");else{if(T->next)printf("二叉树已存在,若想重建,请先清空当前的二叉树!\n\n");else{system("cls");CreateBiTree(T->next,i,j,ch);printf("\n\n二叉树创建完成!\n\n");}}system("pause");break;case 3:if(!T)printf("您还没有建树,请先建树!\n\n");else{l=0;h=0;if(T->next){printf("\n 当前二叉树的树状图如下:\n\n");}Lev_Traverse(T->next,TreeDepth(T->next,l,h));}system("pause");break;case 4:if(!T){printf("您还没有建树,请先建树!\n\n");system("pause");}else{if(!T->next){printf("二叉树目前为空树,请创建非空树后再遍历!\n\n");system("pause");}else{while((choose=Menu())!=0){l=0;h=0;printf("\n 当前二叉树的树状图如下:\n\n");Lev_Traverse(T->next,TreeDepth(T->next,l,h));switch(choose){case 1:FirstPrint(T->next,i);printf("\n\n");system("pause");break;case 2:MiddlePrint(T->next,i);printf("\n\n");system("pause");break;case 3:LastPrint(T->next,i);printf("\n\n");system("pause");break;case 4:PreOrderTraverse(T->next);system("pause");break;case 5:InOrderTraverse(T->next);system("pause");break;case 6:PostOrderTraverse(T->next);system("pause");break;case 7:LevelOrderPrint(T->next);printf("\n\n");system("pause");break;default:exit(ERROR);}}}}break;case 5:if(!T){printf("您还没有建树,请先建树!\n\n");system("pause");}else{if(!T->next){printf("二叉树目前为空树,请创建非空树后再查看信息!\n\n");system("pause");}else{while((choose=Menu1())!=0){l=0;h=0;printf("\n 当前二叉树的树状图如下:\n\n");Lev_Traverse(T->next,TreeDepth(T->next,l,h));switch(choose){case 1:GetRootElem(T->next);system("pause");break;case 2:printf("当前二叉树的深度为: %d\n\n",TreeDepth(T->next,l,h));system("pause");break;case 3:printf("\n二叉树中有效结点的个数为: %d\n\n",GetElemSum(T->next));system("pause");break;case 4:printf("\n二叉树中度为2的结点个数为: %d\n\n",GetLeafNum(T->next)-1);system("pause");break;case 5:printf("\n二叉树中度为1的结点个数为: %d\n\n",GetElemSum(T->next)-2*GetLeafNum(T->next)+1);system("pause");break;case 6:printf("\n二叉树中叶子结点个数为: %d\n\n",GetLeafNum(T->next));system("pause");break;case 7:printf("请输入要统计的元素: ");fflush(stdin);scanf("%c",&ch);GetElemNum(T->next,ch);system("pause");break;case 8:Lchild(T->next,GetElemSum(T->next));system("pause");break;case 9:Rchild(T->next,GetElemSum(T->next));system("pause");break;case 10:LBrother(T->next,GetElemSum(T->next));system("pause");break;case 11:RBrother(T->next,GetElemSum(T->next));system("pause");break;case 12:Partents(T->next,GetElemSum(T->next));system("pause");break;default:exit(ERROR);}}}}break;case 6:if(!T){printf("您还没有建树,请先建树!\n\n");system("pause");}else{if(!T->next){printf("二叉树目前为空树,请创建非空树后再对树进行操作!\n\n");system("pause");}else{while((choose=Menu2())!=0){if(choose!=4&&choose!=5){system("cls");l=0;h=0;printf("\n 当前二叉树的树状图如下:\n\n");Lev_Traverse(T->next,TreeDepth(T->next,l,h));printf("\n二叉树中有效结点的个数为: %d\n\n",GetElemSum(T->next));printf("当前二叉树的深度为: %d\n\n",h);}switch(choose){case 1:num=GetElemSum(T->next);TreeDelete(T->next,GetElemSum(T->next));if(num!=GetElemSum(T->next)){l=0;h=0;printf("\n 删除后二叉树的树状图如下:\n\n");Lev_Traverse(T->next,TreeDepth(T->next,l,h));printf("\n二叉树中有效结点的个数为: %d\n\n",GetElemSum(T->next));printf("当前二叉树的深度为: %d\n\n",h);}system("pause");break;case 2:num=GetElemSum(T->next);TreeInsert(T->next,GetElemSum(T->next));if(num!=GetElemSum(T->next)){l=0;h=0;printf("\n 插入后二叉树的树状图如下:\n\n");Lev_Traverse(T->next,TreeDepth(T->next,l,h));printf("\n二叉树中有效结点的个数为: %d\n\n",GetElemSum(T->next));printf("当前二叉树的深度为: %d\n\n",h);}system("pause");break;case 3:Modify(T->next,GetElemSum(T->next),n);if(n==1){l=0;h=0;printf("\n 修改后二叉树的树状图如下:\n\n");Lev_Traverse(T->next,TreeDepth(T->next,l,h));printf("\n二叉树中有效结点的个数为: %d\n\n",GetElemSum(T->next));printf("当前二叉树的深度为: %d\n\n",h);}system("pause");break;case 4:h=0;ClearBiTree(T->next,GetElemSum(T->next),h);flag=2;break;case 5:DestroyTree(T,T->next);flag=0;break;default:exit(ERROR);}if(choose==4){printf("\n\t您已清空了当前的二叉树,程序将退回到主菜单,请重新建树后再回本菜单操作!\n\n");system("pause");break;}if(choose==5){printf("\n\t您已销毁了当前的二叉树,程序将退回到主菜单,请重新建树后再回本菜单操作!\n\n");system("pause");break;}}}}break;default:exit(ERROR);}}}。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

3.
int head;//队头指针
4.
int tail;//队尾指针
5. } SqQueue;
队列主要用于二叉树遍历过程中的层序遍历,从根节点开始分别将左右孩子放入队列,然后从对头开
始输出。队列的相关操作封装在 SqQueue.h 中,包括入队、出队、判断队列是否为空等操作。
2
四、全局函数的设计
本程序中应用了一些全局函数,本着用到那个函数就把哪个函数设为全局函数的原则,抽象 出了以下全局函数:
9
(9)void swap(BiTree* b) 本函数用子树交换
(10)void displayMenu() 本函数用于展示菜单
4.2 全局函数在具体系统中的分布
BiTree.h 此文件为二叉树的头文件,包含上述所有全局函数
五、功能实现
二叉树的基本操作这个程序的主要功能就是建立二叉树,然后运用先序、中序等遍历方法遍历二叉树, 然后还有统计二叉树的叶子结点个数、求二叉树的深度以及进行子树的交换。
10. }
5.2.5 子树交换
1. //子树交换 7
2. BiTree* temp;//临时变量,用于交换
3. void swap(BiTree* b) {
4.
if (b == NULL) {
5.
return;
6.
}
7.
else {
8.
temp = b->lchild;
9.
b->lchild = b->rchild;
12. }
(4) 层序遍历
1. //层序遍历
2. void LevelOrderTraverse(BiTree* b) {
3.
SqQueue* s = initSqQueue();
4.
BiTree* temp;
5.
if (b) {
6.
append(s, *b);
7.
while (!isEmpty(s)) {
4.1 全局函数列表
(1)BiTree* createBinaryTree(BiTree* b) 本函数用于建立二叉树
(2)void Traverse(BiTree* b) 本函数用于遍历二叉树
(3)void PreOrderTraverse(BiTree* b) 本函数用于前序遍历二叉树
(4)void InOrderTraverse(BiTree* b) 本函数用于中序遍历二叉树
二叉树的基本操作
摘要:
本次课程设计通过对二叉树的一系列操作主要练习了二叉树的建立、四种遍历方式:先 序遍历、中序遍历、后序遍历和层序遍历以及节点数和深度的统计等算法。增加了对二叉树 这一数据结构的理解,掌握了使用 c 语言对二叉树进行一些基本的操作。
关键字:递归、二叉树、层序遍历、子树交换
一、程序简介
3
5.1 二叉树的基本操作流程图如下
菜单界面如下:
5.2 二叉树的基本操作的代码如下
5.2.1 二叉树的建立
1. //按照前序输入二叉树结点的值,“#”表示空
2. BiTree* createBinaryTree(BiTree* b) {
3.
char ch;//定义变量用于储存输入的字符
4
4. 5. 6. 7. 8. 9.
if (!b) {
5.
return 0;
6.
}
7.
leftHeight = getHeight(b->lchild);
8.
rightHeight = getHeight(b->rchild);
9.
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
//生成根节点 b->data = ch; //构造左子树 b->lchild=createBinaryTree(b->lchild); //构造右子树 b->rchild=createBinaryTree(b->rchild); } } return b;
5.2.2 二叉树的遍历 如图所示选择遍历后有三种方案可供选择:
(5)void PostOrderTraverse(BiTree* b) 本函数用于后序遍历二叉树
(6)void LevelOrderTraverse(BiTree* b) 本函数用于层序遍历二叉树
(7)void getLeavesNum(BiTree* b) 本函数用于统计叶子结点个数
(8)int getHeight(BiTree* b) 本函数用于求二叉树的深度
(1) 前序遍历
1. void PreOrderTraverse(BiTree* b) {
2.
if (b == NULL) {
3.
return;
4.
}
5.
//首先打印结点数据
6.
printf("%c ", b->data);
7.
//再先序遍历左子树
8.
PreOrderTraverse(b->lchild);
3.
if (b == NULL) {
4.
return;
5.
}
6.
//首先后序遍历左子树
7.
PostOrderTraverse(b-&g历右子树
9.
PostOrderTraverse(b->rchild);
10.
//最后打印结点数据
11. printf("%c ", b->data);
4.
struct BiNode* rchild;
5. }BiTree;
//左孩子 //右孩子
用一个字符型保存节点数据,分别定义两个 struct BiNode 类型的指针来指向左孩子和右孩子。在 BiTree.h 中实现相关的功能。
3.2 队列的实现
1. typedef struct {
2.
ElemType* data;
9.
//最后先序遍历右子树
10. PreOrderTraverse(b->rchild);
11. }
5
(2) 中序遍历
1. //中序遍历
2. void InOrderTraverse(BiTree* b) {
3.
if (b == NULL) {
4.
return;
5.
}
6.
//首先中序遍历左子树
7.
2.1 功能模块图
2.2 功能模块详解
2.2.1 建立二叉树
输入要建立的二叉树的扩展二叉树的先序遍历序列,来建立二叉树,建立成功会给出 提示。 2.2.2 遍历二叉树
执行操作之后会有四个选项可供选择:先序遍历、中序遍历、后序遍历、层序遍历。 输入对应的序号即可调动相关函数输出相应的遍历序列。 2.2.3 统计叶子节点树
10.
b->rchild = temp;
11.
swap(b->lchild);
12.
swap(b->rchild);
13. }
14. }
部分运行结果截图如下: 建立二叉树:
统计叶子节点个数:
8
求二叉树的深度:
六、参考文献
1. Stephen Prata.《C Primer Plus (第 6 版) 中文版》. 人民邮电出版社. 2016 年 2. CSDN 博客:https:// 3. 谭浩强.《C 程序设计(第四版)》.清华大学出版社. 4. 严蔚敏《数据结构》c 语言版 第二版 人民邮电出版社
作 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. }
scanf("%c", &ch); if (ch == '#') {
b = NULL; } else {
if ((b = (BiTree*)malloc(sizeof(BiTree))) != NULL) {//如果内存分配成功就执行下面操
本程序名为“二叉树基本操作的实现”,其主要为练习二叉树的基本操作而开发,其中包含了建立、遍 历、统计叶子结点和深度等一系列操作。其中定义二叉链表来表示二叉树,用一个字符类型的数据来表示 每一个节点中存储的数据。由于没有进行图形界面的设计,用户可以通过程序中的遍历二叉树一功能来查 看操作的二叉树。
二、功能模块
6
8.
temp=pop(s);
9.
printf("%c ", temp->data);
10.
if (temp->lchild) {
11.
append(s, *temp->lchild);
12.
}
13.
if (temp->rchild) {
14.
append(s, *temp->rchild);
15.
执行之后输出叶子结点的个数。 2.2.4 求二叉树深度
执行之后输出二叉树的深度。 2.2.5 子树交换
交换成功则会给出提示,用户可通过遍历二叉树来观察子树交换之后的二叉树。
三、数据结构和算法设计
3.1 二叉链表的设计
1. typedef struct BiNode {
2.
char data;
3.
struct BiNode* lchild;
7.
}
8.
getLeavesNum(b->lchild);
9.
getLeavesNum(b->rchild);
10. }
相关文档
最新文档