【优选算法之队列+宽搜/优先级队列】No.14--- 经典队列+宽搜/优先级队列算法

文章目录

  • 前言
  • 一、队列+宽搜示例：
    • 1.1 N 叉树的层序遍历
    • 1.2 ⼆叉树的锯⻮形层序遍历
    • 1.3 ⼆叉树最⼤宽度
    • 1.4 在每个树⾏中找最⼤值
  • 二、优先级队列（堆）示例：
    • 2.1 最后⼀块⽯头的重量
    • 2.2 数据流中的第 K ⼤元素
    • 2.3 前 K 个⾼频单词
    • 2.4 数据流的中位数

前言

在这里插入图片描述

👧个人主页：@小沈YO.
😚小编介绍：欢迎来到我的乱七八糟小星球🌝
📋专栏：优选算法
🔑本章内容：队列+宽搜/优先级队列
记得 评论📝 +点赞👍 +收藏😽 +关注💞哦~

一、队列+宽搜示例：

1.1 N 叉树的层序遍历

  1. 题⽬链接：429. N 叉树的层序遍历
  2. 题⽬描述：
    在这里插入图片描述
  3. 解法：
    算法思路：
    层序遍历即可~
    仅需多加⼀个变量，⽤来记录每⼀层结点的个数就好了。
  4. C++代码
