8.14 刷题【7道】

news2024/12/23 0:53:24

二叉树

1. 树中两个结点的最低公共祖先

原题链接

在这里插入图片描述

方法一：公共路径

分别找出根节点到两个节点的路径，则最后一个公共节点就是最低公共祖先了。

时间复杂度分析：需要在树中查找节点，复杂度为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:
    int findPath(TreeNode*root, TreeNode* p, vector<TreeNode*>&path){
        if(!root)
            return 0;
        if(root->val==p->val){
            path.push_back(root);
            return 1;
        }
        int l = findPath(root->left,p,path);
        int r = findPath(root->right,p,path);
        if(l==1||r==1)
            path.push_back(root);
        return l==1||r==1;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        vector<TreeNode*>path1,path2;
        findPath(root,p,path1);
        findPath(root,q,path2);
        if(path1.empty()||path2.empty())
            return NULL;
        TreeNode* res =NULL;
        for(int i = 0;i<path1.size();i++){
            if(i>=path1.size()||i>=path2.size())
                break;
            if(path1[path1.size()-1-i]==path2[path2.size()-1-i])
                res = path1[path1.size()-1-i];
            else
                break;
        }
        return res;
    }
};

方法二：递归

考虑在左子树和右子树中查找这两个节点，如果两个节点分别位于左子树和右子树，则最低公共祖先为自己(root)，若左子树中两个节点都找不到，说明最低公共祖先一定在右子树中，反之亦然。考虑到二叉树的递归特性，因此可以通过递归来求得。

时间复杂度分析：需要遍历树，复杂度为 O(n)

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root)
            return NULL;
        if(root==p||root==q)
            return root;
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        if(left&&right)
            return root;
        if(left==NULL)
            return right;
        else
            return left;
    }
};

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    
    public boolean flag = false;
    public TreeNode ans = null;
    
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        dfs(root,p,q);
        return ans;
    }
    
    public TreeNode dfs(TreeNode root,TreeNode p,TreeNode q){
        
        if(root == null){
            return null;
        }
        
        TreeNode l = dfs(root.left,p,q);
        TreeNode r = dfs(root.right,p,q);
        
        if(l != null && r != null){
            ans = root;
            return ans;
        } else if((l != null || r != null) && (root.val == p.val || root.val == q.val)){
            ans = root;
            return ans;
        } else if(root.val == p.val && root.val == q.val) {
            ans = root;
            return ans;
        } else if(root.val == p.val || root.val == q.val) {
            return root;
        } else if((l != null || r != null)){
            return root;
        }
        return null;
    }
    
}

2. 重建二叉树

原题链接

在这里插入图片描述

根据前序遍历和中序遍历 得到树

过程如下：

  1. 首先根据前序遍历找到 根节点
  2. 找到中序遍历中，该根节点的位置
  3. 中序中 位于 根节点左边的就是 左子树，右边的就是右子树
  4. 由于我们需要在中序遍历中找到根节点的位置，那么每次都需要遍历中序遍历，不如直接用unordered_map存储数值和位置
  5. 便于写代码，我们可以每次把mp[根节点] 的位置 用变量表示出来

在这里插入图片描述

本题的代码不需要死记硬背

就需要明白

由前序确定根节点
由中序确定左右子树的个数
由左右子树的个数确定下一个根节点的位置

根据这三点去写代码即可

