【数据结构】栈、队列、堆总结

最新推荐文章于 2024-08-15 15:05:10 发布
最新推荐文章于 2024-08-15 15:05:10 发布
阅读量568 收藏 1
点赞数
分类专栏： 毕业生-必看系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dai_wen/article/details/81712239
版权
本文详细介绍了如何使用栈和队列实现各种数据结构操作，包括用栈实现队列、用队列实现栈、带有最小值的栈、合法的出栈序列判断、简单计算器的实现、求第K大数字以及寻找动态中位数的方法，通过具体的算法思想和程序实现，展示了数据结构在实际问题中的应用。
摘要由CSDN通过智能技术生成

零、基本操作##

/*栈的基本操作：*/
std::stack<int> s;
s.top();
s.push();
s.pop();
s.empty();
s.size();

/*队列的基本操作：*/
std::queue<int> q;
q.front();
q.push(x);
q.back();
q.pop();
q.empty();
q.size();
/*堆的基本操作*/
int main()
{
	std::priority_queue<int> big_heap;
	std::priority_queue<int,std::vector<int>,std::greater<int> >small_heap;//创建最小堆
	std::priority_queue<int,std::vector<int>,std::less<int> >big_heap2;//创建最大堆

	if(big_heap.empty())//判断堆是否为空
	{
		printf("big_heap is empty!!!\n");
	}

	int test[] = {6,10,1,7,99, 4,33};
	for(int i = 0;i< 7 ;i++)
	{
		big_heap.push(test[i]);//堆插入
	}

	printf("big_heap.top = %d\n",big_heap.top());//取堆顶元素
	big_heap.push(1000);
	printf("big_heap.top = %d\n ",big_heap.top());

	for(int  i =0; i<3; i++)
	{
		big_heap.pop();//删除堆顶
	}
	printf("big_heap.top = %d \n",big_heap.top());
	printf("big_heap.size = %d\n ",big_heap.size());//求堆中元素个数
	return 0;

}

一、用栈实现队列

**1.0题目：**设计一个队列，队列支持如下操作，这些操作的算法复杂度需要的是常数级，O(1),队列的内部存储数据结构的栈，栈的方法只能包括push(),top(),pop(),size(),empty(),等标准的栈方法；
**1.1算法思想：**使用一个临时栈，一个数据栈，先将所有元素入数据栈中，当数据栈不为空时，将数据栈中所有元素按顺序弹入临时栈，再将临时栈弹入数据栈即可。
1.2程序实现

#include<iostream>
#include<stack>
using namespace std;
class Myqueue
{
public:

	void push(int x)
	{
		std::stack<int> temp;
		while(!_data.empty())
		{
			temp.push(_data.top());
			_data.pop();
		}
		temp.push(x);
		while(!temp.empty())
		{
			_data.push(temp.top());
			temp.pop();
		}
	}
	
	int pop()
	{
		int x = _data.top();
		_data.pop();
		return x;
	}

	int front()
	{
		return _data.top();
	}

	bool empty()
	{
		return _data.empty();
	}

	std::stack<int> _data;
};



int main()
{
	Myqueue Q;
	Q.push(111);
	Q.push(222);
	Q.push(333);
	Q.push(444);
	Q.push(555);
	Q.push(666);
	Q.push(777);
	Q.push(888);
	printf("%d\n",Q.front());

	Q.pop();
	printf("%d\n",Q.front());

	Q.pop();
	Q.pop();
	Q.pop();
	printf("%d\n",Q.front());
	
	printf("%d\n",Q.empty());
	Q.pop();
	Q.pop();
	Q.pop();
	Q.pop();

	printf("%d\n",Q.empty());

	return 0;
}

1.3结果展示

二、用队列实现栈

2.0题目设计一个栈，支持如下操作，这些操作算法复杂度需要的时常数阶，O(1),栈的内部存储数据的结构为队列，队列的方法只能包括push()、peek()(front())、pop()、size(),empty()等标准的队列方法；
**2.1算法思想：**使用一个临时队列，一个数据队列，先将要遍历的某个元素入临时队列，再将数据队列中所有元素入临时队列，当临时队列不为空时，再将临时栈弹入数据栈即可。
2.2程序实现

#include<iostream>
#include<queue>
using namespace std;
class Mystack
{
public:
	void push(int x)
	{
		std::queue<int> temp;
		temp.push(x);
		while(!_data.empty())
		{
			temp.push(_data.front());
			_data.pop();
		}

		while(!temp.empty())
		{
			_data.push(temp.front());
			temp.pop();
		}

	}

