C++ 二叉树进阶：相关习题解析

news2024/11/27 2:45:52

目录

1. 二叉树创建字符串。

2. 二叉树的分层遍历1

3. 二叉树的分层遍历2

4. 二叉树的最近公共祖先

5. 将二叉搜索树转换为排序的双向链表

6. 从前序与中序遍历序列构造二叉树

7. 从中序与后序遍历序列构造二叉树

8.  二叉树的前序遍历，非递归迭代实现 

9. 二叉树的中序遍历，非递归迭代实现

10. 二叉树的后序遍历，非递归迭代实现

1. 二叉树创建字符串。

. - 力扣（LeetCode）

  • 初始化字符串并处理空树情况：

    • 定义一个空字符串str用于存储结果。
    • 首先检查输入的根节点是否为nullptr，如果是，则直接返回空字符串。

  • 处理非空根节点：

    • 如果根节点不为空，将根节点的值转换为字符串并添加到str中。
    • 然后检查左子树是否存在：
      • 如果左子树存在（root->left不为nullptr），在str中添加左括号(，递归调用tree2str处理左子树，并将结果添加到str中，最后再添加右括号)。
      • 如果左子树不存在但右子树存在（root->left为nullptr但root->right不为nullptr），在str中添加()，以表示左子树为空但右子树存在。
    • 接着检查右子树是否存在：
      • 如果右子树存在（root->right不为nullptr），在str中添加左括号(，递归调用tree2str处理右子树，并将结果添加到str中，最后再添加右括号)。
class Solution {
public:
    string tree2str(TreeNode* root) 
    {
        string str = "";
        if(root == nullptr) 
            return str;
        str += to_string(root->val);
        if(root->left) 
        {
            str += '(';
            str += tree2str(root->left);
            str += ')';
        }
        else if(root->right)
        {
            str += "()";
        }
        if(root->right)
        {
            str += '(';
            str += tree2str(root->right);
            str += ')';
        } 
        return str;
    }
};

2. 二叉树的分层遍历1

. - 力扣（LeetCode）

二叉树的层序遍历，多了一个条件，把每一层都存放在一个二维动态数组中，主要是控制每一层的个数，然后放入vector中，在把每个vector放入vector的vector中。

层序遍历：依靠队列来实现，当访问根的时候，出根节点，然后把该节点的左右节点分别入队，记住这里队列存储的是二叉树节点的指针，而不是该节点的值，这是因为在遍历的过程中，需要访问左右子节点。

遍历过程：当从队列中取出一个节点的时候，通过 front->val 获取该节点的值并存储在临时vector中

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) 
    {
        queue<TreeNode*> q;
        vector<vector<int>> vv;
        if(root)
            q.push(root);
        while(!q.empty()) 
        {
            int levelSize = q.size();
            vector<int> v;
            for(int i = 0; i< levelSize; ++i) 
            {
                TreeNode* front = q.front();
                q.pop();
                v.push_back(front->val);
                if(front->left)
                    q.push(front->left);
                if(front->right)
                    q.push(front->right);
            }
           vv.push_back(v);
        }
        return vv;
    }
};

3. 二叉树的分层遍历2

. - 力扣（LeetCode）

 该题和二叉树的分层遍历1是一样的，只需要把最后的存储在二维动态数组中的值逆序

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) 
    {
        vector<vector<int>> vv;
        queue<TreeNode*> q;
        if(root)
            q.push(root);
        while(!q.empty()) 
        {
            vector<int> v;
            int leveSize = q.size();
            for(int i = 0; i< leveSize; ++i) 
            {
                TreeNode* front = q.front();
                q.pop();
                v.push_back(front->val);
                if(front->left) 
                {
                    q.push(front->left);
                }
                if(front->right) 
                {
                    q.push(front->right);
                }
            }
            vv.push_back(v);
        }
        reverse(vv.begin(),vv.end());
        return vv;
    }
};

4. 二叉树的最近公共祖先

. - 力扣（LeetCode）

