[LeetCode] 二叉树 I — 深度优先遍历（前中后序遍历） | 广度优先遍历（层序遍历）：递归法迭代法

二叉树

  • 基础知识
  • 深度优先遍历
    • 递归法
    • 迭代法（栈）
    • 144# 二叉树的前序遍历
    • 94# 二叉树的中序遍历
    • 145# 二叉树的后序遍历
  • 广度优先遍历
    • 递归法
    • 迭代法（队列）
    • 102# 二叉树的层序遍历
    • 107# 二叉树的层序遍历 II
    • 199# 二叉树的右视图
    • 637# 二叉树的层平均值
    • 429# N叉树的层序遍历
    • 515# 在每个树行中找最大值
    • 116# 填充每个节点的下一个右侧节点指针
    • 117# 填充每个节点的下一个右侧节点指针 II
    • 104# 二叉树的最大深度
    • 111# 二叉树的最小深度
  • 补充知识：递归
    • 汉诺塔

基础知识

存储方式：数组顺序存储 / 指针链式存储

顺序存储：节点i的左孩子2i+1 、右孩子2i+2、父节点(i-1)/2

链式存储：

struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	
	TreeNode(int x) : val(x), left(NULL), right(NULL) { }
}

完全二叉树：除底层外每层节点数都达到最大，底层节点集中在左边，包括满二叉树

满二叉树：深度为k的满二叉树有2^k-1个节点（1 2 ... 2^(k-1)）

二叉搜索树：有序树，左子树<根节点<右子树，查找、插入、删除时间复杂度均为 O(logn)，最坏情况为O(n)

平衡二叉树：左右子树的高度差（平衡因子）不超过1，避免树的高度过大以确保操作的时间复杂度稳定在 O(logn)

平衡二叉搜索树：AVL树、红黑树、Treap

AVL 树

  • 严格平衡（平衡因子 ≤ 1）
  • 优点：查询效率极高（严格 O(logn)）
  • 缺点：插入/删除可能需要频繁旋转，维护成本高

红黑树

  • 近似平衡（最长路径不超过最短路径的 2 倍）
  • 优点：插入/删除性能更优，适合频繁修改的场景
  • 应用：C++ std::map、Java TreeMap、数据库索引

Treap

  • 结合二叉搜索树和堆的性质，通过随机优先级维护平衡

深度优先遍历 借助栈实现

  • 前序遍历：中左右

  • 中序遍历：左中右

  • 后序遍历：左右中

广度优先遍历 借助队列实现

  • 层次遍历：逐层从左到右访问所有节点

深度优先遍历

递归法

// 前序遍历
void preorder(TreeNode *root, vector<int> &vec) {
    if (root == nullptr) return;
    vec.push_back(root->val);
    preorder(root->left, vec);
    preorder(root->right, vec);
}

// 中序遍历
void inorder(TreeNode *root, vector<int> &vec) {
    if (root == nullptr) return;
    inorder(root->left, vec);
    vec.push_back(root->val);
    inorder(root->right, vec);
}

// 后序遍历
void postorder(TreeNode *root, vector<int> &vec) {
    if (root == nullptr) return;
    postorder(root->left, vec);
    postorder(root->right, vec);
    vec.push_back(root->val);
}

迭代法（栈）

沿着递归实现依靠调用栈的思想，利用栈实现前中后序遍历

// 前序遍历：中入出右左入出-->中左右
vector<int> preorderTraversal(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> st;
    if (root == nullptr) return result;
    st.push(root);
    while (!st.empty()) {
        TreeNode* node = st.top();
        st.pop();
        result.push_back(node->val);
        if (node->right) st.push(node->right);
        if (node->left) st.push(node->left);
    }
    return result;
}

// 中序遍历
vector<int> inorderTraversal(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> st;
    TreeNode *cur = root;
    while (cur != nullptr || !st.empty()) {
        if (cur != nullptr) { // 深度遍历左子节点
            st.push(cur);
            cur = cur->left;
        } else {
            cur = st.top();
            result.push_back(cur->val);
            st.pop();
            cur = cur->right; // 访问根节点并弹出后再访问右子节点
        }
    }
    return result;
}

