[C语言]二叉树基本操作的实现

最新推荐文章于 2024-08-11 14:17:51 发布
最新推荐文章于 2024-08-11 14:17:51 发布
阅读量796 收藏 13
点赞数 5
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CRAJA/article/details/115268295
版权

目录

修改内容

新增二叉树非递归遍历的几种方法

准备工作(结构体以及头文件):

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stack>//栈 
#include<queue>//队列 

using namespace std;

#define MAX_STACK 100 //顺序存储栈的最大空间数 
typedef char Type;//自定义类型

//二叉树节点结构体
typedef struct _BiTNode
{
	Type data;//节点值
	struct _BiTNode *lchild;//指向左孩子节点
	struct _BiTNode *rchild;//指向右孩子节点
	int flag;               //用于非递归遍历 flag == 0表示没被抛出flag == 1表示被抛出过 //这个flag会被重写!!!所以只能连续非递归第二种遍历方式一次,或者重新初始化下
} BiTNode,*BiTree;

**不理解为什么标题是C语言实现的请看我的这篇文章 **

https://blog.csdn.net/CRAJA/article/details/115357997

初始化空二叉树:

之后创建需要用到,索性直接弄了个二级指针T(因为传参数进函数是在函数内新建一个变量存你传进去变量所存的内容)

/*
作用:二叉树的空树创建 
参数:无 
返回值:返回指向根节点指针的二级指针--空树默认为空节点,所以二级指针指向的一级指针应该指向NULL 
*/
BiTree* Creat()
{
	BiTree* T = (BiTree*)malloc(sizeof(BiTree));
	*T = NULL;
	return T;
}

二叉树的创建

用了三种递归的创建方式(应该可以用非递归的,之后实现下)

/*
作用:二叉树的先序创建: #代表该节点为空
参数:(BiTree *)T:指向根节点的 二级指针
返回值:无
*/
void Tree_ProCreat(BiTree *T)
{
	Type data = getchar();
	if(data == '#')
		*T = NULL;
	else
	{
		(*T) = (BiTree)malloc(sizeof(BiTNode));//*T 相当于 lchild 或者 rchild (BiTNode*) 改变一级指针的指向(改变其内部存储的地址)需要使用二级指针
		(*T)->data = data;
		(*T)->flag = 0;
		Tree_ProCreat(&(*T)->lchild);
		Tree_ProCreat(&(*T)->rchild);
	}
}
/*
作用:二叉树的中序创建: #代表该节点为空
参数:(BiTree *)T:指向根节点的 二级指针
返回值:无
*/
void Tree_MidCreat(BiTree *T)
{
	Type data = getchar();
	if(data == '#')
		*T = NULL;
	else
	{
		Tree_MidCreat(&(*T)->lchild);
		(*T) = (BiTree)malloc(sizeof(BiTNode));//*T 相当于 lchild 或者 rchild (BiTNode*)
		(*T)->data = data;
		Tree_MidCreat(&(*T)->rchild);
	}
}
/*
作用:二叉树的后序创建: #代表该节点为空
参数:(BiTree *)T:指向根节点的 二级指针
返回值:无
*/
void Tree_BackCreat(BiTree *T)
{
	Type data = getchar();
	if(data == '#')
		*T = NULL;
	else
	{
		Tree_BackCreat(&(*T)->lchild);
		Tree_BackCreat(&(*T)->rchild);
		(*T) = (BiTree)malloc(sizeof(BiTNode));//*T 相当于 lchild 或者 rchild (BiTNode*)
		(*T)->data = data;
		(*T)->flag = 0;
	}
}

这里每一种方法都会初始化标记点flag

先序遍历

用了三种方法

