实验二 二叉树的操作与实现

最新推荐文章于 2024-01-22 20:13:20 发布
最新推荐文章于 2024-01-22 20:13:20 发布
阅读量1.9k 收藏 26
点赞数 4
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43655282/article/details/104442815
版权

前言

记录实验，同时也是记录常见数据结构算法的实现。

广州大学学生实验报告

开课实验室：计算机科学与工程实验（电子楼416A）
学院 计算机科学与网络工程学院
实验课程 数据结构实验
实验项目 实验二 二叉树的操作与实现

#include <iostream>
using namespace std;

int leave_counts = 0;

//-----二叉树的二叉链表表示-----
typedef struct BiTNode
{
   char data;
   BiTNode* lchild, * rchild;
}BiTNode, *BiTree;

//-----先序遍历建立二叉树-----
void CreatBiTNode(BiTree& T,const char *str)
{
   BiTNode* ParentTNode[20], * p = NULL;
   int top = -1, k=0, j = 0;
   char ch;
   T = NULL;
   ch = str[j];
   while (ch != '\0')
   {
   	switch (ch)
   	{
   	case'(':top++; ParentTNode[top] = p; k = 1; break;
   	case')':top--; break;
   	case',':k = 2; break;
   	default: p = new BiTNode;
   		p->data = ch;
   		p->lchild = NULL;
   		p->rchild = NULL;
   		if (T == NULL) T = p;
   		switch (k)
   		{
   		case 1:ParentTNode[top]->lchild = p; break;
   		case 2:ParentTNode[top]->rchild = p; break;
   		}
   	}
   	j++;
   	ch = str[j];
   }
}

//-----查找某节点-----
BiTNode* FindTNodeChild(BiTree T, char ch)
{
   BiTNode* p;
   if (T == NULL) return NULL;
   else if (T->data == ch)
   	return T;
   else
   {
   	p = FindTNodeChild(T->lchild, ch);
   	if ( p!= NULL)
   		return p;
   	else
   		return FindTNodeChild(T->rchild, ch);
   }
}

//-----先序遍历输出二叉树-----
void ShowBiTree(BiTree T)
{
   if (T)
   {
   	cout << T->data;
   	ShowBiTree(T->lchild);
   	ShowBiTree(T->rchild);
   }
}

//-----输出二叉树的结点个数-----
int NodeCount(BiTree &T)
{
   if (T == NULL) return 0;
   else return NodeCount(T->lchild) + NodeCount(T->rchild)+1;
}

//-----输出二叉树的度-----
int DegreeCount(BiTree T)
{
   return NodeCount(T) - 1;
}

//-----输出二叉树的叶子数-----
int LeaveCount(BiTree T)
{
   if (T != NULL)
   {
   	if (T->lchild == NULL && T->rchild == NULL)
   		leave_counts ++;
   	LeaveCount(T->lchild);
   	LeaveCount(T->rchild);
   	return leave_counts;
   }
}


//-----输出二叉树的深度-----
int DepthOfTree(BiTree T)
{
   if (T == NULL) return 0;
   else
   {
   	int depth_l = DepthOfTree(T->lchild);
   	int depth_r = DepthOfTree(T->rchild);
   	if (depth_l <= depth_r) return depth_r + 1;
   	else return depth_l + 1;
   }
}

int main()
{
   BiTree T = new BiTNode;
   const char* ch = "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))\0";
   CreatBiTNode(T,ch);

   //先序遍历输出
   cout << "先序遍历输出：";
   ShowBiTree(T);
   //输出A的左右孩子
   BiTNode* p = FindTNodeChild(T,'A');
   if (p->lchild != NULL && p->rchild != NULL) cout << "\n结点A的左孩子：" << p->lchild->data << "\t右孩子：" << p->rchild->data<<endl;
   else if (p->lchild != NULL && p->rchild == NULL)cout << "结点A的左孩子：" << p->lchild->data;
   else if(p->lchild == NULL && p->rchild != NULL) cout << "结点A的右孩子：" << p->lchild->data;
   //结点数
   cout << "结点数: " << NodeCount(T) << endl;
   //叶子数
   cout << "叶子数: " << LeaveCount(T) << endl;
   //度
   cout << "度: " << DegreeCount(T) << endl;
   //深度
   cout << "深度" << DepthOfTree(T) << endl;
}

