算法训练day18Leetcode找树左下角的值112路径总和106从中序和后续遍历构造二叉树

513 找树左下角的值

题目描述

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。假设二叉树中至少有一个节点。示例 1:输入: root = [2,1,3]
输出: 1
示例 2:输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7提示:二叉树的节点个数的范围是 [1,104]
-231 <= Node.val <= 231 - 1

我的想法

找出深度最大的叶子节点，左遍历在前

题目分析

我们来分析一下题目：在树的最后一行找到最左边的值。

首先要是最后一行，然后是最左边的值。

如果使用递归法，如何判断是最后一行呢，其实就是深度最大的叶子节点一定是最后一行。

如果对二叉树深度和高度还有点疑惑的话，请看：110.平衡二叉树 (opens new window)。

所以要找深度最大的叶子节点。

那么如何找最左边的呢？可以使用前序遍历（当然中序，后序都可以，因为本题没有 中间节点的处理逻辑，只要左优先就行），保证优先左边搜索，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。

递归三部曲：

  1. 确定递归函数的参数和返回值
    参数必须有要遍历的树的根节点，还有就是一个int型的变量用来记录最长深度。 这里就不需要返回值了，所以递归函数的返回类型为void。

本题还需要类里的两个全局变量，maxLen用来记录最大深度，result记录最大深度最左节点的数值。

代码如下：

int maxDepth = INT_MIN;   // 全局变量 记录最大深度
int result;       // 全局变量 最大深度最左节点的数值
void traversal(TreeNode* root, int depth)
  1. 确定终止条件
    当遇到叶子节点的时候，就需要统计一下最大的深度了，所以需要遇到叶子节点来更新最大深度。

代码如下：

if (root->left == NULL && root->right == NULL) {if (depth > maxDepth) {maxDepth = depth;           // 更新最大深度result = root->val;   // 最大深度最左面的数值}return;
}
  1. 确定单层递归的逻辑
    在找最大深度的时候，递归的过程中依然要使用回溯，代码如下：
                    // 中
if (root->left) {   // 左depth++; // 深度加一traversal(root->left, depth);depth--; // 回溯，深度减一
}
if (root->right) { // 右depth++; // 深度加一traversal(root->right, depth);depth--; // 回溯，深度减一
}
return;

acm模式完整代码

#include <iostream>
#include <memory>struct TreeNode {int val;TreeNode* left;TreeNode* right;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 = INT_MIN;int result;void traversal(TreeNode* root, int depth) {if (root->left == nullptr && root->right == nullptr) {if(depth > maxDepth) {maxDepth = depth;result = root->val;}return;}if (root->left) {depth ++;traversal(root->left, depth);depth --;}if (root->right) {depth ++;traversal(root->right, depth);depth --;}return;}int findBottomLeftValue(TreeNode* root) {traversal(root, 0);return result;}
};int main() {// 使用智能指针创建树节点std::unique_ptr<TreeNode> node1 = std::make_unique<TreeNode>(1);std::unique_ptr<TreeNode> node2 = std::make_unique<TreeNode>(2);std::unique_ptr<TreeNode> node3 = std::make_unique<TreeNode>(3);std::unique_ptr<TreeNode> node4 = std::make_unique<TreeNode>(4);std::unique_ptr<TreeNode> node5 = std::make_unique<TreeNode>(5);std::unique_ptr<TreeNode> node6 = std::make_unique<TreeNode>(6);std::unique_ptr<TreeNode> node7 = std::make_unique<TreeNode>(7);// 组织成树（注意：这里我们使用裸指针，因为树的结构需要共享指针）node1->left = node2.get();node1->right = node3.get();node2->left = node4.get();node3->left = node5.get();node3->right = node6.get();node5->right = node7.get();// 使用 Solution 类的实例Solution solution;int result = solution.findBottomLeftValue(node1.get()); // 传递裸指针// 输出结果std::cout << "The bottom left value is: " << result << std::endl;// 智能指针自动释放内存return 0;
}

112 路径总和

题目描述

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。叶子节点 是指没有子节点的节点。示例 1：输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。
示例 2：输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。
示例 3：输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。提示：树中节点的数目在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

我的思路

遍历到叶子节点，记录过程中值相加

题目分析

递归
可以使用深度优先遍历的方式（本题前中后序都可以，无所谓，因为中节点也没有处理逻辑）来遍历二叉树

  1. 确定递归函数的参数和返回类型
    参数：需要二叉树的根节点，还需要一个计数器，这个计数器用来计算二叉树的一条边之和是否正好是目标和，计数器为int型。

再来看返回值，递归函数什么时候需要返回值？什么时候不需要返回值？这里总结如下三点：