/*
作用:二叉树的先序递归遍历
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_ProPrint(BiTree root)
{
	if(root == NULL)
		return;
	printf("%c ",root->data);
	Tree_ProPrint(root->lchild);
	Tree_ProPrint(root->rchild);
}
/*
作用:二叉树的先序遍历--非递归
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_ProPrint_No(BiTree root)
{
	if(!root)
		return;
	BiTree stack[MAX_STACK];
	int top = 0;
	while(root||top)//只要根节点不空且栈没pop完就一直循环,因为要通过栈中元素来转到右孩子,root和stack为空说明遍历完了
	{
		while(root)//这个循环作用就是疯狂遍历左孩子 //第一次遍历
		{
			printf("%c ",root->data);//先序就是第一次把它压进栈就printf它
			stack[++top] = root;
			root = root->lchild;
		}
		if(top)//这个是第二次遇见节点,往右孩子尝试一下,看看有没有右孩子,然后pop掉工具人节点//第二次访问
		{
			root = stack[top--]->rchild;//这个元素左节点已经被访问了,只要继续访问它的右节点就可以了,它本身已经没有利用价值了,可以弹出了(老工具人了..)
		}
	}
}
//二叉树非递归先序遍历
void Tree_ProPrint_No2(BiTree root)//先序遍历的原理就是  压入根节点打印并弹出 , 再压入左节点 , 再压入右节点   根左右
{
	if(!root)
		return;
	stack <BiTree> Stack;//栈
	Stack.push(root);//把根入栈
	while(!Stack.empty())//栈不空就行
	{
		root = Stack.top();//获取栈顶节点

		printf("%c ",root->data);//展示    核心就是这三步的位置!
		Stack.pop();//抛出
		root->flag = 1;//标记被抛出

		if(root->rchild && root->rchild->flag==0)//先压入右孩子 这里一定要注意!先 push 右节点 再 push 左节点以至于之后每次获取到的节点都优先左节点...一直往左节点递归...
			Stack.push(root->rchild);
		if(root->lchild && root->lchild->flag==0)//再压入左孩子
			Stack.push(root->lchild);
	}
}

我将需要说明的都放到了注释里,可以的话请复制到电脑上仔细阅读

中序遍历

使用三种方法

/*
作用:二叉树的中序递归遍历
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_MidPrint(BiTree root)
{
	if(root == NULL)
		return;
	Tree_MidPrint(root->lchild);
	printf("%c ",root->data);
	Tree_MidPrint(root->rchild);
}
/*
作用:二叉树的中序遍历--非递归
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_MidPrint_No(BiTree root)//这个和前序很像
{
	if(!root)
		return;
	BiTree stack[MAX_STACK];
	int top = 0;
	while(root||top)
	{
		while(root)
		{
			stack[++top] = root;
			root = root->lchild;
		}
		if(top)
		{
			printf("%c ",stack[top]->data);//中序就是在访问它第二次时(即要访问它的右孩子时)就可以printf它了
			root = stack[top--]->rchild;
		}
	}
}
//二叉树非递归中序遍历
void Tree_MidPrint_No2(BiTree root)//根据原理  压入左节点, 再显示并弹出根节点, 再压入右节点   左根右
{
	if(!root)
		return;
	stack <BiTree> Stack;//栈
	Stack.push(root);//把根入栈
	while(!Stack.empty())//栈不空就行
	{
		root = Stack.top();//获取栈顶节点
		if(root->lchild && root->lchild->flag==0)//先遍历左孩子
		{
			Stack.push(root->lchild);
		}
		else
		{
			printf("%c ",root->data);//标记并弹出
			Stack.pop();//抛出
			root->flag = 1;//标记

			if(root->rchild && root->rchild->flag==0)//再遍历右孩子
				Stack.push(root->rchild);
		}
	}
}

后序遍历

用了三种方法

/*
作用:二叉树的后序遍历
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_BackPrint(BiTree root)
{
	if(root == NULL)
		return;
	Tree_BackPrint(root->lchild);
	Tree_BackPrint(root->rchild);
	printf("%c ",root->data);
}
/*
作用:二叉树的后序遍历--非递归
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_BackPrint_No(BiTree root)//这个和上面两种非递归的方法很不同,因为它是在第三次访问时才printf所以不能在第二次访问时就pop了,需要在第三次访问时pop并且printf,但如果pop了就需要标记下它已经被pop了不然会被它的双亲又给push进去了...
{
	if(!root)
		return;
	BiTree stack[MAX_STACK];
	int top = 0;
	while(root||top)
	{
		while(root && root->flag == 0)//如果这个节点是第一次访问就push进栈,遍历它的左孩子//第一次遍历
		{
			stack[++top] = root;
			root = root->lchild;
		}
		if(top)
		{
			if(stack[top]->rchild && stack[top]->rchild->flag == 0)//如果这个节点有左孩子而且左孩子是第一次遍历就去遍历左孩子//第二次遍历
				root = stack[top]->rchild;
			else
			{
				printf("%c ",stack[top]->data);//第三次遍历printf然后pop
				stack[top--]->flag = 1;//表示已经被弹出过,就不会被双亲再push进来了
			}
		}
	}
}
//二叉树非递归后序遍历
void Tree_BackPrint_No2(BiTree root)//根据原理  先压入左节点 再压入右节点 再打印并弹出根节点   左右根
{
	if(!root)
		return;
	stack<BiTree>Stack;
	Stack.push(root);//把根入栈
	while(!Stack.empty())//栈不空就行
	{
		root = Stack.top();//获取栈顶节点
		if(root->lchild && root->lchild->flag==0)//先压入左孩子
			Stack.push(root->lchild);
		else if(root->rchild && root->rchild->flag==0)//再压入右孩子
			Stack.push(root->rchild);
		else
		{
			printf("%c ",root->data);			//打印并弹出
			root->flag = 1;//标记被抛出
			Stack.pop();//抛出
		}
	}
}

话真的都在注释里(呜呜呜 )

层次遍历

//层序遍历
void Tree_LevelPrint(BiTree root)
{
	if(root==NULL)
		return;
//	BiTNode* stack[100];// 存放 BiTNode* 的数组  区别于 BiTNode (*stack)[100] : stack是个指针,指向着存着 BiTNode 的数组
	queue<BiTree> Queue;
	Queue.push(root);//将现在的根节点放入队列尾部
	while(!Queue.empty())
	{
		root = Queue.front();//获取队列头节点
		if(root->lchild)
			Queue.push(root->lchild);//压入右孩子
		if(root->rchild)
			Queue.push(root->rchild);//压入左孩子
		printf("%c ",root->data);//打印双亲节点并让双亲节点出栈
		Queue.pop();
	}
}

销毁整棵树

/*
作用:销毁整棵树
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_Destory(BiTree root)//新建了一个一级指针指向根节点
{
	if(root == NULL)
		return;
	Tree_Destory(root->lchild);
	Tree_Destory(root->rchild);
	free(root);
	root = NULL;
}

二叉树的判空

/*
作用:二叉树的判空
参数:(BiTree)root:指向根节点的 指针
返回值:若二叉树为空则返回 1,否则返回 0
*/
int Tree_Empty(BiTree root)
{
	if(root == NULL)
		return 1;
	return 0;
}
/*

计算二叉树的深度

/*
作用:计算二叉树的深度
参数:(BiTree)root:指向根节点的 指针
返回值:返回二叉树的深度,空树返回0
*/
int Tree_Depth(BiTree root)//返回左右子树中较高的那颗的高度
{
	if(root==NULL)
		return 0;
	int m = Tree_Depth(root->lchild);
	int n = Tree_Depth(root->rchild);
	return (m>n?m:n)+1;//加1是加根节点自身高度
}

统计二叉树的节点数

/*
作用:统计二叉树的节点数
参数:(BiTree)root:指向根节点的 指针
返回值:返回二叉树的节点总数
*/
int Tree_NodeCount(BiTree root)
{
	if(root == NULL)
		return 0;//空节点返回0
	return Tree_NodeCount(root->lchild) + Tree_NodeCount(root->rchild) + 1;//加上自身节点
}

统计二叉树叶子节点数