	int pop()
	{
		int x = _data.front();
		_data.pop();
		return x;
	}

	int top()
	{
		return _data.front();
	}

	bool empty()
	{
		return _data.empty();
	}
	std::queue<int> _data;
};


int main()
{
	Mystack s;
	s.push(10);
	s.push(20);
	s.push(30);
	s.push(40);
	s.push(50);
	s.push(60);
	s.push(70);
	s.push(80);
	printf("%d\n" , s.top());

	s.pop();
	s.pop();
	s.pop();
	printf("%d\n" , s.top());	
	s.pop();
	printf("%d\n" , s.top());	
	
	printf("%d\n" , s.empty());	
	s.pop();
	s.pop();
	s.pop();
	s.pop();
	printf("%d\n" , s.empty());	
	return 0;
}

2.3结果展示

三、包含min的栈

**3.1题目：**设计一个栈，支持如下操作，这些操作的算法复杂度需要的是常数级，O(1)
（1）push(x)
（2）pop()
（3）top()
（4）getMin()
**3.2算法思想：**设置两个栈，一个数据栈一个最小值栈，每次在往数据栈中压入元素时，将其与最小值栈的栈顶作比较，将较小的保存在最小值栈中，这样一来，最小值栈栈顶将保留所有元素中的最小值，在查找时，直接取最小值栈的栈顶即可。
3.3程序实现

#include<iostream>
#include<stack>
using namespace std;

class MinStack
{
public:
    MinStack() 
	{
    }
	 void push(int x)
	{
    	_data.push(x);
    	if (_min.empty())
		{
	    	_min.push(x);
	    }

		  else 
			  {
				  if(x > _min.top())
		            {
		  	          x = _min.top();
		              }
			        _min.push(x);
	             }
        	}

	void pop()
	{
		_data.pop();
		_min.pop();
	}

	int top()
	{
		return _data.top();
	}

	int getMin()
	{
		return _min.top();
	}

private:
	std::stack<int>  _data;
	std::stack<int>  _min;
};


int main()
{
	MinStack s;
	s.push(3);
	printf("%d\n",s.top());
	printf("%d\n",s.getMin());

	s.push(4);
	printf("%d\n",s.top());
	printf("%d\n",s.getMin());

	s.push(-77);
    printf("%d\n",s.top());
	printf("%d\n",s.getMin());
	
	s.push(100);
	printf("%d\n",s.top());
	printf("%d\n",s.getMin());

	return 0;
}

3.4结果展示

四、合法的出栈序列

**4.1题目:**给出一个序列1，判断该序列1是否为某个已知序列2的出栈序列；
**4.2算法思想:**将带带判断的序列存入一个队列中，将已知序列依次压入栈中，每次压入时，将其与队头元素比较，如果相等，就将队头弹出，将栈顶弹出，如果不等，就继续入站，循环以上操作。
4.3程序实现

#include<iostream>
#include<queue>
#include<stack>
using namespace std;

bool Is_correct_order(std::queue<int> &order)
{
	std::stack<int> s;
	for(int  i = 1; i<order.size();++i)
	{
		s.push(i);
		while(!s.empty()&& s.top()==order.front())
		{
			order.pop();
			s.pop();
		}
	}
	if(!s.empty())
	{
		return false;
	}
	return true;
}

int main(){
	int n;
	int train;
	scanf("%d", &n);
	while(n){
		scanf("%d", &train);
		while (train){
			std::queue<int> order;
			order.push(train);
			for (int i = 1; i < n; i++){
				scanf("%d", &train);
				order.push(train);
			}
			if (Is_correct_order(order)){
				printf("Yes\n");
			}
			else{
				printf("No\n");
			}
			scanf("%d", &train);
		}
		printf("\n");
		scanf("%d", &n);
	}
	return 0;
}

4.4结果展示

五、实现简单的计算器

**5.1题目：**设计一个简单的计算器，输入一个字符串存储的数据表达式，可以计算包括“（”，“）”，“+”，“-”四种符号的数学表达式，输入的数学表达式字符串保证是合法的，输入的数学表达式中可能存在空格字符
**5.2算法思想：**维护两个栈，一个存放数字字符，一个存放符号，设计一个标记，每次当遇到"+“或者”-"时，将标记设置为1，将计算结果保存在数字栈中，当遇到”（“时，则不计算，直到将表达式所有的元素都处理完。;
5.3程序实现

#include<iostream>
#include <string>
#include <stack>
using namespace std;

