二叉树/算法题

【2024年华为OD机试】 (B卷,200分)- 二叉树中序遍历(Java & JS & Python&C/C++) 本题的核心是通过解析字符串构建二叉树,然后进行中序遍历。使用栈结构解析字符串,提取节点和子树信息。递归构建二叉树节点关系。递归或迭代实现中序遍历。时间复杂度为O(n + m),适合处理节点数不超过 100 的输入。华为OD(Outsourcing Developer,外包开发工程师)是华为针对软件开发工程师岗位的一种招聘形式,主要包括笔试、技术面试以及综合面试等环节。尤其在笔试部分,算法题的机试至关重要。 阅读详情

title:: 二叉树/算法题
tags:: 算法题

  • 求按顺序结构存储,编号为i,j的最近公共祖先
    • int findNearestAns(int bTree[], int i, int j){
        while(i!=j){
          if(i>j){
            i = i / 2;
          }else{
            j = j / 2;
          }
        }
        return bTree[i];
      }
      
  • 非递归求二叉树高度
    • /**
       * 利用层次遍历求高度
       * @param T 二叉树
       * @return 高度
       */
      int levelOrder_Depth(BiTree T) {
          if (T == NULL)
              return 0;
          SeqQueue q;
          BiTree p = T;
          BiNode *last = T;
          int depth = 0;
          InitQueue(q);
          EnQueue(q, T);
      
          while (!IsQueueEmpty(q)) {
              DeQueue(q, p);
              //visit(p);
              if (!p->lchild) {
                  EnQueue(q, p->lchild);
              }
              if (!p->rchild) {
                  EnQueue(q, p->rchild);
              }
              if (p == last) {
                  depth++;
                  last = p->rchild;
              }
          }
      
          return depth;
      }
      
      /**
       * 利用非递归后序遍历求二叉树高度
       * @param T 二叉树
       * @return 二叉树高度
       */
      int postOrderLeve(BiTree T) {
          if (T == NULL)
              return 0;
          SqStack s;
          BiNode *pre = NULL;
          BiTree p = T;
          int max = 1, depth;
      
          while (p || !IsStackEmpty(s)) {
              if (p) {
                  Push(s, p);
                  p = p->lchild;
              } else {
                  GetTop(s, p);
                  if (p->rchild && p->rchild != pre) {
                      Push(s, p);
                      p = p->rchild;
                  } else {
                      Pop(s, p);
                      depth = getStackSize(s);
                      if (depth > max)
                          max = depth;
                      pre = p;
                      p = NULL;
                  }
              }
          }
          return max;
      }
      
  • 递归求二叉树高度
    • int getTreeHight(bTree T){
        if(!T)
          return 0;
        else{
          int m = getTreeHight(T->lchild);
          int n = getTreeHight(T->rchild);
          return m>n?m+1:n+1;
        }
      }
      
  • 由先序序列和中序序列构建二叉树
    • bTree createBTree(int A[], int B[],int preFirst, int preLast, int inFirst, int inLast){
        preFirst = inFirst = 1;
        preLast = inLast = n;
        int i;
        bTNode *root = (bTNode*)malloc(sizeof(bTNode));
        for(i = inFirst;B[i] != A[preFirst]; i++);
        int lLen = i - inFirst;
        int rLen = inLast - i ;
        
        if(lLen)
          root->lchild = createBTree(A,B,preFirst+1, preFirst + lLen - 1, inFirst, i-1 );
        else
          root->child = NULL;
        if(rLen)
          root->rchild = createBTree(A,B,preFirst+lLen,preLast,i+1,inLast);
        else
          root->rchild =NULL;
        return root;
      }
      
  • 判断二叉链表存储的二叉树是否是完全二叉树
    • bool isFullBTree(bTree T){
        if(T == NULL)
          return true;
        bTree p = T;
        int tree[MAXSIZE];
        for(int i = 0; i < MAXSIZE; i++)
          tree[i] = 0;
        int i = 1;
        int j = 0;
        queue q;
        initial(q);
        enQueue(q,p);
        tree[i] = 1;
        while(!queueEmpty(q)){
          deQueue(q,p);
          if(p->lchild){
            enQueue(q,p->lchild);
            tree[2*i] = 1;
          }
          if(p->rchild){
            enQueue(q,p->rchild);
            tree[2*i+1] = 1;
          }
          i++;
        }
        bool tag = true;
        for(j = 0; j < i;j++){
          if(tree[j] == 0)
            tag = false;
          if(tag == false && tree[j] == 1)
            return false;
        }
        return true;
      }
      
      /**
           均为利用层次遍历,但是更简洁的做法
      **/
      bool isFullBTree(bTree T){
        if(T == NULL)
          return true;
        queue q;
        bTree p = T;
        initial(q);
        enQueue(q,p);
        while(!queueEmpty(q)){
          deQueue(q,p);
          if(p){
            enQueue(q,p->lchild);
            enQueue(q,p->rchild);
          }else{
            while(!queueEmpty(q)){
              deQueue(q,p);
              if(p)
                return false;
            }
          }
        }
        return true;
      }
      
  • 求二叉链表存储的二叉树的双分支结点个数
    • 本质上就是对二叉树进行一次遍历,并统计其中出现的双分支结点个数,所以四种遍历方式均可使用
    • int numberOfHasChildren(bTree T){
        if(T == NULL)
          return 0;
        queue q;
        bTree p = T;
        initial(q);
        enQueue(q,p);
        int num = 0;
        while(!emptyQueue(q)){
          deQueue(q,p);
          if(p->lchild&&p->rchild)
            num ++;
          if(p->lchild)
            enQueue(q,p->lchild);
          if(p->rchild)
            enQueue(q,p->rchild);
        }
        return num;
      }
      
      int num == 0;
      int numberOfHasChildren_2(bTree T){
        if(T == NULL)
          return 0;
        if(T->lchild && T->rchild)
          num++;
        numberOfHasChildren_2(T->lchild);
        numberOfHasChildren_2(T->rchild);
      }
      
      int numberOfHasChildren_3(bTree T){
        if(T == NULL)
          return 0;
        if(T->lchild && T->rchild)
          return numberOfHasChildren_3(T->lchild) + numberOfHasChildren_3(T->rchild) + 1;
        else
          return numberOfHasChildren_3(T->lchild) + numberOfHasChildren_3(T->rchild);
      }
      
  • 交换二叉链表存储的二叉树左右结点
    • int swapTree(bTree T){
        if(T == NULL)
          return 0;
        BtNode *temp = T->lchild;
        T->lchild = T->rchild;
        T->rchild = temp;
        swapTree(T->lchild);
        swapTree(T->rchild);
      }
      
  • 求先序遍历第k个结点的值
    • int i = 0
      int preOrder(bTree T, int k, char &ch){
        if(T){
          i++;
          if(i == k){
            ch = T->data;
            return 1;
          }
        }else{
          return 0;
        }
        preOrder(T->lchild,k);
        preOrder(T->rchild,k);
      }
      
      int j = 0;
      elemType preOrder_1(bTree T, int k){
        elemType ch;
        if(T == NULL)
          return '#';
        j++;
        if(j == k)
          return T->data;
        ch = preOrder_1(T->lchild,k);
        if(ch!='#')
          return ch;
        ch = preOrder_1(T->rchild,k);
        reurn ch;
      }
      
    • 错误代码,在右子树最后一个结点的右孩子为空,向主函数返回KaTeX parse error: Expected 'EOF', got '#' at position 1: #̲后,递归调用栈中的函数都会依次结束,而不返回新的值,因为此时它们已经执行到了第11行,也即先序遍历遍历右子树,并不会返回应该找到的data值,也可以说:有一条控制路径上没有返回值,即true、false路径上函数没有返回值;而且,由于最后需要找到结点的数据值,而该算法有可能在途中就找到了这个值,此时这个值就无法被保存下来,会被后续的返回值刷新
      • char wrFind(BiTree T,int k){
            if(T){
                j++;
                if(j == k){
                    return T->data;
                }
            }else{
                return '#';
            }
            wrFind(T->lchild,k);
            wrFind(T->rchild,k);
        }
        
  • 删除树中以值为x的结点的子树
    • int DeleteTree(BiTree &T){
          if(T){
              DeleteTree(T->lchild);
              DeleteTree(T->rchild);
              free(T);
              return 1;
          }
          return 0;
      }
      
      int SearchNodesByElem(BiTree T, ELemType x){
          if (T){
              if(T->data == x){
                  DeleteTree(T);
                  return 1;
              }
              BiTree Q[MAXSIZE];
              BiTree p;
              int front,rear;
              front = rear = 0;
              Q[rear] = T;
              rear = (rear + 1)%MAXSIZE;
              while (front != rear){
                  p = Q[front];
                  front = (front+1)%MAXSIZE;
                  if (p->lchild){
                      if(p->lchild->data == x){
                          DeleteTree(p->lchild);
                          p->lchild = NULL;
                      }else{
                          Q[rear] = p->lchild;
                          rear = rear+1%MAXSIZE;
                      }
                  }
                  if (p->rchild){
                      if(p->rchild->data == x){
                          DeleteTree(p->rchild);
                          p->rchild = NULL;
                      }else{
                          Q[rear] = p->rchild;
                          rear = rear + 1%MAXSIZE;
                      }
                  }
              }
              return 1;
          } else{
              return 0;
          }
      }
      
  • 找到值为x的结点的所有祖先(该题x不多于一个,假设多于一个,也能按照本题做)
    • typedef struct {
          BiTree t;
          int tag;
      }TreeStack;
      int PostOrderFindAncestors(BiTree T,ELemType x){
          if(T == NULL)
              return 0;
          TreeStack s[MAXSIZE];
          int top = 0;
          BiTree p = T;
          while (p || top != 0){
              while (p && p->data != x){
                  s[top].t = p;
                  s[top].tag = 0;
                  top ++;
                  p = p->lchild;
              }
              if(p && p->data == x){
                  printf("该结点的所有祖先为:");
                  for (int j = top; j < 0; --j) {
                      printf("%c",s[j].t->data);
                  }
                  return 1;
              }
              while(top != 0 && s[top].tag == 1)
                  top--;
              if (top!= 0){
                  p = s[top].t->rchild;
                  s[top].tag = 1;
              }
          }
      }
      
  • 找到两个结点的最近公共祖先
    • /**
       * 找到p,q最近的共同祖先
       * @param T 树
       * @param p
       * @param q
       * @return 最近的公共祖先
       */
      BiNode *ANCESTOR(BiTree T, BiNode *p, BiNode *q){
          TreeStack sp[MAXSIZE],sq[MAXSIZE];
          int topP = 0,topQ = 0;
          BiNode *temp = p;
          while (temp || topP != 0){
              if(temp){
                  sp[topP].t = temp;
                  sp[topP].tag = 0;
                  temp = temp->lchild;
                  topP++;
              }else{
                  temp = sp[topP].t;
                  if(temp->rchild && sp[topP].tag != 1){
                      temp = temp->rchild;
                  } else{
                      temp = sp[--topP].t;
                      if(p == temp)
                          break;
                      temp = NULL;
                  }
              }
          }
      
          temp = q;
          while (temp || topQ != 0){
              if(temp){
                  sq[topQ].t = temp;
                  sq[topQ].tag = 0;
                  temp = temp->lchild;
                  topQ++;
              }else{
                  temp = sq[topQ].t;
                  if(temp->rchild && sq[topQ].tag != 1){
                      temp = temp->rchild;
                  } else{
                      temp = sq[--topQ].t;
                      if(q == temp)
                          break;
                      temp = NULL;
                  }
              }
          }
          int top = topP > topQ ? topQ : topP;
          if (top != 0) {
              for (int j = top; j > 0; --j) {
                  if (sp[top].t == sq[top].t)
                      return sp[top].t;
              }
          }
          return NULL;
      }
      
  • 层次遍历求宽度
    • 和求高度用一个指针记录上一层的最后一个结点有异曲同工之妙
    • /**
       * 层次遍历求非空二叉树的宽度
       * @param T 二叉树的根结点
       * @return 二叉树宽度
       */
      int WidthOfBiTree(BiTree T) {
          BiTree Q[MAXSIZE];
          int front = 0, rear = 0;
          BiNode *p = T;
          BiNode *last = p;  // 记录每一层遍历的最后一个结点
          int MaxWidth = 1, tempWidth = 0;
      
          if (!T) {
              printf("空树");
              return 0;
          }
          Q[rear] = T;
          rear = (rear + 1) % MAXSIZE;
      
          while (front != rear) {
              p = Q[front];
              front = (front + 1) % MAXSIZE;
              tempWidth++;
      
              // 当前结点就是本层最后一个结点,说明该层结点已经全部处理完毕
              if (p == last) {
                  last = p->rchild;
                  if (tempWidth > MaxWidth)
                      MaxWidth = tempWidth;
                  tempWidth = 0;
              }
              //左右子树入队
              if (p->lchild) {
                  Q[rear] = p->lchild;
                  rear = (rear + 1) % MAXSIZE;
              }
              if (p->rchild) {
                  Q[rear] = p->rchild;
                  rear = (rear + 1) % MAXSIZE;
              }
          }
          return MaxWidth;
      }
      /**
       * 层次遍历求宽度
       * 用len记录上层结点遍历完成时,即下一层结点全部进入队列
       * 此时的队列的长度即为下一层的宽度,比较得出最大宽度
       * @param T
       * @return
       */
      int WidthOfBiTree_1(BiTree T) {
          BiTree Q[MAXSIZE];
          int front = 0, rear = 0;
          int width = 1; //最大宽度
          int level = 1;
          int max_Level = 1;//最大宽度层次
          BiNode *p = T;
          int len = 1; //上层队列长度
      
          Q[rear] = T;
          rear = (rear + 1) % MAXSIZE;
          while (rear != front) {
              p = Q[front];
              front = (front + 1) % MAXSIZE;
              len--;
              //左右子树入队
              if (p->lchild) {
                  Q[rear] = p->lchild;
                  rear = (rear + 1) % MAXSIZE;
              }
              if (p->rchild) {
                  Q[rear] = p->rchild;
                  rear = (rear + 1) % MAXSIZE;
              }
      
              //长度为0说明此时本层结点遍历完毕,
              //需要进入下层,而此时队列中元素个数即为下层元素个数
              if (len == 0) {
                  len = (rear - front + MAXSIZE) % MAXSIZE;
                  level++;
                  if (len > width) {
                      width = len;
                      max_Level = level;
                  }
              }
          }
          printf("最大宽度所在层次:%d", max_Level);
          return width;
      }
      
  • 由二叉树的度表示法所构成的后序序列构造二叉树
    • 利用队列求所有结点路径(层次遍历)
    • /**
       * 使用c++自带的stl寻找二叉树的所有路径
       * @param root 二叉树根结点
       * @return 返回包含所有路径的向量
       */
      vector<string> BiTreePath(BiTree root) {
          vector<string> paths;
          if(root == nullptr){
              return paths;
          }
          queue<BiNode*> node_queue;
          queue<string> path_queue;
      
        	//根结点入队
          node_queue.push(root);
          path_queue.push(to_string(root->data));
      
          //基于层次遍历
          while (!node_queue.empty()){
              BiNode* node = node_queue.front();
              string path = path_queue.front();
              node_queue.pop();
              path_queue.pop();
              //到达叶结点,路径也到达终点,可以直接加入结果向量
              if(node->lchild == nullptr && node->rchild == nullptr){
                  paths.push_back(path);
              } else{
                  //处理分支结点
                  if(node->lchild){
                      node_queue.push(node->lchild);
                      path_queue.push(path + "->"+to_string(node->lchild->data));
                  }
                  if(node->rchild){
                      node_queue.push((node->rchild));
                      path_queue.push(path + "->" + to_string(node->rchild->data));
                  }
              }
          }
          return paths;
      }
      
