自学C++ day07 stack && queue

最新推荐文章于 2024-07-12 10:56:01 发布
最新推荐文章于 2024-07-12 10:56:01 发布
阅读量128 收藏
点赞数
分类专栏： 学习笔记 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51262652/article/details/126182519
版权 
#include <iostream> 
#include <stack>
#include <vector>
#include <list> 
#include <queue>
#include <functional> // greater 算法头文件

// stack :
// stack() : 构造栈
// empty() : 检测栈是否为空
// size()  : 返回栈中元素个数
// top() : 返回栈顶元素的引用
// push() : 将元素val 压入stack中
// pop() : 将stak 中尾部元素弹出

// 最小栈!
#if 0
class MinStack {
public:
	void push(int x) {
		elem.push(x);
		if (min.empty() || x < min.top) {
			min.push(x);
		}
		else {
			min.push(min.top());
		}
	}

	void pop() {
		min.pop();
		elem.pop();
	}
	int top() {
		return elem.top();
	}
	int getMin() {
		return min.top();
	}
private:
	std::stack<int> elem;
	std::stack<int> min;

};
#endif 

// 栈的压入弹出序列
#if 0
class Solution {
public:
	bool IsPopOrder(std::vector<int> pushV, std::vector<int> popV) {
		std::stack<int> stack;
		int idx = 0;
		for (int val : pushV) {
			stack.push(val);
			while (!stack.empty() && popV[idx] == stack.top()) {
				stack.pop();
				idx++;
			}
		}
		return idx == popV.size();
	}
};

#endif 

// 逆波兰表达式求值
#if 0
class Solution {
public:
	int evalRPN(vector<string>& tokens) {
		std::stack<int> stack;
		for (auto& s : tokens) {
			if (!(s == "+" || "-" == s || "*" == s || "/" == s)) {
				stack.push(atoi(s.c_str()));
			}
			else {
				int l = stack.top();
				stack.pop();
				int r = stack.top();
				stack.pop();
				switch (s[0]) {
				case '+':stack.push(l + r); break;
				case '-':stack.push(r - l); break;
				case '*':stack.push(l*r); break;
				case '/':stack.push(r / l); break;
				}
			}
		}
		return stack.top();
	}
};
#endif 

// 两个栈实现队列
#if 0
class MyQueue {
public:
	MyQueue() {

	}
	void push(int x) {
		stk1.push(x);
	}

	int pop() {
		if (stk2.empty()) {
			while (!stk1.empty()) {
				stk2.push(stk1.top());
				stk1.pop();
			}
		}
		int pop = stk2.top();
		stk2.pop();
		return pop;
	}

	int peek() {
		if (stk2.empty()) {
			while (!stk1.empty()) {
				stk2.push(stk1.top());
				stk1.pop();
			}
		}
		return stk2.top();
	}

	bool empty() {
		return stk1.empty() && stk2.empty();
	}
private:
	std::stack<int> stk1;
	std::stack<int> stk2;
};
#endif 

// 栈的模拟实现 

namespace pz {
	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() { return _c.size(); }
		bool empty() { return _c.empty(); }

	private:
		std::vector<T> _c;
	};
}

// queue :
// 队列是一种容器适配器,专门用于在FIFO中操作;
// empty() : 检测队列是否为空
// size()  : 返回队列中有效元素的个数
// front() : 返回对头元素的引用;
// back() : 返回对尾元素的引用;
// push_back() : 在队列尾部如队列;
// pop_front() : 在对头部出队列;

// 队列模拟实现:
namespace pz {
	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() { 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:
		std::list<T> _c;
	};
}


// 用队列模拟实现栈
class MyStack {
public:
	void push(int x) {
		if (q1.empty() || q1.size() <= q2.size()) {
			q1.push(x);
			while (!q2.empty()) {
				q1.push(q2.front());
				q2.pop();
			}
		}
		else {
			q2.push(x);
			while (!q1.empty()) {
				q2.push(q1.front());
				q1.pop();
			}
		}
	}

	int pop() {
		int pop = -1;
		if (q1.empty()) {
			pop = q2.front();
			q2.pop();
		}
		else {
			pop = q1.front();
			q1.pop();
		}
		return pop;
	}

	int top() {
		if (q1.empty()) {
			return q2.front();
		}
		else {
			return q1.front();
		}
	}

	bool empty() {
		return q1.empty() && q2.empty();
	}
private:
	std::queue<int> q1;
	std::queue<int> q2;
};

// priority_queue : 优先队列;(默认是大顶堆,java默认是小堆)
// priority_queue() / priority_queue(first,last) : 构造一个空的优先队列!
// empty() : 检测优先队列是否为空
// top() : 返回优先队列的堆顶!
// push(x) : 在优先队列中插入元素x
// pop() : 删除堆顶!

void TestPrirortyQueue() {
	// 默认情况像创建的是大堆!
	std::vector<int>v{ 3,2,7,6,0,4,8,9,5 };
	std::priority_queue<int> q1;

	for (auto& e : v) {
		q1.push(e);
		std::cout << q1.top() << " ";
	}
	std::cout << std::endl;

	// 如果要创建小堆,将第三个模板参数换成greater比较方式
	std::priority_queue<int, std::vector<int>, std::greater<int>> q2(v.begin(), v.end());
	std::cout << q2.top() << std::endl;
}