class Solution 
{
public:
	int calculate(std::string s)
	{
		static const int STATE_BEGIN = 0;
		static const int NUMBER_STATE = 1;
		static const int OPERATION_STATE = 2;
		std::stack<int> number_stack;
		std::stack<char> operation_stack;
		int number = 0;
		int STATE = STATE_BEGIN;
		int compuate_flag = 0;

		for (int i = 0; i < s.length(); i++)
		{
			if (s[i] == ' ')
			{
				continue;
			}
			switch(STATE)
			{
			case STATE_BEGIN:
				if (s[i] >= '0' && s[i] <= '9')
				{
					STATE = NUMBER_STATE;
				}
				else{
					STATE = OPERATION_STATE;
				}
				i--;
				break;
			case NUMBER_STATE:
				if (s[i] >= '0' && s[i] <= '9')
				{
					number = number * 10 + s[i] - '0';
				}
				else{
					number_stack.push(number);
					if (compuate_flag == 1)
					{
						compute(number_stack, operation_stack);
					}
					number = 0;
					i--;
					STATE = OPERATION_STATE;
				}
				break;
			case OPERATION_STATE:
				if (s[i] == '+' || s[i] == '-')
				{
					operation_stack.push(s[i]);
					compuate_flag = 1;
				}
				else if (s[i] == '(')
				{
					STATE = NUMBER_STATE;
					compuate_flag = 0;
				}
				else if (s[i] >= '0' && s[i] <= '9')
				{
					STATE = NUMBER_STATE;			  		
					i--;
				}
				else if (s[i] == ')'){
					compute(number_stack, operation_stack);
				}
				break;
			}
		}
		if (number != 0)
		{
			number_stack.push(number);
			compute(number_stack, operation_stack);
		}
		if (number == 0 && number_stack.empty())
		{
			return 0;
		}
		return number_stack.top();
	}
private:
	void compute(std::stack<int> &number_stack,
		std::stack<char> &operation_stack)
	{
		if (number_stack.size() < 2)
		{
			return;
		}
		int num2 = number_stack.top();
		number_stack.pop();
		int num1 = number_stack.top();
		number_stack.pop();
		if (operation_stack.top() == '+')
		{
			number_stack.push(num1 + num2);
		}
		else if(operation_stack.top() == '-')
		{
			number_stack.push(num1 - num2);
		}
		operation_stack.pop();
	}
};

int main()
{	
	std::string s = "1+121 - (14+(5-6) )";
	Solution solve;
	printf("%d\n", solve.calculate(s));
	return 0;
}

5.4结果展示

六、求第K大数字

**6.1题目：***已知一个未排序的数组，求这个数组中第K大的数字
6.2算法思想维护一个k个元素的最小堆，遍历序列中的每一个元素，使其与根节点比较，如果小于根节点，则丢弃如果大于根节点，则插入堆中，并删除根节点；直到遍历完所有元素，根节点即为第K大节点
6.3程序实现

#include<iostream>
using namespace std;

class solution 
{
public:
	int FindKlargest(std::vector<int>& nums,int k)
	{
		std::priority_queue<int,std::vector<int>,std::greater<int>> less_heap;
		for(int  i =0; i <nums.size();i++)
		{
			if(less_heap.size()<k)
			{
				less_heap.push(nums[i]);
			}
			else
				if(less_heap.top()<nums[i])
				{
					less_heap.pop();
					less_heap.push(nums[i]);
				}
		   
		 }
		return less_heap.top();
	}

};


int main()
{

	std::vector<int> nums;
	nums.push_back(3);
	nums.push_back(14);
	nums.push_back(11);
	nums.push_back(2);
	nums.push_back(22);
	nums.push_back(67);
	nums.push_back(88);
	nums.push_back(90);
	solution solve ;
	printf("%d\n",solve.FindKlargest(nums,2));
	return 0;
}

6.4结果展示

七、寻找中位数

**7.1题目：**设计一个数据结构，该数据结构动态的维护一组数据，且支持如下操作：
1、添加元素：将整型num添加至数据结构中；
2、返回数据中位数，返回其维护的数据的中位数；
中位数定义：
1、若数据个数为奇数，中位数为该组数排序后中间的数。如：1,2,3,—》2
2、若数据个数为偶数，中位数是该组数排序后中间的两个数字的平均值；如1,2,3,4—》2.5

