Leetcode算法训练日记 | day18

news2025/6/22 14:51:36

一、找树左下角的值

1.题目

Leetcode：第 513 题

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

假设二叉树中至少有一个节点。

示例 1:

输入: root = [2,1,3]
输出: 1

示例 2:

输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

2.解题思路

使用队列来实现层序遍历，每次从队列中取出所有节点，并检查每个节点的子节点，将它们加入队列中以便后续遍历。在每一层中，第一个被取出的节点（即队列中的第一个节点）将是该层的最左侧节点，因此将其值设置为结果。当遍历结束时，返回结果变量，它包含了二叉树最底层的左侧值。

3.实现代码

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

// 定义一个结构体TreeNode，用于表示二叉树的节点。
struct TreeNode {
    int val; // 存储节点的值。
    TreeNode* left; // 指向该节点左子树的指针。
    TreeNode* right; // 指向该节点右子树的指针。
    // TreeNode的构造函数，用于创建一个TreeNode实例。
    // 参数x是节点的值，left和right默认为NULL，表示没有左右子节点。
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};


// 一、找树左下角的值（递归法）
class Solution1 {
public:
    int maxDepth = INT_MIN;// 初始化最大深度为最小整数值，用于记录遍历过程中的最大深度。
    int result; // 初始化结果变量，用于存储最底层左侧的值。

    // traversal函数用于递归遍历二叉树，并找到最底层左侧的值。
    void traversal(TreeNode* root, int depth) {
        // 如果当前节点是叶子节点（没有左右子节点），检查当前深度是否大于已知的最大深度。
        if (root->left == NULL && root->right == NULL) {
            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;// 遍历过程中返回，以便继续遍历其他分支。
    }

    // findBottomLeftValue函数是公共成员函数，用于返回二叉树最底层左侧的值。
    int findBottomLeftValue(TreeNode* root) {
        traversal(root, 0);// 调用递归遍历函数，遍历二叉树。
        return result; // 返回记录的最底层左侧的值。
    }
};


// 二、找树左下角的值（迭代法）
class Solution2 {
public:
    // findBottomLeftValue函数用于找到并返回二叉树最底层的左侧值。
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que; // 创建一个队列que，用于存储待遍历的节点。
        if (root != NULL) que.push(root);  // 如果根节点不为空，将其入队。
        int result = 0; // 初始化结果变量为0。

        // 使用while循环遍历队列不为空时的所有节点。
        while (!que.empty()) {
            int size = que.size();// 获取队列中的节点数量。
            for (int i = 0; i < size; i++) { // 遍历当前队列中的所有节点。
                TreeNode* node = que.front(); // 取出队列前端的节点。
                que.pop(); // 将节点从队列中移除。
                if (i == 0) {   // 如果是当前层的第一个节点，将其值设为结果。
                    result = node->val;
                }
                if (node->left) que.push(node->left);// 如果节点有左子节点，将其入队。
                if (node->right) que.push(node->right); // 如果节点有右子节点，将其入队。
            }
        }
        return result;// 返回记录的最底层左侧的值。
    }
};


//测试
// 辅助函数，用于创建一个新的TreeNode
TreeNode* createNode(int value) {
    return new TreeNode(value);
}

// 辅助函数，用于构建二叉树
TreeNode* buildTree(vector<int>& values) {
    if (values.empty()) return NULL;
    TreeNode* root = createNode(values[0]);
    queue<TreeNode*> queueNode;
    queueNode.push(root);
    int i = 1;
    while (!queueNode.empty()) {
        TreeNode* node = queueNode.front();
        queueNode.pop();
        if (i < values.size()) {
            node->left = createNode(values[i++]);
            queueNode.push(node->left);
        }
        if (i < values.size()) {
            node->right = createNode(values[i++]);
            queueNode.push(node->right);
        }
    }
    return root;
}

// 打印容器中的所有元素，用于验证测试结果
void printVector(const vector<int>& vec) {
    for (int value : vec) {
        cout << value << " ";
    }
    cout << endl;
}

