二叉树——精选题目，体验递归的暴力美学！

原创 于 2025-12-04 00:59:12 发布 · 748 阅读 · 37 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c语言 #算法

「C++ 40 周年」主题征文大赛（有机会与C++之父现场交流！） 10w+人浏览 778人参与

目录

1、单值二叉树

2、相同的树

3、对称二叉树

4、另一棵树的子树

5、二叉树的前序遍历

6、二叉树的中序遍历

7、二叉树的后序遍历

8、二叉树的遍历

1、单值二叉树

题目链接：

965. 单值二叉树 - 力扣（LeetCode）https://leetcode.cn/problems/univalued-binary-tree/description/题目描述：

如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。

只有给定的树是单值二叉树时，才返回 true；否则返回 false。

代码实现：

利用函数递归完成：先判断根节点是否为空，为空直接返回true，不为空继续判断其左右孩子节点的值与其是否相等，不相等就返回false，然后进行函数递归。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool isUnivalTree(struct TreeNode* root) {
    if(root==NULL)
    {
        return true;
    }
    //root非空，检查其左右子树的值是否等于根节点的值
    if(root->left && root->left->val!=root->val)
    {
        return false;
    }
    if(root->right && root->right->val!=root->val)
    {
        return false;
    }
    return isUnivalTree(root->left) && isUnivalTree(root->right);
}

2、相同的树

题目链接：

100. 相同的树 - 力扣（LeetCode）https://leetcode.cn/problems/same-tree/description/题目描述：

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

代码实现：

仍然使用函数递归来解决：分步判断，先判断其结构，结构相同了再判断结点的值，结构和结点的值都相同了就是相同的树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *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);
}

3、对称二叉树

题目链接：

101. 对称二叉树 - 力扣（LeetCode）https://leetcode.cn/problems/symmetric-tree/description/题目描述：

给你一个二叉树的根节点 root ， 检查它是否轴对称。如下图所示：

代码实现：

利用相同的树来解决：直接调用相同的树函数，一个树为root->left，另一个树为root->right，不过相同的树函数中递归部分要改成p->left和q->right，p->right和q->left。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *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->right) && isSameTree(p->right,q->left);
 }

bool isSymmetric(struct TreeNode* root) {
    //直接将根节点的左右孩子传给判断相同的树的函数
    return isSameTree(root->left,root->right);
}

4、另一棵树的子树

题目链接：

572. 另一棵树的子树 - 力扣（LeetCode）https://leetcode.cn/problems/subtree-of-another-tree/description/

题目描述：

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

代码实现：

仍然使用相同的树：先判断根节点是否为空，为空返回false，不为空就调用相同的树函数比较root树和subroot树，如果没结束就分别递归判断左子树和右子树，最后返回两个递归的条件或。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *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);
}

5、二叉树的前序遍历

题目链接：
144. 二叉树的前序遍历 - 力扣（LeetCode）https://leetcode.cn/problems/binary-tree-preorder-traversal/description/题目描述：

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

注意：返回的是数组形式哦！

代码实现：

先确定该二叉树中的节点个数，以确定malloc的数组的大小，然后再调用前序遍历函数，将遍历的每个值依次存入到数组中，最后返回该数组。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

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

 //创建二叉树，前序遍历
void preOrder(struct 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
    *returnSize = BinaryTreeSize(root);
    //创建大小为returnSize数组
    int* arr=(int*)malloc(sizeof(int)*(*returnSize));
    //使用创建二叉树函数将节点存入数组中
    int i=0;
    preOrder(root,arr,&i);
    return arr;
}

6、二叉树的中序遍历

题目链接：
94. 二叉树的中序遍历 - 力扣（LeetCode）https://leetcode.cn/problems/binary-tree-inorder-traversal/description/题目描述：

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

返回的依旧是数组形式。

代码实现：

和前序遍历的思路一样，只是遍历方式不同。

先确定该二叉树中的节点个数，以确定malloc的数组的大小，然后再调用中序遍历函数，将遍历的每个值依次存入到数组中，最后返回该数组。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

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

//中序遍历存入数组
void Inorder(struct 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
    *returnSize=binarytreeSize(root);
    //创建数组
    int* arr=(int*)malloc(sizeof(int)*(*returnSize));
    //中序遍历存入数组
    int i=0;
    Inorder(root,arr,&i);
    return arr;
}

7、二叉树的后序遍历

题目链接：
145. 二叉树的后序遍历 - 力扣（LeetCode）https://leetcode.cn/problems/binary-tree-postorder-traversal/description/

