数据结构之二叉树基础相关oj题

@@永恒

已于 2022-04-26 22:58:23 修改

阅读量1.1k

点赞数 9

分类专栏：【数据结构学习】文章标签：数据结构 c语言

于 2022-04-26 22:57:48 首次发布

本文链接：https://blog.csdn.net/qq_53010164/article/details/124343147

版权

【数据结构学习】专栏收录该内容

17 篇文章 1 订阅

订阅专栏

一、单值二叉树

965. 单值二叉树 - 力扣（LeetCode） (leetcode-cn.com)

题目:如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。只有给定的树是单值二叉树时，才返回 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;//左右都是空树不用比，直接满足
    }
    //左右子树都存在的情况下,判断根节点是否和左右子树的值是否相同，如果左右子树不存在，不需要比较
    if(root->left && root->val != (root->left->val) )
    {
        return false;
    }
    if(root->right && root->val != (root->right->val))
    {
        return false;
    }
    
    //以左右子树为根判断是否值相等
    // bool temp = isUnivalTree(root->left);
    // bool ret = isUnivalTree(root->right);
    // return temp && ret;//左子树和右子树都返回true,才是true

    return isUnivalTree(root->left) && isUnivalTree(root->right);
}

运行结果:

思路二：

运用前序遍历，将root左子树里面的所有值和root的值相比较，root值也和右子树相比较

bool PreOrder(struct TreeNode* root,int data)
{
    if(root == NULL)
    {
        return true;
    }
    if(root->val != data)
    {
        return false;
    }
    return PreOrder(root->left,data) && PreOrder(root->right,data);
}

bool isUnivalTree(struct TreeNode* root)
{
    //运用前序遍历，将root左子树里面的所有值和root的值相比较，root值也和右子树相比较
    int data = root->val;
    bool ret = PreOrder(root,data);
    return ret;
}

二、二叉树的前序遍历

144. 二叉树的前序遍历 - 力扣（LeetCode） (leetcode-cn.com)

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

思路:

首先计算结点的个数，开辟多大的数组，然后进行前序遍历将数值放入数组中。

代码：

//计算有多少个结点
 int TreeSize(struct TreeNode* root)
 {
     return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1; 
 }

 void _preorderTraversal(struct TreeNode* root, int* temp,int* i)
 {
     if(root == NULL)
     {
         return ;
     }
     temp[(*i)++] = root->val;
    _preorderTraversal(root->left,temp,i);
    _preorderTraversal(root->right,temp,i);//这是同一层次的i，上面如果i = 2，而这里的i也是2，所以i要址传递
 }
int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
    int* temp = (int*)malloc(sizeof(int) * TreeSize(root));
    if(temp == NULL)
    {
        return NULL;
    }
    //这里自己调用自己的话，不能每次都开辟一个数组吧，所以写一个子函数
    int i = 0;
    _preorderTraversal(root,temp,&i);
    *returnSize = TreeSize(root);//returnSize表示数组大小，也就是结点个数
    return temp;
}

运行结果：

三、二叉树的中序遍历

94. 二叉树的中序遍历 - 力扣（LeetCode） (leetcode-cn.com)

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

代码：

