★ OJ题 ★ 二叉树

椎名澄嵐

于 2024-08-26 15:51:33 发布

阅读量462

点赞数 33

分类专栏： ★ 数据结构 ★ ★ OJ题 ★ 文章标签：算法数据结构 c语言开发语言

本文链接：https://blog.csdn.net/2302_80328146/article/details/141477480

版权

★ 数据结构 ★ 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

★ OJ题 ★

1 篇文章 0 订阅

订阅专栏

Ciallo～(∠・ω< )⌒☆ ~ 今天，我将和大家一起做一些二叉树的OJ题~

一单值二叉树

965. 单值二叉树 - 力扣（LeetCode）

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

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

此题建议用递归方法：

bool isUnivalTree(struct TreeNode* root) 
{
    // 如果当前节点为空，根据定义，空树可以被认为是单值树
    if(root == NULL)
        return true;
    // 检查左子节点是否存在且值是否与根节点相同
    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);
}

如果当前节点（root）为空，则根据单值树的定义，空树可以被认为是单值树，因此返回true。
检查子节点值：
如果左子节点存在且其值与根节点不同，则不满足单值树的定义，返回false。
如果右子节点存在且其值与根节点不同，同样不满足单值树的定义，返回false。
递归检查：如果左子节点和右子节点都满足条件（即要么不存在，要么值与根节点相同），则递归地对左子树和右子树调用isUnivalTree函数，确保这两棵子树也都是单值树。只有当左子树和右子树都是单值树时，才返回true；否则，返回false。

二相同的树

100. 相同的树 - 力扣（LeetCode）

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

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

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);
}

这个函数通过递归的方式检查两棵树是否完全相同。首先，它检查两个节点是否都为空（即都是叶子节点的下一个位置），如果是，则返回true。然后，它检查是否只有一个节点为空（即一棵树比另一棵树短），如果是，则返回false。接下来，它比较两个节点的值是否相等，如果不等，则返回false。最后，如果两个节点的值相等，则递归地调用isSameTree函数来检查它们的左子树和右子树是否也相同。如果所有子树都相同，则返回true；否则，返回false。

三对称二叉树

101. 对称二叉树 - 力扣（LeetCode）

要求：给你一个二叉树的根节点 root ，检查它是否轴对称。

bool _isSymmetric(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 _isSymmetric(p->left, q->right) && _isSymmetric(p->right, q->left);
}

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

主要方法同上题一样，通过递归的方式检查两棵树是否是对称二叉树。

如果两个节点都为空，那么它们是对称的（因为空树和空树总是对称的）。
如果只有一个节点为空，或者两个节点的值不相等，那么它们不对称。
如果两个节点都不为空且值相等，那么递归地检查：

第一个节点的左子树和第二个节点的右子树是否对称。
第一个节点的右子树和第二个节点的左子树是否对称。

如果这两对子树都对称，那么这两棵树就是对称的。
然后，isSymmetric函数是调用_isSymmetric的入口点，它检查根节点的左子树和右子树是否对称。

四二叉树的前序遍历

144. 二叉树的前序遍历 - 力扣（LeetCode）

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

int TreeSize(struct TreeNode* root)
{
    return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}
void preorder(struct TreeNode* root, int* a,int* pi)
{
    if(root == NULL)
    {
        return;
    }
    a[(*pi)++] = root->val;
    preorder(root->left, a, pi);
    preorder(root->right, a, pi);
}
int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
    *returnSize = TreeSize(root);
    int* a = (int*)malloc(sizeof(int) * (*returnSize));
    int i = 0;
    preorder(root, a, &i);
    return a;
}

首先，TreeSize 函数通过递归计算了二叉树中节点的总数，这是为了提前分配足够的内存空间来存储前序遍历的结果。
然后，preorder 函数是一个递归函数，用于实际执行前序遍历。它首先检查当前节点是否为空，如果不为空，就将当前节点的值存入数组 a 中，并更新索引 pi。接着，它递归地对左子树和右子树进行前序遍历。注意：若形参不使用地址pi，在递归的过程中i的值会遗失。
最后，preorderTraversal 函数是外部调用的接口，它首先通过 TreeSize 函数获取树的大小，然后分配足够的内存空间，并调用 preorder 函数来填充这个数组。最后，它返回这个数组和数组的大小。

五另一颗树的子树

572. 另一棵树的子树 - 力扣（LeetCode）

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(root->val == subRoot->val && isSameTree(root, subRoot))
        return true;
    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}

核心：找出root所有子树，和subRoot比较

isSameTree 函数：用来判断两棵树p和q是否完全相同的。（复用第二题）
isSubtree 函数：用来判断一棵树subRoot是否是另一棵树root的子树。
如果root是空树，那么subRoot肯定不是它的子树，返回false。
如果root和subRoot的根节点值相同，并且它们的结构也完全相同（即isSameTree(root, subRoot)返回true），那么subRoot就是root的子树（实际上是相同的树），返回true。
如果上面的条件都不满足，那么就递归地在root的左子树和右子树中查找是否存在与subRoot相同的子树。如果左子树中存在，或者右子树中存在，那么返回true；如果两者都不存在，那么返回false。

六二叉树遍历

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

#include <stdio.h>
#include <stdlib.h>
typedef struct BinTreeNode
{
    struct BinTreeNode* left;
    struct BinTreeNode* right;
    char val;
}BTNode;

BTNode* CreateTree(char* a,int* pi)
{
    if(a[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    BTNode* root = (BTNode*)malloc(sizeof(BTNode));
    root->val = a[(*pi)++];
    root->left = CreateTree(a, pi);
    root->right = CreateTree(a, pi);
    return root;
}
void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	InOrder(root->left);
	printf("%c ", root->val);
	InOrder(root->right);
}
int main()
{
    char a[100];
    scanf("%s", a);
    int i = 0;
    BTNode* root = CreateTree(a, &i);
    InOrder(root);
    return 0;
}

此题为IO题，需要进行接收打印。

CreateTree函数根据给定的前序遍历字符串a和一个指向当前处理位置的指针pi来构建二叉树。当遇到#字符时，表示当前位置为空节点，函数返回NULL。否则，创建一个新节点，设置其值为当前字符，并递归地构建其左右子树。