数据结构—二叉树

最新推荐文章于 2025-07-22 13:11:09 发布
最新推荐文章于 2025-07-22 13:11:09 发布
阅读量86 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mercury__/article/details/105492124
本文详细介绍了二叉树的链式存储结构，包括递归与非递归方式构建二叉树的方法，以及先序、中序、后序和层序遍历的递归与非递归实现。此外，还探讨了二叉树的深度、叶子节点数量的计算，以及二叉树的复制过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

#include "StdAfx.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>


//定义链式存储的二叉树类型
struct TreeNode
{
	char data;//数据域
	struct TreeNode *left;//左域
	struct TreeNode *right;//右域
};
typedef TreeNode *BinTree;



//导入链队列相关
struct Node
{
	BinTree data;//数据域
	struct Node *next;//指针域
};
typedef struct Node *PNode;
struct Queue
{
	PNode f;//f指向头结点
	PNode r;//r指向尾结点
};
typedef struct Queue *LinkQueue;

LinkQueue SetNullQueue()
{
	LinkQueue lqueue;
	lqueue=(LinkQueue)malloc(sizeof(struct Queue));//为队列lqueue分配队列结构体那么大空间
	if(lqueue!=NULL)//分配成功则使f,r指空
	{
		lqueue->f=NULL;
		lqueue->r=NULL;
	}
	else
		printf("alloc failure!");
	return lqueue;
}

int IsNullQueue(LinkQueue lqueue)
{
	return(lqueue->f==NULL);//若头指针指空则为空
}

void InQueue(LinkQueue lqueue,BinTree x)//x入队
{
	PNode p;
	p=(PNode)malloc(sizeof(struct Node));//申请一个结点空间p用于存放输入数据，由p指向
	if(p!=NULL)
	{
		p->data=x;//放入数据至p
		p->next=NULL;
		if(IsNullQueue(lqueue))//若空队列则特殊处理
		{
			lqueue->f=p;
			lqueue->r=p;
		}
		else//不是空队列则按以下操作
		{
			lqueue->r->next=p;//队尾结点指针指向p
			lqueue->r=p;//使队尾指针指向p指向的结点空间p
		}
	}
	else
		printf("alloc failure!");
}

void OutQueue(LinkQueue lqueue)
{
	PNode p;
	if(IsNullQueue(lqueue))//判空
		printf("empty!");
	else
	{
		p=lqueue->f;//使p指向头结点
		lqueue->f=lqueue->f->next;//头指针指向头结点的next所指
		free(p);//释放头结点
	}
}

BinTree FrontQueue(LinkQueue lqueue)
{
	if(lqueue->f==NULL)//判空
	{
		printf("empty!");
		return 0;
	}
	else
		return (lqueue->f->data);//返回头结点数据域
}



//导入链栈相关
typedef int DataType;
typedef struct Node *top;//Node刚才链队列那里已经定义过了所以这里不重复定义了
typedef struct Node *LinkStack;

LinkStack SetNullStack()
{
	LinkStack top=(LinkStack)malloc(sizeof(struct Node));//申请栈顶空间，top指向
	if(top!=NULL)
		top->next =NULL;
	else
		printf("alloc failure");
	return top;//返回栈顶指针
}

int IsNullStack(LinkStack top)
{
	return(top->next == NULL);
}

void Push(LinkStack top,BinTree x)//x进栈
{
	PNode p=(PNode)malloc(sizeof(struct Node));//结点p，用于存放新进栈数据
	if(p!=NULL)
	{
		p->data =x;
		p->next =top->next ;//使p指针域为NULL
		top->next =p;
	}
	else
		printf("alloc failure!\n");
}

void Pop(LinkStack top)
{
	PNode p;
	if(IsNullStack(top))
		printf("empty!\n");
	else
	{
		p=top->next ;//孤立p然后删除
		top->next =p->next ;
		free(p);
	}
}

BinTree top_seq(LinkStack top)
{
	if(IsNullStack(top))
		printf("empty!\n");
	else
		return top->next ->data ;
}



