C++ STL --stack 和queue,priority_queue

news2024/10/7 15:28:48

1. stack的介绍和使用

        1.1 stack的介绍

        https://cplusplus.com/reference/stack/stack/?kw=stack

翻译:

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。

2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。

3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下

操作：

empty：判空操作

back：获取尾部元素操作

push_back：尾部插入元素操作

pop_back：尾部删除元素操作

4. 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器， 默认情况下使用deque。

1.2 stack的使用 

        

 最小栈     z力扣

class MinStack {
 
public:
    stack<int> stk;
    stack<int> m_stk;
    MinStack() {
        m_stk.push(INT_MAX);
    }
    
    void push(int val) {
        stk.push(val);
        int minV=min(m_stk.top(),val);
        m_stk.push(minV);
         


    }
    
    void pop() {
        stk.pop();
        m_stk.pop();
    }
    
    int top() {
        return stk.top();
    }
    
    
    int getMin() {
        
        return m_stk.top();
   

   
    }



};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

栈的压入、弹出序列_牛客题霸_牛客网

逆波兰表达式求值     力扣

用栈实现队列  

1.3 stack的模拟实现 

从栈的接口中可以看出，栈实际是一种特殊的vector，因此使用vector完全可以模拟实现stack。

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

namespace myspace
{

    template <class T>
    class stack
    {
    public:
        stack() {}
        void push(const T &x)
        {
            _c.push_back(x);
        }

        void pop()
        {
            _c.pop_back();
        }

        T &top()
        {
            return _c.back();
        }

        const T &top() const
        {
            return _c.back();
        }

        size_t size() const
        {
            return _c.size();
        }

        bool empty() const
        {
            return _c.empty();
        }

    private:
        vector<T> _c;
    };

}

int main()
{

    system("pause");
    return 0;
}

2. queue的介绍和使用

        2.1 queue的介绍

         https://cplusplus.com/reference/queue/queue/

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。

2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的 成员函数来访问其元素。元素从队尾入队列，从队头出队列。

3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:

empty：检测队列是否为空

size：返回队列中有效元素的个数

front：返回队头元素的引用

back：返回队尾元素的引用

push_back：在队列尾部入队列

pop_front：在队列头部出队列

4. 标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。

2.2 queue的使用

         请课后练习下面的OJ题目：

力扣

2.3 queue的模拟实现

因为queue的接口中存在头删和尾插，因此使用vector来封装效率太低，故可以借助list来模拟实现queue，具体如下：

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;

namespace myspace
{

    template <class T>
    class queue
    {

    public:
        queue() {}
        void push(const T &x)
        {
            _c.push_back(x);
        }

        void pop()
        {
            _c.pop_front();
        }
        T &back()
        {
            return _c.back();
        }

        const T &back() const
        {
            return _c.back();
        }

        T &front()
        {
            return _c.front();
        }
        const T &front() const
        {
            return _c.front();
        }

        size_t size() const
        {
            return _c.size();
        }

        bool empty() const
        {
            return _c.empty();
        }

    private:
        list<T> _c;
    };

}

int main()
{
    myspace::queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);

    cout << q.front() << endl;
    q.pop();
    cout << q.front() << endl;
    cout << q.back() << endl;
    system("pause");
    return 0;
}

3.1 priority_queue的介绍和使用

        3.1 priority_queue的介绍

        https://cplusplus.com/reference/queue/priority_queue/

翻译：

1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。

2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。

3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。

4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭

代器访问，并支持以下操作：

empty()：检测容器是否为空

size()：返回容器中有效元素个数

front()：返回容器中第一个元素的引用

push_back()：在容器尾部插入元素

pop_back()：删除容器尾部元素

5. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。

6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

3.2 priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：默认情况下priority_queue是大堆。

1. 默认情况下，priority_queue是大堆。

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

void TestPriorityQueue()
{

    //默认是大堆
    vector<int> v{3, 2, 7, 6, 0, 4, 1, 9, 8, 5};
    priority_queue<int> q1;
    for (auto &e : v)
    {
        q1.push(e);
    }
    cout << q1.top() << endl;
    priority_queue<int, vector<int>, greater<int>> q2(v.begin(), v.end());
    cout << q2.top() << endl;
}

int main()
{
    TestPriorityQueue();
    system("pause");
    return 0;
}