// 主函数
int main() {

    vector<int> treeValues = { 1, 2, 3, 4, 5, 6, 7 };// 定义二叉树的层序遍历结果，用于构建二叉树
    TreeNode* root = buildTree(treeValues); // 构建二叉树
    Solution1 s1;// 创建Solution类的实例
    Solution2 s2;
    int result1 = s1.findBottomLeftValue(root);// 传入二叉树的根节点
    int result2 = s2.findBottomLeftValue(root);
    cout << "二叉树的左下角的值（递归法）是: " << result1 << endl;
    cout << endl;
    cout << "二叉树的左下角的值（迭代法）是: " << result2 << endl;
    cout << endl;
    return 0;
}

二、路径总和

1.题目

Leetcode：第 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
解释：由于树是空的，所以不存在根节点到叶子节点的路径
2.解题思路

使用递归法和迭代法遍历二叉树节点，使用一个栈来存储每个节点及其对应的路径数值。在遍历过程中，如果遇到叶子节点且其路径数值等于目标和，返回true；否则继续遍历左右子节点。如果遍历结束仍未找到满足条件的路径，返回false。

3.实现代码
#include <iostream>
#include <vector>
#include <stack>
#include <queue>
using namespace std;

// 定义一个结构体TreeNode，用于表示二叉树的节点。
struct TreeNode {
    int val; // 存储节点的值。
    TreeNode* left; // 指向该节点左子树的指针。
    TreeNode* right; // 指向该节点右子树的指针。
    // TreeNode的构造函数，用于创建一个TreeNode实例。
    // 参数x是节点的值，left和right默认为NULL，表示没有左右子节点。
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 一、二叉树的路径总和（递归法）
class Solution1 {
public:
    // traversal是一个辅助函数，用于递归遍历二叉树，检查是否存在路径和等于count的路径。
    // node是当前遍历到的节点，count是当前的路径和与目标和的差值。
    bool traversal(TreeNode* node, int count) {
        // 如果当前节点是叶子节点，并且count不等于0，说明路径和不等于目标和，返回false。
        if (node->left == NULL && node->right == NULL && count != 0) return false;
        // 如果当前节点是叶子节点，并且count等于0，说明路径和等于目标和，返回true。
        if (node->left == NULL && node->right == NULL && count == 0) return true;

        // 如果当前节点有左子节点，递归遍历左子树。
        if (node->left) {
            count -= node->left->val; // 从当前路径和中减去左子节点的值，因为左子节点的值是路径和的一部分。
            if (traversal(node->left, count)) return true;  // 如果在左子树中找到满足条件的路径，返回true。
            count += node->left->val;  // 回溯，将左子节点的值加回到路径和中。
        }
        // 如果当前节点有右子节点，递归遍历右子树。
        if (node->right) {
            count -= node->right->val; // 从当前路径和中减去右子节点的值，因为右子节点的值是路径和的一部分。
            if (traversal(node->right, count)) return true;// 如果在右子树中找到满足条件的路径，返回true。
            count += node->right->val;  // 回溯，将右子节点的值加回到路径和中。
        }
        return false;// 如果遍历完左右子树都没有找到满足条件的路径，返回false。
    }

    // hasPathSum是一个成员函数，用于判断是否存在从根节点到叶子节点的路径和等于目标和的路径。
    // root是二叉树的根节点，targetSum是目标和。
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == NULL) return false;// 如果根节点为空，返回false，因为不存在路径。
        // 调用辅助函数traversal，从根节点开始遍历，初始路径和为targetSum - 根节点的值。
        return traversal(root, targetSum - root->val);
    }
};

