二叉树存储结构及实现

最新推荐文章于 2024-06-07 20:44:42 发布
最新推荐文章于 2024-06-07 20:44:42 发布
阅读量4.2k 收藏 48
点赞数 8
分类专栏： 二叉树存储结构及实现 文章标签： 二叉树 二叉树存储结构及实现 遍历 数据结构 C语言 C++

一、目的

  1. 掌握二叉树的概念及实现方式
  2. 熟悉二叉树的存储结构及运算

二、内容

  1. 编写一个程序btree.cpp，实现二叉树的基本运算，并在此基础上设计一个程序exp7-1.cpp，完成如下功能：
    （1） 由如图7.1所示的二叉树创建对应的二叉链 存储结构b，该二叉树的括号表示串为“A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,G(,I)))”；
    （2） 输出二叉树b；
    （3） 输出‘H’结点的左、右孩子结点值；
    （4） 输出二叉树b的高度；
    （5） 释放二叉树。
  2. 编写一个程序exp7-2.cpp，实现二叉树的先序遍历、中序遍历和后序遍历的递归和非递归算法，以及层次遍历的算法。并对如图7.1所示的二叉树b给出求解结果。

三、源代码

  1. 实现二叉树各种基本运算的方法
#include<stdio.h>
#include<malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node
{
	ElemType data;
	struct node *lchild;
	struct node *rchild;
}BTNode;
void CreateBTree(BTNode *&b,char *str)
{
	BTNode *St[MaxSize],*p;
	int top=-1,k,j=0;char ch;
	b=NULL;
	ch=str[j];
	while(ch!='\0')
	{
		switch(ch)
		{
		case '(':top++;St[top]=p;k=1;break;
		case ')':top--;break;
		case ',':k=2;break;
		default:p=(BTNode *)malloc(sizeof(BTNode));
			p->data=ch;p->lchild=p->rchild=NULL;
			if(b==NULL)
				b=p;
			else
			{
				switch(k)
				{
				case 1:St[top]->lchild=p;break;
				case 2:St[top]->rchild=p;break;
				}
			}
		}
		j++;ch=str[j];
	}
}
void DestroyBTree(BTNode *&b)
{
	if(b!=NULL)
	{
		DestroyBTree(b->lchild);
		DestroyBTree(b->rchild);
		free(b);
	}
}
BTNode *FindNode(BTNode *b,ElemType x)
{
	BTNode *p;
	if(b==NULL)
		return NULL;
	else if(b->data==x)
		return b;
	else
	{
		p=FindNode(b->lchild,x);
		if(p!=NULL)
			return p;
		else
			return FindNode(b->rchild,x);
	}
}
BTNode *LchildNode(BTNode *p)
{
	return p->lchild;
}
BTNode *RchildNode(BTNode *p)
{
	return p->rchild;
}
int BTHeight(BTNode *b)
{
	int lchildh,rchildh;
	if(b==NULL)return(0);
	else
	{
		lchildh=BTHeight(b->lchild);
		rchildh=BTHeight(b->rchild);
		return (lchildh>rchildh)?(lchildh+1):(rchildh+1);
	}
}
void DispBTree(BTNode *b)
{
	if(b!=NULL)
	{
		printf("%c",b->data);
		if(b->lchild!=NULL||b->rchild!=NULL)
		{
			printf("(");
			DispBTree(b->lchild);
			if(b->rchild!=NULL)printf(",");
			DispBTree(b->rchild);
			printf(")");
		}
	}
}


int main()
{
	BTNode *b,*p,*lp,*rp;
	printf("二叉树的基本运算如下：\n");
	printf("（1）创建二叉树\n");
	CreateBTree(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,G(,I)))");
	printf("（2）输出二叉树：");DispBTree(b);printf("\n");
	printf("（3）H结点：");
	p=FindNode(b,'H');
	if(p!=NULL)
	{
		lp=LchildNode(p);
		if(lp!=NULL)printf("左孩子为%c",lp->data);
		else printf("无左孩子");
		rp=RchildNode(p);
		if(rp!=NULL)printf("右孩子为%C",rp->data);
		else printf("");
	}
	printf("\n");
	printf("（4）二叉树b的高度：%d\n",BTHeight(b));
	printf("（5）释放二叉树b\n");
	DestroyBTree(b);
	return 1;
}
  1. 实现二叉树各种遍历算法