2. 如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供> 或者< 的重载。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#include <queue>
class Date
{

public:
    Date(int year = 1900, int month = 1, int day = 1) : _year(year), _month(month), _day(day) {}

    bool operator<(const Date &d) const
    {
        return (_year < d._year) || (_year == d._year && _month < d._month) || (_year == d._year && _month == d._month && _day < d._day);
    }

    bool operator>(const Date &d) const
    {

        return (_year > d._year) || (_year == d._year && _month > d._month) || (_year == d._year && _month == d._month && _day > d._day);
    }

    friend ostream &operator<<(ostream &_cout, const Date &d);

private:
    int _year;
    int _month;
    int _day;
};

ostream &operator<<(ostream &_cout, const Date &d)
{

    _cout << d._year << " " << d._month << " " << d._day << endl;
    return _cout;
}

void TestPriority()
{
    // 大堆，需要用户在自定义类型中提供<的重载
    priority_queue<Date> q1;
    q1.push(Date(2019, 10, 19));
    q1.push(Date(2019, 10, 28));
    q1.push(Date(2018, 3, 4));
    q1.push(Date(2030, 2, 4));

    cout << q1.top() << endl;
    //小顶堆 需要用户的> 的重载
    priority_queue<Date, vector<Date>, greater<Date>> q2;

    q2.push(Date(2024, 2, 3));
    q2.push(Date(2033, 2, 3));
    q2.push(Date(2013, 4, 2));
    cout << q2.top() << endl;
}

int main()
{

    TestPriority();

    system("pause");
    return 0;
}

3.3 在OJ中的使用

  数组中的第K 个最大的元素        力扣

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {

        priority_queue<int> pq;

        for(int i=0;i<nums.size();i++){
            pq.push(nums[i]);
        }

        int j=1;
        while(j<k){
            pq.pop();
            j++;
        }

        return pq.top();

        //新的方法计算
        // sort(nums.begin(),nums.end(),greater<int>());
        // return nums[k-1];

        
    }
};

3.4 priority_queue的模拟实现

通过对priority_queue的底层结构就是堆，因此此处只需对对进行通用的封装即可。

        

#pragma once

#include <iostream>
using namespace std;

#include <vector>
// priority_queue--->堆
namespace bite
{
	template<class T>
	struct less
	{
		bool operator()(const T& left, const T& right)
		{
			return left < right;
		}
	};

	template<class T>
	struct greater
	{
		bool operator()(const T& left, const T& right)
		{
			return left > right;
		}
	};

	template<class T, class Container = std::vector<T>, class Compare = less<T>>
	class priority_queue
	{
	public:
		// 创造空的优先级队列
		priority_queue() : c() {}

		template<class Iterator>
		priority_queue(Iterator first, Iterator last)
			: c(first, last)
		{
			// 将c中的元素调整成堆的结构
			int count = c.size();
			int root = ((count - 2) >> 1);
			for (; root >= 0; root--)
				AdjustDown(root);
		}

		void push(const T& data)
		{
			c.push_back(data);
			AdjustUP(c.size() - 1);
		}

		void pop()
		{
			if (empty())
				return;

			swap(c.front(), c.back());
			c.pop_back();
			AdjustDown(0);
		}

		size_t size()const
		{
			return c.size();
		}

		bool empty()const
		{
			return c.empty();
		}

		// 堆顶元素不允许修改，因为：堆顶元素修改可以会破坏堆的特性
		const T& top()const
		{
			return c.front();
		}
	private:
		// 向上调整
		void AdjustUP(int child)
		{
			int parent = ((child - 1) >> 1);
			while (child)
			{
				if (Compare()(c[parent], c[child]))
				{
					swap(c[child], c[parent]);
					child = parent;
					parent = ((child - 1) >> 1);
				}
				else
				{
					return;
				}
			}
		}

