数据结构：二叉树的详解及相关操作（创建二叉树，前、中、后、层序遍历，节点个数及衍生问题，判断完全二叉树，查找）

最新推荐文章于 2021-05-22 01:22:01 发布
最新推荐文章于 2021-05-22 01:22:01 发布
阅读量216 收藏 2
点赞数 1
分类专栏： 数据结构 C语言 文章标签： 二叉树 队列 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43647942/article/details/112966436
版权

  • 二叉树基本概念:
    一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
    在这里插入图片描述

  • 二叉树的特点：

  • 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。

  • 二叉树的子树有左右之分，其子树的次序不能颠倒。

  • 特殊的二叉树：

  • 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是
    说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。

  • 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K
    的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对
    应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
    在这里插入图片描述

  • 二叉树的存储结构
    二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。

  • 顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。
    在这里插入图片描述

  • 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。

  • 在这里插入图片描述

  • 二叉树的性质

  1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
  2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.
  3. 对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2＋1
  4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=Log2(n+1). (ps：Log2(n+1)是log以2为
    底，n+1为对数)
  5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对
    于序号为i的结点有：
  6. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
  7. 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
  8. 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

    二叉树基本操作

构建二叉树

在这里插入图片描述

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树（# == NULL）
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi) {
	if (*pi == n || a[*pi] == '#') {//如果字符串遍历结束或者字符串内容为'#',返回NULL
		++(*pi);
		return NULL;
	}

	BTNode* NewNode = (BTNode*)malloc(sizeof(BTNode));//申请新的节点来保存数据
	NewNode->_data = a[*pi];
	++(*pi);
	NewNode->_left = BinaryTreeCreate(a, n, pi);//递归构建左子树与右子树
	NewNode->_right = BinaryTreeCreate(a, n, pi);

	return NewNode;//返回树
}

二叉树销毁

void BinaryTreeDestory(BTNode** root) {
	if (*root == NULL) {
		return;
	}
	BinaryTreeDestory(&(*root)->_left);//释放左右子树
	BinaryTreeDestory(&(*root)->_right);
	free(*root);//释放该节点
}

二叉树节点个数

int BinaryTreeSize(BTNode* root) {
	if (root == NULL) {//如果为空,返回0
		return 0;
	}
	return BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;//不为空，返回左右子树节点个数额总和 + 1
}

二叉树叶子节点个数

int BinaryTreeLeafSize(BTNode* root) {
	if (root == NULL) {//节点为空，返回0
		return 0;
	}
	if (root->_left == NULL && root->_right == NULL) {//叶子节点，返回1
		return 1;
	}
	//非叶子节点，叶子节点的个数为左右子树叶子节点个数的和
	return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);
}

二叉树第k层节点个数

int BinaryTreeLevelKSize(BTNode* root, int k) {
	if (root == NULL) {//节点为空，返回0
		return 0;
	}
	if (k == 1) {//k == 1即求该层节点个数
		return 1;
	}
	//k != 1，不是该层，继续向下查找
	return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
}

二叉树查找值为x的节点

BTNode* BinaryTreeFind(BTNode* root, BTDataType x) {
	if (root == NULL) {//节点为空，返回NULL
		return NULL;
	}
	if (root->_data == x) {//该节点就是要找的节点，返回
		return root;
	}
	BTNode* ret = BinaryTreeFind(root->_left, x);//左子树查找
	if (ret) {//如果左子树找到了，返回该节点
		return ret;
	}
	return BinaryTreeFind(root->_right, x);//返回右子树查找的结果
}

二叉树前序遍历

void BinaryTreePrevOrder(BTNode* root) {
	if (root == NULL) {
		return;
	}
	printf("%c ", root->_data);//根左右
	BinaryTreePrevOrder(root->_left);
	BinaryTreePrevOrder(root->_right);
}

二叉树中序遍历

void BinaryTreeInOrder(BTNode* root) {
	if (root == NULL) {
		return;
	}
	BinaryTreeInOrder(root->_left);//左根右
	printf("%c ", root->_data);
	BinaryTreeInOrder(root->_right);
}

二叉树后序遍历