如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。（这种情况就是本文下半部分介绍的113.路径总和ii）

如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。 （这种情况我们在236. 二叉树的最近公共祖先 (opens new window)中介绍）

如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。（本题的情况）

而本题我们要找一条符合条件的路径，所以递归函数需要返回值，及时返回，那么返回类型是什么呢？

遍历的路线，并不要遍历整棵树，所以递归函数需要返回值，可以用bool类型表示

bool traversal(treenode* cur, int count)   // 注意函数的返回类型

2.确定终止条件
首先计数器如何统计这一条路径的和呢？

不要去累加然后判断是否等于目标和，那么代码比较麻烦，可以用递减，让计数器count初始为目标和，然后每次减去遍历路径节点上的数值。

如果最后count == 0，同时到了叶子节点的话，说明找到了目标和。

如果遍历到了叶子节点，count不为0，就是没找到。

递归终止条件代码如下：

if (!cur->left && !cur->right && count == 0) return true; // 遇到叶子节点，并且计数为0
if (!cur->left && !cur->right) return false; // 遇到叶子节点而没有找到合适的边，直接返回
  1. 确定单层递归的逻辑
    因为终止条件是判断叶子节点，所以递归的过程中就不要让空节点进入递归了。

递归函数是有返回值的，如果递归函数返回true，说明找到了合适的路径，应该立刻返回。

if (cur->left) { // 左 （空节点不遍历）// 遇到叶子节点返回true，则直接返回trueif (traversal(cur->left, count - cur->left->val)) return true; // 注意这里有回溯的逻辑
}
if (cur->right) { // 右 （空节点不遍历）// 遇到叶子节点返回true，则直接返回trueif (traversal(cur->right, count - cur->right->val)) return true; // 注意这里有回溯的逻辑
}
return false;

以上代码中是包含着回溯的，没有回溯，如何后撤重新找另一条路径呢。

回溯隐藏在traversal(cur->left, count - cur->left->val)这里， 因为把count - cur->left->val 直接作为参数传进去，函数结束，count的数值没有改变。

为了把回溯的过程体现出来，可以改为如下代码：

if (cur->left) { // 左count -= cur->left->val; // 递归，处理节点;if (traversal(cur->left, count)) return true;count += cur->left->val; // 回溯，撤销处理结果
}
if (cur->right) { // 右count -= cur->right->val;if (traversal(cur->right, count)) return true;count += cur->right->val;
}
return false;

完整代码

#include <iostream>
# include <memory>
struct TreeNode {int val;TreeNode* left;TreeNode* right;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:bool traversal(TreeNode* cur, int count) {if (!cur->left && !cur->right && count == 0) return true;if (!cur->left && !cur->right) return false;if (cur->left) {count -= cur->left->val;if(traversal(cur->left, count)) return true;count += cur->left->val;}if (cur->right) {count -= cur->right->val;if (traversal(cur->right, count)) return true;count += cur->right->val;}return false;}
public:bool hasPathSum(TreeNode* root, int targetSum) {if (root == nullptr) return false;return traversal(root, targetSum - root->val);}
};int main() {// 创建树节点std::unique_ptr<TreeNode> root = std::make_unique<TreeNode>(5);root->left = new TreeNode(4);root->left->left = new TreeNode(11);root->left->left->left = new TreeNode(7);root->left->left->right = new TreeNode(2);root->right = new TreeNode(8);root->right->left = new TreeNode(13);root->right->right = new TreeNode(4);root->right->right->right = new TreeNode(1);// 检查路径和Solution solution;bool hasPath = solution.hasPathSum(root.get(), 22);// 输出结果if (hasPath) {std::cout << "There is a path with sum 22." << std::endl;} else {std::cout << "There is no path with sum 22." << std::endl;}// 清理分配的内存delete root->left->left->left;delete root->left->left->right;delete root->left->left;delete root->left;delete root->right->right->right;delete root->right->right;delete root->right->left;delete root->right;return 0;
}

106从中序与后续遍历构造二叉树

题目描述

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。示例 1:输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]
示例 2:输入：inorder = [-1], postorder = [-1]
输出：[-1]提示:1 <= inorder.length <= 3000
postorder.length == inorder.length
-3000 <= inorder[i], postorder[i] <= 3000
inorder 和 postorder 都由 不同 的值组成
postorder 中每一个值都在 inorder 中
inorder 保证是树的中序遍历
postorder 保证是树的后序遍历

我的想法

先后序遍历找到根节点，再用根节点再中序遍历中进行切割分为左序列和右序列

题目分析