题目描述：

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

返回的也是数组形式的遍历结果。

代码实现：

和前序遍历的思路一样，只是遍历方式不同。

先确定该二叉树中的节点个数，以确定malloc的数组的大小，然后再调用后序遍历函数，将遍历的每个值依次存入到数组中，最后返回该数组。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

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


//后序遍历
void postOrder(struct 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的值
    *returnSize=binarytreeSize(root);
    //创建数组
    int* arr=(int*)malloc(sizeof(int)*(*returnSize));
    //利用后序遍历存储到数组中
    int i=0;
    postOrder(root,arr,&i);
    return arr;
}

8、二叉树的遍历

题目链接：
二叉树遍历_牛客题霸_牛客网https://www.nowcoder.com/practice/4b91205483694f449f94c179883c1fef题目描述：

描述：

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

输入描述：

输入包括1行字符串，长度不超过100。

输出描述：

可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。

代码实现：

先用字符数组存储表示该二叉树的字符串，然后为创建的二叉树创建结构和节点，再根据前序遍历的结果创建出二叉树（这里用递归来创建二叉树），遇到#直接返回NULL，建立完二叉树后，对该二叉树进行中序遍历，输出中序遍历结果。

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

//创建二叉树结构
typedef struct BinaryTreeNode {
    char data;
    struct BinaryTreeNode* left;
    struct BinaryTreeNode* right;
}BTNode;

//创建节点
BTNode* buynode(char x)
{
    BTNode* newnode=(BTNode*)malloc(sizeof(BTNode));
    newnode->data=x;
    newnode->left=newnode->right=NULL;
    return newnode;
}