一、公共祖先的特征总结

  1. 当节点 p 是节点 q 的孩子时，当前节点就是祖先，反之亦然。这是因为在二叉树中，如果一个节点是另一个节点的直接子节点，那么它们的共同祖先就是父节点。
  2. 当 p 和 q 分别在当前节点的左右子树中时，当前节点就是它们的祖先。这是因为从根节点开始向下遍历，只有当两个节点分别位于不同子树时，当前节点才是它们的最低公共祖先。

二、情况 1：二叉搜索树

  • 条件 a：
    • 如果一个节点的值比当前节点小，另一个节点的值比当前节点大，那么当前节点就是它们的祖先。这是因为二叉搜索树的特性是左子树节点的值小于根节点的值，右子树节点的值大于根节点的值。所以当两个节点分别位于当前节点的两侧时，当前节点必然是它们的最低公共祖先。
    • 例如，在一个二叉搜索树中，当前节点值为 10，p节点值为 5，q节点值为 15，那么当前节点就是 p 和 q 的最低公共祖先。
  • 条件 b：
    • 如果两个节点的值都比当前节点小，那么递归到左子树中去找祖先。因为二叉搜索树的特性，值小的节点必然在左子树中。
    • 同理，如果两个节点的值都比当前节点大，那么递归到右子树中去找祖先。
    • 例如，当前节点值为 10，p 节点值为 5，q 节点值为 8，那么需要在当前节点的左子树中继续查找它们的最低公共祖先。

三、情况 2：三叉链

在三叉链的情况下，类似于链表找交点问题。

四、情况 3：普通二叉树(该题目对应的情况)

  • 条件 a：
  • 当一个节点在当前节点的左子树，另一个节点在当前节点的右子树时，当前节点就是它们的祖先。这与公共祖先的特征一致，因为在普通二叉树中，没有特定的大小关系，只能通过遍历整个树来确定最低公共祖先。
  • 例如，在一个普通二叉树中，当前节点有左子树和右子树，p 在左子树中，q 在右子树中，那么当前节点就是 p 和 q 的最低公共祖先。
  • 条件 b：
    • 如果两个节点都在左子树，递归到左子树中查找；如果两个节点都在右子树，递归到右子树中查找。这是因为在普通二叉树中，没有特定的顺序，只能通过逐步遍历子树来确定最低公共祖先。
    • 例如，当前节点有左子树和右子树，p 和 q 都在左子树中，那么需要在当前节点的左子树中继续查找它们的最低公共祖先。

方法一：

这种方法比较直观，先判断节点是否在树中，然后再根据节点的位置来确定最低公共祖先

class Solution {
public:
    bool Find(TreeNode* root,TreeNode* x) 
    {
        if(root == nullptr)
            return false;
        return root == x || Find(root->left,x) || Find(root->right,x);
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
    {
       // 1,先看根节点是不是祖先
        if(root == nullptr || root == p || root == q)
            return root;
        bool pInLeft, pInRight, qInLeft, qInRight;
        pInLeft =  Find(root->left, p);
        pInRight = !pInLeft;
        qInLeft = Find(root->left,q);
        qInRight = !qInLeft;
        if((pInLeft && qInRight) || (qInLeft && pInRight)) 
            return root;
        if(pInLeft && qInLeft) 
           return lowestCommonAncestor(root->left,p,q);
        if(pInRight && qInRight) 
           return lowestCommonAncestor(root->right,p,q);
        return nullptr;
    }
};

 方法二：

先看根是不是和 p 或者 q 中一个相等，如果不是相等，

假设在左子树中找到了 p，在右子树中找到没有找到，右子树这边返回 nullptr， 所以左子树这边的值就是最近公共祖先。反之亦然。

如果一个在左边，一个在右边都有返回值，直接返回根。 

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
    {
        // 1. 先看根节点是不是祖先
        if (root == NULL || root == p || root == q) 
            return root;
        // 2. 如果根节点是祖先，有没有更近的祖先呢
        // 看看左子树
        struct TreeNode* left = lowestCommonAncestor(root->left, p, q);
        // 看看右子树
        struct TreeNode* right = lowestCommonAncestor(root->right, p, q);
        // 3. 如果有的话显然只会在一侧 判断一下
        if (left == NULL) 
            return right;
        if (right == NULL) 
            return left;
        // 4. 如果没有更近的，默认还是返回root
        return root;
    }
};