说到一层一层切割，就应该想到了递归。

来看一下一共分几步：

第一步：如果数组大小为零的话，说明是空节点了。

第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。

第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点

第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）

第五步：切割后序数组，切成后序左数组和后序右数组

第六步：递归处理左区间和右区间

TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {// 第一步if (postorder.size() == 0) return NULL;// 第二步：后序遍历数组最后一个元素，就是当前的中间节点int rootValue = postorder[postorder.size() - 1];TreeNode* root = new TreeNode(rootValue);// 叶子节点if (postorder.size() == 1) return root;// 第三步：找切割点int delimiterIndex;for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {if (inorder[delimiterIndex] == rootValue) break;}// 第四步：切割中序数组，得到 中序左数组和中序右数组// 第五步：切割后序数组，得到 后序左数组和后序右数组// 第六步root->left = traversal(中序左数组, 后序左数组);root->right = traversal(中序右数组, 后序右数组);return root;
}

难点大家应该发现了，就是如何切割，以及边界值找不好很容易乱套。

此时应该注意确定切割的标准，是左闭右开，还有左开右闭，还是左闭右闭，这个就是不变量，要在递归中保持这个不变量。

在切割的过程中会产生四个区间，把握不好不变量的话，一会左闭右开，一会左闭右闭，必然乱套！

首先要切割中序数组，为什么先切割中序数组呢？

切割点在后序数组的最后一个元素，就是用这个元素来切割中序数组的，所以必要先切割中序数组。

中序数组相对比较好切，找到切割点（后序数组的最后一个元素）在中序数组的位置，然后切割，如下代码中我坚持左闭右开的原则：

// 找到中序遍历的切割点
int delimiterIndex;
for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {if (inorder[delimiterIndex] == rootValue) break;
}// 左闭右开区间：[0, delimiterIndex)
vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
// [delimiterIndex + 1, end)
vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );

首先要切割中序数组，为什么先切割中序数组呢？

切割点在后序数组的最后一个元素，就是用这个元素来切割中序数组的，所以必要先切割中序数组。

中序数组相对比较好切，找到切割点（后序数组的最后一个元素）在中序数组的位置，然后切割，如下代码中我坚持左闭右开的原则：

// postorder 舍弃末尾元素，因为这个元素就是中间节点，已经用过了
postorder.resize(postorder.size() - 1);// 左闭右开，注意这里使用了左中序数组大小作为切割点：[0, leftInorder.size)
vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
// [leftInorder.size(), end)
vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

acm模式代码

#include <iostream>
#include <vector>struct TreeNode {int val;TreeNode* left;TreeNode* right;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:TreeNode* traversal(std::vector<int>& inorder, std::vector<int>& postorder) {if (postorder.size() == 0) return nullptr;int rootvalue = postorder[postorder.size() - 1];TreeNode* root = new TreeNode(rootvalue);if (postorder.size() == 1) return root;int delimiterIndex;for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {if (inorder[delimiterIndex] == rootvalue) break;}std::vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);std::vector<int> rightInorder(inorder.begin() + delimiterIndex +1, inorder.end());postorder.resize(postorder.size() - 1);std::vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());std::vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());root->left = traversal(leftInorder, leftPostorder);root->right = traversal(rightInorder, rightPostorder);return root;}
public:TreeNode* buildTree(std::vector<int> &inorder, std::vector<int> &postorder) {if (inorder.size() == 0 || postorder.size() == 0) return nullptr;return traversal(inorder, postorder);}
};void printTree(TreeNode* node) {if (node != nullptr) {printTree(node->left);printTree(node->right);std::cout << node->val << " ";}
}
int main() {// 创建中序和后序遍历的序列std::vector<int> inorder = {9, 3, 15, 20, 7};std::vector<int> postorder = {9, 15, 7, 20, 3};// 创建Solution实例并重建二叉树Solution solution;TreeNode* root = solution.buildTree(inorder, postorder);// 打印重建后的二叉树结构std::cout << "The reconstructed tree (inorder): ";printTree(root);std::cout << std::endl;// 注意：这里没有删除TreeNode的实例，实际应用中应考虑内存管理return 0;
}

今日学习的文章和视频链接

https://www.bilibili.com/video/BV1vW4y1i7dn/?vd_source=8272bd48fee17396a4a1746c256ab0ae
https://programmercarl.com/0106.%E4%BB%8E%E4%B8%AD%E5%BA%8F%E4%B8%8E%E5%90%8E%E5%BA%8F%E9%81%8D%E5%8E%86%E5%BA%8F%E5%88%97%E6%9E%84%E9%80%A0%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E6%80%9D%E8%B7%AF

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

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