2、二叉树的各种遍历算法实现 （返回目录🖱）

#include <iostream>
using namespace std;

int leave_counts = 0;

//-----二叉树的二叉链表表示-----
typedef struct BiTNode
{
	char data;
	BiTNode* lchild, * rchild;
}BiTNode, * BiTree;

//-----用栈来实现二叉链表的非递归-----
typedef struct BiTNodeStack
{
	BiTNode* data;
	BiTNodeStack* next;
}BiTNodeStack,*BiTStack;
//-----初始化栈-----
void InitStack(BiTStack& s)
{
	s = new BiTNodeStack;
	s->data = NULL;
	s->next = NULL;
}
//-----弹出-----
BiTNode* Pop(BiTStack s)
{
	BiTNodeStack* p = new BiTNodeStack;
	p = s->next;
	s->next = p->next;
	return p->data;
}
//-----放入-----
void Push(BiTStack &s,BiTNode *p)
{
	BiTNodeStack* sp = new BiTNodeStack;
	sp->data = p;
	sp->next = s->next;
	s->next = sp;
}

//-----先序遍历建立二叉树-----
void CreatBiTNode(BiTree& T, const char* str)
{
	BiTNode* ParentTNode[20], * p = NULL;
	int top = -1, k = 0, j = 0;
	char ch;
	T = NULL;
	ch = str[j];
	while (ch != '\0')
	{
		switch (ch)
		{
		case'(':top++; ParentTNode[top] = p; k = 1; break;
		case')':top--; break;
		case',':k = 2; break;
		default: p = new BiTNode;
			p->data = ch;
			p->lchild = NULL;
			p->rchild = NULL;
			if (T == NULL) T = p;
			switch (k)
			{
			case 1:ParentTNode[top]->lchild = p; break;
			case 2:ParentTNode[top]->rchild = p; break;
			}
		}
		j++;
		ch = str[j];
	}
}


//-----递归先序遍历输出二叉树-----
void ShowBiTree_preorder(BiTree T)
{
	if (T)
	{
		cout << T->data;
		ShowBiTree_preorder(T->lchild);
		ShowBiTree_preorder(T->rchild);
	}
}
//-----非递归先序遍历输出二叉树-----
void ShowBiTree_preorder_0(BiTree T)
{
	BiTNode* p = new BiTNode;
	p = T;
	BiTStack s;
	InitStack(s);
	while (p || s->next != NULL)
	{
		while (p)
		{
			cout << p->data;
			Push(s, p);
			p = p->lchild;
		}
		if (s->next != NULL)
		{
			p = Pop(s);
			p = p->rchild;
		}
	}
}
//-----递归中序遍历输出二叉树-----
void ShowBiTree_inorder(BiTree T)
{
	if (T)
	{
		ShowBiTree_inorder(T->lchild);
		cout << T->data;
		ShowBiTree_inorder(T->rchild);
	}
}
//-----非递归中序遍历输出二叉树-----
void ShowBiTree_inorder_0(BiTree T)
{
	BiTNode* p = new BiTNode;
	p = T;
	BiTStack s ;
	InitStack(s);
	while (p || s->next != NULL)
	{
	
		if (p)
		{
			Push(s, p);
			p = p->lchild;
		}
		else
		{
			BiTNode* q = new BiTNode;
			q = Pop(s);
			cout << q->data;
			p = q->rchild;
		}
	}
}

//-----递归后序遍历输出二叉树-----
void ShowBiTree_postorder(BiTree T)
{
	if (T)
	{
		ShowBiTree_postorder(T->lchild);
		ShowBiTree_postorder(T->rchild);
		cout << T->data;
	}
}
//-----非递归后序遍历输出二叉树-----
void ShowBiTree_postorder_0(BiTree T)
{
	BiTNode* p = new BiTNode;
	p = T;
	BiTStack s1,s2;
	InitStack(s1);
	InitStack(s2);
	while (p || s1->next != NULL)
	{
		while (p)
		{
			Push(s2, p);
			Push(s1, p);
			p = p->rchild;
		}
		if (s1->next != NULL)
		{
			p = Pop(s1);
			p = p->lchild;
		}
	}
	while (s2->next != NULL)
	{
		p = Pop(s2);
		cout << p->data;
	}
}