旋转变压器软件解码simulink仿真 旋转变压器软件解码simulink仿真、电机转速位置测量 阅读详情

相关推荐

解放双手!利用海康VM全局脚本+通讯管理打造自动化视觉控制系统

本文深入探讨了如何利用海康VisionMaster(VM)的全局脚本和通讯管理功能,打造高效自动化视觉控制系统。通过全局变量实现数据共享与动态调整,结合多协议通讯管理,提升系统响应速度与智能化水平,适用于工业4.0环境下的复杂视觉检测与决策场景。

weixin_28720573的博客 425

【C/C++刷题集】二叉树算法题(一)

本文介绍了四道二叉树相关的算法题目:1. 单值二叉树:通过递归遍历整棵树,检查所有节点值是否与根节点相同;2. 相同树判断:递归比较两棵树的节点结构和值;3. 对称二叉树:使用相同树判断函数,交叉比较左右子树实现镜像对称检查;4. 子树判断:递归检查主树中是否存在与子树完全相同的结构。每个问题都给出递归解法,并通过示例图解析递归过程。四道题目层层递进,从基础遍历到复杂结构比较,展示了递归在树问题中的应用技巧。

小年糕的博客 1356

在ArcGIS Pro软件中进行滑坡的敏感性和易发性分析

滑坡的敏感性和易发性分析需要综合地形、水文、地质及环境等多维数据,本文罗列了基于ArcGIS Pro软件进行的一系列可执行分析。