相关文章

贝锐蒲公英云AP体验：云端快速部署、远程管理，轻松满足办公环境

贝锐蒲公英云AP体验：云端快速部署、远程管理，轻松满足办公环境

公司原本的网络由于采用多个路由器&#xff0c;导致无线信号杂乱&#xff0c;管理不便&#xff0c;且远程办公体验较差&#xff0c;作为IT负责人的我&#xff0c;一直想寻找一个可以实现网络统一管理并有效提升远程工作便捷性的产品。 于是&#xff0c;我决定在公司内部部署贝…
阅读更多...
5G_射频测试_基础概念（二）

5G_射频测试_基础概念（二）

定义了测试参考点&#xff0c;不同的RRU类型 C类型传统RRU Conducted and radiated requirement reference points 4.3.1 BS type 1-C&#xff08;传统RRU一般测试点就是连接天线的射频接头&#xff09; 4.3.2 BS type 1-H&#xff08;宏站MassiveMIMO 矩阵天线&#xff…
阅读更多...
Nginx实现html页面注入浏览器监控js代码片段

Nginx实现html页面注入浏览器监控js代码片段

一、背景 最近看到关于浏览器监控相关的东西&#xff0c;顺带着就记录一下其实现的大致原理过程。 在我们没对web应用做浏览器监控的时候&#xff0c;我们其实无法感知到用户对我们应用页面的使用习惯、使用中是否遇到问题&#xff0c;例如白屏情况出现多少次、请求失败情况、j…
阅读更多...
ROS第 12 课 Launch 启动文件的使用方法

ROS第 12 课 Launch 启动文件的使用方法

文章目录 第 12 课 Launch 启动文件的使用方法1.本节前言2.Lanuch 文件基本语法2.2 参数设置2.3 重映射嵌套 3.实操练习 第 12 课 Launch 启动文件的使用方法 1.本节前言 我们在前面的教程里面通过命令行来尝试运行新的节点。但随着创建越来越复杂的机器人系统中&#xff0c;打…
阅读更多...
nest 集成 redis

nest 集成 redis