int main()
{
	BiTree T = new BiTNode;
	const char* ch = "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))\0";
	CreatBiTNode(T, ch);

	//递归先序遍历输出
	cout << "先序遍历输出：";
	ShowBiTree_preorder(T);
	cout <<" (递归)"<<endl;
	//非递归先序遍历输出
	cout << "先序遍历输出：";
	ShowBiTree_preorder_0(T);
	cout << " (非递归)" << endl<<"----------------"<<endl;

	//递归中序遍历输出
	cout << "中序遍历输出：";
	ShowBiTree_inorder(T);
	cout << " (递归)" << endl;
	//非递归中序遍历输出
	cout << "中序遍历输出：";
	ShowBiTree_inorder_0(T);
	cout << " (非递归)" << endl << "----------------" << endl;

	//递归后序遍历输出
	cout << "后序遍历输出：";
	ShowBiTree_postorder(T);
	cout << " (递归)" << endl;
	//非递归后序遍历输出
	cout << "后序遍历输出：";
	ShowBiTree_postorder_0(T);
	cout << " (非递归)" << endl;
	
}

3、线索二叉树的遍历 （返回目录🖱）

#include<iostream>
using namespace std;

//-----线索二叉树-----
typedef struct BiThrNode
{
	char data;
	BiThrNode* lchild, * rchild;
	int LTag, RTag;
}BiThrNode,*BiThrTree;

BiThrNode* pre = new BiThrNode; // 全局变量pre
//-----先序遍历建立二叉树-----
void CreatBiTNode(BiThrTree& T, const char* str)
{
	BiThrNode* ParentTNode[20], * p = NULL;
	int top = -1, k = 0, j = 0;
	char ch;
	T = NULL;
	ch = str[j];
	while (ch != '\0')
	{
		switch (ch)
		{
		case'(':top++; ParentTNode[top] = p; k = 1; break;
		case')':top--; break;
		case',':k = 2; break;
		default: p = new BiThrNode;
			p->data = ch;
			p->lchild = NULL;
			p->rchild = NULL;
			if (T == NULL) T = p;
			switch (k)
			{
			case 1:ParentTNode[top]->lchild = p; break;
			case 2:ParentTNode[top]->rchild = p; break;
			}
		}
		j++;
		ch = str[j];
	}
}

//-----中序线索化二叉树-----
void InThreading(BiThrTree p)
{
	pre->LTag = 0;
	pre->RTag = 0;
	pre->rchild = NULL;
	if (p)
	{
		InThreading(p->lchild);
		if (!p->lchild)
		{
			p->LTag = 1;
			p->lchild = pre;
		}
		else p->LTag = 0;
		if (!pre->rchild)
		{
			pre->RTag = 1;
			pre->rchild = p;
		}
		else pre->RTag = 0;
		pre = p;
		InThreading(p->rchild);
	}
}

//-----带头结点的二叉树中序线索化-----
void InOrderThreading(BiThrTree& Thrt, BiThrTree T)
{
	Thrt = new BiThrNode;
	Thrt->LTag = 0;
	Thrt->RTag = 1;
	Thrt->rchild = Thrt;
	if (!T) Thrt->lchild = Thrt;
	else
	{
		Thrt->lchild = T; 
		pre = Thrt;
		InThreading(T);
		pre->rchild = Thrt;
		pre->RTag = 1;
		Thrt->rchild = pre;
	}
}

//-----先序遍历输出二叉树-----
void ShowBiTree(BiThrTree T)
{
	if (T)
	{
		cout << T->data;
		ShowBiTree(T->lchild);
		ShowBiTree(T->rchild);
	}
}

int main()
{
	BiThrTree T = new BiThrNode;
	const char* ch = "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";
	
	//先序遍历构造二叉树
	CreatBiTNode(T, ch);

	//二叉树中序线索化
	BiThrTree Thrt = new BiThrNode;
	InOrderThreading(Thrt, T);

	//输出根节点的前驱和后继
	/*中序线索化时引入了头结点，
	所以根节点的前驱即为头结点*/
	cout << "根结点的前驱：" << Thrt << "（Thrt）"<<endl;
	cout << "根结点的后继：" << Thrt->lchild->rchild->data;

}

4、构造哈夫曼树和哈夫曼编码的算法实现（返回目录🖱）