接下来顺便把二叉搜索树的最近公共祖先这个题目也完成了，思路一样

. - 力扣（LeetCode）

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

5. 将二叉搜索树转换为排序的双向链表

. - 力扣（LeetCode）

  • 链接中间关系（步骤①）
    • 二叉搜索树的中序遍历（左 - 根 - 右）会产生一个有序的节点序列。在converList函数中，通过递归实现中序遍历。在遍历过程中，当处理每个节点时，利用一个引用参数prev来连接节点。例如，当prev不为nullptr时，prev - > right = cur和cur - > left = prev这两个操作就把当前节点cur和之前的节点prev双向连接起来。这样就按照中序遍历的顺序逐步构建了链表的中间部分。
  • 找头节点和尾节点（步骤②）
    • 由于中序遍历的第一个节点是最左节点，所以遍历二叉树找到最左节点作为链表的头节点是合理的。从逻辑上来说，这个最左节点在二叉搜索树中是值最小的节点。同样，在找到头节点后，通过不断地沿着节点的右指针移动，最终可以找到最右节点，它将作为链表的尾节点。
  • 返回头节点（步骤③）
    • 因为头节点是中序遍历的第一个节点，而中序遍历是升序排列节点值的，所以这个头节点的值是整个链表（也就是原来二叉搜索树中序遍历后的节点序列）中的最小值。返回头节点就可以作为整个循环双向链表的起始点，方便后续对链表进行操作。
class Solution {
public:
    void converList(Node* cur, Node*& prev) 
    {
        if(cur == nullptr) 
            return;
        converList(cur->left,prev);
        if(prev)
            prev->right = cur;
        cur->left = prev;
        prev = cur;
        converList(cur->right,prev);
    } 
    Node* treeToDoublyList(Node* root) 
    {
        Node* prev  = nullptr;
        converList(root,prev);
        Node* head = root;
        while(head && head->left)
            head = head->left;
        if(head == nullptr)
            return head;
        Node* tail = head;
        while(tail && tail->right) 
            tail =  tail->right;
        head->left = tail;
        tail->right = head;
        return head;
    }
};

6. 从前序与中序遍历序列构造二叉树

. - 力扣（LeetCode）

 这个题目理解起来有一点抽象，画图结合代码理解就可以了。

一、解题关键

  1. 前序遍历的特点是先访问根节点，然后是左子树，最后是右子树。所以前序遍历结果中的第一个元素一定是整棵树的根节点。
  2. 中序遍历的特点是先访问左子树，然后是根节点，最后是右子树。通过在中序遍历中找到根节点的位置，可以确定左子树和右子树的元素范围。

二、构建步骤

  1. 首先，从前往后取前序遍历结果中的第一个元素，创建一个新的节点作为当前子树的根节点。
  2. 然后，在中序遍历结果中找到这个根节点的值，以确定左子树和右子树的范围。
    • 在中序遍历中，根节点左边的元素构成左子树，右边的元素构成右子树。
  3. 接着，对于左子树：
    • 根据确定的左子树范围，在前序遍历结果中找到对应左子树的起始位置（在前序遍历中，根节点后面的一段连续元素是左子树的前序遍历结果）。
    • 递归调用构建函数，传入左子树的前序遍历和中序遍历结果以及对应的范围，构建左子树，并将构建好的左子树连接到根节点的left指针上。
  4. 对于右子树：
    • 类似地，确定右子树在前序遍历中的起始位置（在前序遍历中，左子树部分之后的连续元素是右子树的前序遍历结果）。
    • 递归调用构建函数，传入右子树的前序遍历和中序遍历结果以及对应的范围，构建右子树，并将构建好的右子树连接到根节点的right指针上。
  5. 重复以上步骤，直到所有子树都构建完成。