// 后序遍历：中入出左右入出-->中右左--reverse-->左右中
vector<int> postorderTraversal(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> st;
    if (root == nullptr) return result;
    st.push(root);
    while (!st.empty()) {
        TreeNode *node = st.top();
        result.push_back(node->val);
        st.pop();
        if (node->left) st.push(node->left);
        if (node->right) st.push(node->right);
    }
    reverse(result.begin(), result.end());
    return result;
}

以上三种遍历方法并不统一，前后序遍历用栈遍历，而中序遍历用指针遍历，因为栈无法解决访问节点和处理节点不一致的情况

通过为节点作标记统一迭代法：1. 空指针标记法；2. boolean标记法

// 中序遍历--空指针标记法
vector<int> inorderTraversal(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> st;
    if (root == nullptr) return result;
    st.push(root);
    while (!st.empty()) {
        TreeNode* node = st.top();
        st.pop();
        if (node != nullptr) { // 检查空指针标记，右中左顺序入栈
            if (node->right) st.push(node->right);
            st.push(node);
            st.push(nullptr);
            if (node->left) st.push(node->left);
        } else {
            node = st.top();
            result.push_back(node->val);
            st.pop();
        }
    }
    return result;
}

// 中序遍历--boolean标记法
vector<int> inorderTraversal(TreeNode* root) {
    vector<int> result;
    stack<pair<TreeNode*, bool>> st;
    if (root == nullptr) return result;
    st.push(make_pair(root, false));
    while (!st.empty()) {
        auto node = st.top().first;
        auto visited = st.top().second;
        st.pop();
        if (!visited) { // 检查boolean标记，右中左顺序入栈
            if (node->right) st.push(make_pair(node->right, false));
            st.push(make_pair(node, true));
            if (node->left) st.push(make_pair(node->left, false));
        } else {
            result.push_back(node->val);
        }
    }
    return result;
}

144# 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：

**输入：**root = [1,null,2,3]

输出：[1,2,3]

解释：

img

示例 2：

**输入：**root = [1,2,3,4,5,null,8,null,null,6,7,9]

输出：[1,2,4,5,6,7,3,8,9]

解释：

img

示例 3：

**输入：**root = []

输出：[]

示例 4：

**输入：**root = [1]

输出：[1]

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100
// 递归法
// O(n) 0ms; O(n) 10.84MB
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     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:
    void preorder(TreeNode *root, vector<int> &vec) {
        if (root == nullptr) return;
        vec.push_back(root->val);
        preorder(root->left, vec);
        preorder(root->right, vec);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        preorder(root, result);
        return result;
    }
};

空间复杂度 O(n)为递归过程中栈的开销，平均情况下为 O(logn)，最坏情况下树呈现链状为O(n)

迭代法：先将根节点入栈，根节点出栈后使其右子节点和左子节点入栈（中入出右左入出–>中左右）

// 迭代法--栈
// O(n) 0ms; O(n) 10.8MB
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root == nullptr) return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            result.push_back(node->val);
            if (node->right) st.push(node->right);
            if (node->left) st.push(node->left);
        }
        return result;
    }
};

94# 二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：

img 
输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100
// 递归法
// O(n) 0ms; O(n) 10.71MB
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     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:
    void inorder(TreeNode *root, vector<int> &vec) {
        if (root == nullptr) return;
        inorder(root->left, vec);
        vec.push_back(root->val);
        inorder(root->right, vec);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> vec;
        inorder(root, vec);
        return vec;
    }
};

// 迭代法--栈
// O(n) 0ms; O(n) 10.79MB
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode *cur = root;
        while (cur != nullptr || !st.empty()) {
            if (cur != nullptr) { // 深度遍历左子节点
                st.push(cur);
                cur = cur->left;
            } else {
                cur = st.top();
                result.push_back(cur->val);
                st.pop();
                cur = cur->right; // 访问根节点并弹出后再访问右子节点
            }
        }
        return result;
    }
};

145# 二叉树的后序遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例 1：

**输入：**root = [1,null,2,3]

输出：[3,2,1]

解释：

img

示例 2：

**输入：**root = [1,2,3,4,5,null,8,null,null,6,7,9]

输出：[4,6,7,5,2,9,8,3,1]

