二叉树OJ

最新推荐文章于 2023-03-20 11:17:19 发布
最新推荐文章于 2023-03-20 11:17:19 发布
阅读量445 收藏 1
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43831728/article/details/113314335
版权

二叉树OJ

1.单值二叉树

题目描述

在这里插入图片描述
在这里插入图片描述

解题思路：
  • 针对上面的二叉树的题目，我们可以使用递归的方式对其进行求解
  • 一颗树是单值的，当且仅当根节点的子节点所在的子树也是单值的，同时根节点的值与子节点的值相同。
  • 我们可以使用递归实现这个判断的过程。left 表示当前节点的左孩子是正确的，也就是说：左孩子所在的子树是单值的，并且当前节点的值等于左孩子的值。right 对当前节点的右孩子表示同样的事情。递归处理之后，当根节点的这两种属性都为真的时候，我们就可以判定这颗二叉树是单值的
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
   
    bool isUnivalTree(TreeNode* root) {
        if (root == NULL) 
        {
            return true;
        }
        if (root->left != NULL && root->val != root->left->val) {
            return false;
        }
        if(root->right != NULL && root->val != root->right->val) {
            return false;
        }
        return isUnivalTree(root->left) && isUnivalTree(root->right);

    }
};
复杂度分析

时间复杂度：O(N)，其中 N 是给定树中节点的数量。
空间复杂度：O(H)，其中 H 是给定树的高度。

解题思路Ⅱ：
  • 同样针对这道题，我们还可以使用递归的方式对问题进行求解
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isUnivalTree(TreeNode* root) {
        stack<TreeNode*> s;
        if(root == NULL)
            return true;
        s.push(root);
        int val = root->val; //设置初始值为root的值
        TreeNode* node;
        while(!s.empty())
        {   
            node = s.top();
            s.pop();
            if(val != node->val)
                return false; //发现不一致的现象，直接返回false
            if(node->left != NULL)
                s.push(node->left);
            if(node->right != NULL)
                s.push(node->right);
        }
        return true; //所有节点遍历完都一致，那么返回true

        }
};
2.二叉树的最大深度
题目描述

在这里插入图片描述

解题思路：
  • 如果我们知道了左子树和右子树的最大深度 ll 和 rr，那么该二叉树的最大深度即为max(l,r)+1，而左子树和右子树的最大深度又可以以同样的方式进行计算。因此我们可以用「深度优先搜索」的方法来计算二叉树的最大深度。具体而言，在计算当前二叉树的最大深度时，可以先递归计算出其左子树和右子树的最大深度，然后在 O(1)O(1) 时间内计算出当前二叉树的最大深度。递归在访问到空节点时退出
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) 
    {
        if(root==nullptr)
            return 0;
        int left=maxDepth(root->left);
        int right=maxDepth(root->right);
        return left>right?left+1:right+1;
    }
};
复杂度分析
  • 时间复杂度：O(n)，其中 n 为二叉树节点的个数。每个节点在递归中只被遍历一次。
  • 空间复杂度：O(height)，其中height 表示二叉树的高度。递归函数需要栈空间，而栈空间取决于递归的深度，因此空间复杂度等价于二叉树的高度。

3.翻转二叉树

题目描述

在这里插入图片描述

解题思路：
  • 这是一道很经典的二叉树问题。显然，我们从根节点开始，递归地对树进行遍历，并从叶子结点先开始翻转。如果当前遍历到的节点root 的左右两棵子树都已经翻转，那么我们只需要交换两棵子树的位置，即可完成以 root 为根节点的整棵子树的翻转。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) 
    {
        if (root == NULL) 
        	return root;
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        return root;
    }
};
复杂度分析
  • 时间复杂度：O(N)，其中 NN 为二叉树节点的数目。我们会遍历二叉树中的每一个节点，对每个节点而言，我们在常数时间内交换其两棵子树。
  • 空间复杂度：O(N)。使用的空间由递归栈的深度决定，它等于当前节点在二叉树中的高度。在平均情况下，二叉树的高度与节点个数为对数关系，即 O(logN)。而在最坏情况下，树形成链状，空间复杂度为 O(N)
解法二：使用迭代的方法：
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()) 
        {
            TreeNode* node = st.top();              
            st.pop();
            swap(node->left, node->right);          
            if(node->right) 
                st.push(node->right);   
            if(node->left) 
                st.push(node->left);    
        }
        return root;
    }
};

