数据结构——二叉树

已于 2024-03-02 14:33:59 修改
阅读量1.7k 收藏 32
点赞数 34
分类专栏： 数据结构 文章标签： 数据结构
于 2024-01-21 18:10:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Eristic0618/article/details/135723033
版权

目录

一、前言

1.1 树

1.2 树的相关概念 

二、二叉树

2.1 定义

2.2 特殊类型

2.3 二叉树的性质

2.4 二叉树的存储结构

（1）顺序存储

（2）链式存储

三、二叉树相关操作

3.1 创建一颗二叉树

3.2 二叉树的遍历

（1）前序遍历/先序遍历

（2）中序遍历

（3）后序遍历

（4）层序遍历

3.3 二叉树的其他操作

（1）求二叉树节点个数

（2）求二叉树的高度

（3）求二叉树第k层节点个数

（4）求二叉树叶子节点个数

（5）在二叉树中查找值为x的节点

（6）销毁二叉树

（7）判断是否为完全二叉树

四、二叉树基础OJ题练习

4.1 单值二叉树

4.2 相同的树

4.3 对称二叉树

4.4 二叉树的前序遍历

4.5 二叉树的中序遍历

4.6 二叉树的后序遍历

4.7 另一棵树的子树

4.8 二叉树的构建及遍历

一、前言

1.1 树

树是一种非线性的数据结构，它是由 n 个有限节点组成的一个具有层次关系的集合。之所以称之为“树”是因为它看起来像一颗倒挂着的树，一颗根朝上叶子朝下的树。

其中，类似A这种没有前驱节点的被称为根节点，与A相连的三个子节点与自身的后继节点构成了三颗子树。每颗子树的根节点只能有一个前驱节点，可以有多个后继节点。因此，树是递归定义的。 

需要注意的是，在树形结构中，子树之间不能有交集，否则就不是树而是图了。

1.2 树的相关概念 

关于树的相关概念，需要简单提一嘴

（1）节点的度：一个节点含有的子树的个数称为该节点的度。例如A的度为6。

（2）叶节点/终端节点：度为0的节点。例如B、H、P、L等节点。

（3）分支节点/非终端节点：度不为0的节点。例如D、E、J、F等节点。

（4）父节点/双亲节点：如果一个节点含有子节点，则该节点是自身子节点的父节点。例如A是B的父节点。

（5）子节点/孩子节点：一个节点含有的子树的根节点。例如B是A的子节点。

（6）兄弟节点：具有相同父节点的节点互称兄弟节点。例如B和C是兄弟节点。

（7）树的度：一个树中最大的节点的度就是树的度。例如A的度最大，为6，则树的度为6。

（8）节点的层次：从根开始定义，根为第一层，根的子节点为第二层，向下类推。

（9）树的高度/深度：树中节点的最大层次。例如上图树的高度为4。

（10）堂兄弟节点：父节点在同一层的节点互为堂兄弟节点。例如H和J互为堂兄弟节点。

（11）节点的祖先：从根到该节点所经的所有节点。例如A是所有节点的祖先。

（12）子孙：以某节点为根的树中任意节点都称为该节点的子孙。例如上图所有节点都是A的子孙

（13）森林：n颗互不相交的树组成的集合称为森林。

二、二叉树

2.1 定义

二叉树（Binary tree）是树形结构的一个重要类型，是指树中节点的度不大于2的有序树。

所以一颗非空二叉树由一个根节点加上两颗同样为二叉树的左右子树组成，左右子树不能颠倒。

2.2 特殊类型

（1）斜树：所有的节点都只有左子树的二叉树叫左斜树，所有节点都只有右子树的二叉树叫右斜树。

（2）满二叉树：每层的节点都是满的二叉树

（3）完全二叉树：前n-1层都是满的，最后一层可以不满，但是一定是连续的

2.3 二叉树的性质

（1）若定义根节点的层数为1，则一颗非空二叉树的第n层上最多有2^{n-1}个节点