/*
作用:统计二叉树的叶子节点数
参数:(BiTree)root:指向根节点的 指针
返回值:返回二叉树的叶子节点总数
*/
int Tree_LeafCount(BiTree root)
{
	if(root==NULL)
		return 0;
	if(root->lchild==NULL&&root->rchild==NULL)//如果是叶子节点就返回自身 1
		return 1;
	return Tree_LeafCount(root->lchild)+Tree_LeafCount(root->rchild);//否则就继续搜索
}
/*

遍历二叉树的叶子节点

用了三种方法

/*
作用:先序遍历二叉树的叶子节点
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_LeafProPrint(BiTree root)
{
	if(root == NULL)
		return;
	if(root->lchild==NULL&&root->rchild==NULL)
		printf("%c ",root->data);
	else
	{
		Tree_LeafProPrint(root->lchild);
		Tree_LeafProPrint(root->rchild);
	}
}

/*
作用:中序遍历二叉树的叶子节点
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_LeafMidPrint(BiTree root)
{
	if(root == NULL)
		return;
	Tree_LeafMidPrint(root->lchild);
	if(root->lchild==NULL&&root->rchild==NULL)
		printf("%c ",root->data);
	else
		Tree_LeafMidPrint(root->rchild);
}

/*
作用:后序遍历二叉树的叶子节点
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_LeafBackPrint(BiTree root)
{
	if(root == NULL)
		return;
	Tree_LeafBackPrint(root->lchild);
	Tree_LeafBackPrint(root->rchild);
	if(root->lchild==NULL&&root->rchild==NULL)
		printf("%c ",root->data);
}

统计二叉树度为1的节点数

/*
作用:计算二叉树度为一的节点的数目
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
int Tree_Leaf_One_Count(BiTree root)
{
	if(root==NULL)//空返回0
		return 0;
	if(root->lchild==NULL&&root->rchild||root->rchild==NULL&&root->lchild)
		return Tree_Leaf_One_Count(root->lchild) + Tree_Leaf_One_Count(root->rchild) + 1;//存在一个叶子节点就加个1,再继续找
	else
		return Tree_Leaf_One_Count(root->lchild) + Tree_Leaf_One_Count(root->rchild);
}

二叉树镜像化

/*
作用:二叉树镜像化
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_Mirror(BiTree root)
{
	if(root == NULL)
		return;
	BiTree temp;//交换左右孩子节点 
	temp = root->lchild;
	root->lchild = root->rchild;
	root->rchild = temp;
	Tree_Mirror(root->lchild);
	Tree_Mirror(root->rchild);
}

二叉树的复制

/*
作用:二叉树单节点复制
参数:(BiTree)node:指向 二叉树节点的 指针
返回值:(BiTree)newnode 返回复制出的节点指针
*/
BiTree Tree_NodeCopy(BiTree node)
{
	BiTree newnode = (BiTree)malloc(sizeof(BiTNode));
	newnode->data = node->data;
	newnode->lchild = NULL;
	newnode->rchild = NULL;
	return newnode;
}
/*
作用:二叉树复制
参数:(BiTree)node:指向根节点的 指针
返回值:(BiTree)newroot 指向根节点的指针
*/
BiTree Tree_Copy(BiTree root)
{
	if(root == NULL)
		return NULL;
	BiTree newroot= Tree_NodeCopy(root);
	newroot->lchild = Tree_Copy(root->lchild);
	newroot->rchild = Tree_Copy(root->rchild);
	return newroot;
}

统计二叉树第k层的节点数

/*
作用:计算二叉树第k层的节点数
参数: (BiTree)node:指向根节点的 指针 (int)k:二叉树的第k层
返回值:返回第k层的节点数
*/
int Tree_LevelCount(BiTree root,int k)
{
	if(root == NULL)
		return 0;
	if(k == 1)
		return 1;
	return Tree_LevelCount(root->lchild,k-1) + Tree_LevelCount(root->rchild,k-1);//没找到就往下找并且层数-1 
}

在二叉树中寻找给定节点的双亲

/*
作用:在以 root为根的二叉树中寻找 节点(BiTree)cur的双亲
参数: (BiTree )root:指向根节点的 指针 (BiTree)cur:指向 需要寻找双亲的节点的 指针
返回值:若找到双亲则返回指向其双亲的指针,否则返回NULL
*/
BiTree Tree_Parent(BiTree root,BiTree cur)
{
	if(root == NULL)//如果该节点为空返回空
		return NULL;
	if(root->lchild==cur||root->rchild==cur)//如果此节点为双亲则返回次节点
		return root;
	BiTree p = Tree_Parent(root->lchild,cur);//此节点不是双亲就在左子树中寻找
	if(p)
		return p;//如果找到了双亲(非NULL)就返回双亲
	else
		return Tree_Parent(root->rchild,cur);//在左子树中没找到双亲就去右子树寻找
}

判断两颗二叉树是否相似(结构相似)

/*
作用:判断两颗二叉树 T1 和 T2是否相似
参数:(BiTree)T1:指向一颗二叉树头节点的指针,(BiTree)T2:指向另一颗二叉树头节点的指针
返回值:若两棵子树相似则返回1,不相似则返回0
*/
int Tree_IsSimilar(BiTree root1,BiTree root2)
{
	if(root1 == NULL&&root2 == NULL)
		return 1;
	if(root1 == NULL||root2 == NULL)
		return 0;
	int similar1 = Tree_IsSimilar(root1->lchild,root2->lchild);//判断左子树
	int similar2 = Tree_IsSimilar(root1->rchild,root2->rchild);//判断右子树
	return (similar1 && similar2);//左右子树形状都需要相似才认为二叉树相似
}

垂直打印树(这是某位大佬的思路…)

https://blog.csdn.net/u010909667/article/details/54972495
这位大佬提出了两种二叉树的打印方法(C++的)

/*
作用:垂直打印树
参数:(BiTree)Parent:指向一颗二叉树头节点的二级指针,(BiTree)root:指向同一颗二叉树头节点的二级指针
返回值:无
*/
void Tree_Show(BiTree parent,BiTree root,char *prefix)
{
	strcat(prefix,"|");//遇到一个 根 就往字符串后面加一个'|' 意味这一层打印的是上一层的孩子
	if(root)
	{
		printf("%s--%c\n",prefix,root->data);//如果此时的*root不是空的就打印次节点的 值
		if(parent == root||parent->rchild == root)//意思是如果是最初指在一块时或者是打印完两个孩子了就取消掉这一层创建的 '关系柱子' --> '|'
		{
			int len = strlen(prefix);
			prefix[len-1] = ' ';
		}
		char p1[100],p2[100];
		strcpy(p1,prefix);
		strcat(p1,"  ");
		strcpy(p2,prefix);
		strcat(p2,"  ");
		Tree_Show(root,root->lchild,p1);
		Tree_Show(root,root->rchild,p2);
	}
	else
	{
		if(parent->lchild||parent->rchild)//如果此时的parent只要有一个节点就要打印'#',体现出左右孩子的结构
			printf("%s--#\n",prefix);
	}
}

