LeetCode——二叉树链式结构相关oj题

最新推荐文章于 2024-11-04 17:15:19 发布

霄沫凡

最新推荐文章于 2024-11-04 17:15:19 发布

阅读量603

点赞数 21

分类专栏： LeetCode 文章标签：数据结构算法 c++ c语言

本文链接：https://blog.csdn.net/sjsjnsjnn/article/details/124258474

版权

LeetCode 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

1. 单值二叉树

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

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

链接：https://leetcode-cn.com/problems/univalued-binary-tree/
输入：[1,1,1,1,1,null,1]
输出：true
输入：[2,2,2,5,2]
输出：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);

2. 对称二叉树

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

链接：https://leetcode-cn.com/problems/symmetric-tree/submissions/

思路：

1.如果是一棵空树，他一定是对称的二叉树；

        2.如果不是空树，判断这棵树有没有左右子树，如果没有，则是对称的二叉树，反之则不是；

        3.如果左右子树只存在一个，就不是对称的二叉树；

        4.接下来去判断左子树的左值是否和右子树的右值相等，左子树的右值和右子树的左值是否相等；

bool _isSymmetric(struct TreeNode* root1,struct TreeNode* root2)
{
    //左右子树为空
    if(root1 == NULL && root2 == NULL)
    {
        return true;
    }
    //左右子树有一个为空
    if(root1==NULL ||root2==NULL)
    {
        return false;
    }
    //左右值不相等
    if(root1->val != root2->val)
    {
        return false;
    }
    //递归左子树的左和右子树的右      和        递归左子树的右和右子树的左
    return _isSymmetric(root1->left,root2->right) && _isSymmetric(root1->right,root2->left);
}

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

3. 相同的树

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

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

链接：https://leetcode-cn.com/problems/same-tree/submissions/

思路：

1.如果两棵树都是空树，肯定是相同的树；

2.只有一个树，另一个树为空。一定不是相同的树；

3.对应结点的值如果不相等，一定不是相同的树；

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

4. 二叉树的前序遍历

链接：https://leetcode-cn.com/problems/binary-tree-preorder-traversal/submissions/

前序遍历相对来说理解其原来，实现不是很困难；这道题要注意几个地方，输出结果是以数组的形式输出的，我们要给多大的数组呢？测试用例多样化，我们可以给到一个二叉树的结点给树函数，让其求出结点个数，然后去开辟空间；这样就不会造成浪费；给到的函数中有这样一个参数int* returnSize，这是输出型参数，就是数组的元素个数；也就是我们算出来的二叉树的结点个数；

后面的中序遍历和后续遍历同样如此；

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

void _preorderTraversal(struct TreeNode* root, int* a,int* pi)
{
    if(root == NULL)
    {
        return;
    }
    a[(*pi)++] = root->val;//根
    _preorderTraversal(root->left, a, pi);//左
    _preorderTraversal(root->right, a, pi);//右
}
int* preorderTraversal(struct TreeNode* root, int* returnSize){
    int size=TreeSize(root);
    int* a = malloc(sizeof(int)*size);
    int i = 0;
    _preorderTraversal(root, a, &i);
    *returnSize = size;
    return a;
}

5. 二叉树的中序遍历

链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/

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

 void _inorderTraversal(struct TreeNode* root,int* a,int* pi)
 {
    if(root == NULL)
    {
        return;
    }
    _inorderTraversal(root->left, a, pi); //左
    a[(*pi)++] = root->val;               //根
    _inorderTraversal(root->right, a, pi);//右
 }
int* inorderTraversal(struct TreeNode* root, int* returnSize){
    int size = TreeSize(root);
    int* a = malloc(sizeof(int) * size);
    int i = 0;
    _inorderTraversal(root, a, &i);
    *returnSize = size; 
    return a;
}

6. 二叉树的后序遍历

链接：https://leetcode-cn.com/problems/binary-tree-postorder-traversal/

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

 void _postorderTraversal(struct TreeNode* root,int* a,int* pi)
{
    if(root == NULL)
    {
        return;
    }
    _postorderTraversal(root->left, a, pi);//左
    _postorderTraversal(root->right, a, pi);//右
    a[(*pi)++] = root->val;//根
}
int* postorderTraversal(struct TreeNode* root, int* returnSize){
    int size = TreeSize(root);
    int* a = malloc(sizeof(int) * size);
    int i = 0;
    _postorderTraversal(root, a, &i);
    *returnSize = size; 
    return a;
}

7. 另一棵子树

链接：https://leetcode-cn.com/problems/subtree-of-another-tree

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

思路：让root的每棵子树与subroot相比较（和第3题有些类似，判断相同的树）


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;
    }
    //root的左子树与subroot比较 和 root的右子树与subroot比较 只要有一个相同就是满足条件的
    return isSubtree(root->left,subRoot) || isSubtree(root->right,subRoot);
}

8. 二叉树遍历

这是一道牛客网得到题目：

链接：https://www.nowcoder.com/practice/4b91205483694f449f94c179883c1fef?tpId=60&&tqId=29483&rp=1&ru=/activity/oj&qru=/ta/tsing-kaoyan/question-ranking

描述：

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

输入描述：

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

输出描述：

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

示例：

输入：a b c # # d e # g # # f # # #
输出：c b e g d f a

思路：

本题的关键点时如何让用户输入的字符串是先序遍历（即前序遍历），我们利用前序遍历的思路去创建每个结点，并将其链接起来；根据题目所给的字符串，是否能画出它的前序遍历结构图，如下所示：

动图演示：

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

struct TreeNode* CreateTree(char* str,int* pi)
{
    //遇到‘#’号就跳过去
    if(str[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = str[*pi];//先创建根
    (*pi)++;
    root->left = CreateTree(str,pi);//再创建左子树
    root->right = CreateTree(str,pi);//然后创建右子树
    return root;
}

void Inorder(struct TreeNode* 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;
    struct TreeNode* root = CreateTree(str,&i);
    Inorder(root);
    return 0;
}