双端队列的物理实现（顺序双端队列+链式双端队列）

最新推荐文章于 2024-08-20 15:01:17 发布
最新推荐文章于 2024-08-20 15:01:17 发布
阅读量1k 收藏 3
点赞数
分类专栏： ∨∨坑逼数据结构课 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40889820/article/details/83713501
版权
  • 说明
  • 基于顺序表实现的顺序双端队列
  • 基于链表实现的链式双端队列

一、说明

思路大致与队列相同，增添了从头部入队、尾部出队等操作。

再次感叹delete的耗时

二、基于顺序表实现的顺序双端队列

1、Deque.h

#include<iostream>
using namespace std;
#ifndef _Deque
#define _Deque
namespace wangzhe
{
	template<typename E>
	class Deque
	{
		private:
		        void operator = (const Deque&) {}
		        Deque(const Deque&) {}
		public:
			Deque() {}
			virtual ~Deque() {}
			virtual void clear() =0;
			virtual void Push_back(const E&) =0;
			virtual void Push_front(const E&) =0;
			virtual E Pop_back() =0;
			virtual E Pop_front() =0;
			virtual const E& frontValue() const =0;
			virtual const E& backValue() const =0;
			virtual int length() const =0;
	};
}
#endif

2、ADeque.h

#include<iostream>
using namespace std;
#include"Deque.h"
#ifndef _ADeque
#define _ADeque
namespace wangzhe
{
	template<typename E>
	class ADeque:public Deque<E>
	{
		private:
			int maxSize;//最大容量
		        int front;//头 
		        int rear;//尾 
		        E *listArray;//表 
		public:
			ADeque(int size) ;//构造函数 
			~ADeque() ;//析构函数 
			void clear() ;//清空元素 
			void Push_back(const E& it) ;//从尾部入队 
			void Push_front(const E& it) ;//从头部入队 
			E Pop_back() ;//从尾部出队 
			E Pop_front() ;//从头部出队 
			const E& frontValue() const ;//返回头部元素值 
			const E& backValue() const ;//返回尾部元素值 
			int length() const ;//元素个数 
	};
}
#endif

3、ADeque.cpp

#include<iostream>
using namespace std;
#include"ADeque.h"
namespace wangzhe
{
	template<typename E>
	ADeque<E>::ADeque(int size)
	{
		maxSize=size+1;
		front=1;
		rear=0;
		listArray=new E[maxSize];
	}
	
	template<typename E>
	ADeque<E>::~ADeque()
	{
		delete [] listArray;
	}
	
	template<typename E>
	void ADeque<E>::clear()
	{
		rear=0;
		front=1;
	}
	
	template<typename E>
	void ADeque<E>::Push_back(const E& it)
	{
		if((rear+2)%maxSize==front)
		{
			cout<<"Deque is full"<<endl;
			return;
		}
		rear=(rear+1)%maxSize;
		listArray[rear]=it;
	}
	
	template<typename E>
	void ADeque<E>::Push_front(const E& it)
	{
		if((rear+2)%maxSize==front)
		{
			cout<<"Deque is full"<<endl;
			return;
		}
		front=(front-1)%maxSize;
		listArray[front]=it;
	}
	
	template<typename E>
	E ADeque<E>::Pop_back()
	{
		if(length()==0)
		{
			cout<<"Deque is empty"<<endl;
			return -1;//以-1作为出错的返回值，不严谨 
		}
		E it=listArray[rear];
		rear=(rear-1)%maxSize;
		return it;
	}
	
	template<typename E>
	E ADeque<E>::Pop_front()
	{
		if(length()==0)
		{
			cout<<"Deque is empty"<<endl;
			return -1;//以-1作为出错的返回值，不严谨 
		}
		E it=listArray[front];
		front=(front+1)%maxSize;
		return it;
	}
	
	template<typename E>
	const E& ADeque<E>::frontValue() const
	{
		if(length()==0)
		{
			cout<<"Queue is empty"<<endl;
			return -1;//以-1作为出错的返回值，不严谨 
		}
		return listArray[front];
	}
	
	template<typename E>
	const E& ADeque<E>::backValue() const
	{
		if(length()==0)
		{
			cout<<"Queue is empty"<<endl;
			return -1;//以-1作为出错的返回值，不严谨 
		}
		return listArray[rear];
	}
	
	template<typename E>
	int ADeque<E>::length() const
	{
		return ((rear+maxSize)-front+1)%maxSize;
	}
}

4、main.cpp

#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
#include"ADeque.h"
#include"ADeque.cpp"
using namespace wangzhe;
int main(int argc, char** argv) 
{
	ADeque<int> a(5);
	a.Push_back(9);
	cout<<a.frontValue()<<endl ;
	a.Push_front(8); 
	cout<<a.frontValue()<<endl ;
	a.Push_back(2);
	cout<<a.backValue()<<endl ;
	a.Push_back(3);
	a.Push_back(4);
	a.Push_back(5);
	a.Push_back(6);
	cout<<a.length() <<endl;
	return 0;
}

 