// 二、二叉树的路径总和（迭代法）
class Solution2 {
public:
    // haspathsum函数用于判断是否存在路径和等于sum的路径。
    // root是二叉树的根节点，sum是目标和。
    bool haspathsum(TreeNode* root, int sum) {
        if (root == NULL) return false;// 如果根节点为空，返回false，因为不存在路径。
        stack<pair<TreeNode*, int>> st;// 创建一个栈st，用于存储节点指针和对应的路径数值。
        st.push(pair<TreeNode*, int>(root, root->val));// 将根节点及其路径数值（根节点的值）入栈。

        // 使用while循环遍历栈不为空时的所有元素。
        while (!st.empty()) {
            pair<TreeNode*, int> node = st.top();// 取出栈顶元素，包含节点指针和路径数值。
            st.pop();
            // 如果当前节点是叶子节点，并且路径数值等于sum，返回true。
            if (!node.first->left && !node.first->right && sum == node.second) return true;

            // 如果当前节点有右子节点，将其及其路径数值（当前路径数值加上右子节点的值）入栈。
            if (node.first->right) {
                st.push(pair<TreeNode*, int>(node.first->right, node.second + node.first->right->val));
            }

            // 如果当前节点有左子节点，将其及其路径数值（当前路径数值加上左子节点的值）入栈。
            if (node.first->left) {
                st.push(pair<TreeNode*, int>(node.first->left, node.second + node.first->left->val));
            }
        }
        return false; // 如果遍历完所有节点都没有找到满足条件的路径，返回false。
    }
};


//测试
// 辅助函数，用于创建一个新的TreeNode
TreeNode* createNode(int value) {
    return new TreeNode(value);
}

// 辅助函数，用于构建二叉树
TreeNode* buildTree(vector<int>& values) {
    if (values.empty()) return NULL;
    TreeNode* root = createNode(values[0]);
    queue<TreeNode*> queueNode;
    queueNode.push(root);
    int i = 1;
    while (!queueNode.empty()) {
        TreeNode* node = queueNode.front();
        queueNode.pop();
        if (i < values.size()) {
            node->left = createNode(values[i++]);
            queueNode.push(node->left);
        }
        if (i < values.size()) {
            node->right = createNode(values[i++]);
            queueNode.push(node->right);
        }
    }
    return root;
}

// 打印容器中的所有元素，用于验证测试结果
void printVector(const vector<int>& vec) {
    for (int value : vec) {
        cout << value << " ";
    }
    cout << endl;
}

// 主函数
int main() {

    vector<int> treeValues = { 1, 2, 3, 4, 5, 6, 7 };// 定义二叉树的层序遍历结果，用于构建二叉树
    TreeNode* root = buildTree(treeValues); // 构建二叉树
    Solution1 s1;// 创建Solution类的实例
    Solution2 s2;
    int targetSum = 11;
    int result1 = s1.hasPathSum(root, targetSum);// 传入二叉树的根节点
    int result2 = s2.haspathsum(root, targetSum);
    cout << "targetSum = " << targetSum << endl;
    cout << endl;
    cout << "判断二叉树的路径总和（递归法）结果是: " << result1 << endl;
    cout << endl;
    cout << "判断二叉树的路径总和（迭代法）结果是：" << result2 << endl;
    cout << endl;
    return 0;
}

三、从中序与后序遍历序列构造二叉树

1.题目

Leetcode：第 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]
2.解题思路

创建traversal函数递归地根据中序和后序遍历序列重建二叉树。首先确定根节点，然后根据根节点在中序遍历序列中的位置分割序列，得到左右子树的遍历序列。接着递归地重建左右子树，并将它们分别作为根节点的左右子节点。buildTree函数是重建二叉树的入口点，它调用traversal函数并传入中序和后序遍历序列。

3.实现代码
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

// 定义一个结构体TreeNode，用于表示二叉树的节点。
struct TreeNode {
    int val; // 存储节点的值。
    TreeNode* left; // 指向该节点左子树的指针。
    TreeNode* right; // 指向该节点右子树的指针。
    // TreeNode的构造函数，用于创建一个TreeNode实例。
    // 参数x是节点的值，left和right默认为NULL，表示没有左右子节点。
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};


