文章目录
- 前言
- 一、单值二叉树
- 二、检查两颗树是否相同
- 三、对称二叉树
- 四、另一颗树的子树
- 五、二叉树的前序遍历
- 六、二叉树的后序遍历
- 七、二叉树中序遍历
- 八、二叉树的构建及遍历
- 九、二叉树选择题
- 1.二叉树性质
- 2. 二叉树选择题
- 1. 某⼆叉树共有 399 个结点,其中有 199 个度为 2 的结点,则该⼆叉树中的叶⼦结点数为?
- 2. 在具有 2n 个结点的完全⼆叉树中,叶⼦结点个数为?
- 3. ⼀棵完全⼆叉树的结点数位为531个,那么这棵树的⾼度为?
- 4. 一个具有 767 个结点的完全⼆叉树,其叶⼦结点个数为?
- 5. 某完全⼆叉树按层次输出(同⼀层从左到右)的序列为 ABCDEFGH 。该完全⼆叉树的前序序列为?
- 6. ⼆叉树的先序遍历和中序遍历如下:
- 7. 设⼀棵⼆叉树的中序遍历序列:badce,后序遍历序列:bdeca,则⼆叉树前序遍历序列为?
- 8. 某⼆叉树的后序遍历序列与中序遍历序列相同,均为 ABCDEF ,则按层次输出(同⼀层从左到右)的序列为?
- 总结
前言
经历了对于二叉树的学习,相信大家对于二叉树一定有了深入的了解,接下来和J桑一起来刷起题来吧~
一、单值二叉树
单值二叉树
bool isUnivalTree(struct TreeNode* root) {
if(root == NULL)
{
return true;
}
if(root->left && root->val != root->left->val)
{
return false;
}
if(root->right && root->val != root->right->val)
{
return false;
}
return isUnivalTree(root->left) && isUnivalTree(root->right);
}
二、检查两颗树是否相同
检查两颗树是否相同
bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
if(p == NULL && q == NULL)
{
return true;
}
if(p == NULL || q == NULL)
{
return false;
}
if(p->val != q->val)
{
return false;
}
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
三、对称二叉树
对称二叉树
各位有没有发现对称的树,和上一道题相等的树很像呢?
没错,只是p树在遍历的时候先遍历左孩子,再遍历右孩子。
而q树,先遍历右孩子,在遍历左孩子。
typedef struct TreeNode TreeNode;
bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
if(p == NULL && q == NULL)
{
return true;
}
if(p == NULL || q == NULL)
{
return false;
}
if(p->val != q->val)
{
return false;
}
return isSameTree(p->left, q->right) && isSameTree(p->right, q->left);
}
bool isSymmetric(struct TreeNode* root)
{
if(root == NULL)
{
return true; // 空树是对称的
}
return isSameTree(root->left, root->right);
}
四、另一颗树的子树
另一颗树的子树
另一个树是否是这棵树的子树呢?
要解决这个问题,我们还需要用到两个树是否相同。
bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
if(p == NULL && q == NULL)
{
return true;
}
if(p == NULL || q == NULL)
{
return false;
}
if(p->val != q->val)
{
return false;
}
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
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);
}
五、二叉树的前序遍历
二叉树的前序遍历
并且它的输出是一个数组
它的返回值是int* 类型
为了返回这个数组,我们需要先获取树中结点个数。
前面我们实现过返回结点个数~
可以这样想, 一个结点的个数等于其左右子树结点个数之和加上它本身。
只要分别找到每一个结点左子树和右子树结点之和,就是我们的答案。
将大事化小,当root为NULL的时候结束,不正是递归的思想吗?
// ⼆叉树结点个数
// 一个结点的个数等于其左右子树结点个数之和加上它本身
int BinaryTreeSize(BTNode* root)
{
if (root == NULL)
{
return 0;
}
return 1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}
第二步: 动态的给数组申请内存
int* returnArr = (int* )malloc(sizeof(int) * (*returnSize));
第三步: 前序遍历树
前面也讲过~
对于前序遍历来说,就是按照 根----左----右
的顺序进行遍历。
如下图所示:
对于每个根节点来说,它的遍历方法都是 根----左----右
,我们有时候可能认为遍历到一个结点的左孩子或者右孩子就要回去,其实是不对的。因为它的孩子的遍历方式也是 根----左----右
。
typedef struct TreeNode TreeNode;
int BinaryTreeSize(TreeNode* root)
{
if (root == NULL)
{
return 0;
}
return 1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}
void PreOrder(TreeNode* root, int* arr, int* pi)
{
if (root == NULL)
{
return;
}
arr[(*pi)++] = root->val;
PreOrder(root->left, arr, pi);
PreOrder(root->right, arr, pi);
}
int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
//第一步求出树中结点个数
*returnSize = BinaryTreeSize(root);
//第二步动态的给数组申请内存
int* returnArr = (int* )malloc(sizeof(int) * (*returnSize));
//第三步前序遍历树
int i = 0;
PreOrder(root, returnArr, &i);
return returnArr;
}
六、二叉树的后序遍历
二叉树的后序遍历
后序遍历与前序遍历思路一样。
唯一不同的就是遍历顺序变为左----右----根
typedef struct TreeNode TreeNode;
int BinaryTreeSize(TreeNode* root)
{
if (root == NULL)
{
return 0;
}
return 1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}
void PostOrder(TreeNode* root, int* arr, int* pi)
{
if (root == NULL)
{
return;
}
PostOrder(root->left, arr, pi);
PostOrder(root->right, arr, pi);
arr[(*pi)++] = root->val;
}
int* postorderTraversal(struct TreeNode* root, int* returnSize)
{
//第一步求出树中结点个数
*returnSize = BinaryTreeSize(root);
//第二步动态的给数组申请内存
int* returnArr = (int* )malloc(sizeof(int) * (*returnSize));
//第三步前序遍历树
int i = 0;
PostOrder(root, returnArr, &i);
return returnArr;
}
七、二叉树中序遍历
二叉树中序遍历
中序遍历与前序遍历思路一样。
唯一不同的就是遍历顺序变为左----根----右
typedef struct TreeNode TreeNode;
int BinaryTreeSize(TreeNode* root)
{
if (root == NULL)
{
return 0;
}
return 1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}
void InOrder(TreeNode* root, int* arr, int* pi)
{
if (root == NULL)
{
return;
}
InOrder(root->left, arr, pi);
arr[(*pi)++] = root->val;
InOrder(root->right, arr, pi);
}
int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
//第一步求出树中结点个数
*returnSize = BinaryTreeSize(root);
//第二步动态的给数组申请内存
int* returnArr = (int* )malloc(sizeof(int) * (*returnSize));
//第三步前序遍历树
int i = 0;
InOrder(root, returnArr, &i);
return returnArr;
}
八、二叉树的构建及遍历
二叉树的构建及遍历
我们先来进行思考,既然你要遍历字符串,那我们就要先获取字符串。
#include <stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
int main()
{
// 1. 读取字符串
char arr[100];
scanf("%s",arr);
return 0;
}
获取了字符串后,我们要将每一个字符放入二叉树中,那么我们就要多次创立结点
BTNode* buyNode(char x)
{
BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
if (newnode == NULL)
{
perror("malloc fail!");
exit(1);
}
newnode->_data = x;
newnode->_left = newnode->_right = NULL;
return newnode;
}
拿到了结点之后我们要将结点放入二叉树中,这里用的是前序遍历的方法
BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
{
if(a[(*pi)] == '#')
{
(*pi)++;
return NULL;
}
BTNode* root = buyNode(a[(*pi)++]);
root->_left = BinaryTreeCreate(a, pi);
root->_right = BinaryTreeCreate(a, pi);
return root;
}
最后我们中序遍历就可以了~
总结如下:
#include <stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef char BTDataType;
typedef struct BinaryTreeNode
{
BTDataType _data;
struct BinaryTreeNode* _left;
struct BinaryTreeNode* _right;
}BTNode;
BTNode* buyNode(char x)
{
BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
if (newnode == NULL)
{
perror("malloc fail!");
exit(1);
}
newnode->_data = x;
newnode->_left = newnode->_right = NULL;
return newnode;
}
BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
{
if(a[(*pi)] == '#')
{
(*pi)++;
return NULL;
}
BTNode* root = buyNode(a[(*pi)++]);
root->_left = BinaryTreeCreate(a, pi);
root->_right = BinaryTreeCreate(a, pi);
return root;
}
void InOrder(BTNode* root)
{
if(root == NULL)
{
return;
}
InOrder(root->_left);
printf("%c ",root->_data);
InOrder(root->_right);
}
int main()
{
// 1. 读取字符串
char arr[100];
scanf("%s",arr);
// 2. 根据字符串创立二叉树
//这里我们用前序遍历的方法创建
int i = 0;
BTNode* root = BinaryTreeCreate(arr,&i);
// 3. 最后我们中序输出
InOrder(root);
return 0;
}
九、二叉树选择题
1.二叉树性质
⼆叉树性质:
对任何⼀棵⼆叉树, 如果度为 0 其叶结点个数为 n0 , 度为 2 的分⽀结点个数为 n2 ,则有:
n0 = n2 + 1
证明上述性质: 假设⼀个⼆叉树有 a 个度为2的节点, b 个度为1的节点, c 个叶节点,则这个⼆叉树的边数是 2a+b。
另⼀⽅⾯,由于共有 a+b+c 个节点,所以边数等于 a+b+c-1 结合上⾯两个公式: 2a+b = a+b+c-1 ,
即: a = c-1
2. 二叉树选择题
1. 某⼆叉树共有 399 个结点,其中有 199 个度为 2 的结点,则该⼆叉树中的叶⼦结点数为?
根据二叉树的性质,叶子结点数 = 度为2的结点数 + 1。
- 给定度为2的结点数为199,那么叶子结点数 = 199 + 1 = 200。
答案:B
2. 在具有 2n 个结点的完全⼆叉树中,叶⼦结点个数为?
完全二叉树有以下性质:
- 叶子结点数 = ⌈n/2⌉
- 题中总结点数为 2n,则叶子结点数 = n。
答案:A
3. ⼀棵完全⼆叉树的结点数位为531个,那么这棵树的⾼度为?
完全二叉树的高度公式为:高度 = ⌊log2(N)⌋,其中N是结点数。
- 计算 log2(531) ≈ 9.05,因此高度为 10。
答案:B
4. 一个具有 767 个结点的完全⼆叉树,其叶⼦结点个数为?
完全二叉树的性质:当有 N 个结点时,叶子结点数大约为 ⌊(N + 1) / 2⌋。
- 对于 767 个结点,叶子结点数为 ⌊(767 + 1) / 2⌋ = 384。
答案:B
5. 某完全⼆叉树按层次输出(同⼀层从左到右)的序列为 ABCDEFGH 。该完全⼆叉树的前序序列为?
- 按前序遍历顺序,先访问根结点,再访问左子树,最后访问右子树。
- 根据完全二叉树的结构,前序序列应为 ABDHECFG。
答案:A
6. ⼆叉树的先序遍历和中序遍历如下:
先序遍历:EFHIGJK;
中序遍历:HFIEJKG。
从先序遍历中可以看出,E 是根结点。
答案:A
7. 设⼀棵⼆叉树的中序遍历序列:badce,后序遍历序列:bdeca,则⼆叉树前序遍历序列为?
- 根据后序遍历可知,a 是根结点。
- 从中序遍历可以将其分为两部分:b 是左子树,dce 是右子树。
- 对右子树dce的后序遍历是dec,因此d为右子树的根结点。
最终前序遍历序列为 adbce。
答案:A
8. 某⼆叉树的后序遍历序列与中序遍历序列相同,均为 ABCDEF ,则按层次输出(同⼀层从左到右)的序列为?
- 如果后序遍历和中序遍历相同,这说明二叉树可能是一个退化的二叉树(链状结构),其层次遍历应与它们相同。
答案:A
总结
到这里,我们二叉树的知识就讲啦!
J桑还是有点手忙脚乱的,各位观众老爷感觉怎么样呢?
谢谢大家!