牛客网二叉树题解

最新推荐文章于 2022-09-07 17:56:10 发布
最新推荐文章于 2022-09-07 17:56:10 发布
阅读量507 收藏
点赞数
分类专栏： 题解 文章标签： 链表 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41146650/article/details/125919865
版权

牛客网二叉树题解

牛客网面试必刷TOP101

二叉树的前序遍历

int* preorderTraversal(struct TreeNode* root, int* returnSize ) {
    int *res = malloc(101*sizeof(int)); 
    *returnSize = 0;
    struct TreeNode** stack = malloc(101*sizeof(struct TreeNode*));
    int top=0;
    struct TreeNode *p=root;
    while (p||top)
    {
        // 先把节点压入stack, 访问左孩子
        if(p) {
            res[(*returnSize)++] = p->val;
            stack[top++]=p;
            p=p->left;
        } else {
            // 左节点为空，访问上一个节点的右孩子
            p = stack[--top];
            p=p->right;
        }
    }
    return res;
}

int* preorderTraversal(struct TreeNode* root, int* returnSize ) {
    int *res = malloc(101*sizeof(int)); 
    *returnSize = 0;
    if (!root)return res;
    struct TreeNode** stack = malloc(101*sizeof(struct TreeNode*));
    int top=0;
    struct TreeNode *p=root;
    stack[top++]=p;
    // 栈是后进先出，前序遍历是要先遍历左子树，再遍历右子树
    while (top)
    {
        p = stack[--top];
        res[(*returnSize)++] = p->val;
        if(p->right)
           stack[top++]=p->right;
        if (p->left) 
            stack[top++]=p->left;
    }
    return res;
}

// https://zhuanlan.zhihu.com/p/384818393

二叉树的中序遍历

int* inorderTraversal(struct TreeNode* root, int* returnSize ) {
    int *res = malloc(1001*sizeof(int)); 
    *returnSize = 0;
    struct TreeNode** stack = malloc(1001*sizeof(struct TreeNode*));
    int top=0;
    struct TreeNode *p=root;
    while (p||top)
    {
        // 先把节点压入stack, 访问左孩子
        if(p) {
            stack[top++]=p;
            p=p->left;
        } else {
            // 左节点为空，访问上一个节点的右孩子
            p = stack[--top];
            res[(*returnSize)++] = p->val;
            p=p->right;
        }
    }
    return res;
}

后序遍历

int* postorderTraversal(struct TreeNode* root, int* returnSize ) {
    int *res = malloc(101*sizeof(int)); 
    *returnSize = 0;
    struct TreeNode** stack = malloc(101*sizeof(struct TreeNode*));
    int top=0;
    struct TreeNode *p=root,*r=NULL;
    while (p||top)
    {
        // 先把节点压入stack, 访问左孩子
        if(p) {
            stack[top++]=p;
            p=p->left;
        } else {
            // 左节点为空，访问上一个节点的右孩子
            p = stack[top-1];
            if(p->right&&p->right!=r) p=p->right;
            else {
                top--;
                res[(*returnSize)++] = p->val;
                r=p;
                p=NULL;
            }
        }
    }
    return res;
}

求二叉树的层序遍历

int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes ) {
    // write code here
    int maxlen=1e5+1;
    *returnSize = 0;
    if (!root) return NULL;
    // 初始化列
    *returnColumnSizes = malloc(sizeof(int)*maxlen); 
    
    struct TreeNode** queue = malloc(maxlen*sizeof(struct TreeNode*));
    int f=0,r=0; // 队列的前，后指针
    int** res = malloc(maxlen*sizeof(int *));
    int i=0,j=0; // 表示一维，二维坐标
    res[i] = malloc(sizeof(int)); 

    struct TreeNode*p;
    queue[f++]=root;
    int cur=0,plen=1,len=0,; // 记录，当前遍历层的第几个，当前层的总长度，遍历时对下一层加入队列的个数加+1
    while(r<f) {
        p = queue[r++];
        cur ++ ;
        res[i][j++]=p->val;
        if (p->left) {
            len ++;
            queue[f++]=p->left;
        }
        if (p->right) {
            len ++;
            queue[f++]=p->right;
        }
        if (cur==plen) {
            // 上一层节点已遍历完
            (*returnColumnSizes)[i]=j;
            plen = len;
            res[++i] = malloc(plen*sizeof(int));
            len = 0;
            j = 0;
            cur = 0;
        }
    }
    *returnSize = i;
    return res;
}

