二叉树实验

最新推荐文章于 2024-02-07 10:58:09 发布
最新推荐文章于 2024-02-07 10:58:09 发布
阅读量306 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44755403/article/details/103034659
版权

文章目录

二叉树实验

（一）用到的结构体

typedef struct node 
{
	char info;
	struct node* lchild;
	struct node* rchild;
}tree;
typedef struct stack_1
{
	tree* a[MAX];
	int tag[MAX];
	int top;
}stack;

（二）对栈的操作

void push(stack* st, tree* t)
{
	st->a[st->top] = t;
	st->top++;
}
tree* pop(stack* st)
{
	if (st->top != 0)
	{
		st->top--;
		return st->a[st->top];
	}
	else
		return NULL;
}
tree* top(stack* st)
{
	if (st->top != 0)
	{
		return st->a[st->top - 1];
	}
	else
	{
		return NULL;
	}
}

（三）递归建树

tree *creat()//递归建树
{
	tree *root;
	char ch;
	scanf_s("%c", &ch,1);
	if (ch == '#')
		return NULL;
	else
	{
		root = (tree*)malloc(sizeof(tree));
		root->info = ch;
		root->lchild = creat();
		root->rchild = creat();
	}
	return root;
}

（四）非递归建树

tree *creat_1()//非递归建树
{
	stack_1 A;
	stack_1 *st;
	st = &A;
	tree *root;
	tree *p1, *p2;
	int i = 0;
	char ch[MAX];
	//0---左孩子为空，1---右孩子为空，2建树完成
	scanf_s("%s", ch, MAX);
	getchar();
	st->top = 0;//栈初始化
	while (ch[i] != '\0')
	{
		if (i == 0)//建立根节点
		{
			root = (tree*)malloc(sizeof(tree));
			root->info = ch[i];
			root->lchild = NULL;
			root->rchild = NULL;
			p1 = root;
			push(st, root);
			st->tag[st->top - 1] = 0;

		}
		else//非根节点
		{
			if (ch[i] != '#'&&st->tag[st->top - 1] == 0)//建左树
			{
				p2 = (tree*)malloc(sizeof(tree));
				p2->info = ch[i];
				p2->lchild = NULL;//一定要有，不然会和下面的代码冲突
				p2->rchild = NULL;
				push(st, p2);//入栈
				p1->lchild = p2;//连接新建左孩子
				p1 = p2;//指针下移
				st->tag[st->top - 1] = 0;//0表示此节点没有左孩子
			}
			else if (ch[i] == '#'&&st->tag[st->top - 1] == 0)//左树完成
			{
				p1->lchild = NULL;
				st->tag[st->top - 1] = 1;//左子树构建完成
			}
			else if (ch[i] == '#'&&st->tag[st->top - 1] == 1)//右树完成
			{
				p1->rchild = NULL;
				st->tag[st->top - 1] = 2;//右子树构建完成
			}
			else if (ch[i] != '#'&&st->tag[st->top - 1] == 1)//建右树
			{
				p2 = (tree*)malloc(sizeof(tree));
				p2->info = ch[i];
				p2->lchild = NULL;
				p2->rchild = NULL;
				push(st, p2);
				p1->rchild = p2;
				p1 = p2;
				st->tag[st->top - 1] = 0;
			}
			while (st->tag[st->top - 1] == 2)//是否出栈操作，当左右子树都已建立时，出栈
			{
				st->tag[st->top - 1] = 0;
				p1 = pop(st);
				if (st->top != 0)//避免最后一个节点误操作，如果没有此句，会导致栈的top越界
					p1 = st->a[st->top - 1];
				else
					break;
				if (st->tag[st->top - 1] == 1)//说明此时结点的左子树已存在，并且当前指针是从下一右子树返上来的结点，即：右子树也存在；
				{
					st->tag[st->top - 1] = 2;
				}
			}
			if (p1->lchild != NULL || st->tag[st->top - 1] == 1)//对返上来的结点进行判断，有左子树则改变标记为1
			{
				st->tag[st->top - 1] = 1;
			}

		}
		i++;
	}
	return root;

}