void BinaryTreePostOrder(BTNode* root) {
	if (root == NULL) {
		return;
	}
	BinaryTreePostOrder(root->_left);//左右根
	BinaryTreePostOrder(root->_right);
	printf("%c ", root->_data);
}

层序遍历

  • 层序遍历需要使用队列，从根节点开始，将根节点入队，然后出队，出队时把根节点的两个孩子（如果不为空）入队，下一个元素出队时将该节点的孩子入队，如此往复，队列不为空时一直循环执行此操作，达到层序遍历。
void BinaryTreeLevelOrder(BTNode* root) {
	if (root == NULL) {
		return;
	}
	Queue q;//新建一个队列
	QueueInit(&q);
	QueuePush(&q, root);//将根节点入队
	while (!QueueEmpty(&q)) {
		BTNode* temp = QueueFront(&q);//队头元素出队
		QueuePop(&q);
		if (temp->_left) {//把出队节点的左右孩子（如果有）入队
			QueuePush(&q, temp->_left);
		}
		if (temp->_right) {
			QueuePush(&q, temp->_right);
		}
		printf("%c ", temp->_data);//输出队头元素
	}
}

判断二叉树是否是完全二叉树

  • 依旧使用队列，每个元素出队时不管其孩子是否为空都入队，在执行循环时，如果出队列的元素为空，此时如果是满二叉树则所有节点都已遍历完毕，队列中只有空，所以结束循环，将队列中的元素依次出队，如果均为空，则为完全二叉树。
//返回1表示是完全二叉树，0表示不是完全二叉树
int BinaryTreeComplete(BTNode* root) {
	if (root == NULL) {
		return 1;
	}
	Queue q;//新建一个队列
	QueueInit(&q);
	QueuePush(&q, root);//将根节点入队
	while (!QueueEmpty(&q)) {
		BTNode* temp = QueueFront(&q);//队头元素出队
		QueuePop(&q);
		if (temp == NULL){//如果队头为空，结束循环
			break;
		}
		QueuePush(&q, temp->_left);//左右孩子入队，（空也入队）
		QueuePush(&q, temp->_right);
	}
	while (!QueueEmpty(&q)) {
		BTNode* temp = QueueFront(&q);//队头元素出队
		QueuePop(&q);
		if (temp != NULL) {//如果不为空，返回0，非完全二叉树
			return 0;
		}
	}
	return 1;
}

运行结果

在这里插入图片描述

完整代码

程序中用到队列，队列的实现过于繁琐，这里并没有给出，如果想了解队列的，我的另一篇博客也有介绍
BinaryTree.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "Queue.h"


typedef char BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
// 二叉树销毁
void BinaryTreeDestory(BTNode** root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历	
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);

BinaryTree.c


#include "BinaryTree.h"



// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi) {
	if (*pi == n || a[*pi] == '#') {//如果字符串遍历结束或者字符串内容为'#',返回NULL
		++(*pi);
		return NULL;
	}

	BTNode* NewNode = (BTNode*)malloc(sizeof(BTNode));//申请新的节点来保存数据
	NewNode->_data = a[*pi];
	++(*pi);
	NewNode->_left = BinaryTreeCreate(a, n, pi);//递归构建左子树与右子树
	NewNode->_right = BinaryTreeCreate(a, n, pi);

	return NewNode;//返回树
}

// 二叉树销
void BinaryTreeDestory(BTNode** root) {
	if (*root == NULL) {
		return;
	}
	BinaryTreeDestory(&(*root)->_left);//释放左右子树
	BinaryTreeDestory(&(*root)->_right);
	free(*root);//释放该节点
}

// 二叉树节点个数
int BinaryTreeSize(BTNode* root) {
	if (root == NULL) {//如果为空,返回0
		return 0;
	}
	return BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;//不为空，返回左右子树节点个数额总和 + 1
}

// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root) {
	if (root == NULL) {//节点为空，返回0
		return 0;
	}
	if (root->_left == NULL && root->_right == NULL) {//叶子节点，返回1
		return 1;
	}
	//非叶子节点，叶子节点的个数为左右子树叶子节点个数的和
	return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);
}

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k) {
	if (root == NULL) {//节点为空，返回0
		return 0;
	}
	if (k == 1) {//k == 1即求该层节点个数
		return 1;
	}
	//k != 1，继续向下查找，k--,
	return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
}

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x) {
	if (root == NULL) {//节点为空，返回NULL
		return NULL;
	}
	if (root->_data == x) {//该节点就是要找的节点，返回
		return root;
	}
	BTNode* ret = BinaryTreeFind(root->_left, x);//左子树查找
	if (ret) {//如果左子树找到了，返回该节点
		return ret;
	}
	return BinaryTreeFind(root->_right, x);//返回右子树查找的结果
}

// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root) {
	if (root == NULL) {
		return;
	}
	printf("%c ", root->_data);//根左右
	BinaryTreePrevOrder(root->_left);
	BinaryTreePrevOrder(root->_right);
}

// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root) {
	if (root == NULL) {
		return;
	}
	BinaryTreeInOrder(root->_left);//左根右
	printf("%c ", root->_data);
	BinaryTreeInOrder(root->_right);
}

// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root) {
	if (root == NULL) {
		return;
	}
	BinaryTreePostOrder(root->_left);//左右根
	BinaryTreePostOrder(root->_right);
	printf("%c ", root->_data);
}

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root) {
	if (root == NULL) {
		return;
	}
	Queue q;//新建一个队列
	QueueInit(&q);
	QueuePush(&q, root);//将根节点入队
	while (!QueueEmpty(&q)) {
		BTNode* temp = QueueFront(&q);//队头元素出队
		QueuePop(&q);
		if (temp->_left) {//把出队节点的左右孩子（如果有）入队
			QueuePush(&q, temp->_left);
		}
		if (temp->_right) {
			QueuePush(&q, temp->_right);
		}
		printf("%c ", temp->_data);//输出队头元素
	}
}

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root) {
	if (root == NULL) {
		return 1;
	}
	Queue q;//新建一个队列
	QueueInit(&q);
	QueuePush(&q, root);//将根节点入队
	while (!QueueEmpty(&q)) {
		BTNode* temp = QueueFront(&q);//队头元素出队
		QueuePop(&q);
		if (temp == NULL){//如果队头为空，结束循环
			break;
		}
		QueuePush(&q, temp->_left);//左右孩子入队，（空也入队）
		QueuePush(&q, temp->_right);
	}
	while (!QueueEmpty(&q)) {
		BTNode* temp = QueueFront(&q);//队头元素出队
		QueuePop(&q);
		if (temp != NULL) {//如果不为空，返回0，非完全二叉树
			return 0;
		}
	}
	return 1;
}

test.c

#include "BinaryTree.h"



void test() {
	char arr[] = { "ABD##E#H##CF##G##" };
	int i = 0;
	BTNode* Bt = BinaryTreeCreate(arr, sizeof(arr) / sizeof(arr[0]), &i);
	BinaryTreePrevOrder(Bt);
	printf("\n");
	BinaryTreePostOrder(Bt);
	printf("\n");
	BinaryTreeInOrder(Bt);
	printf("\n");
	BinaryTreeLevelOrder(Bt);
	printf("\n");
	printf("%d\n", BinaryTreeComplete(Bt));
	printf("%c\n", BinaryTreeFind(Bt, 'F')->_data);
	printf("%d\n", BinaryTreeLeafSize(Bt));
	printf("%d\n", BinaryTreeLevelKSize(Bt, 3));
	printf("%d\n", BinaryTreeSize(Bt));
	BinaryTreeDestory(&Bt);
}