#include<stdio.h>
#include<malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node
{
	ElemType data;
	struct node *lchild;
	struct node *rchild;
}BTNode;
void CreateBTree(BTNode *&b,char *str)
{
	BTNode *St[MaxSize],*p;
	int top=-1,k,j=0;char ch;
	b=NULL;
	ch=str[j];
	while(ch!='\0')
	{
		switch(ch)
		{
		case '(':top++;St[top]=p;k=1;break;
		case ')':top--;break;
		case ',':k=2;break;
		default:p=(BTNode *)malloc(sizeof(BTNode));
			p->data=ch;p->lchild=p->rchild=NULL;
			if(b==NULL)
				b=p;
			else
			{
				switch(k)
				{
				case 1:St[top]->lchild=p;break;
				case 2:St[top]->rchild=p;break;
				}
			}
		}
		j++;ch=str[j];
	}
}
void DestroyBTree(BTNode *&b)
{
	if(b!=NULL)
	{
		DestroyBTree(b->lchild);
		DestroyBTree(b->rchild);
		free(b);
	}
}
BTNode *FindNode(BTNode *b,ElemType x)
{
	BTNode *p;
	if(b==NULL)
		return NULL;
	else if(b->data==x)
		return b;
	else
	{
		p=FindNode(b->lchild,x);
		if(p!=NULL)
			return p;
		else
			return FindNode(b->rchild,x);
	}
}
BTNode *LchildNode(BTNode *p)
{
	return p->lchild;
}
BTNode *RchildNode(BTNode *p)
{
	return p->rchild;
}
int BTHeight(BTNode *b)
{
	int lchildh,rchildh;
	if(b==NULL)return(0);
	else
	{
		lchildh=BTHeight(b->lchild);
		rchildh=BTHeight(b->rchild);
		return (lchildh>rchildh)?(lchildh+1):(rchildh+1);
	}
}
void DispBTree(BTNode *b)
{
	if(b!=NULL)
	{
		printf("%c",b->data);
		if(b->lchild!=NULL||b->rchild!=NULL)
		{
			printf("(");
			DispBTree(b->lchild);
			if(b->rchild!=NULL)printf(",");
			DispBTree(b->rchild);
			printf(")");
		}
	}
}