/*
// 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>> vv;
        vector<int> v;
        if(root==nullptr)return vv;
        queue<Node*> q;
        q.push(root);
        while(!q.empty())
        {
            int sz=q.size();//统计本层节点个数
            while(sz--)
            {
                Node* tmp=q.front();
                v.push_back(tmp->val);
                q.pop();
                for(auto&e:tmp->children)//逐次加入孩子节点
                {
                    if(e!=nullptr)
                    q.push(e);
                }
            }
            vv.push_back(v);
            v.clear();
        }
        return vv;
    }
};

1.2 ⼆叉树的锯⻮形层序遍历

  1. 题⽬链接：103. ⼆叉树的锯⻮形层序遍历
  2. 题⽬描述：
    在这里插入图片描述
  3. 解法（层序遍历）：
    算法思路：
    在正常的层序遍历过程中，我们是可以把⼀层的结点放在⼀个数组中去的。
    既然我们有这个数组，在合适的层数逆序就可以得到锯⻮形层序遍历的结果。
  4. C++代码
/**
 * 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>> zigzagLevelOrder(TreeNode* root) 
    {
        vector<vector<int>> vv;
        vector<int> v;
        if(root==nullptr)return vv;
        int cnt=0;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            cnt++;
            int sz=q.size();
            while(sz--)
            {
                TreeNode* tmp=q.front();
                q.pop();
                v.push_back(tmp->val);
                if(tmp->left!=nullptr)q.push(tmp->left);
                if(tmp->right!=nullptr)q.push(tmp->right);
            }
            if(cnt%2==0)reverse(v.begin(),v.end());
            vv.push_back(v);
            v.clear();
        }
        return vv;
    }
};

1.3 ⼆叉树最⼤宽度

  1. 题⽬链接：662. ⼆叉树最⼤宽度
  2. 题⽬描述：
    在这里插入图片描述
  3. 解法（层序遍历）：
    算法思路：
  • 第⼀种思路（会超过内存限制）：
    既然统计每⼀层的最⼤宽度，我们优先想到的就是利⽤层序遍历，把当前层的结点全部存在队列⾥⾯，利⽤队列的⻓度来计算每⼀层的宽度，统计出最⼤的宽度。但是，由于空节点也是需要计算在内的。因此，我们可以选择将空节点也存在队列⾥⾯。
    这个思路是我们正常会想到的思路，但是极端境况下，最左边⼀条⻓链，最右边⼀条⻓链，我们需要存⼏亿个空节点，会超过最⼤内存限制。
  • 第⼆种思路（利⽤⼆叉树的顺序存储 - 通过根节点的下标，计算左右孩⼦的下标）：
    依旧是利⽤层序遍历，但是这⼀次队列⾥⾯不单单存结点信息，并且还存储当前结点如果在数组中存储所对应的下标（在我们学习数据结构 - 堆的时候，计算左右孩⼦的⽅式）。这样我们计算每⼀层宽度的时候，⽆需考虑空节点，只需将当层结点的左右结点的下标相减再加 1 即可。
    但是，这⾥有个细节问题：如果⼆叉树的层数⾮常恐怖的话，我们任何⼀种数据类型都不能存下下标的值。但是没有问题，因为
    • 我们数据的存储是⼀个环形的结构；
    • 并且题⽬说明，数据的范围在 int 这个类型的最⼤值的范围之内，因此不会超出⼀圈；
    • 因此，如果是求差值的话，我们⽆需考虑溢出的情况。
  1. C++代码
/**
 * 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:
    int widthOfBinaryTree(TreeNode* root) 
    {
        queue<pair<TreeNode*,unsigned int>> q;
        q.push(make_pair(root,1));
        unsigned int cnt=0;
        while(!q.empty())
        {
            int sz=q.size();
            cnt=max(q.back().second-q.front().second+1,cnt);
            while(sz--)
            {
                TreeNode* tmp=q.front().first;
                unsigned int ret=q.front().second;
                q.pop();
                if(tmp->left!=nullptr)
                {
                    q.push(make_pair(tmp->left,2*ret));
                }
                if(tmp->right!=nullptr)
                {
                    q.push(make_pair(tmp->right,2*ret+1));
                }
            }
        }
        return cnt;
    }
};
--------------------------------------------------------------------------------------------
//用数组模拟队列
/**
 * 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:
    int widthOfBinaryTree(TreeNode* root) 
    {
        vector<pair<TreeNode*,unsigned int>> v;
        v.push_back({root,1});
        unsigned int cnt=0;
        while(v.size())
        {
            auto&[x1,y1]=v[0];
            auto&[x2,y2]=v.back();
            cnt=max(cnt,y2-y1+1);
            vector<pair<TreeNode*,unsigned int>> tmp;
            for(auto&[x,y]:v)
            {
                if(x->left)tmp.push_back({x->left,2*y});
                if(x->right)tmp.push_back({x->right,2*y+1});
            }
            v=tmp;
        }
        return cnt;
    }
};

1.4 在每个树⾏中找最⼤值

  1. 题⽬链接：515. 在每个树⾏中找最⼤值
  2. 题⽬描述：
    在这里插入图片描述
  3. 解法（bfs）：
    算法思路：
    层序遍历过程中，在执⾏让下⼀层节点⼊队的时候，我们是可以在循环中统计出当前层结点的最⼤值的。
    因此，可以在 bfs 的过程中，统计出每⼀层结点的最⼤值。
  4. C++代码
/**
 * 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<int> largestValues(TreeNode* root) 
    {
        vector<int> v;
        if(root==nullptr)return v;
        queue<TreeNode*> q;
        q.push(root);
        int maxnum=INT_MIN;
        while(!q.empty())
        {
            int sz=q.size();
            while(sz--)
            {
                TreeNode* tmp=q.front();
                maxnum=max(maxnum,tmp->val);
                q.pop();
                if(tmp->left)
                    q.push(tmp->left);
                if(tmp->right)
                    q.push(tmp->right);
            }
            v.push_back(maxnum);
            maxnum=INT_MIN;
        }
        return v;
    }
};

二、优先级队列（堆）示例：

2.1 最后⼀块⽯头的重量

  1. 题⽬链接：1046. 最后⼀块⽯头的重量
  2. 题⽬描述：
    在这里插入图片描述
  3. 解法（利⽤堆）：
    算法思路：
    其实就是⼀个模拟的过程：
    • 每次从⽯堆中拿出最⼤的元素以及次⼤的元素，然后将它们粉碎；
    • 如果还有剩余，就将剩余的⽯头继续放在原始的⽯堆⾥⾯
    重复上⾯的操作，直到⽯堆⾥⾯只剩下⼀个元素，或者没有元素（因为所有的⽯头可能全部抵消了）
    那么主要的问题就是解决：
    • 如何顺利的拿出最⼤的⽯头以及次⼤的⽯头；
    • 并且将粉碎后的⽯头放⼊⽯堆中之后，也能快速找到下⼀轮粉碎的最⼤⽯头和次⼤⽯头；
    这不正好可以利⽤堆的特性来实现嘛？
    • 我们可以创建⼀个⼤根堆；
    • 然后将所有的⽯头放⼊⼤根堆中；
    • 每次拿出前两个堆顶元素粉碎⼀下，如果还有剩余，就将剩余的⽯头继续放⼊堆中；
    这样就能快速的模拟出这个过程。
  4. C++代码
class Solution {
public:
    struct cmp
    {
        bool operator()(int t1,int t2)
        {
            return t1<t2;
        }
    };
    int lastStoneWeight(vector<int>& stones) 
    {
        //priority_queue<int,vector<int>,less<int>> pq;
        priority_queue<int,vector<int>,cmp> pq;
        for(auto&e:stones)
        pq.push(e);
        while(pq.size()>1)
        {
            int tmp1=pq.top();
            pq.pop();
            int tmp2=pq.top();
            pq.pop();
            int tmp=abs(tmp1-tmp2);
            if(tmp==0&&!pq.empty())continue;
            pq.push(tmp);
        }
        return pq.top();
    }
};

2.2 数据流中的第 K ⼤元素

  1. 题⽬链接：703. 数据流中的第 K ⼤元素

  2. 题⽬描述：
    在这里插入图片描述

  3. 解法（优先级队列）：
    算法思路：
    我相信，看到 TopK 问题的时候，兄弟们应该能⽴⻢想到「堆」，这应该是刻在⻣⼦⾥的记忆。

  4. C++代码

class KthLargest {
    priority_queue<int,vector<int>,greater<int>> pq;
    int _k;
public:
    KthLargest(int k, vector<int>& nums) 
    {
        _k=k;
        for(auto&e:nums)
        {
            pq.push(e);
            if(pq.size()>_k)pq.pop();
        }
    }
    
    int add(int val) 
    {
        pq.push(val);
        if(pq.size()>_k)pq.pop();
        return pq.top();
    }
};

/**
 * Your KthLargest object will be instantiated and called as such:
 * KthLargest* obj = new KthLargest(k, nums);
 * int param_1 = obj->add(val);
 */