（2）若定义根节点的层数为1，则高度为n的二叉树的最大节点数为2^{h}-1

（3）若定义根节点的层数为1，则具有n个节点的满二叉树的高度h=\log _{2}\left ( n+1 \right )

（4）非空二叉树中度为0的节点一定比度为2的节点多一个 

（5）对于具有n个节点的完全二叉树，如果按照从上到下从左到右的数组顺序对所有节点从0开始编号，则对于序号为i的节点：

  • 其父节点序号为\left ( i-1 \right )/2
  • 其左子节点序号为2i+1
  • 其右子节点序号为2i+2

2.4 二叉树的存储结构

二叉树可以使用两种结构来存储：顺序结构和链式结构

（1）顺序存储

顺序存储就是使用数组来存储数据，一般只有完全二叉树适合使用数组存储，因为非完全二叉树不连续，会造成空间的浪费。

在前面的数据结构——堆-CSDN博客中我们提到过，堆也是完全二叉树，而平时生活中也只有堆会用数组存储，存储顺序对应二叉树的性质五。

二叉树的顺序存储在物理上是一个数组，而在逻辑上是一颗二叉树。

（2）链式存储

用链表来表示一颗二叉树，即用链来指示节点间的逻辑关系。

链式结构存储又分为二叉链和三叉链，当前我们主要使用二叉链，即左右指针指向左孩子和右孩子所在的节点地址。后面学到高阶数据结构如红黑树才会用到三叉链。

typedef int BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;  //指向左孩子
	struct BinaryTreeNode* right; //指向右孩子
}BTNode;

三、二叉树相关操作

在学习二叉树的相关操作之前，我们得先有一颗二叉树。

为了降低学习成本，我们先手动创建一颗简单的二叉树，快速进入其他的操作学习。等学到高阶二叉树后我们再来研究二叉树真正的创建方式。

3.1 创建一颗二叉树

要创建二叉树，我们得先写一个创建二叉树新节点的函数

BTNode* CreateNewNode(BTDataType x) //创建新节点
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}

然后手动创建一颗和下图一样的二叉树

BTNode* CreateBinaryTree() //创建二叉树
{
	BTNode* node1 = CreateNewNode(1);
	BTNode* node2 = CreateNewNode(2);
	BTNode* node3 = CreateNewNode(3);
	BTNode* node4 = CreateNewNode(4);
	BTNode* node5 = CreateNewNode(5);
	BTNode* node6 = CreateNewNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	return node1;
}

3.2 二叉树的遍历

二叉树遍历即按照一定的顺序依次对二叉树中的节点进行相应的操作，且每个节点只操作一次。

其中又分为前序遍历（先序遍历）、中序遍历、后序遍历和层序遍历。

前序、中序和后序遍历都是使用递归结构来实现，而层序遍历需要用到队列。

（1）前序遍历/先序遍历

先访问根节点，再依次访问左子树和右子树，即为前序遍历。

按照这个顺序，我们来遍历一遍前面创建的二叉树

前序遍历的代码如下： 