三、基于链表实现的链式双端队列

1、Link.h

#include <iostream>
using namespace std;
#ifndef _Link
#define _Link
namespace wangzhe
{
	template<typename E> 
	class Link
	{
	    public:
		    E element;
			Link *next;
			Link(const E& elemval,Link* nextval =NULL)
			{
			    element=elemval;
				next=nextval;	
			}	
			Link(Link* nextval=NULL)
			{
				next=nextval;
			}
	};
}
#endif

2、Deque.h

同顺序表

3、LDeque.h

#include<iostream>
using namespace std;
#include"Link.h"
#include"Deque.h"
#ifndef _LDeque
#define _LDeque
namespace wangzhe
{
	template<typename E>
	class LDeque:public Deque<E>
	{
		private:
			Link<E>* front;
			Link<E>* rear;
			int size;
		public:
			LDeque() ;//构造函数 
			~LDeque() ;//析构函数 
			void clear() ;//清空元素 
			void Push_back(const E& it) ;//从尾部入队 
			void Push_front(const E& it) ;//从头部入队 
			E Pop_back() ;//从尾部出队 
			E Pop_front() ;//从头部出队 
			const E& frontValue() const ;//返回头部元素值 
			const E& backValue() const ;//返回尾部元素值 
			int length() const ;//元素个数 
	};
}
#endif

4、LDeque.cpp

#include<iostream>
using namespace std;
#include"LDeque.h"
namespace wangzhe
{
	template<typename E>
	LDeque<E>::LDeque()
	{
		front=rear=new Link<E>();
		size=0;
	}
	
	template<typename E>
	LDeque<E>::~LDeque()
	{
		clear();
		delete front;
	}
	
	template<typename E>
	void LDeque<E>::clear()
	{
		/*while(front->next!=NULL)
		{
			rear=front->next;
			delete rear;
		}
		rear=front;*/
		rear=front;
		front->next=NULL;
		size=0;
	}
	
	template<typename E>
	void LDeque<E>::Push_back(const E& it)
	{
		rear=rear->next=new Link<E>(it,NULL);
		size++;
	}
	
	template<typename E>
	void LDeque<E>::Push_front(const E& it)
	{
		front->next=new Link<E>(it,front->next);
		size++;
	}
	
	template<typename E>
	E LDeque<E>::Pop_front()
	{
		if(size==0)
		{
			cout<<"Queue is empty"<<endl;
			return -1;//以-1作为出错的返回值，不严谨 
		}
		Link<E>* temp=front->next;
		E it=temp->element;
		front->next=temp->next;
		if(rear==temp) rear=front;
		//delete temp;
		size--;
		return it;
	}
	
	template<typename E>
	E LDeque<E>::Pop_back()
	{
		if(size==0)
		{
			cout<<"Queue is empty"<<endl;
			return -1;//以-1作为出错的返回值，不严谨 
		}
		E it=rear->element;
		Link<E>* temp=front->next;
		while(temp->next!=rear) 
		{
			temp=temp->next;
		}
		//delete rear;
		rear=temp;
		size--;
		return it;
	}
	
	template<typename E>
	const E& LDeque<E>::frontValue() const
	{
		if(size==0)
		{
			cout<<"Queue is empty"<<endl;
			return -1;//以-1作为出错的返回值，不严谨
		}
		return front->next->element;
	}
	
	template<typename E>
	const E& LDeque<E>::backValue() const
	{
		if(size==0)
		{
			cout<<"Queue is empty"<<endl;
			return -1;//以-1作为出错的返回值，不严谨
		}
		return rear->element;
	}
	
	template<typename E>
	int LDeque<E>::length() const
	{
		return size;
	}
}

5、main.cpp

同顺序表