class Date {
public:
	Date(int _year = 2022, int _month = 7, int _day = 19) :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 std::ostream& operator<< (std::ostream& _cout, const Date& d) {
		_cout << d.year << "-" << d.month << "-" << d.day << std::endl;
		return _cout;
	}
private:
	int year;
	int month;
	int day;
};

void TestPriorityQueue1() {
	// 大堆 需要类自定义类提供 < 重载!
	std::priority_queue<Date> q1;
	q1.push(Date(2019, 8, 27));
	q1.push(Date(2018, 8, 27));
	q1.push(Date(2015, 8, 27));
	std::cout << q1.top() << std::endl;

	// 小堆 需要自定义类提供 > 重载!
	std::priority_queue<Date, std::vector<Date>, std::greater<Date>> q2;
	q2.push(Date(2019, 8, 27));
	q2.push(Date(2018, 7, 27));
	q2.push(Date(2015, 6, 27));
	std::cout << q2.top() << std::endl;
}

#if 0
int main() {
	TestPrirortyQueue();
	TestPriorityQueue1();
	return 0;
}
#endif 

#if 0
// 模拟实现 priority_queue 
namespace pz {
	template<class T>
	struct less {
		bool operator()(const T& left, const T& right) {
			return letf < 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) {
			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() {
			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) {
			int 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;
	};
}
#endif 


// 容器适配器
// 适配器是一种设计模式,该模式是将一个类的接口转换成客户希望的零位一个接口

// stl 中 stack 和 queue 默认使用 deque;
// deque原理
// deque 是一种双开口的连续空间的数据结构!
// deque 并不是真正的连续空间,而是有一段段连续的小空间拼接而成,实际deque类似与一个动态的二维数组!

// 用deque 来模拟实现一波stack 和 queue 

#if 0
#include <deque>
namespace pz {
	template <class T,class Collection=std::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.back(); }
		size_t size() const { return c.size(); }
		bool empty() const { return c.empty(); }
	private:
		Collection c;
	};

	
	template<class T,class Collection=std::deque<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:
		Collection c;
	};

}
#endif ```
未尽余火
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++中stack、queue、vector的用法详解
08-29
C++中stack、queue、vector的用法详解 C++中stack、queue、vector是三个常用的容器类，分别用于实现栈、队列和向量的数据结构。本文将通过实例代码详细介绍stack、queue、vector的用法和常用方法。 一、栈（stack...
C++ STL容器stack和queue详解
09-01
C++ STL（Standard Template Library，标准模板库）提供了两种特殊的线性容器：stack（栈）和queue（队列），它们都是基于顺序容器（如vector或deque）实现的抽象数据类型，用于实现特定的数据操作逻辑。 **1. ...
C++ stack 和 queue 的笔记
02-22
C++ stack 和 queue 的笔记
数据结构教学课件：Chapter Three Stack & Queue.ppt
06-16
数据结构教学课件：Chapter Three Stack & Queue.ppt
初始C++
2302_81016149的博客
07-08 805
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
C++ 多态
wxk2227814847的博客
07-10 762
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
C++初探究（2）
Frenemy__的博客
07-09 1473
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 1012
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
C语言操作符详解
z317920的博客
07-11 533
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引
C++：CV::Point函数简介
Ethan_Rich的博客
07-08 451
cv::Point是 OpenCV 库中用于表示二维坐标系下点的一个基本数据类型。它提供了在图像处理、计算机视觉等领域中定位和操作点的能力。以下是关于cv::Point。
深入解析【C++ list 容器】：高效数据管理的秘密武器
小李很执着的博客
07-09 931
C++ 中的 list 容器是一个基于双向链表的序列式容器，适用于需要频繁插入和删除操作的场景，但不支持随机访问。list 提供了多种构造方法和丰富的操作接口，包括插入、删除、访问等。与 vector 相比，list 在插入和删除操作上更高效，但在随机访问和空间利用率上较差。
C++：哈希表
最新发布
m0_61088872的博客
07-12 415
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
Python的异常处理（与C++对比学习）
2302_76941579的博客
07-09 956
通过C++的基础来学习Python的异常处理
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
星羽空间
07-09 346
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
[C++]——同步异步日志系统（3）
plj521的博客
07-10 1531
从本篇开始，正式开始写同步异步日志系统
C++笔试强训3
m0_74189279的博客
07-09 710
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
C-10 凸包
qq_46348003的博客
07-08 212
计算凸包的代码
【C语言小知识】缓冲区
dab112的博客
07-06 840
主要讲解了缓冲区的概念
STL复习-序列式容器和容器适配器部分
bananawolf的博客
07-07 722
STL复习
stack&&与stack&的区别
05-26
`stack&&` 和 `stack&` 是 C++ 中的两种不同的指针类型，它们之间的区别在于： 1. `stack&&` 是右值引用类型，而 `stack&` 是左值引用类型。 2. 右值引用类型是 C++11 中引入的新特性，它可以绑定到临时对象（即将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值