二叉树的基本操作

最新推荐文章于 2024-07-09 18:04:44 发布
最新推荐文章于 2024-07-09 18:04:44 发布
阅读量72 收藏
点赞数
文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52116472/article/details/134542669
版权

1.实现二叉树的各种基本运算7.1，进而完成二叉树的各种遍历应用7.2。（递归和层次遍历）
2.根据表7.8中单词及出现的频度，构造哈夫曼树，输出对应的哈夫曼编码。

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;//St数组作为顺序栈
	int top=-1,k,j=0;//top为栈顶指针
	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) //查找值为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)		//求二叉树b的高度
{
int lchild,rchild;
if(b==NULL) return 0;
else
{
    lchild=BTHeight(b->lchild);
     rchild=BTHeight(b->rchild);
     return (lchild>rchild)?(lchild+1):(rchild+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(,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;
}
2.代码如下：
#include <iostream>
#define MaxSize 100
using namespace std;
typedef char ElemType;
typedef struct node{
ElemType data;//数据元素
struct node *lchild;//指向左孩子结点
struct node *rchild;//指向右孩子结点
}BTNode;
typedef struct
{
    BTNode *data[MaxSize];//存放队中元素
    int front,rear;//队头和队尾指针
}SqQueue;//顺序队类型
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];
	BTNode *p;
	int top=0;
  do{
    while(b)               //根指针t表示的为非空二叉树
    {
      St[top++]=b;             //根指针进栈
      b=b->lchild;           //t移向左子树
     }   //循环结束表示以栈顶元素的指向为根结点的二叉树
         
    if (top)                    //为非空栈
    { b=St[--top];             //弹出根指针
      printf("%c ",b->data);    //访问根结点
      b=b->rchild;             //遍历右子树
     }
   } while(top||b);//父结点未访问，或右子树未遍历
   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)					//将b结点的所有左下结点进栈
			{
				top++;
				St[top]=b;
				b=b->lchild;
			}
			p=NULL;							//p指向当前结点的前一个已访问的结点
			flag=true;						//flag为真表示正在处理栈顶结点
			while (top!=-1 && flag)
			{
				b=St[top];					//取出当前的栈顶元素
				if (b->rchild==p)			//右子树不存在或已被访问,访问之
				{
					printf("%c ",b->data);	//访问b结点
					top--;
					p=b;					//p指向则被访问的结点
				}
				else
				{
					b=b->rchild;			//b指向右子树
					flag=false;				//表示当前不是处理栈顶结点
				}
			}
		} while (top!=-1);
		printf("\n");
	}
}
void InitQueue(SqQueue *&q)
{
  q=(SqQueue*)malloc(sizeof(SqQueue));
  q->front=q->rear=-1;
}
void DestroyQueue(SqQueue *&q)//销毁队列
{
    free(q);
}
bool enQueue(SqQueue *&q,BTNode *e)		//进队列
{	if ((q->rear+1)%MaxSize==q->front)	//队满上溢出
		return false;
	q->rear=(q->rear+1)%MaxSize;
	q->data[q->rear]=e;
	return true;
}
bool deQueue(SqQueue *&q,BTNode *&e)	//出队列
{	if (q->front==q->rear)				//队空下溢出
		return false;
	q->front=(q->front+1)%MaxSize;
	e=q->data[q->front];
	return true;
}
bool QueueEmpty(SqQueue *q)//判断为空
{
    return (q->front==q->rear);
}
void LevelOrder(BTNode *b)
{
	BTNode *p;
	SqQueue *qu;
	InitQueue(qu);					//初始化队列
	enQueue(qu,b);					//根结点指针进入队列
	while (!QueueEmpty(qu))			//队不为空循环
	{
		deQueue(qu,p);				//出队节点p
		printf("%c ",p->data);		//访问节点p
		if (p->lchild!=NULL)		//有左孩子时将其进队
			enQueue(qu,p->lchild);
		if (p->rchild!=NULL)		//有右孩子时将其进队
			enQueue(qu,p->rchild);
	}
}
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);
    }
}
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;
    CreateBTree(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
    printf("二叉树为：");
    DispBTree(b);
    printf("\n");
    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);
	printf("层次遍历序列:");
	LevelOrder(b);
	DestroyBTree(b);
    return 0;
}
3.代码如下：
#include <stdio.h>
#include <string.h>
#define N 50		//叶子结点数
#define M 2*N-1		//树中结点总数
typedef struct
{
	char data[5];	//结点值
   double weight;//权重
   int lchild;//左孩子
   int rchild;//右孩子
   int parent;//双亲结点
} HTNode;
typedef struct
{
	 char cd[N];		//存放哈夫曼码
	 int start;
} HCode;
void CreateHT(HTNode ht[],int n)  //由ht的叶子结点构造完整的哈夫曼树
{
	int i,k,lnode,rnode;
	double min1,min2;
	for(i=0;i<=2*n-1;i++)
        ht[i].parent=ht[i].lchild=ht[i].rchild=-1;
    for(i=n;i<=2*n-2;i++)
     {
           min1=min2=32767;
           lnode=rnode=-1;
           for(k=0;k<=i-1;k++)
            if(ht[k].parent==-1)
           {
               if(ht[k].weight<min1)
               {
                   min2=min1;
                   rnode=lnode;
                   min1=ht[k].weight;
                   lnode=k;
               }
               else if(ht[k].weight<min2)
               {
                   min2=ht[k].weight;
                   rnode=k;
               }
           }
           ht[i].weight=ht[lnode].weight+ht[rnode].weight;
           ht[i].lchild=lnode;
           ht[i].rchild=rnode;
           ht[lnode].parent=i;
           ht[rnode].parent=i;
     }
}
void CreateHCode(HTNode ht[],HCode hcd[],int n)	//由哈夫曼树ht构造哈夫曼编码hcd
{
int i,f,c;
HCode hc;
for(i=0;i<n;i++)
{
    hc.start=n;
    c=i;
    f=ht[i].parent;
    while(f!=-1)
    {
        if(ht[f].lchild==c)
            hc.cd[hc.start--]='0';
        else
            hc.cd[hc.start--]='1';
        c=f;
        f=ht[f].parent;
    }
    hc.start++;
    hcd[i]=hc;
}
}
void DispHCode(HTNode ht[],HCode hcd[],int n)	//输出哈夫曼编码
{
	int i,k;
	int sum=0,m=0,j;
	printf("输出哈夫曼编码:\n");
	for (i=0;i<n;i++)
	{
		j=0;
		printf("          %s:\t",ht[i].data);
		for (k=hcd[i].start;k<=n;k++)
		{
			printf("%c",hcd[i].cd[k]);
			j++;
		}
		m+=ht[i].weight;
		sum+=ht[i].weight*j;
		printf("\n");
	}
	printf("平均长度=%g\n",1.0*sum/m);
}
int main()
{
	int n=15,i;
	char *str[]={"The","of","a","to","and","in","that","he","is","at","on","for","His","are","be"};//定义单词字符数组
	double fnum[]={1192,677,541,518,462,450,242,195,190,181,174,157,138,124,123};//定义每个单词字符的使用频率数组
	HTNode ht[M];
	HCode hcd[N];
	for (i=0;i<n;i++)//完成n个叶子结点的初始化
	{
		strcpy(ht[i].data,str[i]);
		//ht[i].data=str[i];
		ht[i].weight=fnum[i];
	}
	CreateHT(ht,n);
	CreateHCode(ht,hcd,n);
	DispHCode(ht,hcd,n);
	return 1;
}