按之字形顺序打印二叉树

int** Print(struct TreeNode* root, int* returnSize, int** returnColumnSizes ) {
    #define MAXN 1501
    *returnSize = 0;
    if (!root) return NULL;
    // 初始化列
    *returnColumnSizes = malloc(sizeof(int)*MAXN); 
    
    struct TreeNode** queue = malloc(MAXN*sizeof(struct TreeNode*));
    int f=0,r=0; // 队列的前，后指针
    int** res = malloc(MAXN*sizeof(int *));
    int i=0,j=0; // 表示一维，二维坐标
    res[i] = malloc(sizeof(int)); 

    struct TreeNode*p;
    queue[f++]=root;
    int cur=0,plen=1,len=0; // 记录，当前遍历层的第几个，当前层的总长度，遍历时对下一层加入队列的个数加+1
    int level = 1; // 表示第几层
    while(r<f) {
        p = queue[r++];
        cur ++ ;
        if (level&1)
            res[i][j++]=p->val;
        else 
            res[i][j--]=p->val;
        if (p->left) {
            len ++;
            queue[f++]=p->left;
        }
        if (p->right) {
            len ++;
            queue[f++]=p->right;
        }
        if (cur==plen) {
            // 上一层节点已遍历完
            (*returnColumnSizes)[i]=plen;
            plen = len;
            res[++i] = malloc(plen*sizeof(int));
            len = 0;
            level++;
            j = level&1?0:plen-1;
            cur = 0;
            
        }
    }
    *returnSize = i;
    return res;
}

对称的二叉树

bool judge(struct TreeNode* left,struct TreeNode* right) {
    if (!left&&!right) return true;
    if(!left||!right)return false;
    if (left->val != right->val) return false;
    return judge(left->left,right->right) && judge(left->right,right->left);
}


bool isSymmetrical(struct TreeNode* pRoot ) {
    // write code here
    if(!pRoot) return true;
    return judge(pRoot->left,pRoot->right);
}

二叉树的最大深度

int max(int a,int b) {
    return a>b?a:b;
}

int maxDepth(struct TreeNode* root ) {
    if (!root) return 0;
    return 1+max(maxDepth(root->left),maxDepth(root->right));
}

二叉树中和为某一值的路径(一)

bool hasPathSum(struct TreeNode* root, int sum ) {
    if (!root) return false;
    if (!root->left&&!root->right) {
        return sum==root->val;
    }
    return hasPathSum(root->left,sum-root->val) || hasPathSum(root->right,sum-root->val);
}

合并二叉树

struct TreeNode* mergeTrees(struct TreeNode* t1, struct TreeNode* t2 ) {
    if (!t1) return t2;
    if (!t2) return t1;
    t1->val += t2->val;
    t1->left = mergeTrees(t1->left,t2->left);
    t1->right = mergeTrees(t1->right,t2->right);
    return t1;
}

二叉树的镜像

struct TreeNode* Mirror(struct TreeNode* pRoot ) {
    // write code here
    if (!pRoot) return NULL;
    struct TreeNode *p = pRoot->left;
    pRoot->left = pRoot->right;
    pRoot->right = p;
    Mirror(pRoot->left);
    Mirror(pRoot->right);
    return pRoot;
}

重建二叉树