就算过了一载春秋
关注
专栏目录
3. 队列基本概念、【队列顺序+链式存储】实现、双端队列
你说的白是什么白_
08-07 347
队列基本概念、队列顺序+链式存储实现、双端队列
Python数据结构与算法（3.5）——双端队列
热门推荐
盼小辉丶的博客
03-31 1万+
双端队列是另一个线性数据结构。虽然它也是一种受限线性表，但与栈和队列不同的是，双端队列的限制很少，它的基本操作也是线性表操作的子集，但从数据类型的角度来讲，它们与线性表又有着巨大的不同。本节将介绍双端队列的定义及其不同实现，并且给出双端队列的一些实际应用。
双端队列（顺序表）
weixin_51578598的博客
10-05 312
直接转载 队列的应用：双端队列 - xfgnongmin - 博客园
双端队列的出队顺序图_双端队列
cunfen6312的博客
07-29 6294
双端队列的出队顺序图 双端队列 (Double Ended Queue) Double ended queue is a more generalized form of queue data structure which allows insertion and removal of elements from both the ends, i.e , front and back. 双头...
C++STL初阶（13）：双端队列deque和优先级队列priority_queue(包含详细计算)
最新发布
2301_79501467的博客
08-20 692
双开口的含义是：可以在头尾两端进行插入和 删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。尽管名字叫双端队列，但是deque和队列FIFO的特性没有太多关系，我们抛开先进先出的特性进行学习。deque是一个顺序容器（sequence container），而不是容器适配器。
C#实现双端队列
qq_42696107的博客
08-26 1708
C#实现双端链表
基于C#实现双端队列
神仙别闹的自留地
11-25 771
通常情况下，队列的内部都是采用数组来实现，而且带有两个指针 head 和 tail 来指向数组的区间段，为了充分利用数组空间，我们也会用 % 来实现逻辑上的循环数组，如下图。这里有一个注意的细节就是“size 字段“，它是为了方便统计队列是否为满或者队列是否为空。
数据结构-双端队列的链式存储与实现（C++）
RIGLEN_W的博客
01-21 470
使用双链表实现双端队列 采用链表实现队列的好处是较为节省空间，便于增删元素。但是难于遍历。 双端队列是在队列两端都可以进行出队、入队操作的队列。 下面是双链表实现双端队列的代码。 deque.h #pragma once //双端队列的链式存储C++实现 //2020.01.21 //记录：可运行，插入删除操作没有问题，但是没有写自定义的插入删除操作，待后续可完成 #include <...
双端链式队列实现
wang_da_ye的博客
04-09 392
/** * 双端队列，使用双向链表实现 * 队头、队尾都可以进行入队、出队操作的队列 * 双端队列的每一端都是一个栈，都符合栈先进后出的特性 * 双端队列是一种多功能的数据结构，可以使用它来提供队列和栈两种功能 */ #include <stdlib.h> #include "queue.h" typedef struct DoubleLinkNode{ ...
循环队列+链式队列（C语言）
GR_001的博客
04-18 547
今天也要努力学习，争取考上杭电！ 队列的知识 队列也是一种受限的线性表！！！只允许在表的一端进行插入，另一端进行删除（双端队列后面说）。 队头（Front）：允许删除的一端 队尾（Rear）：允许插入的一端 队列的特性：先进先出（First In First Out , FIFO） 双端队列：允许两端都可以进行入队出队操作的队列。依然是线性结构！！！ 输出受限的双端队列：允许一端进行插入和删除，但...
双端队列入队出队等各种操作问题
06-27
实现双端队列入队和出队的基本操作。有详细的源代码，数据类型，算法描述。
说说双端队列
欢迎关注微信公众号：DroidMind
08-21 1130
一、双端队列定义：是指允许两端都可以进行入队和出队操作的队列。二、输出受限双端队列定义：允许一端进行插入和删除操作，但是另一端只允许插入的双端队列三、输入受限双端队列定义：允许一端进行插入和删除操作，但是另一端只允许删除的双端队列
设计循环双端队列C#
weixin_45776347的博客
03-28 609
设计实现双端队列。 你的实现需要支持以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。 insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。 deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 true。 deleteLas...
用Python实现队列---双端队列（链表）
Your_Majesty！的博客
07-03 524
用Python实现队列---双端队列（链表）
双端队列
柯影的博客
09-25 365
顺序队列 循环队列 入队 出队 链式队列 双端队列 队列应用 C语言实现
加油高同志
04-20 854
队列 顺序实现 #define MaxSize 10 typedef struct{ ElemType data[MaxSize];//静态数组存放队列元素 int front,rear;//队头和队尾指针 }SqQueue; 循环队列——入队 bool EnQueue(SqQueue &Q,ElemType x){ if((Q.rear+1)%MaxSize==Q.front){//队满 return false; } Q.data[Q.r
双端队列（C语言实现）
thdwx的博客
04-10 1539
双端队列可以使用循环数组来实现，也可以使用双链表来实现，下面给出双端队列的循环数组实现，链表实现的原理与队列的实现也是类似的，但由于双端队列可能会从尾部删除结点，所以为了效率，使用能够找到前驱结点的双链表。队列是一种操作受限的线性表，它只允许从队头出队，从队尾入队，就像生活中的排队一样。双端队列放宽了这种限制，它可以从队头出队或入队，也可以从队尾出队或入队。双端队列可以从两端进行出队和入队，也可以对一种操作进行限制，例如，入队受限（一端入队）的双端队列和出队（一端出队）的双端队列。
用C#解决LeetCode设计循环双端队列
luobendehaishen的博客
03-25 797
题目 设计实现双端队列。 你的实现需要支持以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。 insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。 deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 true。 delet...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值