void PreOrder(BTNode* root) //二叉树前序遍历
{
	if (root == NULL)
	{
		printf("N "); //遇到空树打印N代表NULL
		return;
	}
	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

我们测试一下

（2）中序遍历

先访问左子树，再访问根节点，最后访问右子树，即为中序遍历

中序遍历的代码如下：

void InOrder(BTNode* root) //二叉树中序遍历
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

可以发现中序遍历和前序遍历只是将代码交换一下即可，后面的后序遍历也是一样。

我们测试一下

（3）后序遍历

先访问左子树和右子树，最后再访问根节点，即为后序遍历

相信经过前面的前序遍历和中序遍历后大家都能掌握遍历的过程规律了，这里就不再讲解，尝试自己算一下结果吧

后序遍历的代码如下：

void PostOrder(BTNode* root) //二叉树后序遍历
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

我们测试一下

（4）层序遍历

从上到下，从左到右逐层访问树的结点的过程就是层序遍历。

与前中后序遍历不同的是，层序遍历不使用递归，而是使用队列来实现。

队列中不是直接存放节点的值，而是存放节点的地址。

其核心思路是，上一层的节点出队列时带入下一层的节点入队列

在写层序遍历的时候，我们把之前的队列搬过来即可

层序遍历代码如下：

void LevelOrder(BTNode* root) //二叉树层序遍历
{
	Queue que;
	QueueInit(&que);
	if (root)
		QueuePush(&que, root);
	while (!QueueEmpty(&que))
	{
		BTNode* front = QueueFront(&que);
		QueuePop(&que);
		printf("%d ", front->data);
		if (front->left != NULL)
			QueuePush(&que, front->left);
		if (front->right != NULL)
			QueuePush(&que, front->right);
	}
	QueueDestroy(&que);
}

测试一下

3.3 二叉树的其他操作

（1）求二叉树节点个数

有人会想，求二叉树节点个数，遍历一下就好了。但是实际上用分治的思想更优。

分治，即分而治之，就是将一个复杂的问题分解成子问题，子问题再分解成更小子问题，直到最后子问题可以简单求解。

例如要求二叉树的节点个数，我们可以将其拆分成左子树、根和右子树。

把左子树的节点个数加上右子树的节点个数，再加上根，即为二叉树的节点个数。

而左子树和右子树也能以相同的方式进行拆分。这样就将一个大问题拆分成了许多个相同的小问题

代码如下：

int BTreeSize(BTNode* root) //求二叉树节点个数
{
	if (root == NULL)
		return 0;
	return BTreeSize(root->left) + BTreeSize(root->right) + 1;
}

测试一下

（2）求二叉树的高度

这里也可以用分治的思想，大家可以自己试一下，后面很多函数都会用到分治思想。

取左右子树的最大值，再加上自身，就是二叉树的高度

代码如下：

int BTreeHeight(BTNode* root) //求二叉树的高度
{
	if (root == NULL)
		return 0;
	int leftHeight = BTreeHeight(root->left);
	int rightHeight = BTreeHeight(root->right);
	return leftHeight >= rightHeight ? leftHeight + 1 : rightHeight + 1;
}

测试一下 

这里递归的返回值必须要记录下来，不然会重复计算

（3）求二叉树第k层节点个数

代码如下：

int BTreeLevelKSize(BTNode* root, int k) //求二叉树第k层节点个数
{
	assert(k > 0);
	if (root == NULL)
		return 0;
	int count = k - 1;
	if (count == 0) //count为0，说明到达第k层
		return 1;
	return BTreeLevelKSize(root->left, count) + BTreeLevelKSize(root->right, count);
}

测试一下

（4）求二叉树叶子节点个数

代码如下：

int BTreeLeafSize(BTNode* root) //求二叉树叶子节点个数
{
	if (root == NULL)
		return 0;
	if (root->left == NULL && root->right == NULL) //左右都为空树，说明是叶子节点
		return 1;
	return BTreeLeafSize(root->left) + BTreeLeafSize(root->right);
}

测试一下

（5）在二叉树中查找值为x的节点

先访问根，根不为x则访问左子树

左子树中没找到则找右子树，找到了则返回节点地址

右子树中找到了返回节点地址，没找到则说明树中没有值为x的节点，返回NULL

代码如下：

BTNode* BTreeFind(BTNode* root, BTDataType x) //在二叉树中查找值为x的节点
{
	if (root == NULL)
		return NULL;
	if (root->data == x)
		return root;
	BTNode* left = BTreeFind(root->left, x);
	if (left)
		return left;
	BTNode* right = BTreeFind(root->right, x);
	if (right)
		return right;
	return NULL;
}

（6）销毁二叉树

销毁一颗二叉树最好使用后序，先销毁其左子树和右子树，最后销毁根节点

代码如下：

void BTreeDestroy(BTNode* root) //销毁二叉树
{
	if (root == NULL)
		return;
	BTreeDestroy(root->left);
	BTreeDestroy(root->right);
	free(root);
}

（7）判断是否为完全二叉树

我们知道，完全二叉树的节点必须是连续的，要判断一颗树是否为完全二叉树，最好使用层序遍历

通过层序遍历将树中的节点地址进入队列，但是与层序遍历不同，这里遇到NULL也要进队列

当我们获取队头元素时，如果是NULL，就结束入队的操作，开始检测队列中是否存在不为空的值

代码如下：

bool BTreeComplete(BTNode* root) //判断是否为完全二叉树
{
	Queue que;
	QueueInit(&que);
	if (root)
		QueuePush(&que, root);
	while (!QueueEmpty(&que))
	{
		BTNode* front = QueueFront(&que);
		if (front == NULL)
			break;
		QueuePop(&que);
		QueuePush(&que, front->left);
		QueuePush(&que, front->right);
	}
	while (!QueueEmpty(&que))
	{
		BTNode* front = QueueFront(&que);
		QueuePop(&que);
		if (front != NULL)
		{
			QueueDestroy(&que);
			return false;
		}
	}
	QueueDestroy(&que);
	return true;
}

测试一下

我们在创建二叉树的函数中手动把树补全一下

再测试一下

关于二叉树相关操作的学习就先到此为止，接下来我们来看看关于二叉树的OJ题

四、二叉树基础OJ题练习

4.1 单值二叉树

OJ题链接：965. 单值二叉树 - 力扣（LeetCode）

代码如下：

bool isUnivalTree(struct TreeNode *root)
{
    if (root == NULL)
        return true;
    bool left, right;
    if (root->left != NULL && root->val != root->left->val)
        return false;
    else
        left = isUnivalTree(root->left);
    if (root->right != NULL && root->val != root->right->val)
        return false;
    else
        right = isUnivalTree(root->right);
    return left && right;
}

4.2 相同的树

OJ题链接：100. 相同的树 - 力扣（LeetCode）

代码如下：

bool isSameTree(struct TreeNode *p, struct TreeNode *q)
{
    if (p == NULL || q == NULL)
    {
        if (p == NULL && q == NULL)
            return true;
        else
            return false;
    }
    if (p->val == q->val)
    {
        if (!isSameTree(p->left, q->left) || !isSameTree(p->right, q->right))
            return false;
        else
            return true;
    }
    else
        return false;
}

4.3 对称二叉树

OJ题链接：101. 对称二叉树 - 力扣（LeetCode）

代码如下：

bool _isSymmetric(struct TreeNode *left, struct TreeNode *right)
{
    if (left == NULL && right == NULL)
        return true;
    else if (left == NULL || right == NULL)
        return false;
    if (left->val != right->val)
        return false;
    return _isSymmetric(left->left, right->right) && _isSymmetric(left->right, right->left);
}

bool isSymmetric(struct TreeNode *root)
{
    return _isSymmetric(root->left, root->right);
}

4.4 二叉树的前序遍历

OJ题链接：144. 二叉树的前序遍历 - 力扣（LeetCode）

这里的前序遍历并不是像我们前面写的只需要把节点值打印出来，而是按照遍历顺序将值存放到一个数组中并返回数组地址

代码如下：

void PreOrder(struct TreeNode *root, int *arr, int *returnSize)
{
    if (root == NULL)
    {
        return;
    }
    arr[(*returnSize)++] = root->val;
    PreOrder(root->left, arr, returnSize);
    PreOrder(root->right, arr, returnSize);
}

int *preorderTraversal(struct TreeNode *root, int *returnSize)
{
    int *arr = (int *)malloc(sizeof(int) * 1000);
    *returnSize = 0;
    PreOrder(root, arr, returnSize);
    return arr;
}

4.5 二叉树的中序遍历

OJ题链接：94. 二叉树的中序遍历 - 力扣（LeetCode）

代码如下：

void InOrder(struct TreeNode *root, int *arr, int *returnSize)
{
    if (root == NULL)
    {
        return;
    }
    InOrder(root->left, arr, returnSize);
    arr[(*returnSize)++] = root->val;
    InOrder(root->right, arr, returnSize);
}

int *inorderTraversal(struct TreeNode *root, int *returnSize)
{
    int *arr = (int *)malloc(sizeof(int) * 1000);
    *returnSize = 0;
    InOrder(root, arr, returnSize);
    return arr;
}

4.6 二叉树的后序遍历

OJ题链接：145. 二叉树的后序遍历 - 力扣（LeetCode）

代码如下：

void PastOrder(struct TreeNode *root, int *arr, int *returnSize)
{
    if (root == NULL)
    {
        return;
    }
    PastOrder(root->left, arr, returnSize);
    PastOrder(root->right, arr, returnSize);
    arr[(*returnSize)++] = root->val;
}

int *postorderTraversal(struct TreeNode *root, int *returnSize)
{
    int *arr = (int *)malloc(sizeof(int) * 1000);
    *returnSize = 0;
    PastOrder(root, arr, returnSize);
    return arr;
}

4.7 另一棵树的子树

OJ题链接：572. 另一棵树的子树 - 力扣（LeetCode）

这里我把前面相同的树中的代码cv了过来（懒狗实锤了doge）

🎊这是个小彩蛋！感觉能一点点看到这的人应该很少吧＞﹏＜

如果发现了这个彩蛋让我在评论区看到你好吗( •̀ ω •́ )✧

代码如下：

bool isSameTree(struct TreeNode *p, struct TreeNode *q)
{
    if (p == NULL || q == NULL)
    {
        if (p == NULL && q == NULL)
            return true;
        else
            return false;
    }
    if (p->val == q->val)
    {
        if (!isSameTree(p->left, q->left) || !isSameTree(p->right, q->right))
            return false;
        else
            return true;
    }
    else
        return false;
}

bool isSubtree(struct TreeNode *root, struct TreeNode *subRoot)
{
    if (root == NULL)
        return false;
    if (isSameTree(root, subRoot))
        return true;
    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}

4.8 二叉树的构建及遍历

OJ题链接：二叉树遍历_牛客题霸_牛客网 (nowcoder.com)

在牛客网里写OJ题，我们就要把二叉树的一些函数贴上去啦

代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef char BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

BTNode* CreateNewNode(BTDataType x) //创建新节点
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}