struct TreeNode* makeTree(int *p,int l1,int r1,int *q,int l2,int r2) {
    if (l1>r1) return NULL;
    struct TreeNode *tree = malloc(sizeof(struct TreeNode));
    tree->val = p[l2];
    int tmp = l1;
    while(q[tmp]!=p[l2])tmp++;
    int d = tmp-l1;
    tree->left = makeTree(p,l1,tmp-1,q,l2+1,l2+d);
    tree->right  = makeTree(p,tmp+1,r1,q,l2+d+1,r2);
    return tree;
}

struct TreeNode* reConstructBinaryTree(int* pre, int preLen, int* vin, int vinLen ) {
    return makeTree(pre,0,preLen-1,vin,0,vinLen-1);
}

输出二叉树的右视图

int* levelOrder(struct TreeNode* root, int* returnSize) {
    // write code here
    int maxlen=1e5+1;
    *returnSize = 0;
    if (!root) return NULL;

    struct TreeNode** queue = malloc(maxlen*sizeof(struct TreeNode*));
    int f=0,r=0; // 队列的前，后指针
    int* res = malloc(maxlen*sizeof(int));

    struct TreeNode*p;
    queue[f++]=root;
    int cur=0,len=0,plen=1,i=0;
    while(r<f) {
        p = queue[r++];
        cur ++ ;
        if (p->left) {
            len ++;
            queue[f++]=p->left;
        }
        if (p->right) {
            len ++;
            queue[f++]=p->right;
        }
        if (cur==plen) {
            // 上一层节点已遍历完
            res[i++] = p->val;
            plen = len;
            len = 0;
            cur = 0;
        }
    }
    *returnSize = i;
    return res;
}

int* solve(int* xianxu, int xianxuLen, int* zhongxu, int zhongxuLen, int* returnSize ) {
    struct TreeNode *tree = makeTree(xianxu,0,xianxuLen-1,zhongxu,0,zhongxuLen-1);
    return levelOrder(tree,returnSize);
}

判断是不是完全二叉树

#define MAXN 105
void travese(struct TreeNode* root,bool *flag,int cur) {
    if(!root||cur>MAXN)return;
    flag[cur] = true;
    travese(root->left,flag,2*cur);
    travese(root->right,flag,2*cur+1);
}

bool isCompleteTree(struct TreeNode* root) {
    bool flag[MAXN] = {false};
    travese(root,flag,1);
    bool res = false;
    for (int i=1;i<MAXN;++i) {
        if (res&&flag[i]) return false;
        if (!flag[i]) res = true;
    }
    return true;
}

判断是不是二叉搜索树

#define MAXN 10001
int res[MAXN];
int len=0;

void inorder(struct TreeNode* root){
    if (!root) return;
    inorder(root->left);
    res[len++] = root->val;
    inorder(root->right);
}

bool isValidBST(struct TreeNode* root ) {
    if (!root) return true;
    inorder(root);
    for(int i=1;i<len;++i) if (res[i]<=res[i-1]) return false;
    return true;
}

判断是不是平衡二叉树

int max(int a,int b) {
    return a>b?a:b;
}

int abs(int a){
    return a>0?a:-a;
}

int maxDepth(struct TreeNode* root,bool * flag ) {
    if (!root || !flag) return 0;
    int l_height = maxDepth(root->left,flag);
    if (!flag) return 0; // 一个优化，用于提前退出
    int r_height = maxDepth(root->right,flag);
    if (!flag) return 0; // 一个优化，用于提前退出
    if (abs(l_height-r_height)>1) *flag = false;
    return 1+max(l_height,r_height);
}

bool IsBalanced_Solution(struct TreeNode* pRoot ) {
    // 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
    bool flag = true;
    maxDepth(pRoot,&flag);
    return flag;
}

序列化二叉树

char* Serialize(struct TreeNode* root ) {
    if (!root) return NULL;
    #define MAXN 300
    struct TreeNode** queue = (struct TreeNode**) malloc(MAXN*sizeof(struct TreeNode*));
    char* res = (char *) malloc(MAXN*sizeof(char));
    memset(res, 0, MAXN);
    int f=0,r=0; // 队列的前，后指针
    struct TreeNode*p;
    queue[f++]=root;
    int len=0;
    while(r<f) {
        p = queue[r++];
        if (!p) {
            res[len++]= -1;
            continue;
        } 
        res[len++]=p->val+1;
        queue[f++]=p->left;
        queue[f++]=p->right;
    }
    res[len]=0;
    return res;
}