class Solution {
public:
    TreeNode* _buildTree(vector<int>& preorder,vector<int>& inorder,int& prei,int inbegin,int inend)
    {
        if(inbegin > inend)
            return nullptr;
        TreeNode* root  = new TreeNode(preorder[prei]);
        int rooti = inbegin;
        while(rooti <= inend)
        {
            if(preorder[prei] == inorder[rooti])
                break;
            else   
                ++rooti;
        }
        // [inbein,rooi-1] rooti [rooti+1,inend]
        if(inbegin <= rooti-1)
            root->left  = _buildTree(preorder,inorder, ++prei,inbegin,rooti-1);
        else
            root->left = nullptr;
        if(rooti + 1 <= inend) 
            root->right =  _buildTree(preorder,inorder, ++prei,rooti+1,inend);
        else
            root->right = nullptr;
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) 
    {
        int prei = 0;
        int inbegin = 0, inend = inorder.size()-1;
        return _buildTree(preorder,inorder,prei,inbegin,inend);
    }
};

7. 从中序与后序遍历序列构造二叉树

. - 力扣（LeetCode）

 注意点：

  1. 中序和后序遍历构建二叉树的情况
    • 在通过中序和后序遍历构建二叉树时，后序遍历的顺序是 “左 - 右 - 根”。当构建右子树时，--end操作是为了更新后序遍历的索引，使其指向右子树的最后一个节点（在构建右子树的递归调用中）。因为后序遍历的特性，一旦处理完根节点（也就是当前正在构建的节点），下一个节点要么是右子树的根节点（如果有右子树），要么是左子树的根节点（如果没有右子树）。在构建右子树后，end已经指向了左子树的最后一个节点，不需要额外的--end操作就可以正确地开始构建左子树。
  2. 中序和前序遍历构建二叉树的情况（推测你这里的prev是类似prei用于前序遍历索引）
    • 前序遍历的顺序是 “根 - 左 - 右”。在构建二叉树的递归过程中，每次构建一个子树时，需要先处理根节点，然后是左子树，最后是右子树。当构建左子树时，++prei操作是为了将索引移动到左子树的根节点（在前序遍历序列中）。而在构建右子树时，同样需要++prei操作来将索引移动到右子树的根节点，因为前序遍历序列中左子树节点之后才是右子树节点。这是由于前序遍历的顺序决定的，需要不断更新索引来按照正确的顺序获取子树的根节点。
class Solution {
public:
    TreeNode* _buildTree(vector<int>& inorder, vector<int>& postorder, int& end, int inbegin, int inend) {
        if (inbegin > inend) 
            return nullptr;
        TreeNode* root = new TreeNode(postorder[end]);
        int rooti = inbegin;
        while (rooti <= inend) {
            if (inorder[rooti] == postorder[end]) 
                break;
            else 
                ++rooti;
        }
        root->right = _buildTree(inorder, postorder, --end, rooti + 1, inend);
        root->left = _buildTree(inorder, postorder, end, inbegin, rooti - 1);
        return root;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int end = postorder.size() - 1;
        return _buildTree(inorder, postorder, end, 0, inorder.size() - 1);
    }
};

8.  二叉树的前序遍历，非递归迭代实现 

. - 力扣（LeetCode）

 一、递归写法

class Solution 
{
public:
    void _preorderTraversal(TreeNode* root, vector<int>& v) 
    {
        if(root == nullptr)
            return;
        v.push_back(root->val);
        _preorderTraversal(root->left,v);
        _preorderTraversal(root->right,v);
    }
    vector<int> preorderTraversal(TreeNode* root) 
    {
        vector<int> ret;
        _preorderTraversal(root,ret);
        return ret;
    }
};

 二、非递归写法

  • 整体过程
    • 创建一个空的结果向量ret用于存储遍历结果。
    • 创建一个栈st用于辅助遍历。
    • 使用一个指针cur指向当前正在处理的节点。
  • 进入循环，只要当前节点不为空或者栈不为空，就继续循环。
    • 第一个内部while循环用于遍历左子树：
      • 只要当前节点cur不为空，就将其值加入结果 ret，表示访问了该节点（先访问根节点）。
      • 将当前节点压入栈中，为后续访问右子树做准备。
      • 将当前节点指向其左子树，继续遍历左子树。
    • 当左子树遍历完后，当前节点cur为空，此时从栈中弹出一个节点top，这个节点是上一个被访问的节点的父节点。
    • 将当前节点cur指向弹出节点的右子树，进行下一轮循环，开始遍历右子树。

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) 
    {
        vector<int> ret;
        stack<TreeNode*> st;
        TreeNode * cur = root;
        while(cur || !st.empty()) 
        {
            //1、先访问树的左路节点
            //2、再访问左路节点的左子树
            while(cur)
            {
                ret.push_back(cur->val);
                st.push(cur); //为了访问右子树
                cur = cur->left;
            }
            //取栈中的左路节点的右子树出来访问
            TreeNode* top = st.top();
            st.pop();   
            cur = top->right;  //迭代
        }
        return ret;
    }
};