解释：

img

示例 3：

**输入：**root = []

输出：[]

示例 4：

**输入：**root = [1]

输出：[1]

提示：

  • 树中节点的数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100
// 递归法
// O(n) 0ms; O(n) 10.73MB
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     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:
    void postorder(TreeNode *root, vector<int> &vec) {
        if (root == nullptr) return;
        postorder(root->left, vec);
        postorder(root->right, vec);
        vec.push_back(root->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> vec;
        postorder(root, vec);
        return vec;
    }
};

迭代法：利用前序遍历迭代法 中入出右左入出–>中左右 的方法，这里 中入出左右入出–>中右左–reverse–>左右中

// 迭代法--栈
// O(n) 0ms; O(n) 10.87MB
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root == nullptr) return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode *node = st.top();
            result.push_back(node->val);
            st.pop();
            if (node->left) st.push(node->left);
            if (node->right) st.push(node->right);
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

广度优先遍历

递归法

void order(TreeNode *root, vector<vector<int>> &vec, int depth) {
    if (root == nullptr) return;
    if (vec.size() == depth) vec.push_back(vector<int>());
    vec[depth].push_back(root->val);
    order(root->left, vec, depth + 1);
    order(root->right, vec, depth + 1);
}

迭代法（队列）

vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>> result;
    queue<TreeNode*> que;
    if (root == nullptr) return result;
    que.push(root);
    while (!que.empty()) { // 以层为单位遍历，size确定当前层需要处理的节点数
        int size = que.size();
        vector<int> vec;
        for (int i = 0; i < size; i++){
            TreeNode *cur = que.front();
            que.pop();
            vec.push_back(cur->val);
            if (cur->left) que.push(cur->left);
            if (cur->right) que.push(cur->right);
        }
        result.push_back(vec);
    }
    return result;
}

102# 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

img 
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -1000 <= Node.val <= 1000
// 递归法
// O(n) 0ms; O(n) 16.77MB
class Solution {
public:
    void order(TreeNode *root, vector<vector<int>> &vec, int depth) {
        if (root == nullptr) return;
        if (vec.size() == depth) vec.push_back(vector<int>());
        vec[depth].push_back(root->val);
        order(root->left, vec, depth + 1);
        order(root->right, vec, depth + 1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

// 迭代法--队列
// O(n) 0ms; O(n) 16.89MB
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if (root == nullptr) return result;
        que.push(root);
        while (!que.empty()) { // 以层为单位遍历，size确定当前层需要处理的节点数
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++){
                TreeNode *cur = que.front();
                que.pop();
                vec.push_back(cur->val);
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

107# 二叉树的层序遍历 II

题目链接

层序遍历后反转

// 迭代法--队列
// O(n) 3ms; O(n) 15.70MB
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if (root == nullptr) return result;
        que.push(root);
        while (!que.empty()) {
            vector<int> vec;
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode *cur = que.front(); 
                vec.push_back(cur->val);
                que.pop();
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
            result.push_back(vec);
        }
        reverse(result.begin(), result.end()); // 默认只反转第一维度的元素顺序
        return result;
    }
};

199# 二叉树的右视图

题目链接

从右侧所能看到的节点正好是层序遍历中的最后一个节点

// 层序遍历
// O(n) 3ms; O(n) 14.77MB
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;
        if (root == nullptr) return result;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode *cur = que.front();
                if (i == size - 1) result.push_back(cur->val);
                que.pop();
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
        }
        return result;
    }
};

637# 二叉树的层平均值

题目链接

// 层序遍历
// O(n) 0ms; O(n) 23.39MB
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        queue<TreeNode*> que;
        if (root == nullptr) return result;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            double sum = 0;
            for (int i = 0; i < size; i++) {
                TreeNode *cur = que.front();
                que.pop();
                sum += cur->val;
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
            result.push_back(sum / size);
        }
        return result;
    }
};

429# N叉树的层序遍历

题目链接