struct TreeNode* Deserialize(char* str) {
    if (!str) return NULL;
    struct TreeNode** queue = (struct TreeNode**) malloc(MAXN*sizeof(struct TreeNode*));
    int f=0,r=0; // 队列的前，后指针
    int len = 0;
    struct TreeNode*p  =  (struct TreeNode*) malloc(sizeof(struct TreeNode));
    p->left=p->right=NULL;
    p->val = str[len++]-1;
    if(p->val<0) p->val+=256; // 在本题题取值范围为0~150， 超过char范围，所以当小于0时需要加256
    struct TreeNode* q;
    queue[f++]=p;
   
    char *s = str;
    while(*s) {
        printf("%d ",*(s++)-1);
    }
    printf("\n");
    while (str[len])
    {
        p = queue[r++];
        if (str[len]&&str[len++]!=-1) {
            q = (struct TreeNode*) malloc(sizeof(struct TreeNode));
            q->val = str[len-1]-1;
            q->left=q->right=NULL;
            if(p->val<0) p->val+=256;
            p->left = q;
            queue[f++]=q;
        }
        if (str[len]&&str[len++]!=-1) {
            q = (struct TreeNode*) malloc(sizeof(struct TreeNode));
            q->left=q->right=NULL;
            q->val = str[len-1]-1;
            if(p->val<0) p->val+=256;
            p->right = q;
            queue[f++]=q;
        } 
    }
    return queue[0];
}

二叉树的最近公共祖先

对于有根树T的两个节点p、q，最近公共祖先LCA(T,p,q)表示一个节点x，满足x是p和q的祖先且x的深度尽可能大
二叉树的公共祖先分成两种情况

  • p 、q 分别位于最近公共祖先的左右子树
  • p 、q 一个节点就是公共祖先，另一个节点位于它的子树中
// 方法一： 求出根节点到p,q的路径，从根节点开始比，直到第一个节点不同退出
// 方法二：递归查找

int lowestCommonAncestor(struct TreeNode* root, int p, int q ) {
    if(!root) return -1; // 表示没找到
    if (root==p||root==q) return root->val;
    // 在左子树查找是否存在p,q
    int lv = lowestCommonAncestor(root->left,p,q);
    // 在右子树查找是否存在p,q
    int lp = lowestCommonAncestor(root->right,p,q);
    // 左右子树都查找到p和q，表示在不同子树
    if (lv != -1 && lp != -1) {
        return root->left; 
    }  
    // p,q在同一个子树，谁先找到表示谁祖先节点
    return lv != -1 ? lv:lp;
}

// 对于二叉搜索而言
int lowestCommonAncestor(struct TreeNode* root, int p, int q ) {
    if(!root) return -1;
    struct TreeNode* tmp=root;
    // 设p为最小值，q为最大值
    if (p>q) {
        int vmin = p;
        p = q;
        q = vmin;
    }
    // 当p,q位于节点两侧时表示tmp为公共祖先，取等号表示，该节点恰好为p,q
    while (!(p<=tmp->val && q>=tmp->val)) {
        if (p>tmp->val) tmp = tmp->right;
        else tmp = tmp->left;
    }
    return tmp->val;
}

二叉搜索树与双向链表

将该二叉搜索树转换成一个排序的双向链表
树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继

