数据结构与算法6：树与二叉树(叶子节点个数、节点个数、前序遍历、后序遍历、中序遍历、二叉树遍历、平衡树)

最新推荐文章于 2023-09-20 22:01:49 发布
最新推荐文章于 2023-09-20 22:01:49 发布
阅读量1.1k 收藏 1
点赞数 1
文章标签： 算法 数据结构 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44902386/article/details/128182963
版权

节点的度：一个节点含有的子树个数称为该节点的度：如下：A的为6
叶节点或终端节点：度为0的节点称为叶节点：如图：B、C、H、I…等节点为叶节点
非终端节点或分支节点：度不为0的节点；如图：D、E、F、G…等节点为分支节点
双亲结点或父节点：若一个结点含有子节点，则这个结点称为其子节点的父节点；如图：A是B的双亲
孩子结点或子节点：一个节点含有的子树的根节点称为该节点的子节点；B是A的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点（亲兄弟）；B、C是兄弟节点
树的度：一棵树中，最大的节点的度称为树的度；下图中树的度为6
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，依次类推
树的高度或深度：树中节点的最大层次；如图树的高度为4
节点的祖先：从根到该节点所经分支上的所有节点；如图，A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如图所有节点都是A的子孙
森林：由m（m>0）棵互不相交的多棵树的集合称为森林

在这里插入图片描述

定义二叉树并进行前序遍历

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef int BTDataType;
typedef struct BinaryTreeNode {
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	BTDataType data;
}BTNode;

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

int main() {
	BTNode* A = (BTNode*)malloc(sizeof(BTNode));
	A->data = 'A';
	A->left = NULL;
	A->right = NULL;

	BTNode* B = (BTNode*)malloc(sizeof(BTNode));
	B->data = 'B';
	B->left = NULL;
	B->right = NULL;

	BTNode* C = (BTNode*)malloc(sizeof(BTNode));
	C->data = 'C';
	C->left = NULL;
	C->right = NULL;

	BTNode* D = (BTNode*)malloc(sizeof(BTNode));
	D->data = 'D';
	D->left = NULL;
	D->right = NULL;

	BTNode* E = (BTNode*)malloc(sizeof(BTNode));
	E->data = 'E';
	E->left = NULL;
	E->right = NULL;

	A->left = B;
	A->right = C;
	B->left = D;
	B->right = E;

	PrevOrder(A);
	printf("NULL\n");

	return 0;
}
特殊的二叉树：
  1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树，，也就是说，如果一个二叉树的层数为K，且结点总数为(2^k)-1，则它就是满二叉树。
  2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为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 = LogN+1

练习题：

  1. 某二叉树共有399个结点，其中有199个度为2的结点，则该二叉树中的叶子结点数为200

  2. 在具有2n个结点的完全二叉树中，叶子结点个数为n

在这里插入图片描述

  1. 一颗完全二叉树得节点数位为531个，那么这棵树得高度为

在这里插入图片描述
示例：计算二叉树的叶子节点个数、节点个数、前序遍历、后序遍历、中序遍历

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef int BTDataType;
typedef struct BinaryTreeNode {
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	BTDataType data;
}BTNode;
//前序遍历
void PrevOrder(BTNode* root) {
	if (root == NULL) {
		return;
	}
	printf("%c->", root->data);
	PrevOrder(root->left);
	PrevOrder(root->right);	
}

//中序遍历
void ZOrder(BTNode* root) {
	if (root == NULL) {
		return;
	}
	ZOrder(root->left);
	printf("%c->", root->data);
	ZOrder(root->right);
}

//后序遍历
void HOrder(BTNode* root) {
	if (root == NULL) {
		return;
	}
	HOrder(root->left);
	HOrder(root->right);
	printf("%c->", root->data);
}

//结点个数
int TreeSize(BTNode* root) {
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}

//叶子节点个数
int TreeLeafSize(BTNode* root) {
	if (root == NULL)
		return 0;
	if (root->left == NULL && root->right == NULL) 
		return 1;
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}