//递归建立二叉树
BinTree create1()
{	
	BinTree bt;
	char ch;
	scanf(" %c",&ch);//输入想放入二叉树根节点的字符，若想让某一个为空则输入@去填充(%前加空格避免将回车字符也作为输入数据)
	if(ch=='@')
		bt=NULL;
	else
	{
		bt=(BinTree)malloc(sizeof(struct TreeNode));
	    bt->data=ch;
	    bt->left=create1();//递归构造左子树
	    bt->right=create1();//递归构造右子树
	}
	return bt;
}



//非递归建立二叉树(要补充成完全二叉树，即除最后一层外其余各层都满的，且最后一层结点从左到右要挨着不能留空隙)
BinTree create2()
{
	LinkQueue queue=SetNullQueue();//建立空队列
	BinTree s,p,bt;
	int count=-1;//设置计数器
	char ch;
	scanf(" %c",&ch);//输入根节点数据
	bt=NULL;
	while(ch!='#')//输入#则结束
	{
		if(ch=='@')//若输入的是@则为虚结点，s指空,计数器加一
		{
			s=NULL;
			count++;
		}
		else//若输入不为虚结点,将ch放入s空间的数据域内，s不指空，计数器加一
		{
			s=(BinTree)malloc(sizeof(struct TreeNode));
			s->data=ch;
			s->left=NULL;
			s->right=NULL;
			count++;		
		}			
		InQueue(queue,s);//将虚结点和新结点入队
		if(count==0)//若计数器为0则s为根节点，bt指向（之后会有很多结点加进去构成树）
			bt=s;
		else
		{
			p=FrontQueue(queue);//p指队头（父节点）
			if(s!=NULL && p!=NULL)//若s及其父节点都不是虚结点
				if(count%2==1)//cout为奇，新结点作为左儿子插入父节点
					p->left=s;
				else
					p->right=s;//为偶则作为右儿子插入父节点
			if(count%2==0)//count为0说明已经处理到右儿子了，即左右两儿子已经处理完成，头结点出队
				OutQueue(queue);
		}
		scanf(" %c",&ch);
	}
	return bt;
}



//深度优先遍历（递归先序遍历）
void preOrder1(BinTree bt)
{
	if(bt)
	{
	    printf("%c",bt->data);//若数不为空则按上左右依次遍历
	    preOrder1(bt->left);
        preOrder1(bt->right);
	}
}



//深度优先遍历（非递归先序遍历）
void preOrder2(BinTree bt)
{
	LinkStack lstack=SetNullStack();//建立空链栈
	BinTree p=bt;
	if(bt)//bt不为空则将其根节点压入链栈
		Push(lstack,bt);
	while(!IsNullStack(lstack))//若连栈不为空
	{
		p=top_seq(lstack);//p取链栈顶元素
		Pop(lstack);//顶元素出栈
		while(p)//当p不为空
		{
			printf("%c",p->data);//输出其数据
			if(p->right)//若右儿子不为空则右进栈
				Push(lstack,p->right);
			p=p->left;//p取其左儿子再次判断
		}
	}
}



//深度优先遍历（递归中序遍历）
void inOrder1(BinTree bt)
{
	if(bt)//若数不为空则按左上右依次遍历
	{
		inOrder1(bt->left);
		printf("%c",bt->data);
		inOrder1(bt->right);
	}
}



//深度优先遍历（非递归中序遍历）
void inOrder2(BinTree bt)
{
    LinkStack lstack=SetNullStack();//建立空链栈
	BinTree p=bt;
	if(bt)//bt不为空则将其根节点压入链栈
		Push(lstack,bt);
	p=p->left;//进入左子树
	while(p||!IsNullStack(lstack))//若栈不为空或者左儿子不为空
	{
		while(p)//进入左子树的左子树
		{
			Push(lstack,p);//左儿子进栈
			p=p->left;
		}
		p=top_seq(lstack);//p取栈顶元素
		Pop(lstack);//栈顶元素出栈
		printf("%c",p->data);//输出栈顶元素
		p=p->right;//判断右子树
	}
}