9. 二叉树的中序遍历，非递归迭代实现

. - 力扣（LeetCode）

与前序遍历类似，就存在一些细微的不同，就是访问顺序。(唯一变化的就是访问节点的时机)

左路节点先不访问，只入栈，然后访问根，再访问左路节点的右子树。

右子树通过迭代的方式再分成左路节点和左路节点的右子树的方式访问。

1、左路节点(入栈)
2、取栈中的节点，(访问节点+访问节点的右子树)

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) 
    {
        vector<int> ret;
        stack<TreeNode*> st;
        TreeNode* cur =  root;
        while(cur || !st.empty()) 
        {
            //1、左路节点入栈，先不能访问(中序)
            while(cur)
            {
                st.push(cur);
                cur = cur->left;
            }
            //2、取出栈中节点，访问和节点的右子树
            TreeNode* top = st.top();
            st.pop();
            ret.push_back(top->val);
            cur =  top->right;
        }
        return ret;
    }
};

10. 二叉树的后序遍历，非递归迭代实现

. - 力扣（LeetCode）

还是一样的，只不过访问的时机不一样

左路节点的访问，所以还需要加一个条件：右为空可以访问，右访问过了，也可以访问

通过一个指针 lastNode 记录上一次访问的节点，以确定何时处理当前节点。如果不加这个指针处理，就是重复拿到栈中的左路节点的值

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) 
    {
        vector<int> ret;
        TreeNode* cur = root;
        TreeNode* lastNode = nullptr;
        stack<TreeNode*> st;
        while(cur || !st.empty()) 
        {
            while(cur) 
            {
                st.push(cur);
                cur = cur->left;
            }
            TreeNode* top = st.top();
            if(top->right == nullptr || lastNode == top->right) 
            {
                ret.push_back(top->val);
                lastNode = top;
                st.pop();
            } 
            else 
            {
                cur = top->right;
            }
        }
        return ret;
    }
};

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

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

相关文章

结合Intel RealSense深度相机和OpenCV来实现语义SLAM系统

结合Intel RealSense深度相机和OpenCV来实现语义SLAM系统

结合Intel RealSense深度相机和OpenCV来实现语义SLAM系统是一个非常强大的组合。以下是一个详细的步骤指南&#xff0c;帮助你构建这样一个系统。 硬件准备 Intel RealSense深度相机&#xff1a;例如D415、D435或L515。计算平台&#xff1a;一台具有足够计算能力的计算机&…
阅读更多...
“前端兼容——CSS篇”（进阶版）

“前端兼容——CSS篇”（进阶版）

“前端兼容——CSS篇”&#xff08;进阶版&#xff09; 上一篇文章写了css 兼容问题处理的基础篇 点击这里基础篇—传送门&#xff0c;这里想给粉丝分享一下css 更深一点的兼容场景&#xff0c;和处理方案 文章目录 “前端兼容——CSS篇”&#xff08;进阶版&#xff09;进阶CS…
阅读更多...
【GIT】Visual Studio 中 Git 界面中， 重置 和 还原

【GIT】Visual Studio 中 Git 界面中， 重置 和 还原