2.3 前 K 个⾼频单词

  1. 题⽬链接：692. 前 K 个⾼频单词
  2. 题⽬描述：
    在这里插入图片描述
  3. 解法（堆）：
    算法思路：
    • 稍微处理⼀下原数组：
    a. 我们需要知道每⼀个单词出现的频次，因此可以先使⽤哈希表，统计出每⼀个单词出现的频次；
    b. 然后在哈希表中，选出前 k ⼤的单词（为什么不在原数组中选呢？因为原数组中存在重复的单词，哈希表⾥⾯没有重复单词，并且还有每⼀个单词出现的频次）
    • 如何使⽤堆，拿出前 k ⼤元素：
    a. 先定义⼀个⾃定义排序，我们需要的是前 k ⼤，因此需要⼀个⼩根堆。但是当两个字符串的频次相同的时候，我们需要的是字典序较⼩的，此时是⼀个⼤根堆的属性，在定义⽐较器的时候需要注意！
    ▪ 当两个字符串出现的频次不同的时候：需要的是基于频次⽐较的⼩根堆
    ▪ 当两个字符串出现的频次相同的时候：需要的是基于字典序⽐较的⼤根堆
    b. 定义好⽐较器之后，依次将哈希表中的字符串插⼊到堆中，维持堆中的元素不超过 k 个；
    c. 遍历完整个哈希表后，堆中的剩余元素就是前 k ⼤的元素
  4. C++代码
class Solution {
    typedef pair<string,int> PII;
public:
    struct cmp
    {
        bool operator()(const PII& p1,const PII& p2)
        {
            if(p1.second==p2.second)
            return p1.first<p2.first;// 频次相同，字典序按照⼤根堆的⽅式排列
            return p1.second>p2.second;
        }
    };
    vector<string> topKFrequent(vector<string>& words, int k) 
    {
        priority_queue<PII,vector<PII>,cmp> pq;
        vector<string> v(k);
        unordered_map<string,int> hash;
        for(auto&e:words)hash[e]++;
        for(auto&e:hash)
        {
            pq.push(e);
            if(pq.size()>k)pq.pop();
        }
        for(int i=k-1;i>=0;i--)
        {
            v[i]=pq.top().first;
            pq.pop();
        }
        return v;
    }
};