void PreOrder(BTNode *b)
{
	if(b!=NULL)
	{
		printf("%C",b->data);
		PreOrder(b->lchild);
		PreOrder(b->rchild);
	}
}
void PreOrder1(BTNode *b)
{
	BTNode *St[MaxSize],*p;
	int top=-1;
	if(b!=NULL)
	{
		top++;
		St[top]=b;
		while(top>-1)
		{
			p=St[top];
			top--;
			printf("%C",p->data);
			if(p->rchild!=NULL)
			{
				top++;
				St[top]=p->rchild;
			}
			if(p->lchild!=NULL)
			{
				top++;
				St[top]=p->lchild;
			}
		}
		printf("\n");
	}
}
void InOrder(BTNode *b)
{
	if(b!=NULL)
	{
		InOrder(b->lchild);
		printf("%c",b->data);
		InOrder(b->rchild);
	}
}
void InOrder1(BTNode *b)
{
	BTNode *St[MaxSize],*p;
	int top=-1;
	if(b!=NULL)
	{
		p=b;
		while(top>-1||p!=NULL)
		{
			while(p!=NULL)
			{
				top++;
				St[top]=p;
				p=p->lchild;
			}
			if(top>-1)
			{
				p=St[top];
				top--;
				printf("%c",p->data);
				p=p->rchild;
			}
		}
		printf("\n");
	}
}
void PostOrder(BTNode *b)
{
	if(b!=NULL)
	{
		PostOrder(b->lchild);
		PostOrder(b->rchild);
		printf("%c",b->data);
	}
}
void PostOrder1(BTNode *b)
{
	BTNode *St[MaxSize];
	BTNode *p;
	int top=-1;
	bool flag;
	if(b!=NULL)
	{
		do
		{
			while(b!=NULL)
			{
				top++;
				St[top]=b;
				b=b->lchild;
			}
			p=NULL;
			flag=true;
			while(top!=-1&&flag)
			{
				b=St[top];
				if(b->rchild==p)
				{
					printf("%c",b->data);
					top--;
					p=b;
				}
				else
				{
					b=b->rchild;
					flag=false;
				}
			}
		}while(top!=-1);
		printf("\n");
	}
}
void TravLevel(BTNode *b)
{
	BTNode *Qu[MaxSize];
	int front,rear;
	front=rear=0;
	if(b!=NULL)printf("%c",b->data);
	rear++;
	Qu[rear]=b;
	while(rear!=front)
	{
		front=(front+1)%MaxSize;
		b=Qu[front];
		if(b->lchild!=NULL)
		{
			printf("%c",b->lchild->data);
			rear=(rear+1)%MaxSize;
			Qu[rear]=b->lchild;
		}
		if(b->rchild!=NULL)
		{
			printf("%c",b->rchild->data);
			rear=(rear+1)%MaxSize;
			Qu[rear]=b->rchild;
		}
	}
	printf("\n");
}
int main()
{
	BTNode *b;
	CreateBTree(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
	printf("二叉树b：");DispBTree(b);printf("\n");
	printf("层次遍历序列：");
	TravLevel(b);
	printf("先序遍历序列：\n");
	printf("		递归算法：");PreOrder(b);printf("\n");
	printf("	非递归算法：");PreOrder1(b);
	printf("中序遍历序列：\n");
	printf("		递归算法：");InOrder(b);printf("\n");
	printf("	非递归算法：");InOrder1(b);
	printf("后序遍历序列：\n");
	printf("		递归算法：");PostOrder(b);printf("\n");
	printf("	非递归算法：");PostOrder1(b);
	DestroyBTree(b);
	return 1;
}

备注：
有问题可以评论，看到后我会尽力及时回复的，谢谢！

ID：1024
关注
  • 8
    点赞
  • 踩
  • 48
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
编写一个程序btree.cpp， 实现二叉树基本运算
xx7755223的博客
10-17 1万+
（验证性实验）实现二叉树的各种基本运算的算法 编写一个程序btree.cpp， 实现二叉树基本运算，并在此基础上设计一个程序exp5-1.cpp，完成如下功能。由图所示的二叉树创建对应的二叉链存储结构b，叉树的括号表示串为“A(B(D,E(H(J,K(L,M(,N))))),C(,I)))”输出二叉树b输出‘H’结点的左、右孩子结点值输出二叉树b的高度释放二叉树b 代码如下 btree //二叉树的基本运算算法 #include <stdio.h>#include <malloc.h
二叉树及其存储结构
weixin_49350820的博客
07-30 310
1.二叉树的定义 二叉树T是一个有限的结点集合，集合可以为空，如果集合不是空集，则二叉树是由根结点和其左子树TL以及右子树TR组成的，其中TL和TR互不相交且皆是二叉树。 1.1二叉树的五种基本形态 a为空树，b只有根结点，c和d分别为左子树和右子树。 1.2特殊二叉树 斜二叉树（Skewed Binary Tree） 完美二叉树（Perfect Binary Tree）或满二叉树（Full Binary Tree） 完全二叉树（Complete Binary Tree） 完全二叉树是指：若二叉树有n
二叉树家谱关系实验报告
weixin_45706341的博客
12-06 7236
用二叉树表示家谱关系并实现各种查找功能 编写一个程序exp7-9.cpp，采用一棵二叉树表示一个家谱关系（由若干家谱记录构成，每个家谱记录由父亲、母亲和儿子的姓名构成，其中姓名是关键字），要求程序具有以下功能。 （1）文件操作功能：家谱记录的输入，家谱记录的输出，清除全部文件记录和将家谱记录存盘。要求在输入家谱记录时按从祖先到子孙的顺序输入，第一个家谱记录的父亲域为所有人的祖先。 （2）家谱操作功能：用括号表示法输出家谱二叉树，查找某人的所有儿子，查找某人的所有祖先（这里的祖先是指所设计的二叉树结构中某结点
实验四 二叉树基本操作的实现
12-25
实验四 二叉树基本操作的实现 二叉树概念及其存储结构 二叉链储存结构的二叉树基本操作 举例说明什么样的二叉树采用顺序存储，什么样的二叉树采用二叉链存储
数据结构 实验报告（二）
最新发布
Vitalis的博客
06-07 692
编写一个程序exp7-3.cpp，实现由先序序列和中序序列以及由中序序列和后序序列构造一棵二叉树的功能（二叉树种的每个结点值为单个字符），要求以括号表示和凹入表示法输出该二叉树，并用先序遍历序列“ABDEHJKLMNCFGI”和中序遍历序列“DBJHLKMNEAFCGI”以及由中序遍历序列“DBJHLKMNEAFCGI”和后序遍历序列“DJLNMKHEBFIGCA”进行验证。编写一个程序exp7-5.cpp，构造一棵哈夫曼树，输出对应的哈夫曼编码和平均查找长度，并对下表（表7.8）所示的数据进行验证。
数据结构实验二 :二叉树的操作与实现
imbzz的博客
01-31 2986
数据结构实验二 :二叉树的操作与实现
实现二叉树的各种基本运算的算法
wzq_030123的博客
11-30 4325
实现二叉树的各种基本运算的算法
实验七--二叉链的基本操作
horizon08的博客
05-21 3158
【目的】1. 领会二叉链存储结构；掌握二叉树的各种基本运算和构造二叉树的算法设计。 2. 领会线索二叉树的构造过程以及构造线索二叉树的算法设计。 【内容及要求】编写程序实现两种方式建立二叉树： 编写一个程序btree.cpp，实现二叉树的基本运算，并在此基础上设计一个程序完成以下功能：(见教材P247，实验题1) (1)由图7.33所示的二叉树创建对应的二叉链存储结构b，该二叉树的括号表示串为“A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”。 (2)输出二叉树b。(采用凹入表
二叉树的存储结构及遍历
代码演奏家
11-19 725
实验四：二叉树的存储结构及遍历 实验项目名称：二叉树的存储结构及遍历 实验目的及要求： 实验目的 （1）理解二叉树的存储结构的表示和运算的C语言实现。 （2）掌握二叉树的先序遍历、中序遍历、后序遍历及层次遍历。 要求： （1）设计二叉树的二叉链表存储结构（动态分配存储空间）。 （2）数据元素为字符类型。 （3）创建二叉树的二叉链表。 （4）实现对二叉树的先序遍历、中序遍历、后序遍历及层次遍历算法。 3.实验原理 对于任意的二叉树来说，每个结点只有两个孩子，一个双亲结点。我们可以设计每个结点至少包括三个域：
二叉树建立及遍历算法实现
06-03
建立二叉树，实现二叉树的先序、中序、后序的递归遍历算法，输出遍历结果。 实现二叉树的先序、中序、后序和层次遍历的非递归算法，输出遍历结果。
JAVA 实现二叉树（链式存储结构）
09-02
在本文中，我们将探讨如何使用Java来实现一个二叉树，采用的是链式存储结构。 首先，我们来看链式存储结构在二叉树中的应用。链式存储结构是通过节点间的引用或指针连接各个节点，而不是像顺序存储结构那样使用数组...
头歌数据结构二叉树的顺序存储及基本操作
05-18
总的来说，顺序存储的二叉树是一种简化了内存管理的数据结构，适用于静态二叉树或已知结构的二叉树，它可以简化存储和遍历操作，但灵活性较低。在实际应用中，我们还需要考虑其他存储方式，如链式存储，以适应更复杂...
数据结构二叉树，c语言简单实现
01-12
在C语言中实现二叉树，我们需要定义一个结构体来表示二叉树节点，一般包括两个指针域，分别存储左右子节点，以及一个数据域存储实际的数据。以下是一个基本的二叉树节点定义： ```c typedef struct TreeNode { int...
Python实现基于二叉树存储结构的堆排序算法示例
09-21
在二叉树存储结构中，调整堆通常涉及节点的交换，这个过程在上述代码中并未直接展示，但可以通过递归的方式实现。当需要交换两个节点时，需要考虑它们的父节点和子节点，确保交换后依然满足堆的性质。在实际应用中，...
二叉树各种基本运算的算法
小宋的博客
11-22 3575
【代码】 #include #include #define MaxSize 100 typedef char ElemType; typedef struct node { ElemType data; //数据元素 struct node *lchild; //指向左孩子节点 struct node *rchild; //指向右孩子节点 } BTNode; void Cre
#头歌 数据结构 实验六 树和二叉树
千浔的博客
12-31 1535
/创建二叉树//St数组作为顺序栈//top作为栈顶指针char ch;b=NULL;//初始时二叉链为空ch=str[j];while(ch!='\0')St[top]=p;k=1;break;//处理左孩子break;//栈顶的子树处理完毕break;//开始处理右孩子default://创建一个结点由p指向它p->data=ch;//存放结点值//左右指针都置为空if(b==NULL) //若尚未建立根结点b=p;
c++实现---二叉树先序、中序、后序遍历的递归与非递归实现以及层次遍历
Fizz6018的博客
09-02 764
二叉树先序、中序、后序遍历的递归与非递归实现以及层次遍历。 #include<iostream> #include<vector> #include<stack> #include<queue> using namespace std; vector<vector<int>> res; vector<int> help; struct TreeNode { int val; struct TreeNode *left;
第28天 ----对二叉树的学习
Bkhole的博客
02-17 363
时隔十一天，重新开始学习 对链串的基本学习 创建、销毁、输出、查找结点、找孩子结点、求树高。 今天干了260行！ 具体内容以及分析老规矩都在代码中 代码如下：---分为两部分 第一部分：自创头文件"btree.h"---------主要内容 //二叉树的基本运算算法 #define _CRT_SECURE_NO_WARNINGS #define MAXSIZE 50 #define ElemType char #include <stdio.h> #include <s
C++实现二叉树 前、中、后序遍历（递归与非递归）
qq_35692267的博客
02-28 254
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/czy47/article/details/81254984 ———————————————— ...
二叉树存储结构及遍历c语言实现
04-25
二叉树可以用链式存储结构或者数组存储结构来实现。下面是链式存储结构的实现： ```c typedef struct Node { int data; struct Node *leftChild; struct Node *rightChild; } Node; // 前序遍历 void preOrder...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值