int main() {
	BTNode* A = (BTNode*)malloc(sizeof(BTNode));
	A->data = 'A';  
	A->left = NULL;
	A->right = NULL;

	BTNode* B = (BTNode*)malloc(sizeof(BTNode));
	B->data = 'B';
	B->left = NULL;
	B->right = NULL;

	BTNode* C = (BTNode*)malloc(sizeof(BTNode));
	C->data = 'C';
	C->left = NULL;
	C->right = NULL;

	BTNode* D = (BTNode*)malloc(sizeof(BTNode));
	D->data = 'D';
	D->left = NULL;
	D->right = NULL;

	BTNode* E = (BTNode*)malloc(sizeof(BTNode));
	E->data = 'E';
	E->left = NULL;
	E->right = NULL;

	A->left = B;
	A->right = C;
	B->left = D;
	B->right = E;
	//先序
	PrevOrder(A);
	printf("NULL\n");

	//中序
	ZOrder(A);
	printf("NULL\n");
	//后序
	HOrder(A);
	printf("NULL\n");

	int i = TreeSize(A);
	printf("%d\n", i);
	int j = TreeLeafSize(A);
	printf("%d\n", j);
	return 0;
}

算法1：给定一个二叉树，找出其最大深度。

示例：

给定二叉树 [3,9,20,null,null,15,7]，返回它的最大深度 3 。

思路：二叉树为空时高度为0；非空时，分解子问题，先求左右子树的深度，我的深度等于左右子树深度大的+1。

int maxDepth(struct TreeNode* root){
    if(root == NULL)
        return 0;
    int leftDepth = maxDepth(root->left);
    int rightDepth = maxDepth(root->right);

    return leftDepth>rightDepth ? leftDepth+1:rightDepth+1;
}

算法2：给定一个二叉树，判断它是否是高度平衡的二叉树。

高度平衡二叉树定义为一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

示例1：

在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：true

示例 2：

在这里插入图片描述

输入：root = [1,2,2,3,3,null,null,4,4]
输出：false
示例 3：

输入：root = []
输出：true

 int maxDepth(struct TreeNode* root){
    if(root == NULL)
        return 0;
    int leftDepth = maxDepth(root->left);
    int rightDepth = maxDepth(root->right);

    return leftDepth>rightDepth ? leftDepth+1:rightDepth+1;
}

bool isBalanced(struct TreeNode* root){
    if(root == NULL)
        return true;
    int leftDepth = maxDepth(root->left);
    int rightDepth = maxDepth(root->right);

    return abs(leftDepth-rightDepth) < 2 && isBalanced(root->left) && isBalanced(root->right);
}

算法3：二叉树的前序遍历

带调试1代码OJ：

#include <stdio.h>
typedef int BTDataType;
typedef struct TreeNode {
     BTDataType val;
     struct TreeNode *left;
     struct TreeNode *right;
 }TreeNode;

int TreeSize(TreeNode* root) {
    return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}

void _prevOrder(TreeNode* root, int* a, int* pi) {
    if (root == NULL) {
        return;
    }
    a[*pi] = root->val;
    (*pi)++;
    _prevOrder(root->left, a, pi);
    _prevOrder(root->right, a, pi);
}
//如果想返回两个值时候，第一种方法是返回结构体，第二种方法是这里的这种，*returnSize = size
int* preorderTraversal(TreeNode* root, int* returnSize) {
    int size = TreeSize(root);
    int* a = (int*)malloc(size * sizeof(int));
    int i = 0;
    _prevOrder(root, a, &i);
    *returnSize = size;
    return a;
}

int main() {
    TreeNode* A = (TreeNode*)malloc(sizeof(TreeNode));
    A->val = 1;
    A->left = NULL;
    A->right = NULL;

    TreeNode* B = (TreeNode*)malloc(sizeof(TreeNode));
    B->val = 2;
    B->left = NULL;
    B->right = NULL;

    TreeNode* C = (TreeNode*)malloc(sizeof(TreeNode));
    C->val = 3;
    C->left = NULL;
    C->right = NULL;

    A->left = B;
    B->left = NULL;
    B->right = NULL;
    A->right = C;
    C->left = NULL;
    C->right = NULL;

    int size = 0;
    int* a = preorderTraversal(A,&size);
    return 0;
}

带调试2代码OJ：

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



struct TreeNode {
     int val;
     struct TreeNode *left;
     struct TreeNode *right;
 };


int TreeSize(struct TreeNode* root) {
    return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}


void _prevOrder(struct TreeNode* root, int* a, int* pi) {
    if (root == NULL) {
        return;
    }
    a[*pi] = root->val;
    (*pi)++;
    _prevOrder(root->left, a, pi);
    _prevOrder(root->right, a, pi);
}
//如果想返回两个值时候，第一种方法是返回结构体，第二种方法是这里的这种，*returnSize = size
int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    int size = TreeSize(root);
    int* a = (int*)malloc(size * sizeof(int));
    int i = 0;
    _prevOrder(root, a, &i);
    *returnSize = size;

    return a;
}