2.4 数据流的中位数

  1. 题⽬链接：295. 数据流的中位数
  2. 题⽬描述：
    在这里插入图片描述
  3. 解法（利⽤两个堆）：
    算法思路：
    这是⼀道关于「堆」这种数据结构的⼀个「经典应⽤」。
    我们可以将整个数组「按照⼤⼩」平分成两部分（如果不能平分，那就让较⼩部分的元素多⼀个），较⼩的部分称为左侧部分，较⼤的部分称为右侧部分：
    • 将左侧部分放⼊「⼤根堆」中，然后将右侧元素放⼊「⼩根堆」中；
    • 这样就能在 O(1) 的时间内拿到中间的⼀个数或者两个数，进⽽求的平均数。
    如下图所⽰：
    在这里插入图片描述

于是问题就变成了「如何将⼀个⼀个从数据流中过来的数据，动态调整到⼤根堆或者⼩根堆中，并且保证两个堆的元素⼀致，或者左侧堆的元素⽐右侧堆的元素多⼀个」为了⽅便叙述，将左侧的「⼤根堆」记为 left ，右侧的「⼩根堆」记为 right ，数据流中来的「数据」记为 x 。
其实，就是⼀个「分类讨论」的过程：

  • 如果左右堆的「数量相同」， left.size() == right.size() ：
    a. 如果两个堆都是空的，直接将数据 x 放⼊到 left 中；
    b. 如果两个堆⾮空：
    i. 如果元素要放⼊左侧，也就是 x <= left.top() ：那就直接放，因为不会影响我们制定的规则；
    ii. 如果要放⼊右侧
    • 可以先将 x 放⼊ right 中，
    • 然后把 right 的堆顶元素放⼊ left 中 ；
  • 如果左右堆的数量「不相同」，那就是 left.size() > right.size() ：
    a. 这个时候我们关⼼的是 x 是否会放⼊ left 中，导致 left 变得过多：
    i. 如果 x 放⼊ right 中，也就是 x >= right.top() ，直接放；
    ii. 反之，就是需要放⼊ left 中：
    • 可以先将 x 放⼊ left 中，
    • 然后把 left 的堆顶元素放⼊ right 中 ；
    只要每⼀个新来的元素按照「上述规则」执⾏，就能保证 left 中放着整个数组排序后的「左半部分」， right 中放着整个数组排序后的「右半部分」，就能在 O(1) 的时间内求出平均数。
  1. C++代码
class MedianFinder 
{
    priority_queue<int,vector<int>,less<int>> left;//大根堆
    priority_queue<int,vector<int>,greater<int>> right;//小根堆
public:
    MedianFinder() 
    {}
    
    void addNum(int num) 
    {
        int n=left.size(),m=right.size();
        if(n==m)
        {
            if(!left.empty()&&num>left.top())
            {
                right.push(num);
                left.push(right.top());
                right.pop();
            }
            else left.push(num);
        }
        else if(n>m)
        {
            if(num<=left.top())
            {
                right.push(left.top());
                left.pop();
                left.push(num);
            }
            else right.push(num);
        }
    }
    
    double findMedian() 
    {
        if(left.size()==right.size())
        return (left.top()+right.top())/2.0;
        else return left.top();
    }
};

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder* obj = new MedianFinder();
 * obj->addNum(num);
 * double param_2 = obj->findMedian();
 */

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

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

相关文章

Android车载——VehicleHal初始化（Android 11）

Android车载——VehicleHal初始化（Android 11）

1 概述 VehicleHal是AOSP中车辆服务相关的hal层服务。它主要定义了与汽车硬件交互的标准化接口和属性管理&#xff0c;是一个独立的进程。 2 进程启动 VehicleHal相关代码在源码树中的hardware/interfaces/automotive目录下 首先看下Android.bp文件&#xff1a; cc_binary …
阅读更多...
Maven的生命周期与依赖作用域介绍

Maven的生命周期与依赖作用域介绍

说明&#xff1a;本文介绍Maven的生命周期&#xff0c;以及在pom.xml文件中每个依赖&#xff08;dependency标签内&#xff09;scope标签的内容。 Maven生命周期 在IDEA项目中&#xff0c;右侧边栏&#xff0c;点Maven&#xff0c;可以看到以下生命周期。 其中&#xff0c; c…
阅读更多...
Spring MVC 常用注解

Spring MVC 常用注解