weixin_49609713的博客 1737

算法题/二叉树的镜像

题目描述 操作给定的二叉树,将其变换为源二叉树的镜像。 输入描述: 二叉树的镜像定义:源二叉树 8 / \ 6 10 / \ / \ 5 7 9 11 镜像二叉树 8 / \ 10

szj_huhu的博客 391

ConvLSTM时空预测实战代码详解

ConvLSTM代码复现

JaysonWong的博客 1万+

CoMP 协同多点传输技术

CoMP CoMP是什么 解决什么问题 有什么缺点 CoMP(Coordinated Multiple Points)协同多点传输,通信术语,LTE-A的重要技术之一。 CoMP传输是指地理位置上分离的多个传输点,协同参与为一个终端的数据(PDSCH)传输或者联合接收一个终端发送的数据(PUSCH),参与协作的多个传输点通常指不同小区的基站。CoMP技术将边缘用户置于几个基站的同频率上,几...

ilean_J的博客 2万+

算法题/创建二叉树

python2.7创建二叉树: #coding:utf-8#创建二叉树节点 class Node(object): def __init__(self,data,left,right): self.data = data self.left = left self.right = right#创建二叉树 class Tree(object):

szj_huhu的博客 323

矢量量化的基本原理:高效数据压缩与信息检索的关键矢量量化(Vector Quantization,简称VQ)是一种数据压缩和信