int main() {

    struct TreeNode node1;
    struct TreeNode node2;
    struct TreeNode node3;
    node1.val = 1;
    node1.left = &node2;
    node1.right = &node3;

    node2.val = 2;
    node2.left = NULL;
    node2.right = NULL;

    node3.val = 3;
    node3.left = NULL;
    node3.right = NULL;

    int size = 0;
    int* a = preorderTraversal(&node1,&size);

    return 0;
}

二叉树遍历

编写一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。例如如下的先序遍历字符串：ABC##DE#G##F### 其中” # “ 表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。

示例：

输入：ABC##DE#G##F###
输出：C B E G D F A

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef char BTDataType;

typedef struct TreeNode {
    BTDataType val;
    struct TreeNode* left;
    struct TreeNode* right;
}TNode;

TNode* CreateTree(char* a, int* pi) {
    if (a[*pi] == '#') {
        (*pi)++;
        return NULL;
    }
    TNode* root = (TNode * )malloc(sizeof(TNode));
    if (root == NULL) {
        printf("malloc fail\n");
        exit(-1);
    }
    root->val = a[*pi];
    (*pi)++;
    root->left = CreateTree(a, pi);
    root->right = CreateTree(a, pi);
    return root;
}

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

int main() {
    char str[100];
    scanf("%s", str);

    int i = 0;
    TNode* root = CreateTree(str, &i);

    InOrder(root);

    return 0;
}
yiyakaa
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构（十四） -- C语言版 -- 树 - 二叉树的叶子节点、深度、拷贝等
青椒*^_^*凤爪爪的博客
05-31 5279
本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。 设计的代码并非全部公开，部分无关紧要代码并没有贴出来。 如果你也对此感兴趣、也想测试源码的话，可以私聊我，非常欢迎一起探讨学习。 由于时间、水平、精力有限，文中难免会出现不准确、甚至错误的地方，也很欢迎大佬看见的话批评指正。 嘻嘻。。。。 。。。。。。。。收！
【C语言数据结构】二叉树入门（求叶子节点数，求总结点数，求深度，满二叉树与完全二叉树）
谁在夜里看海.的博客
04-17 2915
1.n0=n2+12.完全二叉树中，n1=0或13.满二叉树中，深度为n，结点数为2^n-1；结点数为k，深度为log(k+1)4.任意二叉树中，结点数的范围是2^(n-1) ~ 2^n-1。
任意二叉树节点数、度数与叶子数的关系
热门推荐
Lanyan9的博客
11-24 3万+
二叉树的性质——节点数、度数、叶子节点数的关系 对于任意一棵二叉树，如果2度的节点数有n2个，则叶子数n0必定为n2+1(n0=n2+1) (1) 我们假设有二叉树的枝有B个，如果从下往上思考，可以看做是每个节点都有一个枝与之对应，那么可以有B = n - 1成立，之所以有减一是因为根节点没有枝与之相连 (2) 如果从上往下考虑，那么枝子的总数就等于度为1的节点乘1，度为2的节点乘2，依次类推，所以这里有B = n11 + n22 (3) 将以上两个式子合并可以得： 注意这里n1, n2为度数，后边
数据结构关于叶子的计算
Terry的IT世界
08-31 1058
公式：所有结点的度数之和+1=结点总数   一个结点的子数个数称为该结点的度   
完全二叉树根据节点个数求叶子个数
04-24 1万+
“二叉树的第i层至多有2^(i − 1)个结点； 深度为k的二叉树至多有2^k − 1个结点（根结点的深度为1）” 因为2^9-1 完全二叉树的深度是10，前9层是一个满二叉树， 这样的话，前九层的结点就有2^9-1=511个；而第九层的结点数是2^(9-1)=256 所以第十层的叶子结点数是700-511=189个； 现在来算第九层的叶子结点个数。 由于第十层的叶子结点是从第九层延伸的，所
数据结构
qq_27366859的博客
05-14 137
常见的数据结构
非递归前序,中序,后序遍历二叉树(优化算法).rar_nooneyh_二叉树 非递归_前序 中序 后序_树遍历算法_遍历二叉树
09-14
遍历二叉树是指按照特定的顺序访问树中的每一个节点，常见的遍历方法有三种：前序遍历、中序遍历和后序遍历。在递归实现这些遍历时，虽然直观但可能导致栈溢出问题，特别是在处理深度较大的二叉树时。因此，非递归的...
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
本文将深入探讨Python中的二叉树及其遍历方法，包括前序遍历、中序遍历、后序遍历以及层序遍历。通过具体的代码示例，我们将更好地理解这些遍历方法的工作原理和应用场景。 #### 二、二叉树基础知识回顾 二叉树是由...
二叉树的遍历，前序遍历 中序遍历 后序遍历
最新发布
11-11
总结来说，二叉树的前序、中序和后序遍历是数据结构与算法领域中的核心概念，它们对于理解和操作二叉树至关重要。掌握这三种遍历方法不仅有助于提升编程技能，还能在解决问题时提供灵活的思路。无论是进行数据处理、...
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
12-20
二叉树遍历是一种访问二叉树所有节点的方法，通常有三种主要的遍历方式：前序遍历、中序遍历和后序遍历。这些遍历方法在数据结构和算法领域中有着广泛的应用，例如在编译器、文件系统和搜索算法中。 1. **前序遍历*...
【数据结构】二叉树的节点数，叶子数，第K层节点数，高度，查找x节点，判断是否为完全二叉树等方法
luhaoran814的博客
09-20 3574
二叉树的节点数，叶子数，第K层节点数，高度，查找x节点，判断是否为完全二叉树等方法
树的表示方法以及先、中、后序遍历以及求叶子结点个数和树的深度代码C代码
zcg_741454897的博客
12-17 2461
树的概念及性质 暂时略 树的表示方法 图形表示法：直观清晰易于理解。 广义表表示法：不常用。 左孩子右兄弟表示法：可以将多叉树转化为二叉树的一种表示方法，而二叉树更适合计算机表示。（也就是说一般遇到多叉树，转化成二叉树） 二叉树及性质 略 二叉树的存储结构 顺序存储 用一个数组来存储二叉树，结合二叉树的性质，可以保存树的结点之间的关系。最适合完全二叉树和满二叉树，如果是一般二叉...
5430: 数据结构实验：左叶子之和
qq_40605429的博客
05-29 330
求一棵二叉树所有左叶子节点元素值之和。二叉树节点定义如下：struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;};题目部分代码已经完成，您只需要补充并提交以下函数：int sumOfLeftLeaves(struct TreeNode* root);输入输入为若干个整数（不超过512）表...
叶子结点和分支节点_统计二叉树分支及叶子结点的个数
weixin_39888943的博客
12-24 1979
以二叉链表存储结构存储二叉树，统计分支结点及叶子个数。(1)从键盘输入扩展的先序结点数据，以二叉链表存储该二叉树。(2)统计叶子结点个数。(3)统计分支节点个数。(4)要求程序通过一个主菜单进行控制，通过选择菜单项序号调用各功能函数。#include#include#include#defineERROR0#defineOK1#defineFALSE-1#defineTRUE...
数据结构和算法---树---夯实基础（一）
欢迎来到我的知识星球！！！
05-27 2254
树的基本概念和汇总，以及二叉树详解，深入浅出讲解二叉树二叉树遍历（前序、中序、后序、层次遍历、深度优先、广度优先）
对二叉树、节点、度之间关系的思考（附图）
汪雯琦的博客
04-05 2万+
二叉树 节点 二叉树中每个元素都称为节点。 度 度的定义：节点所拥有的子树的数目称为该节点的度 注意： 叶子节点的度为0 二叉树的度表示节点的子树或直接继承者的数目，二叉树的度是一个子树或单子树。2度是两个孩子，或者左和右子树有两个叉树，最大度数为2。 叶子 叶是叶节的缩写。叶子或叶子指的是网络结构中的计算机，它接收来自靠近中心的计算机而不是更远的计算机的信号。叶节点是树的底部段中的节点，叶节...
数据结构树的前序、中序、后序遍历，树叶数量，左右子树交换实现代码
weixin_30333885的博客
06-12 105
1 #include <iostream> 2 using namespace std; 3 struct TreeNode //树结构体定义 4 { 5 char data; 6 TreeNode *lchild,*rchild; 7 }; 8 char getonech(char ar[]) ...
数据结构之树
鹤啸九天
05-06 2914
树有且只有一个根节点，并且只有根节点没有父节点。除父节点外其他每个节点都只有一个父节点，并且每个节点都不能与自己同级的兄妹节点相连。
Python二叉树遍历详解：前序、中序与后序
本文主要介绍三种常见的二叉树遍历方式：前序遍历、中序遍历和后序遍历。 1. **遍历策略**： - **前序遍历（PreorderTraversal）**，也称为先序遍历，其顺序是NLR，即首先访问根节点（Node），然后遍历左子树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值