目录 基础概念 常用注解介绍 基础概念 1、MVC &#xff1a;代表一种软件架构设计思想&#xff0c;通俗的理解&#xff1a;客户端发送请求到后台服务器的Controller(C)&#xff0c;控制器调用Model(M)来处理业务逻辑&#xff0c;处理完成后&#xff0c;返回处理后的数据到Vie…
阅读更多...
Deformable Transformer论文笔记

Deformable Transformer论文笔记

原文链接 [2010.04159] Deformable DETR: Deformable Transformers for End-to-End Object Detection (arxiv.org)https://arxiv.org/abs/2010.04159 原文笔记 What 作者结合了可变形卷积的稀疏空间采样和 Transformer 的关系建模能力的优点。提出了Deformable Detr Defor…
阅读更多...
文心一言 VS 讯飞星火 VS chatgpt （359）-- 算法导论24.3 1题

文心一言 VS 讯飞星火 VS chatgpt （359）-- 算法导论24.3 1题

一、在图 24-2上运行Dijkstra算法&#xff0c;第一次使用结点 s s s作为源结点&#xff0c;第二次使用结点 z z z作为源结点。以类似于图 24-6 的风格&#xff0c;给出每次while循环后的 d d d值和 π π π值&#xff0c;以及集合 S S S中的所有结点。如果要写代码&#xff0c…
阅读更多...
CSRF | GET 型 CSRF 漏洞攻击

CSRF | GET 型 CSRF 漏洞攻击

关注这个漏洞的其他相关笔记&#xff1a;CSRF 漏洞 - 学习手册-CSDN博客 0x01&#xff1a;GET 型 CSRF 漏洞攻击 —— 理论篇 GET 型 CSRF 漏洞是指攻击者通过构造恶意的 HTTP GET 请求&#xff0c;利用用户的登录状态&#xff0c;在用户不知情的情况下&#xff0c;诱使浏览器…
阅读更多...
PCIe配置篇（1）——如何进行配置操作（一）

PCIe配置篇（1）——如何进行配置操作（一）

一、功能的唯一标识——BDF 首先我们简单回顾一下总线&#xff08;Bus&#xff09;、设备&#xff08;Device&#xff09;、功能&#xff08;Function&#xff09;这几个概念&#xff1a; 功能&#xff08;function&#xff09;&#xff1a;是PCI设备中独立的功能单元&#xff…
阅读更多...
【GitHub】上传文件到GitHub

【GitHub】上传文件到GitHub

参考视频&#xff1a;手把手教你在github上传文件_哔哩哔哩_bilibili 1.找到文件夹右键&#xff0c;选择open git bash here 2.完成指令 git initgit add *git commit -m "first commit"3.打开该文件夹&#xff0c;打开隐藏文件.git/config 编辑输入邮箱和GitHub用…
阅读更多...
OpenJudge | 置换选择排序

OpenJudge | 置换选择排序

总时间限制: 1000ms 内存限制: 65536kB 描述 给定初始整数顺串&#xff0c;以及大小固定并且初始元素已知的二叉最小堆&#xff08;为完全二叉树或类似完全二叉树&#xff0c;且父元素键值总小于等于任何一个子结点的键值&#xff09;&#xff0c;要求利用堆实现置换选择排序&a…
阅读更多...
【C++】--类和对象（2）

【C++】--类和对象（2）

&#x1f44c;个人主页: 起名字真南 &#x1f446;个人专栏:【数据结构初阶】 【C语言】 【C】 目录 1 类的默认成员函数2 构造函数3 析构函数4 拷贝构造5 赋值运算符重载5.1 运算符重载5.2 赋值运算符的重载 1 类的默认成员函数 默认成员函数就是用户没有显示实现&#xff0c;…
阅读更多...
【Kubernetes】常见面试题汇总（五十三）

【Kubernetes】常见面试题汇总（五十三）

目录 118. pod 状态为 ErrlmagePull &#xff1f; 119.探测存活 pod 状态为 CrashLoopBackOff &#xff1f; 特别说明&#xff1a; 题目 1-68 属于【Kubernetes】的常规概念题&#xff0c;即 “ 汇总&#xff08;一&#xff09;~&#xff08;二十二&#xff09;” 。…
阅读更多...
Bloom Filter 布隆过滤器

Bloom Filter 布隆过滤器