/**
 * 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:

    unordered_map<int,int> pos;

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n = preorder.size();
        for (int i = 0; i < n; i ++ )
            pos[inorder[i]] = i;
        return dfs(preorder, inorder, 0, n - 1, 0, n - 1);
    }

    TreeNode* dfs(vector<int>&pre, vector<int>&in, int pl, int pr, int il, int ir)
    {
        if (pl > pr) return NULL;
        int k = pos[pre[pl]] - il;
        TreeNode* root = new TreeNode(pre[pl]);
        root->left = dfs(pre, in, pl + 1, pl + k, il, il + k - 1);
        root->right = dfs(pre, in, pl + k + 1, pr, il + k + 1, ir);
        return root;
    }
};

补充题：树的遍历

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

#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
#include <algorithm>
#include<memory>
using namespace std;

const  int N = 35;
int n;
int inorder[N], postorder[N];
unordered_map<int, int > leftChile, rightChile;//哈希表保存树，leftChile[i] = j: i 的左儿子是j,rightChilet同理
unordered_map<int, int > h;//保存中序遍历中各节点的位置

int dfs(int postorder[], int inorder[], int l1, int r1, int l2, int r2)//构造二叉树
{   
    if (l1 > r1) return 0;//没有节点，返回0
    int root = postorder[r1];//根结点为后续遍历的最后一个节点

    int k = h[root];//找到根节点在序遍历中的位置

    leftChile[root] = dfs(postorder, inorder, l1, k - 1 - l2 + l1, l2, k - 1);//构造左儿子
    rightChile[root] = dfs(postorder, inorder,r1-1 - (r2 - (k +1)) , r1 -1, k + 1, r2);//构造右儿子

    return root;
}

int main()
{
    cin >> n;//输入
    for (int i = 0; i < n; i++)
        cin >> postorder[i];

    for (int i = 0; i < n; i++)
    {
        cin >> inorder[i];
        h[inorder[i]] = i;//保存中序遍历中各个节点的位置
    }
    int root = dfs(postorder, inorder, 0, n - 1, 0, n - 1);//构造二叉树

    //数组模拟队列
    int q[N], hh = 0, tt = -1;//按层次遍历
    if (root)//非0 表示有节点
        q[++tt] = root;

    while (hh <= tt)
    {
        int t = q[hh++];
        if (leftChile[t]) q[++tt] = leftChile[t];//非0 为节点，入队列
        if (rightChile[t]) q[++tt] = rightChile[t];//非0 为节点，入队列
    }
    for (int i = 0; i <= tt; i++)//队列中保存的就是按层次遍历的结果
        cout << q[i] << " ";
    return 0;
}

3. 二叉树的下一个节点

原题链接

中序遍历：左根右

在这里插入图片描述

本题要分析节点的特点

  1. 如果节点有右子树，那么右子树的最左边的节点就是该节点后序
  2. 如果没有右子树，会有三种可能，在代码中有体现
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode father;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    /**
     * 模拟
     * 时间复杂度：O(height)，height 为二叉树的高度
     * 空间复杂度：O(1)
     */
    public TreeNode inorderSuccessor(TreeNode p) {
        TreeNode node = p;
        // Case 1. 如果该节点有右子树，那么下一个节点就是其右子树中最左边的节点
        if (node.right != null) {
            node = node.right;
            while (node.left != null) {
                node = node.left;
            }
            return node;
        }
            
        if(node.father != null && node.father.left == node)
            return node.father;
        if(node.father != null && node.father == null)
            return null;
        while(node.father!=null && node.father.right == node)
        {
            node = node.father;
        }
        return node.father;
    }
}

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 hasSubtree(TreeNode* pRoot1, TreeNode* pRoot2) {
        if (!pRoot1 || !pRoot2) return false;
        if (isSame(pRoot1, pRoot2)) return true;
        return hasSubtree(pRoot1->left, pRoot2) || hasSubtree(pRoot1->right, pRoot2);
    }

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

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean hasSubtree(TreeNode pRoot1, TreeNode pRoot2) {
        // 类比字符串匹配
        if (pRoot1 == null || pRoot2 == null) return false;
        if (isPart(pRoot1, pRoot2)) return true;
        // 如果以 pRoot1 开始的子树不能包含 pRoot2 的话，就从 pRoot1.left 和 pRoot1.right 开始
        return hasSubtree(pRoot1.left, pRoot2) || hasSubtree(pRoot1.right, pRoot2);
    }

    // 以 pRoot1 节点为根的情况下，pRoot1 和 pRoot2 同时对应遍历，如果遍历到的值都相同，且 pRoot2 先遍历到 null 或者同时遍历到 null，说明 pRoot2 是 pRoot1 的子结构
    public boolean isPart(TreeNode pRoot1, TreeNode pRoot2) {
        if (pRoot2 == null) return true;
        if (pRoot1 == null || pRoot1.val != pRoot2.val) return false;
        // 同时遍历左右子树
        return isPart(pRoot1.left, pRoot2.left) && isPart(pRoot1.right, pRoot2.right);
    }
}