int main() {
	test();
	return 0;
}
tangke121
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构 二叉树
weixin_45368634的博客
03-30 145
树型机构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树，是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的 特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、…、Tm，其中每一个集合Ti (1 <= i <= m) 又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继 树是递归定义的 概念 节点的度：一个节点含有的子树
数据结构——初学树
qq_44145934的博客
07-29 128
树的简介 树是一种非线性数据结构。由n（n>=0）个节点构成，第一个节点称为根节点。树是由根节点（唯一）+子树（m >= 0）组成且子树之间互不相交。 特点：元素间称为“一对多”关系，呈现分支、分层的形态。 最简单和常用的是二叉树。 树的基本概念 森林： m（m>=0）棵互不相交的树的集合。 任何一棵非空树可表示为一个二元组 Tree = （root，F） ...
数据结构--二叉树
qq_46659987的博客
01-17 2028
树：一种非线性的数据结构，由n（n>=0）个有效结点组成的一个具有层次关系的集合；
二叉树的基本操作（二叉树的前中后遍历，节点个数，叶子个数，k层节点个数，树的高度，x对应节点，节点双亲。）
金金金金金的博客
04-01 218
//二叉树的基本操作，这次写到了一起，直接写到了.h 文件里， //问题不大，也可以运行的，只不过你要加一个运行的.c 文件 #pragma once #include <stdlib.h> #include <stdio.h> #include <assert.h> #include <malloc.h> #include <stdbool...
二叉排序树的构建及验证
nanqiao_0121的专栏
12-24 462
其实二叉排序树的创建也是插入的一种，插入时首先会检查结点是否为空，若为空则插入结点就是根节点，然后才会根据插入结点的值和根节点值比较，选择向左子树或者右子树插入，代码如下： #include using namespace std; typedef struct BitreeNode//构建二叉树结点 {      int item;      struct BitreeNod
Java实现的二叉树常用操作【前序建树，前中后递归非递归遍历及层序遍历】
08-28
Java实现的二叉树常用操作是指使用Java语言来实现二叉树的各种操作，包括前序建树、前中后递归非递归遍历、层序遍历等。下面我们将详细介绍这些操作的实现方法。 一、前序建树 前序建树是指从一个数组中构建一个...
二叉树前中后层序遍历及树，节点构建c++代码样例
最新发布
03-11
本文将详细介绍如何使用C++语言实现二叉树的前、中、后层序遍历以及如何构建和添加节点。 首先，我们需要定义一个二叉树节点类，包含数据、左子节点和右子节点的指针。在C++中，这可以表示为： ```cpp class ...
C++数据结构与算法二叉树的层序遍历代码及注释
04-02
本文将深入探讨C++中的数据结构之一——二叉树，并重点讲解如何实现二叉树的层序遍历。层序遍历，也称为宽度优先搜索（BFS），是一种在二叉树中遍历节点的常用方法，它按照从上至下、从左到右的顺序逐层访问所有节点...
数据结构-二叉树的建立及遍历操作
05-23
数据结构-二叉树的建立及遍历操作
python数据结构：求二叉树节点个数
01-21
求二叉树节点个数 1.设计思想： 建立一棵二叉树，利用递归求二叉树节点个数 2.实现代码 class BinaryTreeNode(object): # 创建二叉树结点的函数 def __init__(self): self.data = '#' self.LChild = None self....
二叉查找树与中间值查找
我想跟代码谈谈
09-29 2174
二叉查找树是具有如下性质的一种二叉树：对于任一结点x，x的左子树结点的关键字均不大于x，右子树结点的关键字均不小于x。 二叉查找树的特点是位置决定了顺序，所以在不对关键字进行排序的情况下，通过位置关系就能找到特定大小的关键字结点。例如，对二叉查找树进行中根遍历就能按升序输出所有的关键字。   二叉查找树的搜索：从根节点开始，对于树中任一结点k，若k的关键字大于待搜索的值x，则搜索k的左子树；
c语言创建满二叉树,递归创建二叉树c语言实现+详细解释
weixin_42552315的博客
05-22 277
该楼层疑似违规已被系统折叠隐藏此楼查看此楼voidCreatBiTree(BiTreeT){chara;scanf("%c",&a);if(a=='@')T=NULL;else{T=(BiTree)malloc(sizeof(BiNode));T->data=a;CreatBiTree(T->lchild);CreatBiTree(T->rchild);}}虽能编...
二叉树的建立与排序
朝辞暮见的博客
05-15 1329
一、树的定义：1、定义：树（Tree）是n（n&gt;=0）个节点的有限集，n=0时称为“空树”。在任意一棵非空树中：⒈有且仅有一个特定的称为根（root）的节点。⒉当n&gt;1时，其余节点可分为m（m&gt;0）个互不相交的有限集T1、T2……Tm，其中每一个集合本身又是一棵树，并且称之为根的子树（SubTree）。2、树的节点的分类：树的节点包含一个数据元素以及若干个指向其子树的分支。节点拥...
数据结构与算法-- 二叉树后续遍历序列校验
0102的博客
04-07 172
二叉树后续遍历序列校验 题目：输入一个整数数组，判断改数组是否是某个二叉搜索树的后续遍历结果，如果是返回true否则false，假设输入数组的任意两个数字不相同。 例如输入{5,7,6,9,11,10,8}则返回true，因为这个整数序列是如下图二叉搜索树的后续遍历结果： 如果输入{7,4，6,5}没有哪个二叉搜索树后续遍历结果是这个序列。 我们必须先知道二叉搜索树的一些基本特性，在之前的文章：二叉查找树实现原理对二叉搜索树进行的详细的说明，已经案例分析，在二叉搜索树中如下两个性质： 对
【数据结构周周练】015 利用递归算法创建链式存储的二叉树并转换左右孩子结点
水亦心的博客
10-24 511
一、前言 哈哈，今天就是程序员节啦，祝大家1024程序员节快乐。 今天要给大家分享的算法是交换二叉树是的左右孩子结点，比较简单，需要创建一个结点用来暂存左孩子结点，下面给大家送上代码。 二、题目 将下图用二叉树存入，并交换二叉树是的左右孩子结点。其中圆角矩形内为结点数据，旁边数字为结点编号，编号为0的结点为根节点，箭头指向的结点为箭尾的孩子结点。   不是完全二叉树   是完全...
二叉树
qq_37254296的博客
09-04 510
一、定义 二叉树是 n 个节点的有限集合，该集合或者为空集（空二叉树），或者由一个根节点和两棵互不相交的、分被称为根节点的左子树和右子树组成。下图为一棵普通的二叉树： 二、二叉树的特点 由二叉树定义以及图示分析得出二叉树有以下特点： 每个节点最多有两棵子树，所以二叉树中不存在度大于2的节点。 左子树和右子树是有顺序的，次序不能任意颠倒。 即使树中某节点只有一棵树，也要区分它是左子树...
二叉树基础
weixin_30552635的博客
05-05 324
前言 树是数据结构中的重中之重，尤其以各类二叉树为学习的难点。一直以来，对于树的掌握都是模棱两可的状态，现在希望通过写一个关于二叉树的专题系列。在学习与总结的同时更加深入的了解掌握二叉树。本系列文章将着重介绍一般二叉树、完全二叉树、满二叉树、线索二叉树、霍夫曼树、二叉排序树、平衡二叉树、红黑树、B树。希望各位读者能够关注专题，并给出相应意见，通过系列的学习做到心中有“树”。 1 重点概...
数据结构（9）——树
qq_34528825的博客
11-24 345
树的定义： 树是n个结点的有限集。n=0时称为空树。在任意一棵非空树中： 1.有且仅有一个特定的称为根结点 2.n > 1时，其余结点可分为m个互不相交的有限集T1、T2、......Tm，其中每个集合本身有时一棵树，并且称为根的子树。如下图： 子树T1，T2是上面的子树 关于树的定义要注意以下两点： 1.n>0时根结点是唯一的。 2.m>0时，子树的个数没有限制
数据结构--6.树
weixin_43798821的博客
04-07 212
树 6.1树的定义 树（Tree)是n(n≥0)个结点的有限集。n=0时称为空树。在任意一棵非空树中：(1)有且仅有一个特定的称为根（Root)的结点；(2)当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1、T2、……Tm,其中每一个集合本身又是一棵树，并且称为根的子树(SubTree),如图所示。 对于树的定义还需要强调两点： 1.n>0时根结点是唯一的，不可能存在多个根结点，别和现实中的大树混在一起，现实中的树有很多根须，那是真实的树，数据结构中的树是只能有一根结点。
数据结构：二叉树遍历详解
“这是一份关于数据结构的英文教学课件，专注于树与二叉树的第二部分，涵盖了二叉树节点的抽象数据类型（ADT）以及遍历算法，包括层次遍历、前序遍历、中序遍历和后序遍历。课件讨论了递归和非递归两种遍历算法实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值