// 从中序与后序遍历序列构造二叉树
class Solution {
private:
    // traversal函数是一个辅助函数，用于递归地重建二叉树。
    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;
        }

        // 根据根节点的位置分割中序遍历序列为左右子树的中序遍历序列。
        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end());

        postorder.resize(postorder.size() - 1);// 移除后序遍历序列中的根节点，为后续递归调用做准备。

        // 根据根节点的位置分割后序遍历序列为左右子树的后序遍历序列。
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        root->left = traversal(leftInorder, leftPostorder);// 递归地重建左子树，并将其作为根节点的左子节点。
        root->right = traversal(rightInorder, rightPostorder); // 递归地重建右子树，并将其作为根节点的右子节点。

        return root;// 返回重建的根节点。
    }
public:
    // buildTree函数是公共成员函数，用于根据给定的中序和后序遍历序列重建二叉树。
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0) return NULL; // 如果中序或后序遍历序列为空，返回空指针。
        return traversal(inorder, postorder);// 调用辅助函数开始重建二叉树。
    }
};

//测试
// 辅助函数，用于创建一个新的TreeNode
TreeNode* createNode(int value) {
    return new TreeNode(value);
}

// 辅助函数，用于构建二叉树
TreeNode* buildTree(vector<int>& values) {
    if (values.empty()) return NULL;
    TreeNode* root = createNode(values[0]);
    queue<TreeNode*> queueNode;
    queueNode.push(root);
    int i = 1;
    while (!queueNode.empty()) {
        TreeNode* node = queueNode.front();
        queueNode.pop();
        if (i < values.size()) {
            node->left = createNode(values[i++]);
            queueNode.push(node->left);
        }
        if (i < values.size()) {
            node->right = createNode(values[i++]);
            queueNode.push(node->right);
        }
    }
    return root;
}

// 打印容器中的所有元素，用于验证测试结果
void printVector(const vector<int>& vec) {
    for (int value : vec) {
        cout << value << " ";
    }
    cout << endl;
}
int main()
{
    Solution s;
    vector<int> inorder = { 9,3,15,20,7 };
    vector<int> postorder = { 9,15,7,20,3 };
    TreeNode* result=s.buildTree(inorder, postorder);
    cout << "从中序与后序遍历序列构造二叉树:" << endl;
    cout <<"root = "<<result->val << endl;
    cout << "root->left = " << result->left->val << endl;
    cout << "root->right = " << result->right->val << endl;
    cout << "root->right->left = " << result->right->left->val << endl;
    cout << "root->right->right = " << result->right->right->val << endl;
    return 0;
}

 ps：以上皆是本人在探索算法旅途中的浅薄见解，诚挚地希望得到各位的宝贵意见与悉心指导，若有不足或谬误之处，还请多多指教。

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

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

相关文章

nandgame中的Memory(内存操作)：栈、堆、静态区

nandgame中的Memory(内存操作)：栈、堆、静态区

Push Memory Push Memory 将内存中的值push到栈内堆栈顶部的值是一个内存地址。从堆栈中弹出地址。获取内存地址的当前内容&#xff0c;并将其推送到堆栈上。POP_A //堆栈顶部的值是一个内存地址。从堆栈中弹出地址。 D *A //获取内存地址的当前内容 PUSH_D //将其推送到…
阅读更多...
JVM性能调优——运行时参数

JVM性能调优——运行时参数

文章目录 1、JVM参数选项类型1.1、标准参数选项1.2、非标准参数选项1.3、非稳定参数选项 2、添加JVM参数的方式3、常用JVM参数选项4、通过Java代码获取JVM参数5、小结 熟悉JVM参数对于系统调优是非常重要的。比如一个高流量的延迟的电子交易平台&#xff0c;它要求的响应时间都…
阅读更多...
ROS机器人未知环境自主探索功能包explore_lite最全源码详细解析（五）

ROS机器人未知环境自主探索功能包explore_lite最全源码详细解析（五）

本系列文章主要针对ROS机器人常使用的未知环境自主探索功能包explore_lite展开全源码的详细解析&#xff0c;并进行概括总结。 本系列文章共包含六篇文章&#xff0c;前五篇文章主要介绍explore_lite功能包中 explore.cpp、costmap_tools.h、frontier_search.cpp、costmap_clie…
阅读更多...
MySQL：关于数据库的一些练习题