目录 简介 Bloom Filter的基本原理 实现 使用 HashFunc越多&#xff0c;性能越好吗&#xff1f; 如何尽量避免误判&#xff1f; 应用 布隆过滤器优点 简介 Bloom Filter是一种空间效率极高的概率数据结构&#xff0c;它用于测试一个元素是否属于集合。Bloom Filter的优…
阅读更多...
【NoSQL】portswigger NoSQL注入 labs 全解

【NoSQL】portswigger NoSQL注入 labs 全解

目录 NoSQL NoSQL 数据库模型 NoSQL 注入的类型 NoSQL 语法注入 检测 MongoDB 中的语法注入 lab1:检测 NoSQL 注入 NoSQL 运算符注入 提交查询运算符 检测 MongoDB 中的运算符注入 lab2:利用 NoSQL 运算符注入绕过身份验证 利用语法注入来提取数据 MongoDB 中的数据…
阅读更多...
【rust/egui/android】在android中使用egui库

【rust/egui/android】在android中使用egui库

文章目录 说在前面AndroidStudio安装编译安装运行问题 说在前面 操作系统&#xff1a;windows11java版本&#xff1a;23android sdk版本&#xff1a;35android ndk版本&#xff1a;22rust版本&#xff1a; AndroidStudio安装 安装AndroidStudio是为了安装sdk、ndk&#xff0c;…
阅读更多...
大数据实时数仓Hologres（三）：存储格式介绍

大数据实时数仓Hologres（三）：存储格式介绍

文章目录 存储格式介绍 一、格式 二、使用建议 三、技术原理 1、列存 2、行存 3、行列共存 四、使用示例 存储格式介绍 一、格式 在Hologres中支持行存、列存和行列共存三种存储格式，不同的存储格式适用于不同的场景。在建表时通过设置orientation属性指定表的存储…
阅读更多...
【重学 MySQL】五十三、MySQL数据类型概述和字符集设置

【重学 MySQL】五十三、MySQL数据类型概述和字符集设置

【重学 MySQL】五十三、MySQL数据类型概述和字符集设置 MySQL数据类型概述MySQL字符集设置注意事项 MySQL数据类型概述 MySQL是一个流行的关系型数据库管理系统&#xff0c;它支持多种数据类型&#xff0c;以满足不同数据处理和存储的需求。理解并正确使用这些数据类型对于提高…
阅读更多...
Linux性能调优技巧

Linux性能调优技巧

目录 前言1. CPU性能优化1.1 调整CPU调度策略1.2 合理分配多核处理 2. 内存性能优化2.1 调整内存分配策略2.2 缓存和分页优化 3. 磁盘I/O性能优化3.1 使用合适的I/O调度器3.2 磁盘分区和文件系统优化 4. 网络性能优化4.1 优化网络参数4.2 调整网络拥塞控制算法 5. 系统监控与优…
阅读更多...
【机器学习】网络安全——异常检测与入侵防御系统

【机器学习】网络安全——异常检测与入侵防御系统

我的主页&#xff1a;2的n次方_ 随着全球互联网和数字基础设施的不断扩展&#xff0c;网络攻击的数量和复杂性都在显著增加。从传统的病毒和蠕虫攻击到现代复杂的高级持续性威胁&#xff08;APT&#xff09;&#xff0c;网络攻击呈现出更加智能化和隐蔽化的趋势。面对这样的…
阅读更多...
Kotlin 处理字符串和正则表达式（二十一）

Kotlin 处理字符串和正则表达式（二十一）

导读大纲 1.1 处理字符串和正则表达式1.1.1 分割字符串1.1.2 正则表达式和三引号字符串1.1.3 多行三引号字符串IntelliJ IDEA 和 Android Studio 中三重引号字符串内部的语法高亮显示 1.1 处理字符串和正则表达式 Kotlin 字符串与 Java 字符串完全相同 可以将 Kotlin 代码中创建…
阅读更多...
Python_文件处理

Python_文件处理

一个完整的程序一般都包括数据的存储和读取&#xff1b;我们在前面写的程序数据都没有进行实际的存储&#xff0c;因此python解释器执行完数据就消失了。实际开发中&#xff0c;我们经常需要从外部存储介质&#xff08;硬盘、光盘、U盘等&#xff09;读取数据&#xff0c;或者将…
阅读更多...
最新文章

Copyright @ 2022~2023