#include"stdio.h"
#include"string.h"
#include"malloc.h"
#include"iostream"
using namespace std;
typedef struct HTNode {
	unsigned int weight;
	unsigned int parent, lchild, rchild;
}HTNode, * HuffTree;
typedef  char** HuffCode;

//------选择权值最小的两个结点的下标-----
void Select(HuffTree& Ht, int m, int& S1, int& S2)
{
	S1 = 0;
	S2 = 0;
	for (int j = 1; j <= m; j++)
	{
		if (Ht[j].parent == 0 && Ht[j].weight != 0)
		{
			if (Ht[j].weight < Ht[S1].weight)
				S1 = j;
		}
	}
	for (int j = 1; j <= m; j++)
	{
		if (Ht[j].parent == 0 && j != S1 && Ht[j].weight != 0)
		{
			if (Ht[j].weight < Ht[S2].weight)
				S2 = j;
		}
	}
	cout <<S1 << " " << S2 << endl;;
}


//-----哈夫曼编码函数-----
void HuffmanCoding(HuffTree& Ht, HuffCode& Hc, int n, char text[]) {   
	if (n <= 1)return;
	int m, i, s1, s2;
	HuffTree p;
	m = 2 * n - 1;
	Ht = (HuffTree)malloc((m + 1) * sizeof(HTNode));
	for (p = Ht + 1, i = 1; i <= m; ++i, ++p) {     //初始化哈夫曼树各个值 
		p->weight = 0;
		p->parent = 0;
		p->lchild = 0;
		p->rchild = 0;
	}
	//读入一段文本 
	for (int i = 0; text[i] != '\0'; i++) {
		Ht[text[i] - 'a' + 1].weight++;      //当文本还没有结束时，统计各个字符的权值 
	}
	//构建哈夫曼树
	for (i = n + 1; i <= m; ++i) {                       
		Select(Ht, i - 1, s1, s2);
		Ht[s1].parent = i; Ht[s2].parent = i;
		Ht[i].lchild = s1; Ht[i].rchild = s2;
		Ht[i].weight = Ht[s1].weight + Ht[s2].weight;
	}

	// -------从叶子到根逆向求每个字符的哈夫曼编码------
	Hc = (HuffCode)malloc((n + 1) * sizeof(char*)); //貌似不能用new，所以使用c语言的动态申请
	char* cd = (char*)malloc((n) * sizeof(char));
	cd[n - 1] = '\0';                 //编码结束符 
	int start;
	for (i = 1; i <= n; ++i) {
		start = n - 1;
		int parent = 0; //暂存父节点下标
		int c = 0;
		for (c = i, parent = Ht[i].parent; parent != 0; c = parent, parent = Ht[parent].parent)
		{
			if (Ht[parent].lchild == c)cd[--start] = '0';
			else cd[--start] = '1';
		}
		//cd[n-1]='\0';
		Hc[i] = new char[26];//动态申请某字母哈夫曼编码的空间
		strcpy(Hc[i], &cd[start]);
	}
	free(cd);

}

//------输出哈夫曼编码------
void show(HuffCode& Hc, int n)
{
	cout << "\n输出哈夫曼编码:\n"; 
	for (int i = 1; i <= n; i++)
	{
		cout <<char(i-1+'a')<<"："<< Hc[i];
		cout << "\n";
	}

}
int main()
{
	HuffTree ht;
	HuffCode hc;
	int n;
	char text[] = "The Chinese official said he viewed the TrumpPresidency not as an aberration but as the product of a failing political system. This jibes with other accounts. The Chinese leadership believes that the United States, and Western democracies in general, haven’t risen to the challenge of a globalized economy, which necessitates big changes in production patterns, as well as major upgrades in education and public infrastructure. In Trump and Trumpism, the Chinese see an inevitable backlash to this failure";
	char* text_transform = strlwr(text); //全部转化为小写                               
	HuffmanCoding(ht, hc, 26, text_transform);
	show(hc, 26);	
}

四、实验过程原始数据记录
1、二叉树的基本操作算法实现

2、二叉树的各种遍历算法实现

3、线索二叉树的遍历

4、构造哈夫曼树和哈夫曼编码的算法实现