MySQL：关于数据库的一些练习题

文章目录 前面的内容已经把数据库的一些必要知识已经储备好了&#xff0c;因此下面就对于这些语句进行一些练习&#xff1a; 批量插入数据 insert into actor values (1, PENELOPE, GUINESS, 2006-02-15 12:34:33), (2, NICK, WAHLBERG, 2006-02-15 12:34:33);SQL202 找出所有…
阅读更多...
C/S医学检验LIS实验室信息管理系统源码 医院LIS源码

C/S医学检验LIS实验室信息管理系统源码 医院LIS源码

LIS系统即实验室信息管理系统。LIS系统能实现临床检验信息化&#xff0c;检验科信息管理自动化。其主要功能是将检验科的实验仪器传出的检验数据经数据分析后&#xff0c;自动生成打印报告&#xff0c;通过网络存储在数据库中&#xff0c;使医生能够通过医生工作站方便、及时地…
阅读更多...
一起学习python——基础篇（14）

一起学习python——基础篇（14）

今天讲一下python的json解析方式。 上一篇文章讲述了将传参数据转换为json格式的数据传给后台&#xff0c;如果后端返回的json格式数据&#xff0c;我们该如何解析呢&#xff1f; 例子一&#xff1a;简单的json数据格式 如果后端返回的json数据如下&#xff0c; { "na…
阅读更多...
【leetcode面试经典150题】34.有效的数独（C++）

【leetcode面试经典150题】34.有效的数独（C++）

【leetcode面试经典150题】专栏系列将为准备暑期实习生以及秋招的同学们提高在面试时的经典面试算法题的思路和想法。本专栏将以一题多解和精简算法思路为主&#xff0c;题解使用C语言。&#xff08;若有使用其他语言的同学也可了解题解思路&#xff0c;本质上语法内容一致&…
阅读更多...
Docker Compose 一键安装

Docker Compose 一键安装

文章目录 一、场景说明二、脚本职责三、参数说明四、操作示例五、注意事项 一、场景说明 本自动化脚本旨在为提高研发、测试、运维快速部署应用环境而编写。 脚本遵循拿来即用的原则快速完成 CentOS 系统各应用环境部署工作。 统一研发、测试、生产环境的部署模式、部署结构、…
阅读更多...
【C++学习】C++11新特性（第二节）—— 右值引用与移动语义超详解

【C++学习】C++11新特性（第二节）—— 右值引用与移动语义超详解

文章目录 文章简介二.右值引用1.什么是左值&#xff0c;什么是右值&#xff1f;什么是左值引用&#xff0c;什么是右值引用&#xff1f;2.左值引用与右值引用比较 三.右值引用使用场景和意义1.左值引用的使用场景&#xff1a;2.左值引用的短板&#xff1a;3.右值引用与移动构造…
阅读更多...
2024大模型落地应用案例集（免费下载）

2024大模型落地应用案例集（免费下载）

【1】扫码关注本公众号 【2】私信发送 2024大模型落地应用案例集 【3】获取本方案PDF下载链接&#xff0c;直接下载即可。
阅读更多...
【Linux】环境下OpenSSH升级到 OpenSSH_9.6P1（图文教程）

【Linux】环境下OpenSSH升级到 OpenSSH_9.6P1（图文教程）

漏洞描述 OpenSSH&#xff08;OpenBSD Secure Shell&#xff09;是加拿大OpenBSD计划组的一套用于安全访问远程计算机的连接工具。该工具是SSH协议的开源实现&#xff0c;支持对所有的传输进行加密&#xff0c;可有效阻止窃听、连接劫持以及其他网络级的攻击。OpenSSH 9.6之前…
阅读更多...
深入浅出Golang image库：编写高效的图像处理代码

深入浅出Golang image库：编写高效的图像处理代码

深入浅出Golang image库&#xff1a;编写高效的图像处理代码 引言image库概览图像处理基础概念image库的主要组成和功能image接口图像格式的支持color模型 结论 图像的基本操作创建图像新图像的创建从文件加载图像 图像的保存与导出图像的颜色和像素处理绘制基本形状和文字 高级…
阅读更多...
无网络连接 请检查你的网络设置 然后重试 [2604] 彻底解决方案