/**
 * 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 TreeNodeSize(struct TreeNode* root)
{
    return root == NULL ? 0 : TreeNodeSize(root->left)  + TreeNodeSize(root->right) + 1;
}
void _inorderTraversal(struct TreeNode* root,int* temp,int* i)
{
    if(root == NULL)
    {
        return NULL;
    }
    _inorderTraversal(root->left,temp,i);
    temp[(*i)++] = root->val;
    _inorderTraversal(root->right,temp,i);
}
int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
    //开辟结点个数的大小
    int size = TreeNodeSize(root);
    int* temp = (int*)malloc(sizeof(int) * size);
    //不能每次都malloc,所以再建立一个子函数
    int i = 0;
    _inorderTraversal(root,temp,&i);
    *returnSize = size;
    return temp;
}

运行结果:

四、二叉树的后序遍历

145. 二叉树的后序遍历 - 力扣（LeetCode） (leetcode-cn.com)

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

代码：

/**
 * 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 TreeNodeSize(struct TreeNode* root)
{
    return root == NULL ? 0 : TreeNodeSize(root->left)  + TreeNodeSize(root->right) + 1;
}
void _inorderTraversal(struct TreeNode* root,int* temp,int* i)
{
    if(root == NULL)
    {
        return NULL;
    }
    _inorderTraversal(root->left,temp,i);
    _inorderTraversal(root->right,temp,i);
    temp[(*i)++] = root->val;
}
int* postorderTraversal(struct TreeNode* root, int* returnSize){
    //开辟结点个数的大小
    int size = TreeNodeSize(root);
    int* temp = (int*)malloc(sizeof(int) * size);
    //不能每次都malloc,所以再建立一个子函数
    int i = 0;
    _inorderTraversal(root,temp,&i);
    *returnSize = size;
    return temp;
}

运行结果:

五、相同的树

100. 相同的树 - 力扣（LeetCode） (leetcode-cn.com)

题目:给你两棵二叉树的根节点 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;
    }
    //其中一个为空，另一个不为空
    else if(p != NULL && q == NULL)
    {
        return false;
    }
    else if(p == NULL && q != NULL)
    {
        return false;
    }
    else//俩个都不为空
    {
        if(p->val != q->val)
        {
            return false;
        }
    }
    return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
}

运行结果：

六、对称二叉树

101. 对称二叉树 - 力扣（LeetCode） (leetcode-cn.com)

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

思路：

首先判断根是否相同，然后判断，左树的左树和右树的右树比，左树的右树和右树的左树比是否相同

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

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;
    }
    //根的左子树与右子树相比较
    bool ret = _isSymmetric(root->left,root->right);
    return ret;
}

运行结果:

七、另一棵树的子树

572. 另一棵树的子树 - 力扣（LeetCode） (leetcode-cn.com)

题目：

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

思路: 用root的每个子树都和subroot比,检查root树和subroot树是否相等,如果根直接不等，则检查root树的左子树和subroot树是否相等,如果根也直接不相等，检查左子树的左子树和subroot树是否相等,如果完全相等，再检查root的左子树的右子树是否和subroot的右子树相等,相等则完成，不相等的话，再比较root的右子树和subroot树是否相同，以此重复

最好时间复杂度:o(n)
最坏时间复杂度:o(n*n)

代码:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool isSameTree(struct TreeNode* root,struct TreeNode* subRoot)
{
    if(root == NULL && subRoot == NULL)
    {
        return true;
    }
    if(root == NULL  || subRoot  == NULL)//一个为空,一个不为空
    {
        return false;
    }
    if(root->val != subRoot->val)//俩个都不为空
    {
        return false;
    }
    //相等,向后进行,比较root的左子树和右子树 
    return isSameTree(root->left,subRoot->left) && isSameTree(root->right,subRoot->right);
}

bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot)
{
    //1.如果root为空，那就不用比了，因为subroot最少为1
    //2.如果root和subroot根不相等，则把这颗树的左子树和subroot比较，还不相等，则把这棵树的右子树和subroot比较
    if(root == NULL)
    {
        return false;
    }
    if(isSameTree(root,subRoot))
    {
        return true;
    }
    //如果俩颗树不相等，则比较root的左子树和右子树 同subroot是否相同
    return isSubtree(root->left,subRoot) || isSubtree(root->right,subRoot);
}

运行结果:

@@永恒

关注

9
点赞
踩
3

收藏

觉得还不错? 一键收藏
6
评论
数据结构之二叉树基础相关oj题

一、单值二叉树965. 单值二叉树 - 力扣（LeetCode） (leetcode-cn.com)题目:如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。只有给定的树是单值二叉树时，才返回 true；否则返回 false。思路一：在左右子树都存在的情况下，用根和左右子树相比较，如果都相等,则再比较根的左子树和其左右子树是否相等，直到其根为空，右子树也是如此。代码：/** * Definition for a binary tree node. * stru
复制链接

扫一扫