void BTreeDestroy(BTNode* root) //销毁二叉树
{
	if (root == NULL)
		return;
	BTreeDestroy(root->left);
	BTreeDestroy(root->right);
	free(root);
}

BTNode* TreeBuild(char* arr,int* pi)
{
    if(arr[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    else 
    {
        BTNode* root = CreateNewNode(arr[*pi]);
        (*pi)++;
        root->left = TreeBuild(arr,pi);
        root->right = TreeBuild(arr,pi);
        return root;
    }
}

void InOrder(BTNode* root)
{
    if (root == NULL)
	{
		return;
	}
	InOrder(root->left);
	printf("%c ", root->data);
	InOrder(root->right);
}

int main() {
    char arr[100];
    scanf("%s",arr);
    int i = 0;
    BTNode* root = TreeBuild(arr,&i);
    InOrder(root);
    BTreeDestroy(root);
    return 0;
}

完.

阿瑾0618
关注
  • 34
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 14
    评论
专栏目录
【数据结构】树
m0_61438674的博客
03-14 909
如果节点为空就返回空，如果该节点的值就是x那就返回该节点的指针，如果该节点的值不是要查找的值那就遍历它的左子树，用tmp1来接收左子树的查找结果，如果tmp1不是空说明在左子树中找到了所以返回tmp1。叶子节点就是该节点的左右子树==NULL ，如果节点为空返回0，如果该节点的左子树和右子树的=空那这个节点就是叶子节点 所以返回1。那最终的返回值就是左子树的叶子节点个数加右子树的叶子结点的个数。先求出左子树的高度，再求出右子树的高度，最终返回的高度就是该节点的左右子树的最大高度+1（自己）。
数据结构（十二） 二叉树的基本操作 --- 创建一个二叉树 前中后序遍历二叉树
liuxuefeng12的博客
01-01 429
//二叉树可以顺序存储也可以链式存储 顺序存储适合满二叉树和完全二叉树但不适合一般的二叉树 //用链式存储对二叉树的一些基本操作 //采用的二叉链表的方法 #include using namespace std; //二叉树的结构体 typedef struct Node { char data; struct Node *lchild; struct Node *rc
数据结构 | 树的定义及实现
天下弈星~的博客
08-07 1245
详细介绍了数据结构——树的相关定义及python实现。
树和二叉树PTA
最新发布
m0_51340432的博客
11-01 934
R6-7 二叉树的三种遍历（先序、中序和后序）R6-12 从下往上打印指定元素的所有祖先。R6-3 统计二叉树度为1的结点个数。R6-4 统计二叉树度为2的结点个数。R6-10 打印二叉树指定层次结点。R6-2 统计二叉树叶子结点个数。R6-11 层次输出第n个结点。R6-1 统计二叉树结点个数。R6-9 二叉树的层次遍历。R6-5 求二叉树的深度。R6-6 先序输出叶结点。R6-8 后缀表达式。
数据结构（十四） -- C语言版 -- 树 - 二叉树的叶子节点、深度、拷贝等
青椒*^_^*凤爪爪的博客
05-31 5261
本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。 设计的代码并非全部公开，部分无关紧要代码并没有贴出来。 如果你也对此感兴趣、也想测试源码的话，可以私聊我，非常欢迎一起探讨学习。 由于时间、水平、精力有限，文中难免会出现不准确、甚至错误的地方，也很欢迎大佬看见的话批评指正。 嘻嘻。。。。 。。。。。。。。收！
数据结构——二叉树 线索化二叉树 C语言
03-16
中序线索二叉树，反方向进行中序遍历(要求非递归，顺前驱进行)。 （1）建立二叉树； (2) 按先序、中序、后序输出二叉树; （3）复制二叉树； （4）在字符模式下画出无缺陷的二叉树
数据结构——二叉树的生成与遍历
02-18
数据结构，实现二叉树的生成与遍历的算法。包含利用先序、中序、后序遍历二叉树算法，二叉树基本操作。（注意没有左子树或右子树时用@或#作为结束符号）
数据结构——二叉树的实现.zip
09-18
这个压缩包文件"数据结构——二叉树的实现.zip"显然包含了关于二叉树实现的详细内容，特别是二叉链表和左子右兄弟两种不同的实现方法。 首先，我们来探讨二叉链表的实现。二叉链表是最基础的二叉树存储方式，每个...
数据结构——二叉树(c).doc
09-25
【二叉树】是数据结构中的重要概念，它是一种特殊的树形数据结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树常用于计算机科学中的算法设计，比如搜索、排序以及表达式求解等场景。 在二叉树中...
二叉树的结点数
嗯呢嗯呢的博客
01-17 3352
二叉树的结点数(*)(10分) 已知二叉树的结点结构定义如下： typedef struct _NODE_ { char data; struct _NODE_ *lch, *rch; } NODE; 说明：data为数据域，均为英文大写字母。lch和rch分别为指示左、右孩子的指针。 请编写函数，求二叉树的结点个数。 函数原型 // 结点数 int BinTreeNumNode(const TNODE *root); 说明：root为二叉树或它的子树的根指针，函...
6-5 统计二叉树叶子结点个数 (10 分)（C语言版）
qq_54210270的博客
02-15 1万+
先说思路： 有下面三种情况： 如果是空树，返回0； 如果只有一个根结点，即左右子树为空NULL，返回1； 如果左右子树不空，返回递归求左右子树叶子结点之和。 本题要求实现一个函数，可统计二叉树的叶子结点个数。 函数接口定义： int LeafCount ( BiTree T); T是二叉树树根指针，函数LeafCount返回二叉树中叶子结点个数，若树为空，则返回0。 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> typede.
数据结构：二叉树的三种创建方法（指针、引用、和指针函数）
ml29895063的博客
05-13 2206
数据结构：二叉树的三种创建方法（指针、引用、和指针函数）
计算二叉树中叶子结点数的算法
小浦原的技术专栏
02-16 1万+
//计算树中叶子结点数int LeafNodes(BTNode *b){ int num1,num2; if(b==NULL) return 0; else if(b->lchild==NULL && b->rchild==NULL) return 1; else { num1=LeafNodes(b->lchild); num2=LeafNodes
数据结构 - 树的创建和遍历
Spike的秃头之路
11-28 1190
1、采用书上第136页定义的树的孩子兄弟链表存储表示，编写递归算法实现树的下列基本操作。(1)构造树 (2)复制树 (3)销毁树 (4)先根遍历树 (5)清空树 (6)后根遍历树 (7)求树的深度 (8)求树的结点数 (9)求树的叶子结点数 2、采用书上第136页定义的树的孩子兄弟链表存储表示，编写非递归算法实现树的下列基本操作。(1)构造树 (2)先根遍历树 (3)后根遍历树 (4)层次遍历树 (5)求树的深度 (6) 求树的叶子结点数 (7)交换树的左右子树 10.1 #include
计算二叉树叶子结点数目
cl博客
05-03 1万+
二叉树按照二叉链表方式存储，编写程序，计算二叉树中叶子结点的数目。按先序输入二叉树各结点，其中#表示取消建立子树结点。输出二叉树中叶子节点的数目。ABD##EH###CF#I##G##4#include &lt;iostream&gt; #include &lt;stdlib.h&gt; #include &lt;cstdio&gt; #define DataType char using na...
C语言实现二叉树中统计叶子结点的个数&度为1&度为2的结点个数
weixin_30466421的博客
11-25 5347
算法思想 统计二叉树中叶子结点的个数和度为1、度为2的结点个数，因此可以参照二叉树三种遍历算法（先序、中序、后序）中的任何一种去完成，只需将访问操作具体变为判断是否为叶子结点和度为1、度为2的结点及统计操作即可。 Code #include <stdio.h> #include <stdlib.h> int LeafCount=0; int D...
计算二叉树的叶子结点个数
zrh_CSDN的博客
07-23 3万+
#include "string.h"  #include "stdio.h"  #include "malloc.h" typedef struct BiTNode{     char data;   /*结点的数据域*/     struct BiTNode *lchild , *rchild;  /*指向左孩子和右孩子*/ } BiTNode , *BiTree; void CreatB...
数据结构之二叉树的创建
热门推荐
顾小豆的博客
02-24 9万+
文章开头首先要感谢一下国嵌嵌入式教育的工作者们。创建二叉树 二叉树不仅比通用树结构简练，而且同时拥有通用树相同的操作。要想创建二叉树，首先就得了解一下二叉树的存储结构。已知二叉树的存储结构分为顺序存储结构和链式存储结构。其中链式存储结构又分为二叉链表和三叉链表。1. 顺序存储结构：按照顺序存储结构的定义，在此约定用一组地址连续的存储单元一次自上而下、自左至右存储完全二叉树上的节点元素，即将完全二叉...
并查集与高级数据结构——二叉树、线段树、树状数组
在数据结构的学习中，中根序遍历是一种对二叉树进行访问的方法，它遵循特定的顺序：先访问左子节点，然后访问根节点，最后访问右子节点。中序遍历对于理解和分析二叉树的性质至关重要，例如在二叉搜索树中，中序遍历...
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值