在 Visual Studio 的 Git 界面中&#xff0c;“重置” 和 “还原” 是两个常用的 Git 操作。它们的主要区别在于应用场景和影响范围。 1. 重置&#xff08;Reset&#xff09; 重置用于更改当前分支的提交历史&#xff0c;通常用于撤销或删除某些提交。重置操作可能会更改 Git…
阅读更多...
leetcode - 684. 冗余连接

leetcode - 684. 冗余连接

684. 冗余连接 解决思路 大致上的思路就是将元素加入到 并查集 中&#xff0c;那么在遍历到边的时候先去判断的边的两个端点的 根节点 是否相等&#xff0c;如果相等&#xff0c;那么就代表此刻把这条边加上去就形成了环【可以这么理解&#xff0c;如果形成了环&#xff0c;那…
阅读更多...
汽车IVI中控OS Linux driver开发实操（二十六）：i.MX图形库

汽车IVI中控OS Linux driver开发实操（二十六）：i.MX图形库

概述： 下表列出了整个GPU系列，在i.MX 6板上，只有6Quad和6QuadPlus支持OpenCL。表中还显示了OpenCL的关键性能指标GFLOPS的理论数量。一些基准测试，如Clpeak，可用于验证它。 i.MX G2D API G2D应用程序编程接口（API）设计为易于理解和使用2DBit blit（BLT）功能。它允许用…
阅读更多...
自适应阻抗案例分析（上）

自适应阻抗案例分析（上）

案例分析一 Duchaine,V.,Gosselin,C.(2009).Safe,stable and intuitive control for physical human-robot interaction.In IEEE international conference on robotics and automation,2009.ICRA09(pp.3383-3388).IEEE. 主要贡献 1.利用外力反馈调整阻尼系数&#xff0c;同…
阅读更多...
sql进阶篇

sql进阶篇

1.更新记录 AC&#xff1a; update examination_info set tag replace(tag, "PYTHON", "Python") where tag "PYTHON";2.删除记录 AC&#xff1a; DELETE FROM exam_record WHERE timestampdiff(minute, start_time, submit_time) < 5AND…
阅读更多...
RustRover加载Rust项目报错

RustRover加载Rust项目报错

问题描述&#xff1a; 昨天还可以正常使用的RustRover今天打开Rust项目一直报错&#xff1a; warning: spurious network error (3 tries remaining): [7] Couldnt connect to server (Failed to connect to 127.0.0.1 port 51342 after 105750 ms: Couldnt connect to server…
阅读更多...
Vue 权限管理

Vue 权限管理

vue 中&#xff0c;比较常见的需要进行权限管控的权限控制实现思路有四条&#xff1a;、 菜单的控制 在登录请求中&#xff0c;会得到权限数据&#xff0c;当然&#xff0c;这个需要后端返回数据的支持&#xff0c;前端根据权限数据&#xff0c;展示对应的菜单&#xff0c;单…
阅读更多...
三十二、2024年交通管理专业知识测试题

三十二、2024年交通管理专业知识测试题

你还在为自己的学习发愁吗？你还在为你还在为自己面对枯燥无味的教科书、一层层叠叠的试卷复习而发呆吗？如何提高的学习兴趣，如何摆脱枯燥乏味的书本和试卷，采用一种全新的方式去努力复习功课、增进知识呢，如何激自己的学习热情，接触更广阔的知识面，争取在期末考试中考出…
阅读更多...
国际版同城服务同城信息任务发布平台系统小程序源码

国际版同城服务同城信息任务发布平台系统小程序源码

国际版同城服务同城信息任务发布平台系统&#x1f30d;&#x1f4e2;&#xff1a;连接世界的每一个角落 &#x1f310; 开篇&#xff1a;跨越国界的同城服务 在这个全球化的时代&#xff0c;我们不再局限于自己的城市&#xff0c;而是渴望与世界每一个角落建立联系。为了满足…
阅读更多...
Docker 命令指南：详细概述与示例应用

Docker 命令指南：详细概述与示例应用