五、实验结果及分析
在二叉树的操作当中，有许多步骤的思路是一样的，所以递归在二叉树中的使用会更加广泛。我觉得递归的思想能在二叉树的操作中得到很好的锻炼。二叉树在数据压缩等方面以其的特性而广泛被应用，所以我觉得掌握二叉树在某些实际应用中的实现方法也是特别重要的。

猫咪钓鱼
关注
专栏目录
二叉树的基本操作C语言实现
03-12
用C语言实现关于二叉树的初始化、插入、删除、路径、等数据结构的操作
数据结构基础系列(6)：树和二叉树
10-18
数据结构课程是计算机类专业的专业基础课程，在IT人才培养中，起着重要的作用。课程按照大学计算机类专业课程大纲的要求，安排教学内容，满足需要系统学习数据结构的人。系列课程包含11个部分，本课为第6部分“树和二叉树”，介绍树的相关概念和表示方法，重点是二叉事的性质、存储结构、遍历等基本操作的实现，以及应用基本操作解决问题的方法。
【数据结构与算法】【C++】二叉树实验报告（四）
最新发布
鸿蒙初开
01-22 1011
本实验旨在熟练掌握二叉链的存储特点、二叉树的基本操作以及基于二叉链的二叉树操作算法实现。实验内容包括定义二叉链类，实现二叉树的基本操作算法，并在主函数中定义对象并调用成员函数进行验证。实验中，需完成建立二叉链存储的二叉树、遍历二叉树、求二叉树的深度、交换结点的左右子树、统计叶子结点个数、前序次序打印叶子结点、计算二叉树的最大宽度以及非递归方式遍历二叉树等任务。在实验过程中，需注意输入二叉树序列的格式，并解决求二叉树深度时没有返回值的问题。同时，需通过调试找出编译错误的位置，并对照错误消息修改相应的代码。
C++课程设计：实现学生考勤管理系统
晨钟暮鼓林中径，晚风花间寺中人
05-08 6376
功能描述：某实验室对学生每天的学习时间进行管理,记录其到达时间和其离开时间。两个时间之间的时间段作为其当天的学习时间。设计一个考勤管理系统。 功能要求： 1.信息录入功能，提示用户逐项输入学生信息，并检查输入信息的合法性(如时、分、秒的取值范围)，同时以分为单位计算每位同学的学习时间； 2.考勤信息浏览功能，显示所有人的考勤情况； 3.排序功能，按学习时间长短进行排序并显示 4.使用菜单选择操作，方便用户查看不同任务的解决方法以及结果； 5.将处理后的数据信息保存到data.txt文件中。 // 学生考勤管
二叉树实验 （数据结构）
Popcorn_zyh的博客
11-03 1876
二叉树实验报告
广州大学 数据结构实验报告 实验二 二叉树的操作与实现
05-23
在本实验中，广州大学的学生们被要求实现二叉树的基本操作和算法，包括二叉树的创建、遍历以及特殊类型如线索二叉树的处理。 首先，二叉树的基本操作算法涉及到从给定的字符串构建二叉树。这通常通过先序遍历的方式...
实验四 二叉树基本操作的实现
12-18
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉树，并实现其基本操作。二叉树是一种非线性的数据结构，它由一个有限集合的节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验...
实验四 二叉树操作实现.pdf
10-27
在本实验中，我们主要关注的是二叉树的链式存储结构及其基本操作的实现，包括创建、遍历、计算深度、统计不同度数节点数量以及进行左右子树的交换。 首先，二叉树的链式存储结构是通过结构体来表示的，如实验中所示...
实验四 二叉树操作实现.docx
10-27
本实验主要涉及二叉树的基本概念、操作及其在链式存储结构上的实现。实验的目标是熟练掌握二叉树的创建、遍历以及计算深度、结点度数等算法，并通过递归方式编写C程序。实验内容包括利用前序遍历输入的字符串构建...
实验二、二叉树操作.pdf
10-27
总结来说，这个实验旨在通过实际操作加深对二叉树概念的理解，掌握二叉树的存储结构和遍历方法。通过编写和测试代码，不仅可以巩固理论知识，还能提升编程实践能力。在实际应用中，二叉树常用于编译器设计、数据库...
数据结构实验6：C++实现二叉树类
u25th_engineer的博客
11-19 2913
                                             实验6                                                                  学号：      姓名：      专业：   6.1 实验目的 掌握二叉树的动态链表存储结构及表示。 掌握二叉树的三种遍历算法（递归和非递归两类）。 运用二叉...