此外,在矢量量化过程中,可能会引入一定的信息损失,对一些精细特征的表示可能存在一定的误差。它通过将高维数据映射到低维码本空间中,并将相似的数据映射到相同的码本向量中,实现对数据的高效表示和存储。最重要的是,矢量量化可以用于数据的检索和分析,提供了高效的数据查询和处理手段。通过使用码本索引,我们可以高效地存储和检索大量的数据。在图像处理中,矢量量化可以用于图像压缩,将复杂的图像数据转化为较少的码字,实现图像的存储和传输。矢量量化通过将连续的高维数据分割并映射到有限的码本集合中,实现数据的离散表示和压缩。

m0_70886513的博客 1374

算法题/重建二叉树

输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6},则重建二叉树并返回。#coding:utf-8 class TreeNode: def __init__(self, x): self.val = x

szj_huhu的博客 257

“三进制”bonsai27b+NInfer=6g显存闪电侠(token真的自由了!)

本文将1.58-bit三元大模型Bonsai27B成功移植至NInfer推理引擎,并在RTX 4080 SUPER上实现100+ token/s的极速推理。通过自研补丁扩展NInfer支持Ada架构与三元量化格式,解决激活布局、行置换等关键bug,实测PPL 6.445,单流吞吐达96.7–130.8 t/s,20题基准得分16/20。附完整复现包(含文档、工具、源码补丁),零权重分发,助力垃圾显卡跑通27B级模型。