4.相同的树

题目描述

在这里插入图片描述

解题思路：
  • 如果两个二叉树都为空，则两个二叉树相同。如果两个二叉树中有且只有一个为空，则两个二叉树一定不相同。
  • 如果两个二叉树都不为空，那么首先判断它们的根节点的值是否相同，若不相同则两个二叉树一定不同，若相同，再分别判断两个二叉树的左子树是否相同以及右子树是否相同。这是一个递归的过程，因此可以使用深度优先搜索，递归地判断两个二叉树是否相同
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) 
    {
        if(!p && !q) return true;
        if(!p || !q) return false;
        return (p->val == q->val) 
                && (isSameTree(p->left,q->left) 
                && isSameTree(p->right,q->right));
    }
};
复杂度分析
  • 时间复杂度:O(min(m,n))，其中 m 和 n 分别是两个二叉树的节点数。对两个二叉树同时进行深度优先搜索，只有当两个二叉树中的对应节点都不为空时才会访问到该节点，因此被访问到的节点数不会超过较小的二叉树的节点数。
  • 空间复杂度：O(min(m,n))，其中 m 和 n 分别是两个二叉树的节点数。空间复杂度取决于递归调用的层数，递归调用的层数不会超过较小的二叉树的最大高度，最坏情况下，二叉树的高度等于节点数。
5.对称二叉树
题目描述

在这里插入图片描述

解题思路

在这里插入图片描述

  • 我们可以实现这样一个递归函数，通过「同步移动」两个指针的方法来遍历这棵树，pp 指针和 qq 指针一开始都指向这棵树的根，随后 p 右移时，q左移，p 左移时，q 右移。每次检查当前 p 和 q 节点的值是否相等，如果相等再判断左右子树是否对称。
复杂度分析
  • 假设树上一共 nn 个节点。
  • 时间复杂度：这里遍历了这棵树，渐进时间复杂度为 O(n)
  • 空间复杂度：这里的空间复杂度和递归使用的栈空间有关，这里递归层数不超过 n，故渐进空间复杂度为 O(n)
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) 
    {
        if(root == NULL)    return true;
        return isMirror(root->left,root->right);
    }
    
    bool isMirror(TreeNode *p,TreeNode *q)          //递归函数
    {
        if(!p && !q)        return true;        //如果p,q均为NULL
        if(!p || !q)        return false;       //p,q只有一者为NULL

        return (p->val==q->val) && isMirror(p->left,q->right) && isMirror(p->right,q->left);        
    }
};
方法二：迭代
  • 「方法一」中我们用递归的方法实现了对称性的判断，那么如何用迭代的方法实现呢？首先我们引入一个队列，这是把递归程序改写成迭代程序的常用方法。初始化时我们把根节点入队两次。每次提取两个结点并比较它们的值（队列中每两个连续的结点应该是相等的，而且它们的子树互为镜像），然后将两个结点的左右子结点按相反的顺序插入队列中。当队列为空时，或者我们检测到树不对称（即从队列中取出两个不相等的连续结点）时，该算法结束。
class Solution {
public:
    bool check(TreeNode *u, TreeNode *v) {
        queue <TreeNode*> q;
        q.push(u); q.push(v);
        while (!q.empty()) {
            u = q.front(); q.pop();
            v = q.front(); q.pop();
            if (!u && !v) continue;
            if ((!u || !v) || (u->val != v->val)) return false;

            q.push(u->left); 
            q.push(v->right);

            q.push(u->right); 
            q.push(v->left);
        }
        return true;
    }

    bool isSymmetric(TreeNode* root) {
        return check(root, root);
    }
};
6.二叉树的前序遍历
题目描述

在这里插入图片描述

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


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
 typedef struct TreeNode Node;

int GetNodeCount(Node *root)
{
     if(NULL==root)
        return 0;
     return GetNodeCount(root->left)+GetNodeCount(root->right)+1;
}