7.2算法思想维护一个最大堆和最小堆；
（1）最小堆的堆顶大于最大堆的堆顶
（2）最小堆和最大堆元素个数之差不大于1；
（3）每遍历一个元素将其与最大堆的堆顶进行比较；
【1】最大堆，最小堆元素个数相等时，如果当前遍历的元素大于最大堆堆顶元素，则插入最小堆内
否则插入最大堆内
【2】最大堆，最小堆元素个数不相等时，
最大堆元素个数大于最小堆元素：
1）当前元素大于最大堆对顶元素，则插入最小堆内
2）当前元素小于最大堆堆顶元素，则将最大堆堆顶插入最小堆，
将当前元素插入最大堆
最大堆元素个数小于最小堆元素：
1）当前元素小于最大堆对顶元素，则插入最大堆内
2）当前元素大于最大堆堆顶元素，则将最小堆堆顶插入最大堆，
将当前元素插入最小堆
7.3程序实现

#include<iostream>
#include<queue>
using namespace std;
class MedianFinder
{
public:

	void addNum(int num)
	{
		if(big_heap.empty())
		{
			big_heap.push(num);
			return ;
		}

		if(big_heap.size() == small_heap.size())
		{
			if(num < big_heap.top())
			{
				big_heap.push(num);
			}
			else
				small_heap.push(num);
		}

		else if(big_heap.size()>small_heap.size())
		{
			if(num>big_heap.top())
				small_heap.push(num);
			else {
				small_heap.push(big_heap.top());
				big_heap.pop();
				big_heap.push(num);
			}
		}

		else if(big_heap.size()<small_heap.size())
		{
			if(num <small_heap.top())//
				big_heap.push(num);
			else
			{
				big_heap.push(small_heap.top());
				small_heap.pop();
				small_heap.push(num);
			}
		}
	}
	double findMedian()
	{
		if(big_heap.size()==small_heap.size())
		{
			return (big_heap.top()+small_heap.top())/2;
		}
		else if(big_heap.size()>small_heap.size())
		{
			return big_heap.top();
		}
		else return small_heap.top();

	}

	std::priority_queue<int,std::vector<double>,std::greater<double>> small_heap;
	std::priority_queue<int,std::vector<double>,std::less <double>>  big_heap;//注意
};
int main()
{
	MedianFinder M;
	M.addNum(2);
	M.addNum(1);

	printf("%lf\n",M.findMedian());

	M.addNum(4);
	printf("%lf\n",M.findMedian());

	M.addNum(3);
	printf("%lf\n",M.findMedian());
	return 0;
}

7.4结果展示