shensanshu的博客 1万+

新手必看!Cisco Packet Tracer 8.2从安装到完成第一个局域网实验(附常见问题解决)

本文为网络新手提供了Cisco Packet Tracer 8.2的完整入门指南。从官方下载安装、界面熟悉,到核心的拖拽设备、连线、配置IP地址三步操作,手把手教你完成第一个局域网组网实验。文章重点讲解了如何通过Ping命令验证连通性,并附带了连线错误、IP配置不当等常见问题的解决思路,帮助初学者快速上手这款强大的思科模拟器。

android的专栏 870

算法题/层次遍历二叉树

python2.7#coding:utf-8#创建二叉树 class Node(object): def __init__(self.data,left,right): self.data = data self.left = left self.right = right#创建二叉树 class Tree(object): def _

szj_huhu的博客 392

redhawk:Low Power Analysis

1.rush current与switch cell 在standby状态下为了控制leakage power我们选择power gating的设计方式,使用power switch cell关闭block/power domain的电源。 power switch的基本介绍可见: 低功耗设计-Power Switch power switch的table中有四种状态,对应block工作、待机和上电,下电。low power analysis主要分析上电的过程。 上电过程可以看做mos电容

m0_61544122的博客 3210

数据结构-树/二叉树与基本算法题

树的基本概念 为什么会有树这种结构?因为现实生活中,我们需要一对多的数据处理。 树的结点:使用树结构存储的每一个数据元素都被称为“结点”。例如,上图1中,数据元素 1 就是一个结点;父结点(双亲结点)、子结点和兄弟结点:对于上图1中的结点 1,2,3,4 来说,1 是 2,3,4 结点的父结点(也称为“双亲结点”),而 2,3,4 都是 1 结点的子结点(也称“孩子结点”)。对于 2,3,4 来说,它们都有相同的父结点,所以它们互为兄弟结点。根结点:每一个非空树都有且只有一个被称为根的结点。上图1中

