用双端队列实现双端栈的底层实现，附有例子~

最新推荐文章于 2024-03-31 21:43:28 发布
最新推荐文章于 2024-03-31 21:43:28 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： 底层实现 文章标签： 栈 双端队列 双端栈 底层实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a17816876003/article/details/49302735
版权 
#include<iostream>
#include <deque>
using namespace std;

enum stackNumber
{
	one, two
};

template<typename T>
class dualStack
{
public:
	dualStack();
	void push(const T & item, stackNumber n );
	void pop(stackNumber n);
	const T & top(stackNumber n) const;
	bool empty(stackNumber n) const;
	int size(stackNumber n) const;
private:
	deque<T> dualStackElements;
	int count1, count2;
};

template<typename T>
dualStack<T>::dualStack(){ count1 = 0; count2 = 0; dualStackElements.push_front(NULL); }


template<typename T>
void dualStack<T>::push(const T & item, stackNumber n)
{
	if (n == one)
	{
		dualStackElements.push_front(item);
		count1++;
	}

	if (n == two)
	{
		dualStackElements.push_back(item);
		count2++;
	}
}

template<typename T>
void dualStack<T>::pop(stackNumber n)
{
	if (n == one)
	{
		if (count1 == 0)
		{
			cout << "栈已空\n";
			return;
		}
		dualStackElements.pop_front();
		count1--;

	}

	if (n == two)
	{
		if (count2 == 0)
		{
			cout << "栈已空\n";
			return;
		}
		dualStackElements.pop_back();
		count2--;

	}

}


template<typename T>
const T & dualStack<T>::top(stackNumber n) const
{
	const T temp = NULL;
	if (n == one)
	{
		if (this->empty(one))
		{
			cout << "栈已空";
			return temp;
		}

		return dualStackElements.front();


	}

	if (n == two)
	{
		if (this->empty(two))
		{
			cout << "栈已空";
			return temp;
		}

	return dualStackElements.back();
		

	}

}


template<typename T>
bool dualStack<T>::empty(stackNumber n) const
{
	if (n == one)
		return dualStackElements.front()==NULL;

	if (n == two)
		return dualStackElements.back()==NULL;
}

template<typename T>
int dualStack<T>::size(stackNumber n) const
{
	if (n == one)
		return count1;

	if (n == two)
		return count2;
}
//以下测试main
#include"dualstk.h"
#include<ctime>
#include<stdlib.h>


using namespace std;
 
int main()
{
    dualStack<int> stk;
    int i = 1;
    int num;
    srand(unsigned int(time(0)));
    cout << "随机产生的从0~99的数字20个：" << endl;
    for (; i <= 20; i++)
    {
        num = rand() % 100;
        cout << num << " ";
        if (num % 2)
        {
            stk.push(num, one);
            continue;
        }
        stk.push(num, two);
    }
    cout << endl;
    system("pause");
    while (!stk.empty(one))
    {
        cout << stk.top(one) << " ";
        stk.pop(one);
    }
    cout << endl;
    while (!stk.empty(two))
    {
        cout << stk.top(two) << " ";
        stk.pop(two);
    }
    cout << endl;
    cout << stk.top(one);
    cout << endl;
    system("pause");


    return 0;
}

</pre><pre name="code" class="cpp">//其实都很简单，并没有使用双端队列的队列的性质，从两端看成两个栈，进行的操作。
//初始化时，push了NULL作为empty的标志。
</pre><pre name="code" class="cpp">//缺点：在top函数中，由于返回类型必须是const T & ,必须有返回值，而NULL的返回值对于Int就是0，肯定会被输出，甚为讨厌，原本想返回new T()，但是返回值类型对不//上，请大家指教如何消灭这个0，或者如何返回垃圾值！
</pre><pre name="code" class="cpp">
//以下是实现的另一个版本，差别就在构造是并不添加NULL，是否empty仅用count1,count2是否为0作为判断，不知道哪个版本相对好些，请大家指教~~
//仅仅修改了构造函数以及top函数
#include<iostream>
#include <deque>
using namespace std;


enum stackNumber
{
<span style="white-space:pre">	</span>one, two
};


template<typename T>
class dualStack
{
public:
<span style="white-space:pre">	</span>dualStack();
<span style="white-space:pre">	</span>void push(const T & item, stackNumber n );
<span style="white-space:pre">	</span>void pop(stackNumber n);
<span style="white-space:pre">	</span>const T & top(stackNumber n) const;
<span style="white-space:pre">	</span>bool empty(stackNumber n) const;
<span style="white-space:pre">	</span>int size(stackNumber n) const;
private:
<span style="white-space:pre">	</span>deque<T> dualStackElements;
<span style="white-space:pre">	</span>int count1, count2;
};


template<typename T>
dualStack<T>::dualStack(){ count1 = 0; count2 = 0;  }




template<typename T>
void dualStack<T>::push(const T & item, stackNumber n)
{
<span style="white-space:pre">	</span>if (n == one)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>dualStackElements.push_front(item);
<span style="white-space:pre">		</span>count1++;
<span style="white-space:pre">	</span>}