5. 二叉树的镜像（两个指针互换可用 swap）

原题链接
在这里插入图片描述
在这里插入图片描述

/**
 * 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:
    void mirror(TreeNode* root) {
        if (!root) return;
        swap(root->left, root->right);
        mirror(root->left);
        mirror(root->right);
    }
};

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public void mirror(TreeNode root) {
        dfs(root);
    }
    
    public void dfs(TreeNode root){
        if(root == null){
            return;
        }
        
        TreeNode temp = root.right;
        
        root.right = root.left;
        root.left = temp;
        
        dfs(root.left);
        dfs(root.right);
        
    }
    
}

6. 对称的二叉树

原题链接
在这里插入图片描述
在这里插入图片描述

错解：通过根节点比较子节点

没写完，太复杂

/**
 * 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 dfs(root->left,root->right);
    }
    
    bool dfs(TreeNode* r1,TreeNode* r2)
    {
        if(r1==NULL && r2==NULL)
            return true;
        if(r1!=NULL&&r2==NULL || r1==NULL&&r2!=NULL)
            return false;
        if(r1->left->val != r2->right->val || r1->right->val != r2->left->val)
            return false;
        return dfs(r1->left,r2->right) && dfs(r1->right,r2->left);
    }
    
};

正解：比较当前节点的值即可

/**
 * 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 dfs(root->left,root->right);
    }
    
    bool dfs(TreeNode* r1,TreeNode* r2)
    {
        if(r1==NULL && r2==NULL)
            return true;
        if(r1!=NULL&&r2==NULL || r1==NULL&&r2!=NULL)
            return false;
        if(r1->val != r2->val)
            return false;
        return dfs(r1->left,r2->right) && dfs(r1->right,r2->left);
    }
    
};

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        
        if(root == null){
            return true;
        }
        
        return dfs(root.left,root.right);
        
    }
    
    public boolean dfs(TreeNode l,TreeNode r){
        
        if((l == null && r != null) || (l != null && r == null)){
            return false;
        }
        
        if(l == null && r == null){
            return true;
        }
        
        if(l.val != r.val){
            return false;
        }
        
        return dfs(l.left,r.right) && dfs(l.right,r.left);
        
    }
    
}

7. 不分行从上往下打印二叉树( 层序遍历二叉树bfs )

原题链接

在这里插入图片描述

/**
 * 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:
    vector<int> printFromTopToBottom(TreeNode* root) {
        vector<int> ans;
        if(root==NULL)
            return ans;
        queue<TreeNode*> q;
        q.push(root);
        while(q.size())
        {
            auto t = q.front();
            q.pop();
            ans.push_back(t->val);
            
            if(t->left != NULL)
                q.push(t->left);
            if(t->right != NULL)
                q.push(t->right);
        }
        return ans;
    }
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/877410.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

CUDA、cuDNN以及Pytorch介绍

CUDA、cuDNN以及Pytorch介绍

文章目录 前言一、CUDA二、cuDNN三、Pytorch 前言 在讲解cuda和cuDNN之前&#xff0c;我们首先来了解一下英伟达&#xff08;NVIDA&#xff09;公司。 NVIDIA是一家全球领先的计算机技术公司&#xff0c;专注于图形处理器&#xff08;GPU&#xff09;和人工智能&#xff08;…
阅读更多...
买机票系统---（java实现）

买机票系统---（java实现）

/* * 案例 * 卖机票 * 需求&#xff1a;机票价格按照淡季和旺季&#xff0c;头等舱和经济舱收费&#xff0c;输入机票原价&#xff0c;月份和头等舱或经济舱 * 旺季&#xff08;5-10月&#xff09;&#xff1a;头等舱9折&#xff0c;经济舱8.5折 * 淡季&#xff08;11-来年4月&…
阅读更多...
小目标检测（5）——有线硬触发和有线软触发架构学习

小目标检测（5）——有线硬触发和有线软触发架构学习

文章目录 引言正文PLC介绍有线硬触发有线软触发硬件接口 总结引用 引言 之前花了很多时间也就是仅仅看懂了基本代码,最近和老师交流之后,发现还有很多东西都需要弄.最终的灯检机,并不是直接接上计算机就使用的,并不是单纯通过计算机控制的,还有一个叫做PLC(可编程逻辑控制器),…
阅读更多...
Python自动化实战之使用Selenium进行Web自动化详解

Python自动化实战之使用Selenium进行Web自动化详解

概要 为了完成一项重复的任务&#xff0c;你需要在网站上进行大量的点击和操作&#xff0c;每次都要浪费大量的时间和精力。Python的Selenium库就可以自动化完成这些任务。 在本篇文章中&#xff0c;我们将会介绍如何使用Python的Selenium库进行Web自动化&#xff0c;以及如何…
阅读更多...
免费敏捷工具做敏捷需求管理

免费敏捷工具做敏捷需求管理

传统的瀑布工作模式使用详细的需求说明书来表达需求&#xff0c;需求人员负责做需求调研&#xff0c;根据调研情况编制详细的需求说明书&#xff0c;进行需求评审&#xff0c;评审之后签字确认交给研发团队设计开发。在这样的环境下&#xff0c;需求文档是信息传递的主体&#…
阅读更多...
vscode自带的代码诊断工具在为 c++17 的特性报错，如何取消这些报错

vscode自带的代码诊断工具在为 c++17 的特性报错，如何取消这些报错

ctrlshiftP 打开设置界面&#xff0c;找到这个项 调整为 c17 即可
阅读更多...
ssh做端口转发

ssh做端口转发

问题 主机1能访问外网&#xff0c;主机2 不能访问外网外部主机想要访问主机2 解决 在主机1上做本地端口转发。可以用ssh来做本地端口转发(转发到远端)。 方法&#xff1a; 在&#xff08;本地&#xff09;主机1上执行 ssh -C -f -N -g -L 10.0.8.3:18888:10.0.8.4:8888 li…
阅读更多...
【深度学习】PyTorch快速入门

【深度学习】PyTorch快速入门

【深度学习】学习PyTorch基础 介绍PyTorch 深度学习框架是一种软件工具&#xff0c;旨在简化和加速构建、训练和部署深度学习模型的过程。深度学习框架提供了一系列的函数、类和工具&#xff0c;用于定义、优化和执行各种深度神经网络模型。这些框架帮助研究人员和开发人员专注…
阅读更多...
Autoware感知02—欧氏聚类（lidar_euclidean_cluster_detect）源码解析

Autoware感知02—欧氏聚类（lidar_euclidean_cluster_detect）源码解析

文章目录 引言一、点云回调函数&#xff1a;二、预处理&#xff08;1&#xff09;裁剪距离雷达过于近的点云&#xff0c;消除车身的影响&#xff08;2&#xff09;点云降采样&#xff08;体素滤波&#xff0c;默认也是不需要的&#xff09;&#xff08;3&#xff09;裁剪雷达高…
阅读更多...
linux shell快速入门

linux shell快速入门

linux shell快速入门 0 、前置1、简单使用 0 、前置 一安装linux的虚拟环境 1、简单使用 1、新建/usr/shell目录 2、新建hello.sh 文件 3、编写脚本文件# !/bin/bashecho "hello world"查看是否具备执行权限 新增执行权限 chomd x hello.sh执行hello.sh文件 /b…
阅读更多...
AI大模型自动生成PowerPoint（PPT）

AI大模型自动生成PowerPoint（PPT）

1&#xff0c;使用现有开源大模型工具&#xff0c;生成markdown语言文件&#xff08;我这里使用chatGLM2-6B&#xff09; eg&#xff0c;请用Markdown语言生成一个大纲&#xff0c;主题是&#xff1a;给小白用户的第一课&#xff0c;如何快速的学好Python markdown语言文本如下…
阅读更多...
[C++ 网络协议编程] UDP协议

[C++ 网络协议编程] UDP协议

目录 1. UDP和TCP的区别 2. UDP的工作原理 3. UDP存在数据边界 4. UDP的I/O函数 4.1 sendto函数 4.2 recvfrom函数 4. 已连接(connected)UDP套接字和未连接(unconnected)UDP套接字 5. UDP的通信流程 5.1 服务器端通信流程 5.2 客户端通信流程 1. UDP和TCP的区别 主要…
阅读更多...
电脑系统重装日记

电脑系统重装日记

重装原因 电脑C盘几乎爆炸故重装系统一清二白 此片原因 记录重装过程&#xff0c;强调一些要注意的点&#xff0c;以防日后重装。 重装过程 1.清空电脑文件后重启&#xff0c;电脑冒蓝光&#xff0c;一直蓝屏反复重启&#xff0c;故只能重装系统以解难题。 2.准备一个U盘&…
阅读更多...
英语翻译，纯人工翻译哪里比较专业？

英语翻译，纯人工翻译哪里比较专业？

我们知道&#xff0c;人类语言是复杂的&#xff0c;给定的单词或短语含义会根据上下文内容和目标受众的不同而有所不同。机器翻译的准确率比较低。而专业的人工翻译是保持原文真实、原意的唯一保证。那么&#xff0c;针对英语翻译&#xff0c;如何做好人工翻译&#xff0c;北京…
阅读更多...
app专项测试（网络测试流程）

app专项测试（网络测试流程）

目录 一、网络测试的一般流程 二、背景介绍 三、弱网功能测试 四、弱网UI测试 五、无网状态测试 六、网络切换测试 七、用户体验关注 八、响应时间 九、异常测试 一、网络测试的一般流程 step1&#xff1a;首先要考虑网络正常的情况 ①　各个模块的功能正常可用 ②…
阅读更多...
（十八）大数据实战——Hive的metastore元数据服务安装

（十八）大数据实战——Hive的metastore元数据服务安装

前言 Hive的metastore服务作用是为Hive CLI或者Hiveserver2提供元数据访问接口。Hive的metastore 是Hive元数据的存储和管理组件&#xff0c;它负责管理 Hive 表、分区、列等元数据信息。元数据是描述数据的数据&#xff0c;它包含了关于表结构、存储位置、数据类型等信息。本…
阅读更多...
i18n 配置vue项目中英文语言包（中英文转化）

i18n 配置vue项目中英文语言包（中英文转化）

一、实现效果 二、下载插件创建文件夹 2.1 下载cookie来存储 npm install --save js-cookienpm i vue-i18n -S 2.2 封装组件多页面应用 2.3 创建配置语言包字段 三、示例代码 3.1 main.js 引用 i18n.js import i18n from ./lang// 实现语言切换:i18n处理element&#xff0c…
阅读更多...
AI 绘画Stable Diffusion 研究（八）sd采样方法详解

AI 绘画Stable Diffusion 研究（八）sd采样方法详解

大家好&#xff0c;我是风雨无阻。 本文适合人群&#xff1a; 希望了解stable Diffusion WebUI中提供的Sampler究竟有什么不同&#xff0c;想知道如何选用合适采样器以进一步提高出图质量的朋友。 想要进一步了解AI绘图基本原理的朋友。 对stable diffusion AI绘图感兴趣的朋…
阅读更多...
使用QT可视化设计对话框详细步骤与代码

使用QT可视化设计对话框详细步骤与代码

一、创建对话框基本步骤 创建并初始化子窗口部件把子窗口部件放到布局中设置tab键顺序建立信号-槽之间的连接实现对话框中的自定义槽 首先前面三步在这里是通过ui文件里面直接进行的&#xff0c;剩下两步则是通过代码来实现 二、项目创建详细步骤 创建新项目 为项目命名 为…
阅读更多...
提高 After Effects 效率的 40 个最佳快捷键

提高 After Effects 效率的 40 个最佳快捷键

After Effects 是运动图形和视觉效果的强大工具&#xff0c;但它也可能让人不知所措。拥有如此多的特性和功能&#xff0c;很容易让人迷失在软件中。但是&#xff0c;有一种方法可以简化您的工作流程并提高工作效率 - 使用键盘快捷键。 After Effects素材文件巨大、占用电脑内…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023