无网络连接 请检查你的网络设置 然后重试 [2604] 彻底解决方案

错误提示&#xff1a;无网络连接 请检查你的网络设置 然后重试 [2604] 彻底解决方案如下&#xff1a; 方案一&#xff1a; 打开Internet Explorer浏览器&#xff0c;选择"工具 > Internet 选项"。 在Internet属性窗口下&#xff0c;点击高级下滑到安全模块分类…
阅读更多...
[漏洞复现]D-Link未授权RCE漏洞复现(CVE-2024-3273)

[漏洞复现]D-Link未授权RCE漏洞复现(CVE-2024-3273)

声明&#xff1a;亲爱的读者&#xff0c;我们诚挚地提醒您&#xff0c;Aniya网络安全的技术文章仅供个人研究学习参考。任何因传播或利用本实验室提供的信息而造成的直接或间接后果及损失&#xff0c;均由使用者自行承担责任。Aniya网络安全及作者对此概不负责。如有侵权&#…
阅读更多...
Linux查看系统配置信息的命令【lscpu】【free】【df】【uname】【lsblk】【top】

Linux查看系统配置信息的命令【lscpu】【free】【df】【uname】【lsblk】【top】

目录 1.查看CPU信息【lscpu】 2.查看内存信息【free】 3.查看文件系统信息【df】 4.查看系统信息【uname】 知识扩展&#xff1a;Red Hat Enterprise Linux 和 Debian GNU/Linux 两者的发展介绍 知识扩展&#xff1a;Centos 和 ubuntu的区别 知识扩展&#xff1a;更多 …
阅读更多...
Quanto: PyTorch 量化工具包

Quanto: PyTorch 量化工具包

量化技术通过用低精度数据类型 (如 8 位整型 (int8)) 来表示深度学习模型的权重和激活&#xff0c;以减少传统深度学习模型使用 32 位浮点 (float32) 表示权重和激活所带来的计算和内存开销。 减少位宽意味着模型的内存占用更低&#xff0c;这对在消费设备上部署大语言模型至关…
阅读更多...
Python学习从0开始——项目一day01爬虫

Python学习从0开始——项目一day01爬虫

Python学习从0开始——项目一day01爬虫 一、导入代码二、使用的核心库三、功能测试3.1初始代码3.2新建文件3.3代码调试 四、页面元素解析4.1网页4.2修改代码4.3子页面4.4修改代码 一、导入代码 在Inscode新建一个python类型的项目&#xff0c;然后打开终端&#xff0c;粘贴以下…
阅读更多...
高中数学：三角函数-基础知识

高中数学：三角函数-基础知识

一、任意角 顺时针旋转是负值角 逆时针旋转式正值角 一个角对应一个终边 一个终边对应无数个角 xk*360 例题 二、弧度制 弧长与半径的比值&#xff0c;就是角度 常见角度与弧度的对应关系 例题 三、弧长与扇形面积公式 注意&#xff1a;弧度制下的扇形面积公式&#x…
阅读更多...
SpringBoot --pagehelper分页

SpringBoot --pagehelper分页

目录 1.建立数据库 2.页面显示 3.基本逻辑 4.配置依赖 5.使用pagehelper 6.页面列表 页面 效果 1.建立数据库 create database if not exists my_book; use my_book; create table if not exists myBook (id int primary key auto_increment,name varchar(50) not …
阅读更多...
Python(4)：函数(命名+参数+内置函数+匿名函数)

Python(4)：函数(命名+参数+内置函数+匿名函数)

文章目录 一、关于*的一些打散功能二、函数的特点和命名规范三、函数的返回值return四、函数的参数1.无参数的函数2.有参数的函数 五、函数的命名空间六、全局变量和局部变量七、函数的作用域以及执行顺序(LEGB)八、递归函数九、常见内置函数十、匿名函数-lambda 一、关于*的一…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023