<span style="white-space:pre">	</span>if (n == two)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>dualStackElements.push_back(item);
<span style="white-space:pre">		</span>count2++;
<span style="white-space:pre">	</span>}
}


template<typename T>
void dualStack<T>::pop(stackNumber n)
{
<span style="white-space:pre">	</span>if (n == one)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>if (count1 == 0)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>cout << "栈已空\n";
<span style="white-space:pre">			</span>return;
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>dualStackElements.pop_front();
<span style="white-space:pre">		</span>count1--;


<span style="white-space:pre">	</span>}


<span style="white-space:pre">	</span>if (n == two)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>if (count2 == 0)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>cout << "栈已空\n";
<span style="white-space:pre">			</span>return;
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>dualStackElements.pop_back();
<span style="white-space:pre">		</span>count2--;


<span style="white-space:pre">	</span>}


}




template<typename T>
const T & dualStack<T>::top(stackNumber n) const
{
<span style="white-space:pre">	</span>const T temp = NULL;
<span style="white-space:pre">	</span>if (n == one)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>if (this->empty(one))
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>cout << "栈已空";
<span style="white-space:pre">			</span>return temp;
<span style="white-space:pre">		</span>}


<span style="white-space:pre">		</span>return dualStackElements.front();




<span style="white-space:pre">	</span>}


<span style="white-space:pre">	</span>if (n == two)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>if (this->empty(two))
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>cout << "栈已空";
<span style="white-space:pre">			</span>return temp;
<span style="white-space:pre">		</span>}


<span style="white-space:pre">	</span>return dualStackElements.back();
<span style="white-space:pre">		</span>


<span style="white-space:pre">	</span>}


}




template<typename T>
bool dualStack<T>::empty(stackNumber n) const
{
<span style="white-space:pre">	</span>if (n == one)
<span style="white-space:pre">		</span>return count1==0;


<span style="white-space:pre">	</span>if (n == two)
<span style="white-space:pre">		</span>return count2==0;
}