//深度优先遍历（递归后序遍历）
void postOrder1(BinTree bt)
{
	if(bt)//若数不为空则按左右上依次遍历
	{
		postOrder1(bt->left);
		postOrder1(bt->right);
		printf("%c",bt->data);
	}
}



//深度优先遍历（非递归后序遍历）
void postOrder2(BinTree bt)
{
	LinkStack lstack=SetNullStack();//建立空链栈
	BinTree p=bt;
	while(p||!IsNullStack(lstack))//若栈不为空或者根节点不为空
	{
		while(p)
		{
			Push(lstack,p);//根节点进栈
			p=p->left?p->left:p->right;//若有左儿子则p为左儿子否则为右儿子
		}
		p=top_seq(lstack);//p取栈顶元素
		Pop(lstack);//栈顶元素出栈
		printf("%c",p->data);//输出栈顶元素
		if(!IsNullStack(lstack)&&(top_seq(lstack)->left==p))//从左子树退回进入右子树
			p=top_seq(lstack)->right;
		else
			p=NULL;//从右子树退回上一级
	}
}



//广度优先遍历（层序遍历）,根节点开始一层一层往下遍历，同一层按从左到右遍历(使用链队列)
void levelOrder(BinTree bt)
{
	BinTree p;
	LinkQueue queue=SetNullQueue();//创建空队列queue
	if(bt)//bt非空则...
	{
		p=bt;
		InQueue(queue,bt);//根节点入队
		while(!IsNullQueue(queue))//队列不空时执行循环
		{
			p=FrontQueue(queue);
			OutQueue(queue);//根节点出队
			printf("%c",p->data);//打印出队的所存放数据
			if(p->left!=NULL)//左儿子进队
				InQueue(queue,p->left);
			if(p->right!=NULL)//右儿子进队
				InQueue(queue,p->right);
		}
	}
}






//统计二叉树叶子节点数
int LeafNode(BinTree bt)
{
	if(bt==NULL)//若二叉树为空，则叶子结点数为0
		return 0;
	else//若二叉树不为空
	{
		if(bt->left==NULL && bt->right==NULL)//左右儿子为空，则为叶子结点
			return 1;
		else
			return( LeafNode(bt->left) + LeafNode(bt->right) );//遍历左右子树叶子结点数
	}
}



//统计二叉树深度(左右子树深度更高的那个+1)
int deep(BinTree bt)
{
	if(bt==NULL)
		return 0;
	else
	{
		int i=deep(bt->left);//递归计算左子树深度
		int j=deep(bt->right);//递归计算右子树深度
		int max=i>j?i:j;//判断两子树深度更高的那个
		return max+1;//+1
	}
}



//复制一颗二叉树(先复制左子树再复制右子树，最后复制结点数据)
BinTree copy(BinTree bt1)
{
	BinTree bt2;
	if(bt1)
	{
		bt2=(BinTree)malloc(sizeof(struct TreeNode));
		if(bt2)
		{
			bt2->left=copy(bt1->left);//递归复制左子树
			bt2->right=copy(bt1->right);//递归复制右子树
			bt2->data=bt1->data;
			return bt2;
		}
		else
			printf("alloc failure");
	}
	else
		return 0;
}