如有不足，请指教

xx小寂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
二叉树基本操作实验
CS@zeny的博客
11-20 1220
数据结构(实验报告)–二叉树 二叉树的基本操作 实验目的： 理解二叉树的定义 掌握二叉树的链式存储结构 掌握二叉树基本操作的递归算法 实验内容： 先序创建二叉树； 分别实现二叉树的先序、中序、后序递归遍历； 如果将空孩子显示为‘#’,实现二叉树的先序递归遍历 统计二叉树的结点数和叶结点数（写在同一个函数里）； 计算二叉树的深度； 交换二叉树的左右子树； 销毁二叉树。 实验代码 #include <stdio.h> #include <malloc.h&g
二叉树基本操作实现
qq_43710269的博客
04-16 3567
链式二叉树 数组表示二叉树要求二叉树必须是完全二叉树或者是满二叉树，所以二叉树还可以用链式表示其结构代码如下： typedef int DataType; typedef struct BinaryTree{ struct BinaryTree* _left; struct BinaryTree* _right; DataType data; };BTNode 前序遍历 前序遍历的顺序为根，左子树，右子树，所以也被称为先根遍历。 如图以这个二叉树为例： 这
C语言二叉树基本操作
qq_27638851的博客
08-30 2228
【代码】C语言二叉树基本操作。
二叉树基本操作
奔赴在热爱征程上的小小孩~
10-26 703
二叉树的操作
二叉树基本操作演示程序C语言编写
qq_59536908的博客
06-17 5297
问题描述：设计一个与二叉树基本操作相关的演示程序要求：开发工具Dev C++ c语言编写1.创建二叉树。2.将创建的二叉树，以树状形式输出。3.分别以先序、中序、后序三种遍历方式访问二叉树。4.输出二叉树中的叶子结点以及叶子结点的个数。5.输出二叉树的高度。.........
二叉树基本操作代码
qq_42862882的博客
04-30 5091
import java.io.UnsupportedEncodingException; import java.util.*; public class treeTest { public static void main(String[] args) throws ClassNotFoundException, UnsupportedEncodingException { // ...
二叉树基本操作（16个）
weixin_63003502的博客
04-28 3132
二叉树基本操作（16个）
C站万字详解二叉树基本操作演示程序（附图）
weixin_46103589的博客
01-01 3796
文章目录一、实验环境二、设计需求分析三、实际设计思路四、对象与功能剖析五、代码实现及算法思路分析BinaryTree包【二叉树节点类（TreeNode）】【二叉树类（Tree）】【字母二叉树类（LetterTree）】【数字二叉树类（NumTree）】Function包【退出类（Exit）】【创建二叉树类（ConstructTree）】【打印二叉树类（PrintTree）】【二叉树高度类（GetHeight）】【叶子点个数类（GetLeafSize）】【叶子结点打印类（LeafNode）】【前序遍历类（Pr
数据结构之二叉树基本操作
weixin_43644527的博客
01-15 1351
#include<iostream> using namespace std; #define END "#"//结束标志 //使用二叉链表方式定义二叉树结构 typedef char ElemType; typedef struct BtNode { BtNode* leftchild;//左孩子 BtNode* rightchild;//右孩子 ElemType data;//数据域 }BtNode,*BinaryTree; ...
二叉树-基于C语言实现的二叉树基本操作.zip
04-26
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。 在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...
二叉树基本操作_二叉树基本操作_
10-02
二叉树的基本操作主要包括创建、查找、插入和删除节点，这些操作对于理解和掌握二叉树至关重要。接下来，我们将详细讨论这些操作。 1. **创建二叉树** 创建一个二叉树首先需要定义二叉树节点的数据结构。在链表...
二叉树基本操作的程序实现.zip_二叉树的基本操作
09-21
这篇文档“二叉树基本操作的程序实现”涵盖了二叉树的一些核心概念和基本操作，旨在帮助初学者理解并实现这些概念。 二叉树由节点构成，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树的主要类型有...
实验四 二叉树基本操作的实现
12-18
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉树，并实现其基本操作。二叉树是一种非线性的数据结构，它由一个有限集合的节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验...
数据结构--树和二叉树的一些知识点总结
最新发布
weixin_68489989的博客
07-09 434
数据结构--树和二叉树的一些知识点总结
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 670
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
Redis教程(二十三)：Redis的底层数据结构
十三月的博客
07-09 1490
Redis是一种高性能的key-value数据库，广泛用于缓存、消息队列、应用程序会话管理等领域。它之所以能提供高效的数据操作性能，很大程度上归功于其底层使用了多种优化过的数据结构来存储数据。
数据结构--顺序表
LH__1314的博客
06-30 5118
当我们想要使⽤大量使⽤同⼀类型的数据时，通过⼿动定义⼤量的独立的变量对于程序来说，可读性非常差，我们可以借助数组这样的数据结构将⼤量的数据组织在⼀起，结构也可以理解为组织数据的方式。在使用完顺序表后，就要销毁顺序表，因为动态顺序表内存是动态开辟的，所以需要对动态内存进行释放，并将有效数据和空间容量个数置为0；到这里，顺序表的知识就完成了，学完这些，我们也要写顺序表的实践，就是通讯录——在下一篇进行实现。求数组的长度，求数组的有效数据个数，向下标为数据有效个数的位置插入数据（注意：这里是。
二叉树基本操作的实现
10-25
下面是二叉树基本操作的实现方法： 1. 创建二叉树：通过前序遍历的数组构建二叉树，其中 '#' 表示空节点。具体实现方法可以参考引用中的 BinaryTreeCreate 函数。 2. 销毁二叉树：遍历二叉树，依次释放每个节点的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值