// 迭代法--队列
// O(n) 14ms; O(n) 15.7MB
/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> result;
        queue<Node*> que;
        if (root == nullptr) return result;
        que.push(root);
        while (!que.empty()) {
            vector<int> vec;
            int size = que.size();
            for (int i = 0; i < size; i++) {
                Node *cur = que.front();
                vec.push_back(cur->val);
                que.pop();
                for (Node *child : cur->children) que.push(child);
            }
            result.push_back(vec);
        }
        return result;
    }
};

515# 在每个树行中找最大值

题目链接

// 层序遍历
// O(n) 0ms; O(n) 22.41MB
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;
        if (root == nullptr) return result;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            int max = INT_MIN;
            for (int i = 0; i < size; i++) {
                TreeNode *cur = que.front();
                max = max > cur->val ? max : cur->val;
                que.pop();
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
            result.push_back(max);
        }
        return result;
    }
};

116# 填充每个节点的下一个右侧节点指针

题目链接

// 层序遍历
// O(n) 16ms; O(n) 19.0MB
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root == nullptr) return root;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                Node *cur = que.front();
                que.pop();
                if (i == size - 1) cur->next = nullptr;
                else cur->next = que.front();
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
        }
        return root;
    }
};

117# 填充每个节点的下一个右侧节点指针 II

题目链接

与上题代码相同（是否为完美二叉树不影响代码逻辑）

// 层序遍历
// O(n) 7ms; O(n) 18.52MB
class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root == nullptr) return root;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                Node *cur = que.front();
                que.pop();
                if (i == size - 1) cur->next = nullptr;
                else cur->next = que.front();
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
        }
        return root;
    }
};

104# 二叉树的最大深度

题目链接

// 递归法
// O(n) 0ms; O(n) 18.61MB
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};

// 层序遍历
// O(n) 0ms; O(n) 18.68MB
class Solution {
public:
    int maxDepth(TreeNode* root) {
        int depth = 0;
        queue<TreeNode*> que;
        if (root == nullptr) return depth;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode *cur = que.front();
                que.pop();
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
        }
        return depth;
    }
};

111# 二叉树的最小深度

题目链接

注意：叶子节点需要左右孩子都为空

// 层序遍历
// O(n) 0ms; O(n) 143.41MB
class Solution {
public:
    int minDepth(TreeNode* root) {
        int depth = 0;
        queue<TreeNode*> que;
        if (root == nullptr) return depth;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode *cur = que.front();
                que.pop();
                if (!cur->left && !cur->right) return depth;
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
        }
        return depth;
    }
};

补充知识：递归

推荐教学视频：快速掌握递归

  • 确定问题，即函数参数和返回值
  • 解决基准问题，确定终止条件
  • 拆解问题，寻找规模更小的子问题，确定单层递归逻辑

每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中

栈溢出，系统输出的异常是Segmentation fault，考虑是否是无限递归导致

汉诺塔

void hanoi(int n, char F, char A, char T) {
	if (n = 1) {
		printf("move %d from %c to %c\n", n, F, T);
		return;
	}
	
	hanoi(n-1, F, T, A);
	printf("move %d from %c to %c\n", n, F, T);
	hanoi(n-1, A, F, T);
}

本文参考 LeetCode官方题解 及 代码随想录

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Hugging Face GGUF 模型可视化

Hugging Face GGUF 模型可视化

Hugging Face GGUF 模型可视化 1. Finding GGUF files (检索 GGUF 模型)2. Viewer for metadata & tensors info (可视化 GGUF 模型)References 无知小儿&#xff0c;仙家雄霸天下&#xff0c;依附强者才是唯一的出路。否则天地虽大&#xff0c;也让你们无路可走&#xff0…
阅读更多...
基于Coze平台实现抖音链接提取文案转小红书文案的智能体开发全流程解析

基于Coze平台实现抖音链接提取文案转小红书文案的智能体开发全流程解析

文章目录 引言：跨平台内容运营的AI解法实例最终效果1. 平台特性对比与转化需求分析1.1 用户画像与内容风格对比1.2 文案转化核心需求2. Coze平台技术架构解析2.1 Coze核心能力矩阵2.2 关键技术组件选型3. 智能体工作流设计3.1 完整处理流程3.2 关键节点说明4. 核心模块实现详解…
阅读更多...
【低功耗 Power 学习专栏 -- Power domian 和 power rail】