完整代码：

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define MAX 1000
typedef struct node 
{
	char info;
	struct node* lchild;
	struct node* rchild;
}tree;
typedef struct stack_1
{
	tree* a[MAX];
	int tag[MAX];
	int top;
}stack;
void push(stack* st, tree* t)
{
	st->a[st->top] = t;
	st->top++;
}
tree* pop(stack* st)
{
	if (st->top != 0)
	{
		st->top--;
		return st->a[st->top];
	}
	else
		return NULL;
}
tree* top(stack* st)
{
	if (st->top != 0)
	{
		return st->a[st->top - 1];
	}
	else
	{
		return NULL;
	}
}
tree *creat()//递归建树
{
	tree *root;
	char ch;
	scanf_s("%c", &ch,1);
	if (ch == '#')
		return NULL;
	else
	{
		root = (tree*)malloc(sizeof(tree));
		root->info = ch;
		root->lchild = creat();
		root->rchild = creat();
	}
	return root;
}
tree *creat_1()//非递归建树
{
	stack_1 A;
	stack_1 *st;
	st = &A;
	tree *root;
	tree *p1, *p2;
	int i = 0;
	char ch[MAX];
	//0---左孩子为空，1---右孩子为空，2建树完成
	scanf_s("%s", ch, MAX);
	getchar();
	st->top = 0;//栈初始化
	while (ch[i] != '\0')
	{
		if (i == 0)//建立根节点
		{
			root = (tree*)malloc(sizeof(tree));
			root->info = ch[i];
			root->lchild = NULL;
			root->rchild = NULL;
			p1 = root;
			push(st, root);
			st->tag[st->top - 1] = 0;

		}
		else//非根节点
		{
			if (ch[i] != '#'&&st->tag[st->top - 1] == 0)//建左树
			{
				p2 = (tree*)malloc(sizeof(tree));
				p2->info = ch[i];
				p2->lchild = NULL;//一定要有，不然会和下面的代码冲突
				p2->rchild = NULL;
				push(st, p2);//入栈
				p1->lchild = p2;//连接新建左孩子
				p1 = p2;//指针下移
				st->tag[st->top - 1] = 0;//0表示此节点没有左孩子
			}
			else if (ch[i] == '#'&&st->tag[st->top - 1] == 0)//左树完成
			{
				p1->lchild = NULL;
				st->tag[st->top - 1] = 1;//左子树构建完成
			}
			else if (ch[i] == '#'&&st->tag[st->top - 1] == 1)//右树完成
			{
				p1->rchild = NULL;
				st->tag[st->top - 1] = 2;//右子树构建完成
			}
			else if (ch[i] != '#'&&st->tag[st->top - 1] == 1)//建右树
			{
				p2 = (tree*)malloc(sizeof(tree));
				p2->info = ch[i];
				p2->lchild = NULL;
				p2->rchild = NULL;
				push(st, p2);
				p1->rchild = p2;
				p1 = p2;
				st->tag[st->top - 1] = 0;
			}
			while (st->tag[st->top - 1] == 2)//是否出栈操作，当左右子树都已建立时，出栈
			{
				st->tag[st->top - 1] = 0;
				p1 = pop(st);
				if (st->top != 0)//避免最后一个节点误操作，如果没有此句，会导致栈的top越界
					p1 = st->a[st->top - 1];
				else
					break;
				if (st->tag[st->top - 1] == 1)//说明此时结点的左子树已存在，并且当前指针是从下一右子树返上来的结点，即：右子树也存在；
				{
					st->tag[st->top - 1] = 2;
				}
			}
			if (p1->lchild != NULL || st->tag[st->top - 1] == 1)//对返上来的结点进行判断，有左子树则改变标记为1
			{
				st->tag[st->top - 1] = 1;
			}

		}
		i++;
	}
	return root;

}
void preprint(tree* t)//递归前序输出
{
	tree* p1;
	p1 = t;
	if (!p1)
		return;
	else
	{
		printf("%c->", p1->info);
		preprint(p1->lchild);
		preprint(p1->rchild);

	}
}
void inorprint(tree* t)
{
	tree* p1;
	p1 = t;
	if (!p1)
		return;
	else
	{
		inorprint(p1->lchild);
		printf("%c->", p1->info);
		inorprint(p1->rchild);

	}
}
void postprint(tree* t)
{
	tree* p1;
	p1 = t;
	if (!p1)
		return;
	else
	{
		postprint(p1->lchild);
		postprint(p1->rchild);
		printf("%c->", p1->info);

	}
}
void preprint_1(tree* t)//非递前序输出；
{
	stack A;
	stack* st;
	st = &A;
	tree* p1;
	p1 = t;
	st->top = 0;
	
	while (p1 || st->top != 0)
	{
		if (p1)
		{
			printf("%c->", p1->info);
			push(st, p1);
			p1 = p1->lchild;
		}
		else {
			p1 = pop(st);
			p1 = p1->rchild;

		}
	}
}
void inorprint_1(tree* t) //非递归中序输出
{
	stack B;
	stack* st;
	st = &B;
	st->top = 0;
	tree *p1;
	p1 = t;
	while (p1 || st->top != 0)
	{
		if (p1)
		{
			push(st, p1);
			p1 = p1->lchild;
		}
		else
		{
			p1 = pop(st);
			printf("%c-->", p1->info);
			p1 = p1->rchild;
		}
	}
}
void postprint_1(tree* t)//非递归后序遍历
{
	stack C;
	stack* st;
	st = &C;
	st->top = 0;
	tree* p1;
	p1 = t;
	while (p1 || st->top != 0)
	{
		if (p1)
		{
			push(st, p1);
			st->tag[st->top-1] = 0;
			p1 = p1->lchild;
		}
		else//空
		{
			if (st->tag[st->top-1] == 0)
			{
				p1 = st->a[st->top - 1];
				st->tag[st->top - 1] = 1;
				p1 = p1->rchild;
			}
			else if (st->tag[st->top-1] == 1)
			{
				p1 = st->a[st->top - 1];
				printf("%c***->", p1->info);
				st->tag[st->top - 1] = 0;
				st->top--;
				p1=NULL;//避免多次入栈
			}
		}
	}
}
void fun()//输出递归菜单
{
	
	printf("\n**************二叉树递归操作菜单***********\n");
	printf("****“A”--------前序遍历二叉树--------****\n");
	printf("****“B”--------中序遍历二叉树--------****\n");
	printf("****“C”--------后序遍历二叉树--------****\n");
	printf("****“D”---------本次执行结束---------****\n");
	printf("*******************************************\n\n");
}
void fun_1()//输出非递归菜单
{

	printf("\n*************二叉树非递归操作菜单**********\n");
	printf("****“1”--------前序遍历二叉树--------****\n");
	printf("****“2”--------中序遍历二叉树--------****\n");
	printf("****“3”--------后序遍历二叉树--------****\n");
	printf("****“4”---------本次执行结束---------****\n");
	printf("*******************************************\n\n");
}
void fun2()
{
	printf("\n*************二叉树操作菜单**********\n");
	printf("****“d”--------递归操作--------****\n");
	printf("****“f”-------非递归操作-------****\n");
	printf("****“@”--------退出程序--------****\n");
	printf("*************************************\n\n");
}
void fun3()
{
	printf("\n*************二叉树建立菜单**********\n");
	printf("****“q”--------递归建立--------****\n");
	printf("****“w”-------非递归建立-------****\n");
	printf("*************************************\n\n");
}
int getnode(tree *root)
{
	if (root == NULL)
		return 0;
	else if (root->lchild == NULL&&root->rchild == NULL)
		return 1;
	else
		return getnode(root->lchild) + getnode(root->rchild);
}
int getnode_1(tree *root)
{
	stack A;
	stack *st;
	st = &A;
	st->top = 0;
	int sum = 0;
	while (root || st->top != 0)
	{
		if (root)
		{
			if (root->lchild == NULL&&root->rchild == NULL)
				sum++;
			push(st, root);
			root = root->lchild;
			
		}
		else
		{
			root = pop(st);//往上返一层
			root = root->rchild;
		}
	}
	return sum;
}
tree* getlastnode(tree * root)
{
	tree *p;
	p = root;
	while (p&&p->rchild)
	{
		p = p->rchild;
	}
	return p;
}
tree* getfather(tree* t,char x,char y) 
{  stack  s; 
tree *antor;
   tree* data[100]={0}; 
   int i=0,j; 
   s.top=-1; 
   while(t || s.top>-1) 
   {   while(t) 
		{ 
			s.a[++s.top]=t; 
		  s.tag[s.top]=0; 
		  t=t->lchild;  
		 } 
		while(s.top>-1 && s.tag[s.top]) 
		 {   
			t=s.a[s.top]; 
			 if(t->info==x) 
			 while(i<=s.top)  //记录x结点的所有祖先结点  
			{ 
				 data[i] = s.a[i];
            i++; 
       } 
          else if(t->info==y)  
    { 
               while(s.top>-1) 
       { 
        j=i-1; 
        while(j>=0&&t!=data[j])//查找y与x的最近公共祖先结点  
        j--; 
        if(j>=0) 
        {  
     antor=data[j]; //返回公共祖先结点地址  
     return antor; 
        }  
        t=s.a[--s.top]; 
       } 
        } 
       --s.top; 
   }    
   if(s.top>-1) 
   { 
     t=s.a[s.top]; 
              s.tag[s.top]=1; 
              t=t->rchild; 
   } 
   else  t=NULL; 
  } 
} 
int main()
{
	tree* T=NULL;
	char A, B;
	tree* root;
	char u;
	char a;
	root = NULL;
	fun3();
	printf("请选择以何种方式建立二叉树（递归和非递归）:");
	u = getchar();
	getchar();
	if (u == 'q')
	{
		printf("输入一组数据(以#分隔):\n");
		root = creat();
		getchar();
	}
	else if(u=='w')
	{
		printf("输入一组数据(以#分隔):\n");
		root = creat_1();
	}
	int k = getnode_1(root);
	printf("\n叶子节点：%d\n", k);
	tree * p4 = getlastnode(root);
	printf("中序的最后一个节点是：%c\n", p4->info);
	printf("查找共同祖先(输入两个结点值)：\n");
	scanf_s("%c%c", &A, 1, &B, 1);
	getchar();
	tree* P=getfather(root, A, B);
	printf("%c和%c的共同祖先是：", A, B);
	printf("%c\n", P->info);
	while (1)
	{
		char p;
		printf("\n     -----请选择操作类型-----\n");
		fun2();
		scanf_s("%c", &p, 1);
		getchar();
		if (p == 'd')
		{
			fun();
			while (1)
			{
				a = getchar();
				getchar();
				if (a == 'A') 
				{
					printf("前序遍历："); preprint(root); printf("\n"); 
				}
				else if (a == 'B')
				{
					printf("中序遍历："); inorprint(root); printf("\n");
				}
				else if (a == 'C')
				{
					printf("后序遍历："); postprint(root); printf("\n");
				}
				else if(a=='D'){
					break;

				}
			}
		}
		else if (p == 'f')
		{
			fun_1();
			while (1)
			{
				a = getchar();
				getchar();
				if (a == '1')
				{
					printf("前序遍历："); preprint_1(root); printf("\n");
				}
				else if (a == '2')
				{
					printf("中序遍历："); inorprint_1(root); printf("\n");
				}
				else if (a == '3')
				{
					printf("后序遍历："); postprint_1(root); printf("\n");
				}
				else if(a=='4') {
					break;

				}

			}
		}
		else if (p == '@')
		{
			break;
		}
		else {
			printf("********\n");
			printf("**警告**：非法字符，请重新操作！\n");
			printf("********\n");
		}
	}
	return 0;
}