展示二叉树所有叶子节点到根节点的路径

/*
作用:展示二叉树所有叶子节点到根节点的路径
参数:((BiTree)T:指向二叉树头节点的指针,(char *)stack:存放依次经过的节点的值,(int)top:最后一个存放在stack中的节点的位置
返回值:无
*/
void Tree_PrintLeafPath(BiTree root,char *stack,int top)
{
	if(root == NULL)
		return;
	stack[top] = root->data;//将此节点放到stack中
	if(root->lchild==NULL&&root->rchild==NULL)//如果此节点使叶子节点就全部输出
	{
		for(int i = top; i>=0; i--)
			printf("%c ",stack[i]);
		putchar('\n');
		return;
	}
	Tree_PrintLeafPath(root->lchild,stack,top+1);
	Tree_PrintLeafPath(root->rchild,stack,top+1);
}

判断二叉树是否镜像对称(完全对称)

来自力扣 101. 对称二叉树
https://leetcode-cn.com/problems/symmetric-tree/

int dfs_Symmetric(BiTree left,BiTree right)
{
	if(left == NULL && right == NULL)
		return 1;
	if(left==NULL&&right||left&&right==NULL)
		return 0;
	if(left->data!=right->data)
		return 0;
	return dfs_Symmetric(left->rchild,right->lchild) && dfs_Symmetric(left->lchild,right->rchild);
}
/*
作用:判断二叉树是否镜像对称(值也对称)
参数:(BiTree)root:指向二叉树根节点的指针
返回值:若该二叉树镜像对称则返回1,否则返回0
*/
int Tree_IsSymmetric(BiTree root)
{
	if(root==NULL)
		return 0;
	return dfs_Symmetric(root->lchild,root->rchild);
}

根节点到叶子节点 的路径求和

来自力扣的 112. 路径总和
https://leetcode-cn.com/problems/path-sum/

int dfs_SumPath(BiTree root,int sum,int num)
{
	if(root==NULL)
		return 0;
	if(root->lchild==NULL&&root->rchild==NULL)
	{
		if(sum==num)
			return 1;
		return 0;
	}
	return dfs_SumPath(root->lchild,sum+root->data,num)||dfs_SumPath(root->rchild,sum+root->data,num);
}
/*
作用:判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 num
参数:(BiTree)root:指向二叉树根节点的指针,(int)num:目标和
返回值:若存在节点和等于num则返回1,否则返回0
*/
int Is_SumPath(BiTree root,int num)
{
	if(root==NULL)
		return 0;
	return dfs_SumPath(root,0,num);
}

效果图

在这里插入图片描述

总结

二叉树真的很神奇,这篇总结也真的蛮用心的写了,因为我也是初学者,可能会有很多地方没弄好,有什么建议请您讲出,我一定洗耳恭听!

完整代码