【低功耗 Power 学习专栏 -- Power domian 和 power rail】

文章目录 power rail(followpin) 和 Power domain1. Power Domain2. Power Rail3. Followpin4. Power Stripe5. IR Drop芯片中电源管理设计 举例 power rail(followpin) 和 Power domain followpin 指两部分&#xff0c;一个就是 STD cell 上下的 VDD, VSS。同时&#xff0c;f…
阅读更多...
PopupMenuButton组件的功能和用法

PopupMenuButton组件的功能和用法

文章目录 1 概念介绍2 使用方法3 示例代码 我们在上一章回中介绍了Sliver综合示例相关的内容&#xff0c;本章回中将介绍PopupMenuButton组件.闲话休提&#xff0c;让我们一起Talk Flutter吧。 1 概念介绍 我们在本章回中介绍的PopupMenuButton组件位于AppBar右侧&#xff0c;…
阅读更多...
TiDB 分布式数据库多业务资源隔离应用实践

TiDB 分布式数据库多业务资源隔离应用实践

导读 随着 TiDB 在各行业客户中的广泛应用 &#xff0c;特别是在多个业务融合到一套 TiDB 集群中的场景&#xff0c;各企业对集群内多业务隔离的需求日益增加。与此同时&#xff0c;TiDB 在多业务融合场景下的资源隔离方案日趋完善&#xff0c;详情可参考文章 《你需要什么样的…
阅读更多...
CommonAPI学习笔记-2

CommonAPI学习笔记-2

一. 概述 ​ 这篇文章主要是想整理并且分析CommonAPI代码生成工具根据fidl和fdepl配置文件生成出来的代码的结构和作用。 二. fidl ​ 用户根据业务需求在fidl文件中定义业务服务接口的结构以及自定义数据类型&#xff0c;然后使用core生成工具传入fidl文件生成该fidl的核心…
阅读更多...
ELK模块封装starter

ELK模块封装starter

文章目录 1.combinations-elk-starter1.目录结构2.log4j2-spring.xml 从环境变量读取host和port3.ELKProperties.java 两个属性4.ELKAutoConfiguration.java 启用配置类5.ELKEnvironmentPreparedListener.java 监听器从application.yml中获取属性值6.spring.factories 注册监听…
阅读更多...
KNN算法：从思想到实现（附代码）

KNN算法：从思想到实现（附代码）

引言 K最近邻算法&#xff08;K Nearest Neighbors, KNN&#xff09;是一种简单而有效的机器学习算法&#xff0c;用于分类和回归问题。其核心思想基于“近朱者赤&#xff0c;近墨者黑”&#xff0c;即通过测量不同特征值之间的距离来进行分类或预测数值。本文将详细介绍KNN的…
阅读更多...
学前端框架之前，你需要先理解 MVC

学前端框架之前，你需要先理解 MVC

MVC 软件架构设计模式鼎鼎大名&#xff0c;相信你已经听说过了&#xff0c;但你确定自己已经完全理解到 MVC 的精髓了吗&#xff1f; 如果你是新同学&#xff0c;没听过 MVC&#xff0c;那可以到网上搜一些文章来看看&#xff0c;不过你要有心理准备&#xff0c;那些文章大多都…
阅读更多...
第十八章 视图

第十八章 视图

目录 一、概述 二、语法 2.1. 创建视图 2.2. 查询视图 2.3. 修改视图 2.4. 删除视图 2.5. 示例 三、检查选项 3.1. CASCADED&#xff08;级联&#xff09; 3.2. LOCAL&#xff08;本地&#xff09; 四、视图的更新 五、视图作用 5.1. 简单 5.2. 安全 5.3. 数据独…
阅读更多...
【MySQL】第一弹---MySQL 在 Centos 7环境安装

【MySQL】第一弹---MySQL 在 Centos 7环境安装

✨个人主页&#xff1a; 熬夜学编程的小林 &#x1f497;系列专栏&#xff1a; 【C语言详解】 【数据结构详解】【C详解】【Linux系统编程】【MySQL】 目录 1. 卸载不要的环境 2. 检查系统安装包 3. 卸载这些默认安装包 4. 获取mysql官方yum源 5. 安装mysql yum 源&am…
阅读更多...
实验2 词法分析(一)