Docker 命令指南&#xff1a;详细概述与示例应用 Docker 是一个强大的容器化平台&#xff0c;为容器的创建、管理和运行提供了广泛的支持。通过 Docker 的命令行工具&#xff0c;用户可以从基本的镜像管理、容器操作到复杂的网络和数据存储管理执行各种任务。本节将详细介绍 D…
阅读更多...
【问题记录】解决VMware虚拟机中鼠标侧键无法使用的问题

【问题记录】解决VMware虚拟机中鼠标侧键无法使用的问题

前言 有项目需要在Linux系统中开发&#xff0c;因为要测试Linux中相关功能&#xff0c;要用到shell&#xff0c;在Windows中开发太麻烦了&#xff0c;因此我选择使用UbuntuXfce4桌面来开发&#xff0c;这里我用到了Linux版本的IDEA&#xff0c;除了快捷键经常和系统快捷键冲突…
阅读更多...
【vue3|第29期】Vue3中的插槽：实现灵活的组件内容分发

【vue3|第29期】Vue3中的插槽：实现灵活的组件内容分发

日期&#xff1a;2024年10月24日 作者&#xff1a;Commas 签名&#xff1a;(ง •_•)ง 积跬步以致千里,积小流以成江海…… 注释&#xff1a;如果您觉在这里插入代码片得有所帮助&#xff0c;帮忙点个赞&#xff0c;也可以关注我&#xff0c;我们一起成长&#xff1b;如果有不…
阅读更多...
【Linux系统编程】第三十九弹---探索信号处理的奥秘：阻塞信号与sigset_t的深入剖析及实战

【Linux系统编程】第三十九弹---探索信号处理的奥秘：阻塞信号与sigset_t的深入剖析及实战

✨个人主页&#xff1a; 熬夜学编程的小林 &#x1f497;系列专栏&#xff1a; 【C语言详解】 【数据结构详解】【C详解】【Linux系统编程】 目录 1、信号处理 2、阻塞信号 2.1、信号其他相关常见概念 2.2、在内核中的表示 2.3、sigset_t 2.4、信号集操作函数 3、完整…
阅读更多...
IDEA解决 properties 文件乱码问题

IDEA解决 properties 文件乱码问题

博主介绍&#xff1a; 计算机科班人&#xff0c;全栈工程师&#xff0c;掌握C、C#、Java、Python、Android等主流编程语言&#xff0c;同时也熟练掌握mysql、oracle、sqlserver等主流数据库&#xff0c;具有丰富的项目经验和开发技能。提供相关的学习资料、程序开发、技术解答、…
阅读更多...
三款护眼台灯测评推荐：书客、松下、米家护眼台灯好用吗？

三款护眼台灯测评推荐：书客、松下、米家护眼台灯好用吗？

最近护眼台灯非常火&#xff0c;赶上儿子需要换一个学习台灯&#xff0c;于是我开始仔细研究护眼台灯怎么挑&#xff0c;刚好选了三款市面上认可度比较高的三款护眼台灯进行全面详细的护眼测评&#xff0c;书客、松下、米家护眼台灯好用吗&#xff1f;我们通过外观设计、光谱结…
阅读更多...
虚拟机桥接模式连不上，无法进行SSH等远程操作

虚拟机桥接模式连不上，无法进行SSH等远程操作

说明&#xff1a;以下情况在window10上遇到&#xff0c;解决后顺便做了个笔记&#xff0c;以防后续再次用到&#xff0c;也给同道中人提供一个解决方案 一、首先按照以下步骤进行检查 1、是否连接了对应的wifi 2、是否设置了桥接模式 3、上述1、2确认无误的情况下请查看右上…
阅读更多...
filebeat+elasticsearch+kibana日志分析

filebeat+elasticsearch+kibana日志分析

1 默认配置 1.1 filebeat filebeat-7.17.yml,从网关中下载k8s的配置&#xff0c;指定es和kibana的配置 通过kibana查询可以查询到日志了&#xff0c;但此时还不知道具体怎么用。 1.2 kibana 在Discover中创建索引格式&#xff1a;filebeat-*&#xff0c;得到如下图&#xf…
阅读更多...
HTML练习题:彼岸的花(web)

HTML练习题:彼岸的花(web)

展示效果: 代码: <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><title>彼岸の花</title><style…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023