//主函数
int main()
{
	BinTree bt1=create1();//递归构建一颗二叉树bt1
	preOrder1(bt1);//递归先序遍历
	printf("\n");
	preOrder2(bt1);//非递归先序遍历
	printf("\n");
	inOrder1(bt1);//递归中序遍历
	printf("\n");
	inOrder2(bt1);//非递归中序遍历
	printf("\n");
	postOrder1(bt1);//递归后序遍历
	printf("\n");
	postOrder2(bt1);//非递归后序遍历
	printf("\n");
	levelOrder(bt1);//层序遍历
	printf("\n");
	int i=LeafNode(bt1);//求叶子结点
	printf(" %d",i);
	printf("\n");
	int j=deep(bt1);//求深度
	printf(" %d",j);
	printf("\n");
	BinTree bt2=copy(bt1);//复制二叉树
	preOrder1(bt2);
	printf("\n");
	BinTree bt3=create2();//非递归构建一颗二叉树bt2
	preOrder1(bt3);//递归先序遍历
	printf("\n");
	system("pause");
}
#include“stdafx.h”详解
尚钦
08-17 4万+
1，用VS2008新建项目，选择【Win32】-【Win32控制台应用程序】-输入名称：Test-【确定】   再选【下一步】-默认情况下，我们都是在【空项目】前打上对勾，建立一个纯的C或C++程序。 我们这里选择默认，即【预编译头】前打上对勾，之后【完成】 2，在Test
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
二叉树
姜姜的Blog
11-28 122
二叉树叶子结点算法 #include <stdio.h> #include<stdlib.h> typedef struct btnode /*定义结点类型*/ { char data; struct btnode *lchild,*rchild; }bitnode,*bitree; bitree createbitree() { bit...
【数据结构】二叉树
DerrictC的博客
09-18 2400
该算法从堆的根节点开始，通过比较和交换节点值，将根节点调整到其在堆中的正确位置，以确保堆的每个父节点的值都大于或等于其子节点的值（在最大堆中），或者小于或等于其子节点的值（在最小堆中）。我们常见的二叉树的结构叫逻辑结构如下图1，这是我们自己想象出来的二叉树的样子，但实际上二叉树并不是就像图中所示的那样，二叉树真正的结构，也叫物理结构，是像数组一样每个数据一行排开，如图2，图2所示及是实实在在。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。如果二叉树为空，则退出；
数据结构——二叉树
Eristic0618的博客
01-21 2816
本篇文章围绕数据结构中的二叉树展开详细讲解，包含树的概念、二叉树的定义、特殊类型、性质、相关操作和二叉树OJ题等
数据结构——遍历二叉树
weixin_74209413的博客
10-07 3047
遍历定义-- 顺着某一条搜索路径巡访二叉树中的结点，使得每个结点均被访问一次，而且仅被访问一次(又称周游)。“访问”的含义很广，可以是对结点作各种处理，如：输出结点的信息、修改结点的数据值等，但要求这种访问不破坏原来的数据结构。遍历目的-- 得到树中所有结点的一个线性排列。遍历用途--它是树结构插入、删除、修改、查找和排序运算的前提，是二又树一切运算的基础和核心。遍历方法依次遍历二叉树的三个组成部分，便是遍历了整个二叉树。
数据结构之二叉树
qq_37080455的博客
06-27 6306
1、基本概念：树就是一种类似现实生活中的树的数据结构（倒置的树）。任何一颗非空树只有一个根节点。2、一棵树具有以下特点：3、树的形状如下图所示： 4、区别： 层数：从根节点开始算，为第一层。 高度：从最下面的叶子节点开始算，且从0开始计数。 深度：从根节点开始算，从0开始计数。树的基本名词解释：二叉树（Binary tree）是每个节点最多只有两个分支（即不存在分支度大于 2 的节点）的树结构。二叉树 的分支通常被称作“左子树”或“右子树”。并且，二叉树 的分支具有
数据结构二叉树题库
闲狗的博客
08-01 1万+
《数据结构二叉树之闲死攻略（一）》 目录 华文课后题 王道课后题 华文课后题 1、一棵有512个结点的完全二叉树的高度为多少？（独根树高度为1） 解析： 答案： 10 2、请写出下面这棵二叉树的中序遍历 解析： 左-根-右 left-root-right 答案： LXMECKPBQHDA 3、下列关于二叉树性质的说法正确的有： A、非空满二叉树的结点个数...
【数据结构】——二叉树详解
atwdy的博客
07-28 6万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
数据结构二叉树实验报告
weixin_45590210的博客
11-22 4743
第一个实验是求一颗树的结点个数,叶子结点个数,某一个结点的深度,以及整颗树的宽度. 先来考虑一下如何读入一颗树.其实递归的读入左右子树即可. 参考代码: 树的结构体: struct Tree{ char data; Tree * lson,* rson; }; 读入部分 bool input(Tree *now){ // 这部分只是读入这颗树,不一定要这么写 cin >> now->data; if(now->data == '0') return
头歌数据结构二叉树的二叉链表存储及基本操作
05-18
在IT领域，数据结构是计算机科学的基础，而二叉树是一种重要的抽象数据类型。本题主要涉及二叉树的链式存储方式以及基于链表的二叉树的基本操作，包括先序遍历、计算二叉树的高度、节点总数、叶子节点数、层次遍历...
头歌数据结构二叉树的顺序存储及基本操作
05-18
在计算机科学中，二叉树是一种重要的数据结构，它的每个节点最多有两个子节点，分别称为左子树和右子树。这种特殊的树形结构在很多领域都有应用，特别是在文件系统和数据库系统中，利用二叉树可以实现高效的排序和...
数据结构二叉树功能展示
06-02
数据结构二叉树功能展示包括以完全前序序列创建二叉树"; cout以前序和中序序列创建二叉树"; cout前序遍历二叉树"; cout中序遍历二叉树"; cout后序遍历二叉树"; cout广度优先遍历二叉树"; cout求某结点的双亲";...
C语言数据结构二叉树简单应用
08-30
本文主要介绍了C语言数据结构二叉树简单应用的相关知识点，涵盖了二叉树的创建、先中后序递归遍历、统计叶子结点的总数、求树的高度、反转二叉树、输出每个叶子结点到根节点的路径、输出根结点到每个叶子结点的路径...
数据结构 二叉树
03-20
数据结构中的二叉树是一种非常重要的非线性数据结构，其在计算机科学中扮演着核心角色，尤其是在数据存储和检索方面。本文将深入探讨二叉树的定义、特性、操作及其实现细节，旨在帮助读者全面理解二叉树及其在实际...
【数据结构】
2401_89443484的博客
07-20 180
比如找helloworld。
【PTA数据结构 | C语言版】堆中的路径
等风来
07-20 751
将一系列给定数字插入一个初始为空的最小堆 h。随后对任意给定的下标 i，打印从第 i 个结点到根结点的路径。输入格式:每组测试第 1 行包含 2 个正整数 n 和 m (≤10^3)，分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间 [−10^4,10^4] 内的 n 个要被插入一个初始为空的小顶堆的整数。最后一行给出 m 个下标。输出格式:对输入中给出的每个下标 i，在一行中输出从第 i 个结点到根结点的路径上的数据。数字间以 1 个空格分隔，行末不得有多余空格。
Python 库手册：collections 额外数据结构模块
qq_41176800的博客
07-19 512
collections 是 Python 内建的一个功能强大的容器模块，提供了几种常用的专用容器类型，这些容器在许多场景下比内置的 list、dict、set 和 tuple 更高效、可读性更强。通过 UserDict、UserList、UserString 派生自定义容器类，适用于类封装、接口设计或行为增强。这些类是对内建类型 dict、list、str 的封装，可用于继承并定制行为。2、deque 是实现栈、队列、缓存（如 LRU）等场景的首选容器。多个字典逻辑上组合为一个视图，常用于构建嵌套作用域。
算法和数据结构在程序开发方面的应用
最新发布
Ba2213的博客
07-22 108
从上面的例子中我们可以发现，可能我们在数据结构和算法的学习中会感觉到比较枯燥和乏味，课本上的案例可能没有看上去那么有意思和有实际用途，但是只要在生活和实际开发中花点时间观察和尝试，就可以想出如何将这些看上去较为单调的知识转化为节省时间/提高效率的手段，从而进一步将数据结构和算法应用到实际之中。在这么一个需求下，系统已经封装好的库便爱莫能助了，因为要完成这么一件事情，首先要结合所学的知识想到。此时，我们便简单地将数据结构和算法应用到了实际的一个开发需求之中。
数据结构二叉树详解
"数据结构二叉树优选ppt资料.ppt" 这份资料主要涵盖了数据结构中的核心概念——二叉树。二叉树是数据结构中的一个重要组成部分，它是一种特殊的树形结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值