		// 向下调整
		void AdjustDown(int parent)
		{
			size_t child = parent * 2 + 1;
			while (child < c.size())
			{
				// 找以parent为根的较大的孩子
				if (child + 1 < c.size() && Compare()(c[child], c[child + 1]))
					child += 1;

				// 检测双亲是否满足情况
				if (Compare()(c[parent], c[child]))
				{
					swap(c[child], c[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
					return;
			}
		}
	private:
		Container c;
	};
}

void TestQueuePriority()
{
	bite::priority_queue<int> q1;
	q1.push(5);
	q1.push(1);
	q1.push(4);
	q1.push(2);
	q1.push(3);
	q1.push(6);
	cout << q1.top() << endl;

	q1.pop();
	q1.pop();
	cout << q1.top() << endl;

	vector<int> v{ 5,1,4,2,3,6 };
	bite::priority_queue<int, vector<int>, bite::greater<int>> q2(v.begin(), v.end());
	cout << q2.top() << endl;

	q2.pop();
	q2.pop();
	cout << q2.top() << endl;
}

4. 容器适配器

4.1 什么是适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总 结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

        

4.2 STL标准库中stack和queue的底层结构

虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque，比如：

4.3 deque的简单介绍(了解) 

4.3.1 deque的原理介绍

deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图所示：

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落 在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示：

 那deque是如何借助其迭代器维护其假想连续的结构呢

4.3.2 deque的缺陷

与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必vector高的。与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。

但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。

4.4 为什么选择deque作为stack和queue的底层默认容器

stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性结构，都可以作为stack的底层容器，比如vector和list都可以；queue是先进先出的特殊线性数据结构，只要具有push_back和pop_front操作的线性结构，都可以作为queue的底层容器，比如list。但是STL中对stack和queue默认选择deque作为其底层容器，主要是因为：

1. stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作。

2. 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的元素增长时，deque不仅效率高，而且内存使用率高。 结合了deque的优点，而完美的避开了其缺陷。

4.5 STL标准库中对于stack和queue的模拟实现 

4.5.1 queue的模拟实现  

        

#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
using namespace std;

namespace myspace
{

    template <class T, class Con = deque<T>>

    class queue
    {

    public:
        queue() {}

        void push(const T &x)
        {
            _c.push_back(x);
        }

        void pop()
        {
            _c.pop_front();
        }

        T &front()
        {
            return _c.front();
        }

        const T &front() const
        {
            return _c.front();
        }

        T &back()
        {
            return _c.back();
        }

        const T &back() const
        {
            return _c.back();
        }

        size_t size() const
        {
            return _c.size();
        }

        bool empty() const
        {
            return _c.empty();
        }

    private:
        Con _c;
    };

}

void TestStack()
{

    myspace::queue<int> q1;
    q1.push(1);
    q1.push(2);
    q1.push(3);
    q1.push(4);

    q1.push(5);
    q1.push(6);
    cout << q1.front() << endl;
    cout << q1.back() << endl;
    q1.pop();
    cout << q1.empty() << endl;
}

int main()
{

    TestStack();

    system("pause");
    return 0;
}

 4.5.2 stack的模拟实现 

#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
using namespace std;

namespace myspace
{
    template <class T, class Con = deque<T>>
    class stack
    {

    public:
        stack() {}
        void push(const T &x)
        {
            _c.push_back(x);
        }

        void pop()
        {
            _c.pop_back();
        }

        T &top()
        {
            return _c.back();
        }

        const T &top() const
        {
            return _c.top();
        }

        size_t size() const
        {
            return _c.size();
        }

        size_t empty() const
        {
            return _c.empty();
        }

    private:
        Con _c;
    };

}

void TestStack()
{

    myspace::stack<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);

    cout << s.top() << endl;
    s.pop();
    cout << s.top() << endl;
}

int main()
{
    TestStack();
    system("pause");
    return 0;
}

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

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

相关文章

Arm MMU深度解读

Arm MMU深度解读

文章目录 一、MMU概念介绍二、虚拟地址空间和物理地址空间2.1、(虚拟/物理)地址空间的范围2.2、物理地址空间有效位(范围) 三、Translation regimes四、地址翻译/几级页表&#xff1f;4.1、思考&#xff1a;页表到底有几级&#xff1f;4.2、以4KB granule为例&#xff0c;页表的…
阅读更多...
java SSM农产品订购网站系统myeclipse开发mysql数据库springMVC模式java编程计算机网页设计

java SSM农产品订购网站系统myeclipse开发mysql数据库springMVC模式java编程计算机网页设计

一、源码特点 java SSM农产品订购网站系统是一套完善的web设计系统&#xff08;系统采用SSM框架进行设计开发&#xff0c;springspringMVCmybatis&#xff09;&#xff0c;对理解JSP java编程开发语言有帮助&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要采…
阅读更多...
[云原生] K8s之ingress

[云原生] K8s之ingress

1.Ingress的相关知识 1.1 Ingress的简介 service的作用体现在两个方面&#xff0c;对集群内部&#xff0c;它不断跟踪pod的变化&#xff0c;更新endpoint中对应pod的对象&#xff0c;提供了ip不断变化的pod的服务发现机制&#xff1b;对集群外部&#xff0c;他类似负载均衡器…
阅读更多...
STM32 学习11 独立看门狗与窗口看门狗

STM32 学习11 独立看门狗与窗口看门狗

STM32 学习11 独立看门狗与窗口看门狗 一、**看门狗概述**二、**STM32中的看门狗类型**1. 独立看门狗&#xff08;IWDG&#xff09;&#xff08;1&#xff09;基本概念&#xff08;2&#xff09;独立看门狗框图&#xff08;3&#xff09;独立看门狗配置步骤&#xff08;4&#…
阅读更多...
基于Java+SpringBoot+vue+element实现汽车订票管理平台详细设计和实现

基于Java+SpringBoot+vue+element实现汽车订票管理平台详细设计和实现

基于JavaSpringBootvueelement实现汽车订票管理平台详细设计和实现 博主介绍&#xff1a;多年java开发经验&#xff0c;专注Java开发、定制、远程、文档编写指导等,csdn特邀作者、专注于Java技术领域 作者主页 央顺技术团队 Java毕设项目精品实战案例《1000套》 欢迎点赞 收藏 …
阅读更多...
Django用户访问日志记录插件[django_user_visit 2.0]汉化

Django用户访问日志记录插件[django_user_visit 2.0]汉化

Django用户访问日志记录插件&#xff1a; django_user_visit汉化包 为了给用户显示中文&#xff0c;制作的汉化包&#xff0c;与原来版本区别仅仅是字符串 1&#xff1a;用户不同设备登录时&#xff0c;将会记录 2&#xff1a;用户与之前的ip不相同时&#xff0c;将会记录 3&am…
阅读更多...
每日OJ题_路径dp⑥_力扣174. 地下城游戏

每日OJ题_路径dp⑥_力扣174. 地下城游戏

目录 力扣174. 地下城游戏 解析代码 力扣174. 地下城游戏 174. 地下城游戏 难度 困难 恶魔们抓住了公主并将她关在了地下城 dungeon 的 右下角 。地下城是由 m x n 个房间组成的二维网格。我们英勇的骑士最初被安置在 左上角 的房间里&#xff0c;他必须穿过地下城并通过对…
阅读更多...
windows server 2019 服务器配置的方法步骤

windows server 2019 服务器配置的方法步骤

一、启用远程功能二、测试三、解决多用户登录的问题 一、启用远程功能 右键点击【此电脑】–【属性】&#xff0c;进入“【控制面板\系统和安全\系统】”&#xff0c;点击-【远程设置】(计算机找不到就使用【winE】快捷键) 2、在“远程桌面”下方&#xff0c;点击【允许远程连…
阅读更多...
【Stable Diffusion】入门：原理简介+应用安装（Windows）+生成步骤

【Stable Diffusion】入门：原理简介+应用安装（Windows）+生成步骤

【Stable Diffusion】入门&#xff1a;原理简介应用安装&#xff08;Windows&#xff09;生成步骤 原理简介应用安装 原理简介 稳定扩散生成模型(Stable Diffusion)是一种潜在的文本到图像扩散模型&#xff0c;能够在给定任何文本输入的情况下生成照片般逼真的图像。 应用安…
阅读更多...
安全信息化管理平台——数据分析与可视化

安全信息化管理平台——数据分析与可视化

在当今的信息化时代&#xff0c;数据分析与可视化已经成为各个领域中不可或缺的组成部分。对于企业而言&#xff0c;如何将安全信息进行整合、分析并直观地呈现出来&#xff0c;成为了一项至关重要的任务。这就催生了一种新型的管理平台——安全信息化管理平台。 数据分析&…
阅读更多...
大数据与云计算

大数据与云计算

目录 一、大数据时代二、云计算——大数据的计算三、云计算发展现状四、云计算实现机制五、云计算压倒性的成本优势 一、大数据时代 我们先来看看百度关于 “大数据”&#xff08;Big Data&#xff09;的搜索指数。 可以看出&#xff0c;“大数据” 这个词是从2012年才引起关注…
阅读更多...
UE5蓝图联机 客户端修改值后，服务器未得知值已修改

UE5蓝图联机 客户端修改值后，服务器未得知值已修改

修改变量的“复制”属性要选择以下这个。 目的是确保游戏状态中客户端和服务器已同步。 参考资料&#xff1a; 在Unreal Engine中&#xff0c;"复制"&#xff08;Replication&#xff09;是指确保游戏状态在网络中的多个客户端和服务器之间保持同步的过程。当你在游…
阅读更多...
《ElementPlus 与 ElementUI 差异集合》el-input 和 el-button 属性 size 有变化

《ElementPlus 与 ElementUI 差异集合》el-input 和 el-button 属性 size 有变化

差异 element-ui el-input 和 el-button 中&#xff0c;属性size 值是 medium / small / minielement-plus el-input 和 el-button 中&#xff0c;属性size 值是 ‘large’ | ‘default’ | ‘small’&#xff1b; 如果你是自动升级&#xff0c;Vue3 系统会有如下警告“ el-b…
阅读更多...
Flink 性能优化总结（反压优化篇）

Flink 性能优化总结（反压优化篇）

反压的理解 Flink 中每个节点间的数据都以阻塞队列的方式传输&#xff0c;下游来不及消费导致队列被占满后&#xff0c;上游的生产也会被阻塞&#xff0c;最终导致数据源的摄入被阻塞。简单来说就是系统接收数据的速率远高于它处理数据的速率。 反压如果不能得到正确的处理&am…
阅读更多...
Windows下IntelliJ IDEA远程连接服务器中Hadoop运行WordCount（详细版）

Windows下IntelliJ IDEA远程连接服务器中Hadoop运行WordCount（详细版）

使用IDEA直接运行Hadoop项目&#xff0c;有两种方式&#xff0c;分别是本地式&#xff1a;本地安装HadoopIDEA&#xff1b;远程式&#xff1a;远程部署Hadoop&#xff0c;本地安装IDEA并连接&#xff0c; 本文介绍第二种。 一、安装配置Hadoop (1)虚拟机伪分布式 见上才艺&a…
阅读更多...
【C++】反向迭代器仿函数模板进阶

【C++】反向迭代器仿函数模板进阶

反向迭代器&仿函数&模板进阶 一&#xff0c;反向迭代器1. 什么是反向迭代器2. 模拟实现3. 如何使用 二&#xff0c;仿函数1. 仿函数的概念2. 仿函数的用法 三&#xff0c;模板1. 非类型模板参数2. 模板的特化2.1 特化概念2.2 函数模板特化2.3 类模板特化2.3.1 全特化2.…
阅读更多...
借助 Terraform 功能协调部署 CI/CD 流水线-Part2

借助 Terraform 功能协调部署 CI/CD 流水线-Part2

在第一部分的文章中&#xff0c;我们介绍了3个步骤&#xff0c;完成了教程的基础配置&#xff1a; 使用 Terraform 创建 AWS EKS Infra在 EKS 集群上部署 ArgoCD 及其依赖项设置 Bitbucket Pipeline并部署到 ECR Repo 本文将继续完成剩余的步骤&#xff0c;以实现 Terraform 编…
阅读更多...
【2024金三银四】

【2024金三银四】

💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学习,不断总结,共同进步,活到老学到老导航 檀越剑指大厂系列:全面总结 jav…
阅读更多...
搭建mysql主从复制(主主复制)

搭建mysql主从复制(主主复制)

1&#xff1a;设主库允许远程连接(注意&#xff1a;设置账号密码必须使用的插件是mysql_native_password&#xff0c;其他的会连接失败) #切换到mysql这个数据库&#xff0c;修改user表中的host&#xff0c;使其可以实现远程连接 mysql>use mysql; mysql>update user se…
阅读更多...
Vue3全家桶 - VueRouter - 【3】嵌套路由【children】

Vue3全家桶 - VueRouter - 【3】嵌套路由【children】

嵌套路由【children】 如果在路由视图中展示的组件包含自己的路由占位符&#xff08;路由出口&#xff09;&#xff0c;则此处会用到嵌套路由&#xff1b;如图所示&#xff1a;点击关于链接&#xff0c;则会展示About组件&#xff0c;在其组件中又包含了路由链接和路由占位符&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023