输入数据：

ABDH#K###E##CFI###G#J##

二叉树：
在这里插入图片描述
输出如下：
在这里插入图片描述

编程之美，趋之若鹜
关注
数据结构实验报告——二叉树
11-14
数据结构实验报告，二叉树实验报告。采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作，求所有叶子及结点总数的操作
《数据结构》实验报告五：二叉树
热门推荐
Amentos的博客
10-30 1万+
《数据结构》实验报告：二叉树基本概念 + 结点总数 + 叶子结点数 + 二叉树深度 + 中序非递归遍历 算法实现
二叉树实验 （数据结构）
Popcorn_zyh的博客
11-03 1867
二叉树实验报告
数据结构实验报告，二叉树的基本操作（C语言）
VLOKL的博客
03-31 6231
数据结构实验报告，二叉树的基本操作（C语言）
数据结构教程实验五二叉树建立及应用
Annzz123的博客
06-16 1936
三、实验要求⒈ 要求采用二叉链表作为存贮结构，完成二叉树的建立、先序、中序、和后序遍历的操作。其中先序遍历和后序遍历采用递归算法，中序遍历采用非递归算法。⒉ 输入数据：树中每个结点的数据类型设定为字符型。3。设计一棵二叉树，输入完全二叉树的先序序列，用#代表虚结点（空指针），如ABD###CE##F##，建立二叉树，求先序、中序和后序遍历，求该二叉树所有叶子结点总数。
数据结构二叉树实验头文件
12-10
在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 一棵深度为k，且有2^k-1个结点的...
二叉树实验代码
12-01
在这个“二叉树实验代码”中，我们将会深入探讨二叉树的概念、类型以及相关的操作。 二叉树的基本概念是每个节点最多有两个子节点，分别被称为左子节点和右子节点。这种结构允许快速的搜索、插入和删除操作，因为...
Bitreesearch.rar_java二叉树实验
09-22
在这个“Bitreesearch.rar_java二叉树实验”中，我们主要探讨的是如何利用Java语言来实现二叉排序树（Binary Search Tree, BST），以及如何进行中序遍历来展示树中的数据。这个实验将帮助我们深入理解二叉树的性质和...
数据结构实验——exp4--二叉树实验
qq_65814357的博客
06-10 2658
一、 实验任务实验测试数据基本要求：第一组数据： bt151.btr第二组数据： bt21.btr 2.求二叉树的叶子结点数和1度结点数。 实验测试数据基本要求：第一组数据： bt261.btr第二组数据： bt21.btr3.键盘输入一个元素x，求其父节点、兄弟结点、子结点的值，不存在时给出相应提示信息。对兄弟结点和孩子结点，存在时要明确指出是左兄弟、左孩子、右兄弟或右孩子。 实验测试数据基本要求：第一组数据： bt31.btr第二组数据： bt21.btr4.键盘输入一个
头歌数据结构二叉树的顺序存储及基本操作
05-18
头歌数据结构二叉树的顺序存储及基本操作 第1关树和二叉树基本概念 第2关二叉树的顺序存储及基本操作 在计算机科学中，二叉树是每个节点最多只有两个分支的树结构，即每个节点的分支度不大于2。通常分支被称作左子树和右子树，同时二叉树的分支具有左右次序，不能颠倒。 二叉树是一种最简单、最基础、最重要的树结构，链式结构的存储使其可以按照需要来分配内存，具有非常广泛的应用。基于二叉树的改进树结构排序和检索的效率非常高，常被用于文件系统和数据库系统。
数据结构实验报告（五）
cqc1161的博客
11-25 1366
数据结构实验报告（五） 一、实验名称 实验五  树和二叉树的实验2 二、 实验目的 1、  熟练理解树和二叉树的相关概念，掌握的存储结构和相关操作实现； 2、  掌握树的顺序结构的实现； 3、  学会运用树的知识解决实际问题 三、 实验内容 自己确定一个二叉树（树结点类型、数目和结构自定）利用链式存储结构方法存储。实现树的构造，并完成： 1）  用前序遍历、中序遍历、后序遍历输出
数据结构上机实验——二叉树的实现、二叉树遍历、求二叉树的深度/节点数目/叶节点数目、计算二叉树度为1或2的节点数、判断二叉树是否相似
Crocodile1006的博客
10-29 1952
数据结构、二叉树、创建一颗二叉树、对这棵二叉树进行遍历、求二叉树的深度/节点数目/叶节点数目、计算二叉树中度为 1 或 2 的结点数、判断2棵二叉树是否相似，若相似返回1，否则返回0
广州大学数据结构实验报告二《二叉树的操作与实现》
Software_Star的博客
11-11 1467
广州大学数据结构实验二《二叉树的操作与实现》，完整实验报告
《数据结构》实验报告（六）之二叉树的相关操作
最新发布
Li的博客
02-07 1277
三种遍历算法的递归算法不同之处仅在于访问根结点和遍历左、右子树的先后关系，需要注意的是，任何一棵二叉树的叶子结点在先序，中序，后序遍历中，其访问的相对次序不变，包括双序遍历仅是在先序遍历的基础上，在访问右子树之前再次访问根结点；(1)由如图1所示的二叉树创建对应的二叉链存储结构b，该二叉树的括号表示串为“A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”;内容：编写一个程序，实现二叉树的先序遍历、中序遍历和后序遍历的递归算法，并对图1所示的二叉树b给出求解结果。
数据结构实验6：C++实现二叉树类
u25th_engineer的博客
11-19 2908
                                             实验6                                                                  学号：      姓名：      专业：   6.1 实验目的 掌握二叉树的动态链表存储结构及表示。 掌握二叉树的三种遍历算法（递归和非递归两类）。 运用二叉...
【数据结构】实验九：二叉树
m0_65787507的博客
07-27 1162
数据结构实验
数据结构实验5：二叉树的应用
weixin_58628068的博客
01-11 1343
一个二叉树可以是空的，即不包含任何节点。一个非空二叉树包含一个根节点，以及分别为左子树和右子树的两个二叉树。根节点包含一个数据元素。左子树和右子树都是二叉树，可以是空二叉树或非空二叉树int data;//左孩子//右孩子。
二叉树实验：左右子树交换算法
"二叉树实验，通过左右子树交换改变二叉树结构，涉及到先序遍历、中序遍历以及二叉树节点交换的递归实现。" 在这个二叉树实验中，主要目标是交换二叉树中所有节点的左右子树，并通过中序遍历来验证交换的结果。实验...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值