/*
名称:二叉树链式结构的实现
作者:Raja
时间:2021-3-31
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stack>//栈 
#include<queue>//队列 

using namespace std;

#define MAX_STACK 100 //顺序存储栈的最大空间数 
typedef char Type;//自定义类型

//二叉树节点结构体
typedef struct _BiTNode
{
	Type data;//节点值
	struct _BiTNode *lchild;//指向左孩子节点
	struct _BiTNode *rchild;//指向右孩子节点
	int flag;               //用于非递归遍历 flag == 0表示没被抛出flag == 1表示被抛出过 //这个flag会被重写!!!所以只能连续非递归第二种遍历方式一次,或者重新初始化下
} BiTNode,*BiTree;

/*
作用:二叉树的空树创建 
参数:无 
返回值:返回指向根节点指针的二级指针--空树默认为空节点,所以二级指针指向的一级指针应该指向NULL 
*/
BiTree* Creat()
{
	BiTree* T = (BiTree*)malloc(sizeof(BiTree));
	*T = NULL;
	return T;
}
/*
作用:二叉树的先序创建: #代表该节点为空
参数:(BiTree *)T:指向根节点的 二级指针
返回值:无
*/
void Tree_ProCreat(BiTree *T)
{
	Type data = getchar();
	if(data == '#')
		*T = NULL;
	else
	{
		(*T) = (BiTree)malloc(sizeof(BiTNode));//*T 相当于 lchild 或者 rchild (BiTNode*) 改变一级指针的指向(改变其内部存储的地址)需要使用二级指针
		(*T)->data = data;
		(*T)->flag = 0;
		Tree_ProCreat(&(*T)->lchild);
		Tree_ProCreat(&(*T)->rchild);
	}
}
/*
作用:二叉树的中序创建: #代表该节点为空
参数:(BiTree *)T:指向根节点的 二级指针
返回值:无
*/
void Tree_MidCreat(BiTree *T)
{
	Type data = getchar();
	if(data == '#')
		*T = NULL;
	else
	{
		Tree_MidCreat(&(*T)->lchild);
		(*T) = (BiTree)malloc(sizeof(BiTNode));//*T 相当于 lchild 或者 rchild (BiTNode*)
		(*T)->data = data;
		Tree_MidCreat(&(*T)->rchild);
	}
}
/*
作用:二叉树的后序创建: #代表该节点为空
参数:(BiTree *)T:指向根节点的 二级指针
返回值:无
*/
void Tree_BackCreat(BiTree *T)
{
	Type data = getchar();
	if(data == '#')
		*T = NULL;
	else
	{
		Tree_BackCreat(&(*T)->lchild);
		Tree_BackCreat(&(*T)->rchild);
		(*T) = (BiTree)malloc(sizeof(BiTNode));//*T 相当于 lchild 或者 rchild (BiTNode*)
		(*T)->data = data;
		(*T)->flag = 0;
	}
}
/*
作用:二叉树的先序遍历
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_ProPrint(BiTree root)
{
	if(root == NULL)
		return;
	printf("%c ",root->data);
	Tree_ProPrint(root->lchild);
	Tree_ProPrint(root->rchild);
}
/*
作用:二叉树的先序遍历--非递归
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_ProPrint_No(BiTree root)
{
	if(!root)
		return;
	BiTree stack[MAX_STACK];
	int top = 0;
	while(root||top)//只要根节点不空且栈没pop完就一直循环,因为要通过栈中元素来转到右孩子,root和stack为空说明遍历完了
	{
		while(root)//这个循环作用就是疯狂遍历左孩子 //第一次遍历
		{
			printf("%c ",root->data);//先序就是第一次把它压进栈就printf它
			stack[++top] = root;
			root = root->lchild;
		}
		if(top)//这个是第二次遇见节点,往右孩子尝试一下,看看有没有右孩子,然后pop掉工具人节点//第二次访问
		{
			root = stack[top--]->rchild;//这个元素左节点已经被访问了,只要继续访问它的右节点就可以了,它本身已经没有利用价值了,可以弹出了(老工具人了..)
		}
	}
}
//二叉树非递归先序遍历
void Tree_ProPrint_No2(BiTree root)//先序遍历的原理就是  压入根节点打印并弹出 , 再压入左节点 , 再压入右节点   根左右
{
	if(!root)
		return;
	stack <BiTree> Stack;//栈
	Stack.push(root);//把根入栈
	while(!Stack.empty())//栈不空就行
	{
		root = Stack.top();//获取栈顶节点

		printf("%c ",root->data);//展示    核心就是这三步的位置!
		Stack.pop();//抛出
		root->flag = 1;//标记被抛出

		if(root->rchild && root->rchild->flag==0)//先压入右孩子 这里一定要注意!先 push 右节点 再 push 左节点以至于之后每次获取到的节点都优先左节点...一直往左节点递归...
			Stack.push(root->rchild);
		if(root->lchild && root->lchild->flag==0)//再压入左孩子
			Stack.push(root->lchild);
	}
}
/*
作用:二叉树的中序遍历
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_MidPrint(BiTree root)
{
	if(root == NULL)
		return;
	Tree_MidPrint(root->lchild);
	printf("%c ",root->data);
	Tree_MidPrint(root->rchild);
}
/*
作用:二叉树的中序遍历--非递归
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_MidPrint_No(BiTree root)//这个和前序很像
{
	if(!root)
		return;
	BiTree stack[MAX_STACK];
	int top = 0;
	while(root||top)
	{
		while(root)
		{
			stack[++top] = root;
			root = root->lchild;
		}
		if(top)
		{
			printf("%c ",stack[top]->data);//中序就是在访问它第二次时(即要访问它的右孩子时)就可以printf它了
			root = stack[top--]->rchild;
		}
	}
}
//二叉树非递归中序遍历
void Tree_MidPrint_No2(BiTree root)//根据原理  压入左节点, 再显示并弹出根节点, 再压入右节点   左根右
{
	if(!root)
		return;
	stack <BiTree> Stack;//栈
	Stack.push(root);//把根入栈
	while(!Stack.empty())//栈不空就行
	{
		root = Stack.top();//获取栈顶节点
		if(root->lchild && root->lchild->flag==0)//先遍历左孩子
		{
			Stack.push(root->lchild);
		}
		else
		{
			printf("%c ",root->data);//标记并弹出
			Stack.pop();//抛出
			root->flag = 1;//标记

			if(root->rchild && root->rchild->flag==0)//再遍历右孩子
				Stack.push(root->rchild);
		}
	}
}
/*
作用:二叉树的后序遍历
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_BackPrint(BiTree root)
{
	if(root == NULL)
		return;
	Tree_BackPrint(root->lchild);
	Tree_BackPrint(root->rchild);
	printf("%c ",root->data);
}
/*
作用:二叉树的后序遍历--非递归
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_BackPrint_No(BiTree root)//这个和上面两种非递归的方法很不同,因为它是在第三次访问时才printf所以不能在第二次访问时就pop了,需要在第三次访问时pop并且printf,但如果pop了就需要标记下它已经被pop了不然会被它的双亲又给push进去了...
{
	if(!root)
		return;
	BiTree stack[MAX_STACK];
	int top = 0;
	while(root||top)
	{
		while(root && root->flag == 0)//如果这个节点是第一次访问就push进栈,遍历它的左孩子//第一次遍历
		{
			stack[++top] = root;
			root = root->lchild;
		}
		if(top)
		{
			if(stack[top]->rchild && stack[top]->rchild->flag == 0)//如果这个节点有左孩子而且左孩子是第一次遍历就去遍历左孩子//第二次遍历
			{
				root = stack[top]->rchild;
			}
			else
			{
				printf("%c ",stack[top]->data);//第三次遍历printf然后pop
				stack[top--]->flag = 1;//表示已经被弹出过,就不会被双亲再push进来了
			}
		}
	}
}
//二叉树非递归后序遍历
void Tree_BackPrint_No2(BiTree root)//根据原理  先压入左节点 再压入右节点 再打印并弹出根节点   左右根
{
	if(!root)
		return;
	stack<BiTree>Stack;
	Stack.push(root);//把根入栈
	while(!Stack.empty())//栈不空就行
	{
		root = Stack.top();//获取栈顶节点
		if(root->lchild && root->lchild->flag==0)//先压入左孩子
			Stack.push(root->lchild);
		else if(root->rchild && root->rchild->flag==0)//再压入右孩子
			Stack.push(root->rchild);
		else
		{
			printf("%c ",root->data);			//打印并弹出
			root->flag = 1;//标记被抛出
			Stack.pop();//抛出
		}
	}
}
//层序遍历
void Tree_LevelPrint(BiTree root)
{
	if(root==NULL)
		return;
//	BiTNode* stack[100];// 存放 BiTNode* 的数组  区别于 BiTNode (*stack)[100] : stack是个指针,指向着存着 BiTNode 的数组
	queue<BiTree> Queue;
	Queue.push(root);//将现在的根节点放入队列尾部
	while(!Queue.empty())
	{
		root = Queue.front();//获取队列头节点
		if(root->lchild)
			Queue.push(root->lchild);//压入右孩子
		if(root->rchild)
			Queue.push(root->rchild);//压入左孩子
		printf("%c ",root->data);//打印双亲节点并让双亲节点出栈
		Queue.pop();
	}
}
/*
作用:销毁整棵树
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_Destory(BiTree root)//新建了一个一级指针指向根节点
{
	if(root == NULL)
		return;
	Tree_Destory(root->lchild);
	Tree_Destory(root->rchild);
	free(root);
	root = NULL;
}
/*
作用:二叉树的判空
参数:(BiTree)root:指向根节点的 指针
返回值:若二叉树为空则返回 1,否则返回 0
*/
int Tree_Empty(BiTree root)
{
	if(root == NULL)
		return 1;
	return 0;
}
/*
作用:计算二叉树的深度
参数:(BiTree)root:指向根节点的 指针
返回值:返回二叉树的深度,空树返回0
*/
int Tree_Depth(BiTree root)//返回左右子树中较高的那颗的高度
{
	if(root==NULL)
		return 0;
	int m = Tree_Depth(root->lchild);
	int n = Tree_Depth(root->rchild);
	return (m>n?m:n)+1;//加1是加根节点自身高度
}
/*
前提:二叉树不为空
作用:找到二叉树的根节点
参数:(BiTree)root:指向根节点的 指针
返回值:返回二叉树根节点的值
*/
Type Tree_Root(BiTree root)
{
	return root->data;
}
/*
作用:统计二叉树的节点数
参数:(BiTree)root:指向根节点的 指针
返回值:返回二叉树的节点总数
*/
int Tree_NodeCount(BiTree root)
{
	if(root == NULL)
		return 0;//空节点返回0
	return Tree_NodeCount(root->lchild) + Tree_NodeCount(root->rchild) + 1;//加上自身节点
}
/*
作用:统计二叉树的叶子节点数
参数:(BiTree)root:指向根节点的 指针
返回值:返回二叉树的叶子节点总数
*/
int Tree_LeafCount(BiTree root)
{
	if(root==NULL)
		return 0;
	if(root->lchild==NULL&&root->rchild==NULL)//如果是叶子节点就返回自身 1
		return 1;
	return Tree_LeafCount(root->lchild)+Tree_LeafCount(root->rchild);//否则就继续搜索
}
/*
作用:先序遍历二叉树的叶子节点
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_LeafProPrint(BiTree root)
{
	if(root == NULL)
		return;
	if(root->lchild==NULL&&root->rchild==NULL)
		printf("%c ",root->data);
	else
	{
		Tree_LeafProPrint(root->lchild);
		Tree_LeafProPrint(root->rchild);
	}
}
/*
作用:中序遍历二叉树的叶子节点
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_LeafMidPrint(BiTree root)
{
	if(root == NULL)
		return;
	Tree_LeafMidPrint(root->lchild);
	if(root->lchild==NULL&&root->rchild==NULL)
		printf("%c ",root->data);
	else
		Tree_LeafMidPrint(root->rchild);
}
/*
作用:后序遍历二叉树的叶子节点
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_LeafBackPrint(BiTree root)
{
	if(root == NULL)
		return;
	Tree_LeafBackPrint(root->lchild);
	Tree_LeafBackPrint(root->rchild);
	if(root->lchild==NULL&&root->rchild==NULL)
		printf("%c ",root->data);
}
/*
作用:计算二叉树度为一的节点的数目
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
int Tree_Leaf_One_Count(BiTree root)
{
	if(root==NULL)//空返回0
		return 0;
	if(root->lchild==NULL&&root->rchild||root->rchild==NULL&&root->lchild)
		return Tree_Leaf_One_Count(root->lchild) + Tree_Leaf_One_Count(root->rchild) + 1;//存在一个叶子节点就加个1,再继续找
	else
		return Tree_Leaf_One_Count(root->lchild) + Tree_Leaf_One_Count(root->rchild);
}
/*
作用:二叉树镜像化
参数:(BiTree)root:指向根节点的 指针
返回值:无
*/
void Tree_Mirror(BiTree root)
{
	if(root == NULL)
		return;
	BiTree temp;//交换左右孩子节点
	temp = root->lchild;
	root->lchild = root->rchild;
	root->rchild = temp;
	Tree_Mirror(root->lchild);
	Tree_Mirror(root->rchild);
}
/*
作用:二叉树单节点复制
参数:(BiTree)node:指向 二叉树节点的 指针
返回值:(BiTree)newnode 返回复制出的节点指针
*/
BiTree Tree_NodeCopy(BiTree node)
{
	BiTree newnode = (BiTree)malloc(sizeof(BiTNode));
	newnode->data = node->data;
	newnode->lchild = NULL;
	newnode->rchild = NULL;
	return newnode;
}
/*
作用:二叉树复制
参数:(BiTree)node:指向根节点的 指针
返回值:(BiTree)newroot 指向根节点的指针
*/
BiTree Tree_Copy(BiTree root)
{
	if(root == NULL)
		return NULL;
	BiTree newroot= Tree_NodeCopy(root);
	newroot->lchild = Tree_Copy(root->lchild);
	newroot->rchild = Tree_Copy(root->rchild);
	return newroot;
}
/*
作用:计算二叉树第k层的节点数
参数: (BiTree)node:指向根节点的 指针 (int)k:二叉树的第k层
返回值:返回第k层的节点数
*/
int Tree_LevelCount(BiTree root,int k)
{
	if(root == NULL)
		return 0;
	if(k == 1)
		return 1;
	return Tree_LevelCount(root->lchild,k-1) + Tree_LevelCount(root->rchild,k-1);//没找到就往下找并且层数-1
}
/*
作用:在以 root为根的二叉树中寻找 节点(BiTree)cur的双亲
参数: (BiTree )root:指向根节点的 指针 (BiTree)cur:指向 需要寻找双亲的节点的 指针
返回值:若找到双亲则返回指向其双亲的指针,否则返回NULL
*/
BiTree Tree_Parent(BiTree root,BiTree cur)
{
	if(root == NULL)//如果该节点为空返回空
		return NULL;
	if(root->lchild==cur||root->rchild==cur)//如果此节点为双亲则返回次节点
		return root;
	BiTree p = Tree_Parent(root->lchild,cur);//此节点不是双亲就在左子树中寻找
	if(p)
		return p;//如果找到了双亲(非NULL)就返回双亲
	else
		return Tree_Parent(root->rchild,cur);//在左子树中没找到双亲就去右子树寻找
}
/*
作用:判断两颗二叉树 T1 和 T2是否相似
参数:(BiTree)T1:指向一颗二叉树头节点的指针,(BiTree)T2:指向另一颗二叉树头节点的指针
返回值:若两棵子树相似则返回1,不相似则返回0
*/
int Tree_IsSimilar(BiTree root1,BiTree root2)
{
	if(root1 == NULL&&root2 == NULL)
		return 1;
	if(root1 == NULL||root2 == NULL)
		return 0;
	int similar1 = Tree_IsSimilar(root1->lchild,root2->lchild);//判断左子树
	int similar2 = Tree_IsSimilar(root1->rchild,root2->rchild);//判断右子树
	return (similar1 && similar2);//左右子树形状都需要相似才认为二叉树相似
}
/*
作用:垂直打印树
参数:(BiTree)Parent:指向一颗二叉树头节点的二级指针,(BiTree)root:指向同一颗二叉树头节点的二级指针
返回值:无
*/
void Tree_Show(BiTree parent,BiTree root,char *prefix)
{
	strcat(prefix,"|");//遇到一个 根 就往字符串后面加一个'|' 意味这一层打印的是上一层的孩子
	if(root)
	{
		printf("%s--%c\n",prefix,root->data);//如果此时的*root不是空的就打印次节点的 值
		if(parent == root||parent->rchild == root)//意思是如果是最初指在一块时或者是打印完两个孩子了就取消掉这一层创建的 '关系柱子' --> '|'
		{
			int len = strlen(prefix);
			prefix[len-1] = ' ';
		}
		char p1[100],p2[100];
		strcpy(p1,prefix);
		strcat(p1,"  ");
		strcpy(p2,prefix);
		strcat(p2,"  ");
		Tree_Show(root,root->lchild,p1);
		Tree_Show(root,root->rchild,p2);
	}
	else
	{
		if(parent->lchild||parent->rchild)//如果此时的parent只要有一个节点就要打印'#',体现出左右孩子的结构
			printf("%s--#\n",prefix);
	}
}
/*
作用:展示二叉树所有叶子节点到根节点的路径
参数:((BiTree)T:指向二叉树头节点的指针,(char *)stack:存放依次经过的节点的值,(int)top:最后一个存放在stack中的节点的位置
返回值:无
*/
void Tree_PrintLeafPath(BiTree root,char *stack,int top)
{
	if(root == NULL)
		return;
	stack[top] = root->data;//将此节点放到stack中
	if(root->lchild==NULL&&root->rchild==NULL)//如果此节点使叶子节点就全部输出
	{
		for(int i = top; i>=0; i--)
			printf("%c ",stack[i]);
		putchar('\n');
		return;
	}
	Tree_PrintLeafPath(root->lchild,stack,top+1);
	Tree_PrintLeafPath(root->rchild,stack,top+1);
}