实验2 词法分析(一)

实验2 词法分析(一) [实验目的]&#xff1a; 1 . 熟悉给定的词法分析程序&#xff1b; 2 . 改进词法分析程序。 [实验内容]&#xff1a; 1.运行TESE编译演示.exe&#xff0c;观看词法分析程序的分析过程&#xff0c;理解词法分析的原理。并尝试在“TEST源程序输入框”输入一段…
阅读更多...
【PyQt】PyQt工具栏

【PyQt】PyQt工具栏

PyQt工具栏 在 PyQt 中创建工具栏主要涉及 QMainWindow、QToolBar 和 QAction 类 界面展示 基本示例 import sys from PyQt5.QtWidgets import QMainWindow, QApplication, QAction from PyQt5.QtGui import QIcon from PyQt5.QtCore import Qtclass MainWindow(QMainWindow…
阅读更多...
STM32 串口收发数据包

STM32 串口收发数据包

接线图 HEX数据包接收 文本数据包接收 代码配置 发送HEX数据包 //存储发送或接收的载荷数据 uint8_t TX_Packet[4]; uint8_t RX_Packet[4];void Serial_SendPacket(void) {Serial_SendByte(0xFF);//发送包头Serial_SendArray(TX_Packet, 4);//发送4个载荷数据Serial_SendByte…
阅读更多...
zabbix5.0.46版本源码安装

zabbix5.0.46版本源码安装

zabbix5.0.46版本源码安装 1.安装环境说明 本例中安装zabbix开源软件和zabbix运行所需的中间件和数据库apache、php和flyingdb&#xff0c;软件版本信息如下&#xff1a; 软件版本zabbix5.0.46apachehttpd-2.4.61aprapr-1.7.5apr-util1.6.3php7.3.24PostgreSQL16.6 主机操作…
阅读更多...
[Android] IKTV专享版

[Android] IKTV专享版

[Android] IKTV专享版 链接&#xff1a;https://pan.xunlei.com/s/VOILXXuEd3ASo93c88UW79sxA1?pwd4tsw# 2025年2月最新免费K歌神器&#xff01;家庭KTV软件&#xff0c;手机平板电视盒子电脑都可用
阅读更多...
【OS】AUTOSAR架构下的Interrupt详解（下篇）

【OS】AUTOSAR架构下的Interrupt详解（下篇）

目录 3.代码分析 3.1中断配置代码 3.2 OS如何找到中断处理函数 3.3 Os_InitialEnableInterruptSources实现 3.4 Os_EnableInterruptSource 3.5 DisableAllInterrupts 3.5.1Os_IntSuspendCat1 3.5.2 Os_InterruptDisableAllEnter 3.5.3 Disable二类中断 3.5.4 Disable一…
阅读更多...
flutter 专题四十七 Flutter 应用启动流程分析

flutter 专题四十七 Flutter 应用启动流程分析

众所周知&#xff0c;任何应用程序的启动都是从main()函数开始的&#xff0c;Flutter也不例外&#xff0c;main.dart文件的main函数开始的&#xff0c;代码如下。 void main() > runApp(MyApp());main函数则调用的是runApp函数&#xff0c;源码如下。 void runApp(Widget …
阅读更多...
html中的表格属性以及合并操作

html中的表格属性以及合并操作

表格用table定义&#xff0c;标签标题用caption标签定义&#xff1b;用tr定义表格的若干行&#xff1b;用td定义若干个单元格&#xff1b;&#xff08;当单元格是表头时&#xff0c;用th标签定义&#xff09;&#xff08;th标签会略粗于td标签&#xff09; table的整体外观取决…
阅读更多...
大语言模型轻量化：知识蒸馏的范式迁移与工程实践

大语言模型轻量化：知识蒸馏的范式迁移与工程实践

大语言模型轻量化&#xff1a;知识蒸馏的范式迁移与工程实践 &#x1f31f; 嗨&#xff0c;我是LucianaiB&#xff01; &#x1f30d; 总有人间一两风&#xff0c;填我十万八千梦。 &#x1f680; 路漫漫其修远兮&#xff0c;吾将上下而求索。 摘要 在大型语言模型&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023