// 对于1个节点，需要先求出前驱节点，然后再求出后继节点
static struct TreeNode* p=NULL;
struct TreeNode* Convert(struct TreeNode* pRootOfTree ) {
    if (!pRootOfTree) return NULL;
    // 返回中序遍历时的第一个节点，即最左的节点
    struct TreeNode* head = Convert(pRootOfTree->left);
    if (!head) head = pRootOfTree;
    // p 表示遍历该的节点的前驱节点
    pRootOfTree->left = p;
    if (p) p->right = pRootOfTree;
    // 设为下次遍历的前驱节点
    p = pRootOfTree;
    Convert(pRootOfTree->right);
    return head;
}
antRain
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2022年牛客网-后端开发笔试题目
04-06
InnoDB、TCP、二叉树、线程、抽象类、范型、包装类型、判断比赛山脉、abb型字符、跑路问题、
牛客编程题--必刷101之二叉树篇
qq_36317312的博客
05-11 644
前序遍历 public int[] preorderTraversal (TreeNode root) { // write code here List<Integer> list = new ArrayList<>(); dfs(list,root); int[] res = new int[list.size()]; for(int i =0;i<list.size();i++){
【LeetCode】【牛客】二叉树刷题
芊樱烛渊的博客
05-25 288
一、相同的树 给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。 示例 1： 输入：p = [1,2,3], q = [1,2,3] 输出：true 示例 2： 输入：p = [1,2], q = [1,null,2] 输出：false 示例 3： 输入：p = [1,2,1], q = [1,1,2] 输出：false 提示： 两棵树上的节点数目都在范围 [0, 100] 内 -10.
Leetcode104 二叉树的最大深度
neverSaynever_的博客
05-14 230
给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明:叶子节点是指没有子节点的节点。 3 / \ 9 20 / \ 15 7 二叉树的深度为3 方法一：递归（推荐使用） 知识点：二叉树递归 递归是一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。因此递归过程，最重要的就是查看能不能讲原本的问题分解为更小的子问题，这..
【浅刷Java数据结构】牛客 二叉树遍历
qq_52276036的博客
05-23 177
题目：: 二叉树遍历 先序创建树的思路：先创建根节点，再创建其左子树，再创建其右子树。 import java.util.*; class TreeNode{ public char val; public TreeNode left; public TreeNode right; public TreeNode(char val){ this.val=val; } } public class Main{ public static i
牛客——二叉树
哦啦啦啊哦哦
04-27 971
文章目录1、二叉树的前序遍历2、二叉树的中序遍历3、二叉树的后序遍历4、二叉树的层序遍历5、按之字形顺序打印二叉树(有层，可以用这个来做有层的东西)6、 二叉树的最大深度7、二叉树中和为某一值的路径(一)找到就行 只输出true false8、二叉树中和为某一值的路径(二) 返回具体的所有的路径9、二叉树中和为某一值的路径(三)可以不从根开始1、1、1、1、1、1、1、1、1、1、1、 1、二叉树的前序遍历 class Solution: def preorderTraversal(self ,
牛客网剑指offer——Java题解.pdf
09-07
本资源总结了牛客网剑指offer Java题解的关键知识点，涵盖了Java基本概念、数据结构和算法等方面的知识。 JZ1 二维数组中的查找 * 题目描述：在一个二维数组中查找指定的整数。 * 解题思路：使用双指针，从右上角...
js-leetcode题解之验证平衡二叉树-题解.zip
最新发布
05-09
本题解聚焦于“验证平衡二叉树”这一问题，这是一道典型的二叉树问题，涉及到深度优先搜索（DFS）或广度优先搜索（BFS）的解法。在JavaScript中解决这个问题，可以加深对二叉树操作的理解，并锻炼到递归和迭代的编程...
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树遍历问题二叉树遍历问题
10-20
二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题...
牛客网 二叉树
makerjj的博客
08-20 425
牛客网 二叉树 题目描述 1 / \ 2 3 / \ / \ 4 5 6 7 /\ /\ /\ /\ 如上图所示，由正整数 1, 2, 3, …组成了一棵无限大的二叉树。从某一个结点到根结点（编号是1的结点）都有一条唯一的路径，比如从5到根结点的路径是（5, 2, 1），从4到根结点的路径是（4, 2, 1），从根结点1到根结...
Codeup——611 | 问题 D: 二叉树遍历
qq_44888152的博客
10-12 507
题目描述 编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。 输入 输入包括1行字符串，长度不超过100。 输出 可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。 样例输入 a#b#cdef##### a## 样例输出 a b
7-4 二叉树的遍历！（简单） (25 分)
qq_48508278的博客
05-09 4863
7-4 二叉树的遍历！（简单） (25 分) 二叉树作为FDS课程最核心的数据结构之一，要求每个人都掌握！ 这是一道简单的二叉树问题！ 我们将给出一颗二叉树，请你输出它的三种遍历，分别是先序遍历，中序遍历，后序遍历！ 输入格式: 二叉树将以这样的形式给出： 第一行给出一个正整数N（N<=100)，表示二叉树上的节点个数！ 接下来N行，每行包含三个整数，i，l，r，分别代表第i个节点的左右孩子！ 如果它的左/右孩子为空，则在对应位置给出-1！ 题目保证1是根节点！ 输出格式: 请你
L2-011 玩转二叉树 （25 分）
Mercury_Lc的博客
02-25 2599
L2-011 玩转二叉树 （25 分） 给定一棵二叉树的中序遍历和前序遍历，请你先将树做个镜面反转，再输出反转后的层序遍历的序列。所谓镜面反转，是指将所有非叶结点的左右孩子对换。这里假设键值都是互不相等的正整数。 输入格式： 输入第一行给出一个正整数N（≤30），是二叉树中结点的个数。第二行给出其中序遍历序列。第三行给出其前序遍历序列。数字间以空格分隔。 输出格式： 在一行中输出该树反转...
c语言二叉树的遍历——简单算法
qq_44700756的博客
11-10 309
#include <stdio.h> #include <stdlib.h> #define N 100 /*二叉树非递归*/ typedef struct btnode { char data; btnode *lchild; btnode *rchild; }btnode; int i=0; int aa[]={55,10,7,-1,-1,22,-1,-1,66,-1,100,-1,-1}; char a[]={'a','b','c','#','#','d','#'
【LeetCode】二叉搜索树相关题解汇总
前端学习博客
09-07 1204
这里是小飞侠Pan🥳，立志成为一名优秀的前端程序媛！！！本篇文章同时收录于我的github前端笔记仓库中，持续更新中，欢迎star~👉。
[编程题] 二叉树
HK_John的博客
03-27 588
时间限制：3秒 空间限制：32768K 有一棵二叉树，树上每个点标有权值，权值各不相同，请设计一个算法算出权值最大的叶节点到权值最小的叶节点的距离。二叉树每条边的距离为1，一个节点经过多少条边到达另一个节点为这两个节点之间的距离。 给定二叉树的根节点root，请返回所求距离。 强调一点：我就是被卡在这很久的：不是所有节点中的最大最小值
牛客Top200---输出二叉树的右视图（java）
小样yx的博客
08-23 222
题目 思路 首先，需要重建二叉树，这个之前碰到过，重建二叉树跳转链接，然后可以对重建后的二叉树进行层次遍历，将每层最后一个节点值放入数组中，最后层次遍历结束返回数组即可，这里数组由于需要知道大小，所以要先用ArrayList来新增每层最后一个元素 import java.util.*; public class Solution { public int[] solve (int[] xianxu, int[] zhongxu) { TreeNode root = reConst
每日一题之二叉树
m0_50290125的博客
11-17 588
描述 给定一个二叉树root和一个值 sum ，判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径。 1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点 2.叶子节点是指没有子节点的节点 3.路径只能从父节点到子节点，不能从子节点到父节点 4.总节点数目为n 例如： 给出如下的二叉树，\ sum=22sum=22， 返回true，因为存在一条路径5\to 4\to 11\to 25→4→11→2的节点值之和为 22 数据范围： 1.树上的节点数满足...
剑指offer剑指offer
01-25
在Java代码示例中，isCBT方法用于检测给定的二叉树是否为完全二叉树，通过使用队列存储节点并逐一检查节点的左右子节点是否存在违反完全二叉树定义的情况。如果存在不符合条件的节点，方法将返回false。这体现了队列...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值