迷途 517

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

【C/C++刷题集】二叉树算法题(二)

本文介绍二叉树遍历的递归实现方法,包括前序、中序、后序遍历。前序遍历按"根→左→右"顺序收集节点值,中序遍历为"左→根→右",后序遍历为"左→右→根"。每个算法都包含计算节点数的BinaryTreeSize函数和实现具体遍历顺序的递归函数。文末还展示了根据先序字符串构建二叉树并进行中序遍历的示例,通过createTree函数递归构建树,InOrder函数实现遍历输出。所有方法都采用动态内存分配存储结果数组,体现了递归在树遍历中的典型应用。

小年糕的博客 1411

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

完全/满二叉树相关算法题|判断是否为完全/满二叉树(C)

如果一棵二叉树的所有层都被完全填满,除了最后一层(叶子层),并且最后一层的所有节点都尽可能地靠左,那么它就是完全二叉树。采用层次遍历算法,将所有节点加入队列(包括空节点),遇到空节点时,查看其后是否有非空节点。如果当前节点没有孩子或者开始出现子节点为空的情况,则后续所有节点必须为叶子节点,否则返回 false。根据完全二叉树的定义,具有n个节点的完全二叉树与满二叉树中编号从1~n的节点一一对应。一棵二叉树中,每个节点要么没有子节点,要么有两个子节点,并且所有叶子节点都在同一层。判断一棵树是否是满二叉树。

ChoSeitaku的博客 545

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

算法题之-重建二叉树 第二天(2019/5/30)

1.题目描述 输入某二叉树的前序遍历和中序遍历的结果, 请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 例如输入前序遍历序列{1,2,4,7,3,5,6,8}和 中序遍历序列{4,7,2,1,5,3,8,6},则重建二叉树并返回。 2.思路 我们知道,前序遍历的规则是 根左右 ,那么第一个节点是根节点,这样确定了根节点之后, 我们根据中序遍历可以将数划分为左子树和右子树;...

qq_36761506的博客 134

LeetCode算法题 (二叉树的直径)Day11!!!C/C++