template<typename T>
int dualStack<T>::size(stackNumber n) const
{
<span style="white-space:pre">	</span>if (n == one)
<span style="white-space:pre">		</span>return count1;


<span style="white-space:pre">	</span>if (n == two)
<span style="white-space:pre">		</span>return count2;
}<span style="font-family:Arial, Helvetica, sans-serif;"><span style="white-space: normal;">
</span></span>
辉度
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python实现双端队列
12-22
双端队列的数据存储结构可以是顺序表，也可以是链表，本篇文章使用 Python 来分别实现顺序双端队列和链双端队列。 一、实现顺序双端队列 顺序双端队列是使用顺序表存储数据的双端队列，Python 中的列表元组都属于...
Python实现的数据结构与算法之双端队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之双端队列。分享给大家供大家参考。具体分析如下： 一、概述 双端队列（deque，全名double-ended queue）是一种具有队列和栈性质的线性数据结构。双端队列也拥有两端：队...
【RDMA】技术详解（四）：RDMA之Verbs和编程步骤
bandaoyu的note
01-20 9038
原文：https://blog.csdn.net/weixin_33978451/article/details/112398245 Verbs直译过来是“动词”的意思，它在RDMA领域中有两种含义： 1) 由IB规范所描述的一组抽象定义 规定了各厂商的软硬件在各种Verbs下应该执行的动作或者表现出的行为，IB规范并未规定如何编程实现这些Verbs，在这种含义下，Verbs是与操作系统无关的。 举个例子，IB规范要求所有RDMA设备必须支持Create QP的行为（IB 规范11.2.5.1）：
【RDMA】12. RDMA之Verbs|OFED
bandaoyu的note
01-25 3908
原文：https://zhuanlan.zhihu.com/p/329198771 Verbs直译过来是“动词”的意思，它在RDMA领域中有两种含义： 1) 由IB规范所描述的一组抽象定义，规定了各厂商的软硬件在各种Verbs下应该执行的动作或者表现出的行为，IB规范并未规定如何编程实现这些Verbs，在这种含义下，Verbs是与操作系统无关的。 举个例子，IB规范要求所有RDMA设备必须支持Create QP的行为（IB 规范11.2.5.1）： 描述： ​ 为指定的设备创建一个QP。 ​ 用户必
【STL】C++ STL超全总结
行码棋
07-09 2237
C++ STL 1 vector 1.1 介绍 vector为可变长数组（动态数组），定义的vector数组可以随时添加数值和删除元素。在局部函数中开vector数组，是在堆空间里面开的，与开全局变量比较类似，所以经常见到在局部函数中开大容量数组。 初始化一维初始化 指定长度和初始值的初始化 初始化中有多个元素 拷贝初始化 二维初始化 定义第一维固定长度为，第二维可变化的二维数组 行列均可变 行列长度均固定 行 列初始值为0 c++17或者c++20支持的形式（不常用） .........
【RDMA】RDMA技术详解（四）：RDMA之Verbs和编程步骤
小鱼菜鸟的博客
01-20 2590
目录 什么是Verbs 相关名词解释 Verbs API Verbs API是什么 设计Verbs API的原因 Verbs API所包含的内容 使用Verbs API编写RDMA应用程序 查看接口定义 包含头文件 编写应用 编译 & 执行 官方示例程序 libibverbs librdmacm 参考文献 ibv_...
【RDMA】12. RDMA之Verbs
小鱼菜鸟的博客
01-25 245
原文：https://zhuanlan.zhihu.com/p/329198771 Verbs直译过来是“动词”的意思，它在RDMA领域中有两种含义： 1) 由IB规范所描述的一组抽象定义，规定了各厂商的软硬件在各种Verbs下应该执行的动作或者表现出的行为，IB规范并未规定如何编程实现这些Verbs，在这种含义下，Verbs是与操作系统无关的。 ...
12. RDMA之Verbs
weixin_39094034的博客
10-31 677
Verbs直译过来是“动词”的意思，它在RDMA领域中有两种含义： 1) 由IB规范所描述的一组抽象定义，规定了各厂商的软硬件在各种Verbs下应该执行的动作或者表现出的行为，IB规范并未规定如何编程实现这些Verbs，在这种含义下，Verbs是与操作系统无关的。
java深入阅读书单
cajan2的专栏
09-30 1324
《Java深度历险》（看看第1、2、5三章） 《 java reflection in action 》（有一定基础再看）
STL基础学习笔记
Coolbike的博客
03-31 546
STL基础知识，简要介绍了常用容器、算法和迭代器。主要参考黑马STL课程，个人学习笔记，如有错误还请纠正。
新手编程导论
农发行小伟
10-11 6532
第一部分 前 言 By Chenyi 眼前这本书充分体现了作者的所思、所想、所感，他用自己独特的眼光审视着计算机技术的世界，也用自己独特的思维逻辑对技术进行解读，并用自己特有的，呵呵，偶尔带有“四个逗号=一个逗号”这样的语言风格，进行着自己的诠释。创新是一种美，独立思考也是：） 学习是一件因人而异的事情，因为每个人的生活经历、教育背景、年龄、认知模型等等，都是不尽相同的，也
JS中队列和双端队列实现及应用详解
10-14
主要介绍了JS中队列和双端队列实现及应用,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
python双端队列原理、实现与使用方法分析
01-21
本文实例讲述了python双端队列原理、实现与使用方法。分享给大家供大家参考，具体如下： 双端队列 双端队列（deque，全名double-ended queue），是一种具有队列和栈的性质的数据结构。 双端队列中的元素可以从两端弹...
JAVA 分析线程池中的keepAliveTime参数具体实现
过了这个村没这个老王的博客
07-30 3490
分析线程池中的keepAliveTime参数具体实现 参数意义 创建线程池时，有一个重要参数就是keepAliveTime，标记线程空闲多久后被释放。 那么他到底是怎么实现的呢？ 猜想 有一个线程在维护时间，可笑。专门有一个线程去维护，浪费资源，而且时间也不够精确。而且还要开辟空间记录线程开始空闲的时间，消耗空间。 源码分析 java.util.concurrent.ThreadPoolExecutor#getTask /** * Performs blocking or timed wa
用循环链表实现队列
过了这个村没这个老王的博客
11-01 1265
队列记住的是back的地址 构造时back指向back，表示空队列； #include #include #include using namespace std; template class listNode { public: T NodeData; listNode *next; listNode(T data, listNode * ne){ NodeData =
静态方法抛出运行时异常导致反射生成实例失败
过了这个村没这个老王的博客
06-03 746
静态方法抛出运行时异常导致反射生成实例失败 文章目录静态方法抛出运行时异常导致反射生成实例失败场景还原生成实例失败的类抛出运行时异常的方法无法捕获异常之处重试接口类测试main方法测试输出结论 场景还原 1. 启动时，static属性获取时便打印了异常，不过没有注意到。 2. 之后在异常无法捕获之处既无正常往下走到return，也没有被Catch捕获异常，甚至在该行无法Step in进入debug，最终被外层的finally块处理。 生成实例失败的类 public class InnerPositionT
分析ThreadLocal如何做到单个线程独享
过了这个村没这个老王的博客
07-29 468
分析ThreadLocal如何做到单个线程独享 前情概要 我们可能都知道SimpleDateFormat这个类的实例它不是线程安全的，如果不知道，我把代码贴这儿： // 类的成员变量 protected Calendar calendar; // 这个私有方法会对calendar对象进行赋值，但是没有加锁，在多并发场景下，就造成了问题。 // Called from Format after creating a FieldDelegate private StringBuffe
pi_heif-0.17.0-cp310-cp310-manylinux_2_17_aarch64.whl
最新发布
07-27
pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。
这个示例没有使用到双端队列，请使用双端队列实现
07-14
下面是使用双端队列实现环形取色器的示例代码： ```jsx import React, { useState } from 'react'; import { ColorPicker } from 'antd'; const ColorPickerExample = () => { const [colors, setColors] = ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值