void _PreOrder(Node *root,int* pRet,int* index)   //用于保存
{
    if(root)
    {
        pRet[*index]=root->val;
        (*index)++;
        _PreOrder(root->left,pRet,index);
        _PreOrder(root->right,pRet,index);
    }
}
int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
    *returnSize=0;
    int *pRet=(int*)malloc(sizeof(int)*GetNodeCount(root));
    _PreOrder(root,pRet,returnSize);
    return pRet;
}
方法一：递归
  • 首先我们需要了解什么是二叉树的前序遍历：按照访问根节点——左子树——右子树的方式遍历这棵树，而在访问左子树或者右子树的时候，我们按照同样的方式遍历，直到遍历完整棵树。因此整个遍历过程天然具有递归的性质，我们可以直接用递归函数来模拟这一过程。
  • 定义 preorder(root) 表示当前遍历到 root 节点的答案。按照定义，我们只要首先将 root 节点的值加入答案，然后递归调用 preorder(root.left) 来遍历 root 节点的左子树，最后递归调用 preorder(root.right) 来遍历 root 节点的右子树即可，递归终止的条件为碰到空节点。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution 
{
private:
    vector<int> Pre;
public:
    vector<int> preorderTraversal(TreeNode* root) 
    {
        if(root==nullptr)
            return Pre;
        Pre.push_back(root->val);
        preorderTraversal(root->left);
        preorderTraversal(root->right);
        return Pre;
    }
};
复杂度分析
  • 时间复杂度：O(n)，其中 n 是二叉树的节点数。每一个节点恰好被遍历一次。
  • 空间复杂度：O(n)，为递归过程中栈的开销，平均情况下为O(logn)，最坏情况下树呈现链状，为 O(n)
方法二：迭代
  • 我们也可以用迭代的方式实现方法一的递归函数，两种方式是等价的，区别在于递归的时候隐式地维护了一个栈，而我们在迭代的时候需要显式地将这个栈模拟出来，其余的实现与细节都相同，具体可以参考下面的代码。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) 
    {
        stack<TreeNode*> st;
        vector<int> result;
        st.push(root);
        while(!st.empty())
        {
            TreeNode *node=st.top();
            st.pop();
            if(node!=NULL)
            {
                result.push_back(node->val);
            }
            else
            {
                continue;
            }
            st.push(node->right);
            st.push(node->left);
        }
        return result;
    }
};
7.平衡二叉树

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 因为从上到下计算树的高度的话，会有很多的重复计算，那么我们会想到把从上到下计算树的高度改变成为从下到上计算树的高度，那么修改之后的代码如下所示：
    在这里插入图片描述
  • 但是，其实上面的那个代码也不是完全正确的，因为按照上面的那种代码的思路来思考，实践发现结果给我们返回左侧的树是一颗平衡二叉树，但是根据平衡二叉树的概念可以找到，左侧的那棵树其实并不是一颗平衡二叉树，所以说，上面的代码其实还是有问题的。
  • 上面的那个代码也是有优点的，至少规避了第一种方法重复计算所带来的复杂的问题
  • 要对上面的代码进行修改，就是要根据平衡二叉树的概念，增加一个对左右子树高度的判断就可以了
    在这里插入图片描述
题目描述

在这里插入图片描述

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

int maxDepth(struct TreeNode* root)
{
    int leftHeight = 0;
	int rightHeight = 0;
    if(NULL==root)
        return 0;
    leftHeight=maxDepth(root->left);
    rightHeight=maxDepth(root->right);
    return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;

}
bool isBalanced(struct TreeNode* root)
{
    int leftHeight = 0;
	int rightHeight = 0;
	if(NULL == root)
		return 1;   //空树也是平衡树
	leftHeight = maxDepth(root->left);
	rightHeight = maxDepth(root->right);
	return abs(rightHeight - leftHeight) < 2 && isBalanced(root->left) && isBalanced(root->right);
}

在这里插入图片描述

8.二叉树的遍历
题目描述在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

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


typedef struct TreeNode
{
    struct TreeNode *left;
    struct TreeNode *right;
    char ch;
}TreeNode;

//创建结点
TreeNode *BuyTreeNode(char ch)
{
    TreeNode *newnode=(TreeNode*)malloc(sizeof(TreeNode));
    if(NULL==newnode)
        return NULL;
    newnode->left=NULL;
    newnode->right=NULL;
    newnode->ch=ch;
    return newnode;
}