通过今天的题目,我们了解了二叉树这一数据结构,也通过了一个问题拆分成若干个子问题来帮助我们完成今天的这道题目。以上就是关于这个二叉树问题的全部分析了。如果后续你遇到类似的问题,或者对这一问题有了新的思考方向,都可以再次回顾我们的讨论内容。相信你在不断实践和思考中,能够轻松应对这类问题。荆轲刺秦!!!

m0_75144071的博客 644

94.二叉树的中序遍历,extend()与append()的区别,力扣/Leetcode算法题,面试算法题,Python3,Python,二叉树,

二叉树的遍历,extend()与append()的区别

u013373155的博客 400

【二叉树】—— 算法题

利用二叉树的递归思想,判断每一个节点值与其左右子节点的值是否相等,如果遇到空节点,就返回true(说明每一个节点值都相等);如果该节点的值与其左右子节点的值都相等,就接着递归该节点的左右子树。这里首先求二叉树的节点个数;利用相同的树的方法,判断二叉树根节点的左右子树是否对称(判断对称直接判断一个节点的左子树和另一个节点的右子树是否相等即可)。遍历到节点都不为空,且值相等,继续遍历 (这因为3的左右节点都为空,就一步带过)遍历结束,没有遇到一个节点为空一个节点不为空或者值不相等的情况,就返回true。

LH__1314的博客 4408

数据结构算法题/二叉树中两个节点的最近公共父节点

这个问题可以分为三种情况来考虑: 情况一:root未知,但是每个节点都有parent指针 此时可以分别从两个节点开始,沿着parent指针走向根节点,得到两个链表,然后求两个链表的第一个公共节点,这个方法很简单,不需要详细解释的。 情况二:节点只有左、右指针,没有parent指针,root已知 思路:有两种情况,一是要找的这两个节点(a, b),在要遍历的节点(root)的两侧,那么这个节点就是...

fkyyly的专栏 1130

算法题(二十五):序列化/反序列化二叉树

题目描述 请实现两个函数,分别用来序列化和反序列化二叉树 分析 结点为空时用“#”代替,反序列化时,遇到“#”输出null 代码 public class SerializeTree { public static void main(String[] args) { // TODO Auto-generated method stub TreeNode root = ne...

qq_24034545的博客 256

二叉树算法题(1)

判断二叉树是否对称,需要判断根节点的左右孩子是否相等,需要判断根节点左孩子的左孩子与根节点右孩子的右孩子、左孩子的的有右子与右孩子的左孩子是否相等...需要用到递归。想要求二叉树root的最大深度,只需要求左子树、右子树的最大深度的较大值,想要求左右子树最大深度,就需要求出左右子树的左右子树的最大深度。根节点左右孩子val值相等、根节点左孩子的左孩子与根节点右孩子的右孩子、左孩子的的有右子与右孩子的左孩子... 以此类推,才对称。翻转二叉树,需要交换根节点的左右孩子,需要交换根节点左右孩子的左右孩子...

2302_80161869的博客 407

递归——二叉树中的深搜

计算布尔二叉树的值。

m0_74317866的博客 1886

二叉树进阶算法题详解

这篇文章讲解了二叉树的6道进阶算法题,涵盖层序遍历、非递归遍历和最近公共祖先等核心问题。每道题配有题目解析、算法思路和代码实现。

dev_jin的博客 871

【C++进阶】----二叉树进阶算法题

前中后序遍历的思路是一样的1.访问一棵树时,先访问左路节点2.访问左路节点的右子树区别:记录节点的值的时机不提供a.前序遍历需要在将左路节点压入栈的时候记录值b.中序遍历需要在弹出左路节点的时候记录值c.后序遍历需要在确保左右子树访问过之后弹出左路节点时记录值相比于前序遍历和中序遍历,后序遍历访问左路节点的右子树时需要考虑右子树是否已经访问过了,所以后序遍历额外引入了一个perv指针用于记录上一个访问的节点。前、中、后序遍历的本质是根节点的访问时机差异见根就取(压栈时访问);左空再取。

Wangshijie1015的博客 717
jayus71
博客等级 码龄7年 0粉丝 1原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值