int dfs_Symmetric(BiTree left,BiTree right)
{
	if(left == NULL && right == NULL)
		return 1;
	if(left==NULL&&right||left&&right==NULL)
		return 0;
	if(left->data!=right->data)
		return 0;
	return dfs_Symmetric(left->rchild,right->lchild) && dfs_Symmetric(left->lchild,right->rchild);
}
/*
作用:判断二叉树是否镜像对称(值也对称)
参数:(BiTree)root:指向二叉树根节点的指针
返回值:若该二叉树镜像对称则返回1,否则返回0
*/
int Tree_IsSymmetric(BiTree root)
{
	if(root==NULL)
		return 0;
	return dfs_Symmetric(root->lchild,root->rchild);
}

int dfs_SumPath(BiTree root,int sum,int num)
{
	if(root==NULL)
		return 0;
	if(root->lchild==NULL&&root->rchild==NULL)
	{
		if(sum==num)
			return 1;
		return 0;
	}
	return dfs_SumPath(root->lchild,sum+root->data,num)||dfs_SumPath(root->rchild,sum+root->data,num);
}
/*
作用:判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 num
参数:(BiTree)root:指向二叉树根节点的指针,(int)num:目标和
返回值:若存在节点和等于num则返回1,否则返回0
*/
int Is_SumPath(BiTree root,int num)
{
	if(root==NULL)
		return 0;
	return dfs_SumPath(root,0,num);
}