TreeNode *CreateBinTree(char szTree[],int size,int *index,char invalid)
{
    TreeNode *root=NULL;
    //创建根节点
    if(*index<size&&szTree[*index]!=invalid)
    {
        root=BuyTreeNode(szTree[*index]);
        //创建根节点的左子树
        ++(*index);
        root->left=CreateBinTree(szTree,size,index,invalid);
        //创建根节点的右子树
        ++(*index);
        root->right=CreateBinTree(szTree,size,index,invalid);
    }
    
    return root;
}

void InOrder(TreeNode *root)
{
    if(root)
    {
        InOrder(root->left);
        printf("%c ",root->ch);
        InOrder(root->right);
    }
}

int main()
{
    char szTree[100]={0};
    int size=0;
    int index=0;
    while(EOF != scanf("%s",&szTree))
    {
        scanf("%s",&szTree);
        size=strlen(szTree);
        TreeNode *root=CreateBinTree(szTree,size,&index,'#');
        //进行中序遍历
        InOrder(root);
        printf("\n");
    }
    return 0;
}
9.另一个树的子树
题目描述

在这里插入图片描述
在这里插入图片描述

/**
 * 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(NULL==q&&NULL==p)
        return true;
    //一棵树为空，那肯定不相同
    if(p==NULL||q==NULL)
        return false;
    return p->val==q->val&&isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);

}
bool isSubtree(struct TreeNode* s, struct TreeNode* t)
{
    if(NULL==s&&NULL==t)
        return true;
    if(NULL==s||NULL==t)
        return false;
    if(s->val==t->val&&isSameTree(s,t))   //根一样
        return true;
    return isSubtree(s->left,t)||isSubtree(s->right,t);
}
yyyyeahhhhhh
关注
专栏目录
cd.zip_THU OJ_oj_reconfiguration_thu dsa_重构 二叉树
09-23
在本压缩包“cd.zip_THU OJ_oj_reconfiguration_thu dsa_重构 二叉树”中，主要涉及的是清华大学（THU）在线判题系统（Online Judge，简称OJ）上的一个编程挑战，具体是关于二叉树的重构问题。这个任务涉及到的数据...
OJ：求树的高度/深度 (递归) —— 二叉树
最新发布
fantastic_13_7的博客
04-05 341
求二叉树的高度/深度（递归）
二叉树层次遍历
weixin_43742643的博客
03-19 108
二叉树结构 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ 简单层次遍历 class Solution { public: void levelOrder(TreeNode* root) { queue<TreeNode*> Q;
二叉树OJ题（干货满满）
qq_54469537的博客
10-11 1658
12道二叉树典型OJ题思路分析+详细图解
二叉树的oj题
m0_70386582的博客
10-12 339
二叉树
【数据结构】二叉树（OJ）
君子慎独，不欺暗室。卑以自牧，含章可贞。
03-20 451
单值二叉树 相同的树 另一棵树的子树 对称二叉树 翻转二叉树 二叉树遍历 二叉树的最大深度 二叉树的前序遍历 二叉树的中序遍历 二叉树的后序遍历
西南科技大学SWUST OJ 数据结构 树和二叉树答案 树和二叉树.zip
01-01
西南科技大学（SWUST）的在线编程平台（OJ）提供了关于这些主题的编程题目，帮助学生深入理解和应用这些知识。以下是对这些题目涉及知识点的详细解析： 1. **基本概念**： - **树**：树是一种非线性的数据结构，由...
程序设计基础 OJ 题库 NUIST
10-22
在OJ题库中，常见的数据结构包括数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树等）、哈希表等。理解并熟练运用这些数据结构可以有效地组织和操作数据，实现高效的算法。 在NUIST的"程序设计基础"课程中，...
华为OJ答案
07-23
1. **基础算法**：包括排序（如冒泡、快速、归并排序）、查找（如二分查找、哈希查找）、图论（如最短路径、拓扑排序）、树结构（如二叉树、AVL树、红黑树）等。这些基础知识是解决OJ题目时的必备工具。 2. **数据...
前缀表达式求值_二叉树_
10-01
另一方面，`308.doc`文档可能包含了一道在线判断系统（Online Judge，简称OJ）上的题目，要求用C语言解决与前缀表达式和二叉树相关的算法问题。在解决这类题目时，需要熟悉上述概念，能够正确地将前缀表达式转化为...
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
小乔美哒哒
03-12 3504
有的时候我们在写LeetCode等编程题时，会发现有人用了下面的初始化方法： struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 这是允许我们用 TreeNode node(int x)的法式把val赋值为x，left，right为NULL。 ...
5432: 数据结构实验：二叉树倾斜度
qq_40605429的博客
06-04 1145
5432: 数据结构实验：二叉树倾斜度时间限制(普通/Java):1000MS/3000MS     内存限制:65536KByte总提交:121           测试通过:23描述求一棵二叉树的倾斜度，其中一个节点的倾斜度定义为“左子树元素之和”与“右子树元素之和”差的绝对值（空节点的元素值为0），二叉树的倾斜度定义为所有节点的倾斜度之和。二叉树节点定义如下：struct TreeNode ...
南邮 OJ 1019 计算二叉树的高度和结点数
呈凹的博客
08-03 807
计算二叉树的高度和结点数 时间限制(普通/Java) : 1000 MS/ 3000 MS          运行内存限制 : 65536 KByte 总提交 : 1011            测试通过 : 301  比赛描述 二叉树是非常重要的树形数据结构，根据该树的先序、中序或后序遍历序列可以建立一棵二叉树。例如输入先序遍历序列A B # D # # C E # # F #
二叉树深度的计算
qq_31997185的博客
09-20 4578
1. 最大深度：根节点到最远叶子节点路径上的节点数： def maxdepth(root): if not root: return 0 if not root.rchild and not root.lchild: return 1 else: ml = maxdepth(root.lchild) ml += 1 mr = maxdepth(root.rchild) mr += 1
计算二叉树深度算法（递归、非递归）入门详解
sunnyoldboy博客
07-28 3万+
二叉树在应用时，经常需要知道二叉树的深度。二叉树的深度就是二叉树的层数，即从树根算起，到最底下一层的层数是多少，即二叉树中结点的最大层次值。 本文给出了计算二叉树深度的算法，包括递归算法和非递归算法。......
计算二叉树的深度
热门推荐
qq_47142993的博客
08-02 5万+
[算法步骤] 如果是空树，递归结束，深度为0；否则执行一下操作 递归计算左子树的深度计为m; 递归计算右子树的深度计为n; 如果m大于n，二叉树的深度为m+1，否则为n+1； [算法描述] int Depth(BiTree T) { int m, n; if (T == NULL) return 0; //如果是空树，深度为0，递归结束 else { m = Depth(T->lchild); //递归计算左子树的深度记为m
【数据结构】——二叉树oj题详解
weixin_62678196的博客
09-01 1090
二叉树的OJ题详解
（C语言）二叉树经典oj题练习
博主qq1077644249
08-16 798
我们先自己定义一个二叉树结构体类型，然后基于分治的思想，递归构建二叉树，构建二叉树先malloc出根节点然后再构建左子树，右子树即可。因为字符串需要构建之后指针向后移动找到下一个字符，所以需要定义一个i下标，通过传址调用把i的地址传过去，实现对下标i的控制。构建之后i下标向后移动，指针指向’#‘代表到了空节点了完成返回NULL即可。如果一个树的左子树与右子树镜像对称，那么这个树是对称的。 > 因此，如果同时满足下面的条件，两个树互为镜像： > 1、它们的两个根结点具有相同的值 > 2、每个树的右子树都与
二叉树OJ题详解
Sxy_wspsby的博客
12-04 772
第一题：单值二叉树力扣链接：力扣 单值二叉树就是每一个节点存放的数据都相同，那么如何判断一棵树为单值二叉树呢？我们就拿最简单的一棵树为例子，比如根节点为1它的左子树和右子树也为1的一棵树，我们只需要比较根节点和它的左子树是否相等，根节点和它的右子树是否相等，也就是说判断一个二叉树是否为单值二叉树最重要的是判断父节点与左右子树的值是否相同。 /** * Definition for a binary tree node. * struct TreeNode { * int val;
快速解决THU OJ二叉树重构问题的源码解析
在THU OJ上，用户可以找到关于数据结构和算法的问题，包括二叉树的重构问题。 3. 二叉树重构问题源码：源码是实现二叉树重构算法的代码文件。它可能包含了算法逻辑、数据结构的定义以及可能的测试用例。在THU OJ上...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值