//创建二叉树
BTNode* CreateTree(char* arr,int* pi)
{
    if(arr[(*pi)]=='#')
    {
        (*pi)++;//进循环了才需要++
        return NULL;
    }
    BTNode* root = buynode(arr[(*pi)++]);
    root->left=CreateTree(arr,pi);
    root->right=CreateTree(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[101]={0};
    scanf("%s",arr);
    //根据先序遍历创建二叉树
    int i=0;
    BTNode* root=CreateTree(arr, &i);
    //输出中序遍历结果
    InOrder(root);
    return 0;
}

子集问题，两种解法都得会！——递归与位运算的硬核对决
Echo_Wish
05-02 306
不要满足于“能做出来”，而要追求“怎么做得更优雅”。如何把“选择问题”建模为“二叉树路径”？如何从“数据结构的视角”看待递归与位运算的本质？如何针对不同场景选取最适合的算法策略？
2025华为OD机试（JAVA&Go）真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ
热门推荐
MISAYAONE的博客
11-20 31万+
华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录，Java实现。
二叉树OJ——递归的暴力美学
cyzzzuzm的博客
06-22 1411
递归的暴力美学
【数据结构】递归暴力美学：二叉树链式结构的深度解析（含源码）
2402_87731470的博客
07-28 1万+
本文聚焦二叉树链式结构，以递归思想为核心展开解析。首先介绍链式节点的构成及适配各类二叉树的特性，随后详细讲解前序、中序、后序的递归遍历逻辑，以及借助队列实现的层序遍历。还通过代码演示节点总数、叶子节点数、树高、第 k 层节点数等统计操作的递归实现，分析避免变量累加异常的方案，讲解完全二叉树的判断方法，并结合经典 OJ 题，展现递归 “暴力美学” 在链式结构中的应用与独特魅力。
题目练习之二叉树那些事儿
2401_82924480的博客
11-06 1320
二叉树题目练习
题目练习之二叉树那些事儿（续集）
2401_82924480的博客
11-07 1036
二叉树题目练习
2025华为OD机试（Python）真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ
MISAYAONE的博客
11-20 26万+
华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录，Python实现。
2025 华为OD机试（C语言）真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ
MISAYAONE的博客
02-25 10万+
华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录，C语言实现。
2025 华为OD机试（JavaScript）真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ
MISAYAONE的博客
02-10 8万+
华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录，JavaScript实现。
实现二叉树（C语言带详细递归图！！！）
m0_72637272的博客
05-29 1592
二叉树是：1. 空树2. 非空：根节点，根节点的左子树、根节点的右子树组成的。
二叉树的遍历——递归以及非递归实现
06-03
vs2010下运行编写，使用了STL栈，实现了基本的插入、删除、计算深度、查找，主要是遍历，包括递归遍历，以及非递归的前序中序后序遍历，每个函数都有测试用例，如果存在错误，请在给我留言。
二叉树遍历——递归与非递归实现
jjy223404的博客
04-27 991
二叉树遍历——递归与非递归实现描述分析递归版本的二叉树遍历设计代码非递归版本的二叉树遍历非递归先序遍历设计步骤代码非递归后序遍历设计步骤代码非递归中序遍历设计步骤代码非递归遍历二叉树完整代码及测试 描述 实现二叉树的先序、中序、后序遍历，包括递归方式和非递归方式。 分析 使用递归实现二叉树遍历十分容易。在递归过程中，系统自动帮你压栈从而回溯时，关键信息不会被丢失。而非递归实现二叉树遍历时，无法再依...
DS二叉树——二叉树之父子结点
weixin_52247921的博客
10-19 712
#include <bits/stdc++.h> using namespace std; queue<char> father;//开一个爸爸队列放爸爸 class BiTreeNode{ public: char date; //节点数据 BiTreeNode *leftchild; BiTreeNode *rightchild; BiTreeNode() :leftchild(NULL),rightchild(NUL...
数据结构-模拟实现顺序表和链表
最新发布
2301_81261819的博客
12-03 279
本文介绍了Java中顺序表(ArrayList)和链表(LinkedList)的实现与应用。首先展示了基于ArrayList实现的洗牌和发牌操作，包括创建牌组、洗牌算法及发牌过程。其次详细讲解了数组模拟ArrayList的实现，包含扩容、插入、删除等核心操作。然后阐述了链表结构的特点，分别模拟实现了单向链表和双向链表，实现了头插尾插、按位置/值删除等功能。最后对比了ArrayList和LinkedList在存储结构、访问效率、插入性能等方面的差异：ArrayList物理连续存储，支持O(1)随机访问但插入效
Redis底层数据结构 -- ziplist, quicklist, skiplist
人工智能专业学生
11-29 3051
Redis底层数据结构学习笔记总结了ziplist、quicklist和skiplist三种核心结构。ziplist是紧凑型线性存储，用于小型List/Hash/ZSet，内存占用小但修改效率低；quicklist结合链表和ziplist，优化List结构的插入删除性能；skiplist作为ZSet底层，实现O(logN)的查找和范围查询。三种结构各有特点：ziplist空间最优但修改慢，quicklist折中平衡，skiplist查询高效但内存略大。这些设计体现了Redis在内存优化和查询性能间的权衡。
电子鼻数据结构
m0_73879806的博客
11-30 983
电子鼻测得的数据结构本质上是：原始数据：多传感器 × 时间序列矩阵处理后数据：样本 × 特征矩阵 + 标签附加信息：实验条件、样品类别、环境参数。
数据结构 带头节点的双向循环链表
似流水般平静而坚定。
12-01 284
本文实现了一个带头节点的双向循环链表，包含初始化、插入、删除等基本操作。链表节点包含数据域和前后指针，链表结构体维护头节点和当前大小。主要功能包括：1）初始化链表；2）在指定节点前插入元素；3）打印链表；4）删除指定节点；5）头删/尾删；6）头插/尾插。每个操作都处理了指针调整和内存管理，并维护链表大小。代码使用断言检查参数有效性，确保操作安全。这种实现方式适用于需要频繁在头部/尾部操作的场景，循环特性简化了边界条件处理。
数据结构核心内容
2501_90980137的博客
12-03 518
◦ 线性结构：元素间呈一对一关系，包括数组（固定大小、随机访问快）、链表（动态大小、插入删除快）、栈（先进后出，栈顶操作）、队列（先进先出，首尾操作）、哈希表（键值映射，平均O(1)查询）。◦ 排序核心：冒泡排序（O(n²)，稳定）、快速排序（O(nlogn)，不稳定，分治思想）、归并排序（O(nlogn)，稳定，分治+合并）、堆排序（O(nlogn)，不稳定，利用堆特性）。◦ 基础操作：增（插入）、删（删除）、改（更新）、查（查找）、排序（调整元素顺序）。
嵌入式第二十三篇——数据结构基本概念
2303_78799336的博客
11-30 945
数据结构是计算机存储和组织数据的方式，包括线性结构（数组、链表、栈、队列）和非线性结构（树、图）。基本操作有插入、删除、查找、遍历和排序。时间复杂度描述算法执行效率，常见类型有O(1)、O(logn)、O(n)、O(nlogn)、O(n²)等，计算时忽略低阶项和常数系数。时间复杂度与空间复杂度不同，前者关注时间增长趋势，后者关注内存需求。常见时间复杂度按效率排序为O(1)最快，O(n!)和O(nⁿ)最慢。
评论 25
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值