树和二叉树
xinlingdexueba的专栏
11-27 833
《数据结构》实验五：   树和二叉树实验 一．.实验目的      巩固树和二叉树的相关知识，特别是二叉树的相关内容。学会运用灵活应用。 1.回树和二叉树的逻辑结构和存储方法，清楚掌握树和二叉树的遍历操作。 2.学习树的相关知识来解决实际问题。 3.进一步巩固程序调试方法。 4.进一步巩固模板程序设计。 二．实验时间    准备时间为第10周到第12
数据结构实验二 :二叉树的操作与实现
imbzz的博客
01-31 3029
数据结构实验二 :二叉树的操作与实现
数据结构之二叉树实验
// 在校菜鸟大学生的日常学习博客
09-01 4689
二叉树实验实验目的实验环境实验要求实验内容源代码运行结果 实验目的 通过实验掌握二叉树的基本存储结构； 掌握二叉树的建立与遍历的基本算法，并加以应用； 实验环境 CodeBlocks 实验要求 熟悉c语言的语法知识； 掌握二叉树的链式存储结构—二叉链表的定义、构造、遍历等基本操作； 实验内容 完成二叉树的二叉链表的存储结构的定义、创建、前序遍历、中序遍历、后序遍历、求叶子数和求深度等函数的编写。完成以下函数的编写： (1) 编写一个函数输出结点的值。visit( BiTree T) (2)编写一个函
最优二叉树
爱敲代码的小赤佬
04-14 1041
所谓哈夫曼树即最优二叉树，其特点是带权路径长度最小 建树原理：将最小数结点放到最下面，大数放到离顶点近的地方，建树时从下往上建，每上一层下一层的数就被重复加一次，这样最终得到完整树 数据结构实验之二叉树六：哈夫曼编码 Problem Description 字符的编码方式有多种，除了大家熟悉的ASCII编码，哈夫曼编码(Huffman Coding)也是一种编码方式，它是可变字长编码。该方法完...
二叉树的详解与常见算法实现
weixin_39318565的博客
12-23 4190
文章目录一、 二叉树的基本概念 一、 二叉树的基本概念 **二叉树：**二叉树是每个节点最多有两个子树的树结构。 **根节点：**一棵树最上面的节点称为根节点。 父节点、子节点：如果一个节点下面连接多个节点，那么该节点称为父节点，它下面的节点称为子 节点。 **叶子节点：**没有任何子节点的节点称为叶子节点。 **兄弟节点：**具有相同父节点的节点互称为兄弟节点。 **节点度：**节点拥有的子树数。上图中，13的度为2，46的度为1，28的度为0。 **树的度：**所有结点的度数的最大值。二叉树的度小于等
二叉树的基本算法实现
最白の白菜的博客
12-28 2810
二叉树的基本算法实现 实验目的： 用二叉链表存储方式存储二叉树，并实现以下相关算法： 1、创建二叉树 2、用非递归算法先中后序遍历二叉树 3、分别求出二叉树中度为0、1、2的结点个数 4、求出树的高度 5、销毁二叉树 实验代码如下： #include <stdio.h> #include <stdlib.h> #include <...
实验三 二叉树基本操作的实现
陈的博客
12-06 1875
实验三 二叉树基本操作的实现 实验目的 掌握二叉树的存储实现 掌握二叉树的遍历思想 .掌握二叉树的基本操作的程序实现 实验内容 1.编写函数，输入字符序列，建立二叉树的二叉链表。 2.编写函数，实现二叉树的先序、中序、后序递归遍历操作。 3.编写函数，求二叉树的结点个数。 4.编写函数，求二叉树的叶子个数。 5.编写一个主函数，在主函数中设计一个简单的菜单，分别调用上述函数。 #include<stdio.h> #include<stdlib.h> #include<
二叉树的构建与遍历操作实现
"东北石油大学的一份数据结构实验报告，涉及二叉树的建立及遍历操作，使用C++实现，包括前序、中序、后序遍历的递归与非递归方法，并实现了层序遍历。实验环境中使用了WinXP操作系统和Visual C++ 6.0软件。实验目标...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猫咪钓鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值