长颈鹿仙女
关注
专栏目录
堆 栈 队列总结
代码青春
06-10 112
堆： 数据结构 - 先进先出 栈 ： 数据结构 - 先进后出 - 线性表 队列表 ： 数据结构-先进先出- 先删后加 -线性表-出队入队
《数据结构初阶》用队列实现栈&&用栈实现队列的细致解析
m0_62171658的博客
03-29 4149
《数据结构初阶》用队列实现栈&&用栈实现队列的细致解析
数据结构学习-队列
活着就是应该在解放自我
08-31 252
定义 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这也比较符...
浅谈 堆、栈、队列
最新发布
weixin_63681863的博客
08-15 398
堆、栈和队列是计算机科学中常见的数据结构和概念，它们在内存管理、算法设计和程序执行中扮演着不同的角色。它们各自有不同的实现方式和用途，彼此之间并没有直接的关系，但在某些场景下可以相互配合使用。
栈 队列 堆
Kingrrr的博客行程
03-07 223
简要介绍数据结构之栈队列堆
数据结构——栈、堆以及队列
lingwu_hb的博客
09-27 440
洛谷P1981 表达式求值 1）涉及栈的知识点不太多，主要是栈的进栈和出栈操作。注意在c++中，pop() 没有返回值，一般和 top() 结合起来使用！ 一些细节： c++ 的 cin 会根据输入的类型自动进行判断读取，不必像 c 语言那么僵硬的一直用字符类型进行处理。 c++ 里面的 cin/cout 效率不如 scanf()/printf() ，所以在数据很大的时候最好还是使用后者。 洛谷P5788单调栈 1）单调栈概念：栈中元素递增或者递减。 2）应用：单调栈内存储的元素一般都为下标，而不是真正
【数据结构】堆栈、队列的原理及java实现
简约人生的博客
04-21 8247
栈(stack)又名堆栈，它是一种先进后出(FILO)的线性表。其限制是仅允许在表的一端进行插入和删除运算。 队列 是一种先进先出的线性表。其限制仅在表的一端（尾端）进行插入，另一端（首端）进行删除的线性表，先进先出FIFO。
栈和队列学习总结
热门推荐
Marmara
04-04 1万+
一、栈 1、特点及应用 先进后出。（如果会和队列先进先出记混的话，就记场景吧：弹栈弹栈，就是把最上面的最新进来的弹出去；而队列就像我们火车站排队检票出站一样，谁排在前面谁就先出去。） 应用的话，其实我们经常接触呀。比如Undo操作（就是撤销操作）就是使用的栈的思想，以及程序调用的系统栈。下面我们举一个经典的括号匹配的例子： 题目要求： 给定一个只包括...
数据结构实验报告 栈、队列和矩阵.doc
09-29
栈是一种“后进先出”（LIFO, Last In First Out）的数据结构，类似于现实生活中堆叠的盘子。栈的主要操作包括压入（push，将元素放入栈顶）和弹出（pop，移除栈顶元素）。在递归算法中，函数调用的回溯过程就利用了...
栈、队列和堆详解(c++)
weixin_49312527的博客
05-22 1804
111
数据结构中线性表，队列和栈
01-07
在计算机科学中，数据结构是...总结来说，数据结构中的线性表、栈和队列是编程基础，它们各自具备特定的特性，适用于不同的应用场景。理解并掌握这些数据结构的原理和实现，对于提升编程技能和解决实际问题至关重要。
栈、堆、队列
try_again_later的博客
06-10 426
栈 一、栈（LIFO后进先出） 栈的抽象数据类型 template <class T> class stack { virtual void clear()=0;//变为空栈 virtual bool isEmpty()=0;//若栈空返回true virtual bool isFull()=0;//若栈满返回true virtual bool push...
栈、队列和堆
for_what_why的博客
10-17 295
一、栈 a)栈的定义 栈是一种线性结构，采用先进后出（Last In First Out）的原则，可以理解为‘’客栈‘’，只有一个正门，方便记忆。 在栈中进行插入和删除操作的一端被称为栈顶（Top）,另一端成为栈底（Bottom）。 栈的顺序存储是指用一组连续的存储单元依次存储自栈顶到栈底的数据元素，栈需要预先申请栈的存储空间，也就是说栈空间的容量是有限的。 b)栈的特点 基本类型的变...
简单数据结构(队列 栈 树 堆 )
weixin_30929195的博客
07-17 259
基础知识 基本概念 程序 = 算法 + 数据结构 数据结构是计算机存储、组织数据的方式。 数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。 通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。 数据结构往往同高效的检索算法和索引技术有关。 常见数据结构 集合：set，multiset 线性...
数据结构之堆栈队列（一）
SmileTimLi的博客
11-29 362
目录 数据结构值堆栈队列           1.堆 2.栈  -- 操作系统在建立某个进程时或者线程为这个线程建立存储区域 3.堆、栈区别总结： 4.队列 5.堆、栈、队列三者区别  1.堆 堆通常是一个可以被看做一棵树的数组对象。 堆总是满足下列性质：      堆中某个节点的值总是不大于或不小于其父节点的值，堆总是一棵完全二叉树。      将根节点最大的堆叫做最大堆或...
第二章 栈、队列、堆
Stay Hungry Stay Foolish 求知若饥 虚心若愚
09-05 1170
文章目录栈、队列、堆基础知识（1）Stack（栈）（2）Queue（队列）（3）Heap（堆）（4）Deque（双端队列）leetcode例1 使用队列实现栈（225）例2 使用栈实现队列例3 包含min函数的栈例4 合法的出栈队列例5 简单的计算器例6 数组中第K大的数例7 寻找中位数剑指offer 栈、队列、堆 基础知识 （1）Stack（栈） 方法 功能 Stack stac...
堆与栈 队列
志在千里
09-01 1538
首先，我们举一个例子：  void f() { int* p=new int[5]; }  这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是： 在栈内存中存放了一个指向一
堆栈和队列知识小结
weixin_44549988的博客
05-18 392
开发工具与关键技术： 作者：杨镇虹 撰写时间：2020.05.18 一、堆栈的压入和弹出 堆栈的定义和特点：堆栈的简称为栈，它是一种特殊的线性表，只能在表的一端进行做插入和删除操作的线性表，在表中，允许插入和删除的一端称作“栈顶”，而另一端称作“栈底”。元素的插入栈顶的操作称作为“入栈”，删除栈顶的元素操作称为“出栈”。特点是先进的后出。 堆栈的存储结构也有两种存储结构，一种是顺序栈，采用顺序结构存储的；另一种是链栈它采用链式结构存储的。 顺序栈的压入和弹出，先压入进去的元素是最后才弹出来的，后压入进去的元
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值