1.准备工作 安装redis npm install ioredis pnpm install --save nestjs-redis ioredis pnpm install --save nestjsplus/redis 这个命令nest g res redis创建redis需要用的 之后再appmoudlue加入 providers: [ AppService, { provide: REDIS_CLIENT, async useFactory(…
阅读更多...
【Java】Maven的基本使用

【Java】Maven的基本使用

Maven的基本使用 Maven常用命令 complie&#xff1a;编译clean&#xff1a;清理test&#xff1a;测试package&#xff1a;打包install&#xff1a;安装 mvn complie mvn clean mvn test mvn package mvn installMaven生命周期 IDEA配置Maven Maven坐标 什么是坐标&#xff1f;…
阅读更多...
可视化 | 【echarts】中国地图热力图

可视化 | 【echarts】中国地图热力图

文章目录 &#x1f4da;html和css&#x1f4da;js&#x1f407;整体框架&#x1f407;getGeoJson&#x1f407;echarts绘图⭐️整体框架⭐️option配置项 【echarts】渐变条形折线复合图【echarts】金字塔图 &#x1f4da;html和css html&#xff1a;整合<!DOCTYPE html&g…
阅读更多...
Docker：容器的两种运行模式(Foreground、Detached)

Docker：容器的两种运行模式(Foreground、Detached)

Docker容器进程有两种运行模式&#xff0c;通俗理解如下&#xff1a; 后台模式就是在后台运行&#xff0c;不会让当前进程卡主&#xff0c;你可以做其他事情。 前台模式是在前台运行&#xff0c;会导致当前卡住&#xff0c;并输出日志至当前控制台。 Foreground 前台模式&…
阅读更多...
5G_射频测试_发射机测量（四）

5G_射频测试_发射机测量（四）

6.2 Base station output power 用于测量载波发射功率的大小&#xff0c;功率越大小区半径越大但是杂散也会越大 载波功率&#xff08;用频谱仪测&#xff09;天线口功率&#xff08;用功率计测&#xff09;载波功率是以RBW为单位的filter测量的积分功率不同带宽的多载波测试时…
阅读更多...
CAP 角度下的 Redis 与 Zookeeper 锁架构比较

CAP 角度下的 Redis 与 Zookeeper 锁架构比较

在分布式系统设计中&#xff0c;CAP理论提供了一个重要的框架&#xff0c;帮助我们理解在一致性、可用性和分区容忍性之间的权衡。在这篇博客中&#xff0c;我们将从CAP的角度出发&#xff0c;比较Redis与Zookeeper在锁架构上的异同。 Redis锁架构&#xff1a; 一致性&#x…
阅读更多...
java垃圾回收GC过程

java垃圾回收GC过程

GC&#xff08;Gabage Collection&#xff09; 用于回收堆中的垃圾数据 清理方法 1.标记-清理 对数据标记&#xff0c;然后清理 缺点&#xff1a;容易产生内存碎片 2.标记-整理 对标记后的数据清理&#xff0c;剩下数据前移 缺点&#xff1a;每次清理后数据都要迁移&#xff0…
阅读更多...
JAVA算法-查找

JAVA算法-查找

目录 基本查找*&#xff1a; 二分查找*&#xff1a; 数据单调递增&#xff1a; 数据单调递减&#xff1a; 总结规律&#xff1a; 插值查找*&#xff1a; 斐波那契查找&#xff08;了解原理&#xff09;&#xff1a;以后补 分块 查找*&#xff1a; 特殊 情况&#xff0…
阅读更多...
docker部署

docker部署

//创建一个文件夹 mkdir soft //进入soft文件夹 cd soft 安装必要的系统工具: yum install -y yum-utils device-mapper-persistent-data lvm2 配置阿里云Docker Yum源: yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.rep…
阅读更多...
c# 视频播放之Windows Media Player

c# 视频播放之Windows Media Player

最近想给软件加个视频播放功能&#xff0c;在网上看有好几个方式&#xff0c;最后决定用 Windows Media Player 和Vlc.DotNet.Forms。 这篇文章主要讲Windows Media Player&#xff0c;它的优点&#xff1a;代码简单&#xff0c;视频操作功能都有&#xff0c;能播放网络和本地…
阅读更多...
Springboot之监听器

Springboot之监听器

Springboot之事件监听器 事件监听的几种方式1 方式一&#xff1a;实现接口1.1 创建事件1.2 创建事件监听器1.3 发布事件 2 方式二&#xff1a;注解方式2.1 创建事件2.1.1 创建发送邮件事件2.1.2 创建发送短信事件 2.2 创建事件监听器2.3 发布事件2.4 事件异步处理&#xff08;方…
阅读更多...
数据结构之顺序表的增删查改

数据结构之顺序表的增删查改

别丢了你的勇敢 前言&#xff1a; 自今日起&#xff0c;我们正式越过C语言的大山&#xff0c;走向了数据结构的深山&#xff0c;现如今摆在我们面前的第一个坎就是顺序表&#xff0c;我们需要了解顺序表的定义&#xff0c;并且知道&#xff0c;如何对其进行增删查改&#xff0…
阅读更多...
MyBatis 使用报错： Can‘t generate mapping method with primitive return type

MyBatis 使用报错： Can‘t generate mapping method with primitive return type

文章目录 前言问题原因解决方案个人简介 前言 今天在新项目中使用 MyBatis 报如下错误&#xff1a;Cant generate mapping method with primitive return type 问题原因 发现是 Mapper 注解引入错误&#xff0c;错误引入 org.mapstruct.Mapper, 实际应该引入 org.apache.ibat…
阅读更多...
接口测试 04 -- Jsonpath断言、接口关联处理

接口测试 04 -- Jsonpath断言、接口关联处理

1. JsonPath基本介绍 1.1 JsonPath简介 JsonPath是一种用于在JSON数据中定位和提取特定数据的表达式语言。它类似于XPath用于XML的定位和提取&#xff0c;可以帮助我们灵活地从复杂的JSON结构中获取所需的数据。 1.2 JsonPath的特点 ● JsonPath可处理的报文类型为字典类型 …
阅读更多...
4.servera修改主机名，配置网络,以及在cmd中远程登录servera的操作

4.servera修改主机名，配置网络,以及在cmd中远程登录servera的操作

1.先关闭这两节省资源 2.对于新主机修改主机名&#xff0c;配置网络 一、配置网络 1.推荐图形化界面nmtui 修改完成后测试 在redhat ping一下 在redhat远程登录severa 2、使用nmcli来修改网络配置 2.1、配置要求&#xff1a;主机名&#xff1a; node1.domain250.exam…
阅读更多...
Linux练习题

Linux练习题

1 简答题：请列举你所知道的Linux发行版 常见的Linux发行版： Red Hat Enterprise Linux 6/7/8 CentOS 6/7/8 Suse Linux Enterprise 15 Debian Linux 11 Ubuntu Linux 20.04/21.04 Rocky Linux 8/9 2 简答题：Linux系统的根目录、/dev目录的作用是什么 /：linux文件系统的…
阅读更多...
最新文章

Copyright @ 2022~2023