int main()
{
	char* s1 = (char*)malloc(sizeof(char)*100);
	char stack[100];
//	BiTree p = NULL;
//	BiTree *T = &p;
	BiTree *T = Creat();
	printf("树的先序创建(#代表该节点为空):");
	Tree_ProCreat(T);
	printf("二叉树T已创建");
	printf("\nT树的先序遍历:\n");
//	Tree_ProPrint_No2(*T);//非递归先序遍历第二种方法
//	putchar('\n');
	Tree_ProPrint_No(*T);
	putchar('\n');
	Tree_ProPrint(*T);
	printf("\nT树的中序遍历:\n");
//	Tree_MidPrint_No2(*T);
//	putchar('\n');
	Tree_MidPrint_No(*T);
	putchar('\n');
	Tree_MidPrint(*T);
	printf("\nT树的后序遍历:\n");
//	Tree_BackPrint_No2(*T);
//	putchar('\n');
	Tree_BackPrint_No(*T);
	putchar('\n');
	Tree_BackPrint(*T);
	printf("\nT树的层次遍历:\n");
	Tree_LevelPrint(*T);
	if(Tree_Empty(*T))
	{
		printf("\nT树为空树\n");
	}
	else
	{
		printf("\nT树的根节点为:%c",Tree_Root(*T));
	}

	printf("\nT树的深度为:%d",Tree_Depth(*T));

	printf("\nT树的节点个数为:%d",Tree_NodeCount(*T));

	printf("\nT树的叶子节点总数为%d个 ",Tree_LeafCount(*T));
	printf("\n先序遍历T树叶子节点为:");
	Tree_LeafProPrint(*T);
	printf("\n中序遍历T树叶子节点为:");
	Tree_LeafMidPrint(*T);
	printf("\n后序遍历T树叶子节点为:");
	Tree_LeafBackPrint(*T);

	printf("\nT树所有叶子节点到根节点的路径分别是\n");
	Tree_PrintLeafPath(*T,stack,0);

	int k = 2;
	printf("\nT树第%d层的节点为%d个",k,Tree_LevelCount(*T,k));

	printf("\nT树的形状是:\n");
	s1[0] = '\0';
	Tree_Show(*T,*T,s1);

	printf("\n复制原二叉树");
	BiTree newroot = Tree_Copy(*T);
	printf("\n新二叉树newT已创建");
	BiTree *newT = &newroot;
	printf("\nnewT树与T树是否相似(1.相似,0不相似):%d",Tree_IsSimilar(*T,*newT));

	Tree_Mirror(*newT);
	printf("\nnewT树镜像化成功");

	printf("\nnewT树的先序遍历:");
	Tree_ProPrint(*newT);
	printf("\nnewT树的中序遍历:");
	Tree_MidPrint(*newT);
	printf("\nnewT树的后序遍历:");
	Tree_BackPrint(*newT);
	printf("\nnewT树的层次遍历:");
	Tree_LevelPrint(*newT);

	printf("\nnewT树与T树是否相似(1.相似,0不相似):%d",Tree_IsSimilar(*T,*newT));

	printf("\nnewT树的形状是:\n");
	s1[0] = '\0';
	Tree_Show(*newT,*newT,s1);

	printf("\nnewT树所有叶子节点到根节点的路径是\n");
	Tree_PrintLeafPath(*newT,stack,0);

	Tree_Destory(*newT);
	printf("\nnewT树销毁成功");
	*newT = NULL;

	if(Tree_Empty(*newT))
	{
		printf("\nnewT树为空树");
	}
	return 0;
}
CRAJA
关注
专栏目录
二叉树的基本操作
学习笔记
07-19 2535
二叉树的基本操作包括创建、获取四种遍历方式
C语言实现二叉树的基本操作
tellsummer的博客
12-27 855
代码如下#include<stdio.h> #include<stdlib.h> //二叉树的节点定义 typedef struct TreeNode { char ch; //数据域 struct TreeNode *lchild; //左孩子 struct TreeNode *rchild; //右孩子 }BTNode,*PBTNod
二叉树的基本操作（C语言实现）
03-23
NULL 博文链接：https://touch-2011.iteye.com/blog/1058160
[源码和文档分享]基于C语言的二叉树基本操作的实现
qq_38474694的博客
07-13 117
1 问题描述在主程序中编写一个简单的菜单，将有关二叉树的操作建立一棵二叉树的存储结构遍历一棵二叉树（包括层次遍历）统计二叉树叶子结点的个数求二叉树的深度子树交换2 基本要求建立一棵二叉树的存储结构遍历一棵二叉树（包括层次遍历）统计二叉树叶子结点的个数求二叉树的深度子树交换3 算法思想CreatBiTree()运用递归创造二叉树的每一个节点Exchange(...
数据结构之二叉树(C语言版)
最新发布
跃渊的博客
08-11 690
这期我们就讲完了二叉树的基本内容，希望对大家有所帮助，欢迎大家批评指正！
二叉树的基本操作（C语言）
zhan_qian的博客
10-21 338
#include<stdio.h> #include<stdlib.h> #include<time.h> struct TreeNode{ int data; struct TreeNode *left; struct TreeNode *right; }; struct TreeNode *createNode(int num){/*创建新的树节点*/ struct TreeNode *T; T=(struct TreeNod.
C语言二叉树的基本操作（超全）
热门推荐
qq_51553982的博客
05-25 4万+
二叉树作为数据结构其实是一个挺有意思的结构，可以有多种应用 我们直接来看一下二叉树的代码： #include<stdlib.h> #include<stdio.h> #include<malloc.h> #include<string.h> #define maxsize 100 //二叉树的基本操作：建立，前序，中序，后序，层次，求叶子数，求层数,求结点树 //二叉树的数据结构 //创建数据域和左右指针域 typedef struct Tree { c
二叉树-基于C语言实现的二叉树基本操作.zip
04-26
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。 在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...
C语言实现二叉树的基本操作源码.zip
10-30
在IT领域，二叉树是一种基础且重要的数据结构，它在很多算法...以上就是关于C语言实现二叉树基本操作的详细解释。通过理解和掌握这些概念，你可以编写出高效、可靠的二叉树操作代码，这对于解决许多计算问题至关重要。
C语言二叉树基本操作
11-21
以上就是C语言中二叉树基本操作的核心内容。通过创建节点、插入节点和进行前序遍历，我们可以对二叉树进行基本的操作和理解。这些概念是进一步学习二叉树的其他操作（如中序遍历、后序遍历、层次遍历等）的基础，也...
二叉树的基本操作C语言实现
03-12
用C语言实现关于二叉树的初始化、插入、删除、路径、等数据结构的操作
二叉树的使用方法
qq_30534935的博客
02-11 1270
转载： http://blog.jobbole.com/108184/ https://blog.csdn.net/zhanggonglalala/article/details/79738213 https://blog.csdn.net/heyanxi0101/article/details/79593542 一、概述 平衡树：所有结点左右子树深度差≤1 排序树：所有结点“左小右大 字典树：由...
【数据结构】【C/C++】二叉树的三种遍历 递归方法代码实现
YuXi_0520的博客
03-03 2503
首先你要学会创建一棵二叉树，可以参考我的这篇文章【数据结构】【C/C++】创建二叉树-链式存储-C和C++双语教学 其次，你要知道什么叫做先序中序和后序遍历，可以参考这篇文章【数据结构】理解二叉树的三种遍历–前序、中序、后序 +层序（简明易懂） 知道了这些后，我们来一起看看二叉树先序中序和后序遍历的实现代码！ 非递归方法请关注下一篇 解析与代码 还记得我们上一篇中说的么？【数据结构】理解二叉树的三...
c语言实现二叉树的基本操作
tellsummer的博客
11-26 1万+
#include<stdlib.h> //二叉树的节点定义 typedef struct TreeNode { char ch; //数据域 struct TreeNode *lchild; //左孩子 struct TreeNode *rchild; //右孩子 }BTNode,*PBTNode;//先序构造二叉树 void creat
二叉树基本操作-C语言实现
小铅笔
12-06 1356
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct BiTNode { int data; struct BiTNode *lchild, *rchild; } BiTNode, *BiTree; void CreatBiTree(BiTree &amp;T) { int e; s...
二叉树的基本操作（c语言）
qq_39838607的博客
09-13 1162
二叉树的基本操作 创建二叉树 二叉树的叶子节点 二叉树的节点总数 二叉树的高度
用c语言二叉树的基本操作实现
04-26
C语言中实现二叉树的基本操作，需要定义一个二叉树结构体，并实现以下基本操作： 1. 创建二叉树：创建一个空的二叉树，或者给定节点值创建一个带有左右子树的二叉树。 2. 遍历二叉树：可以通过递归实现先序遍历、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值