数据结构之Deque

最新推荐文章于 2024-06-03 11:18:41 发布
最新推荐文章于 2024-06-03 11:18:41 发布
阅读量366 收藏
点赞数
分类专栏： Deque 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yijiemuhuashi/article/details/118559710
版权

Deque的ADT定义如下：

package com.dzlijian.utils.comments;

/**
 * 
 * @ClassName:  Deque   
 * @Description:双端队列ADT 
 * @author: 长子科技 
 * @date:   2021年7月7日 下午11:03:32   
 *   
 * @param <E>  
 * @Copyright: 2021 www.tydic.com Inc. All rights reserved. 
 */
public interface Deque<E> {
	public int size();
	public boolean  empty();
	public void  addFirst(E e);
	public void  addLast(E e);
	
	public E  removeFirst();
	public E  removeLast();
	
	public E  peekFirst();
	public E  peekLast();

}

1，数组方式实现：

package com.dzlijian.utils.comments;

import java.util.Arrays;

import org.apache.commons.collections.list.GrowthList;
/**
 * 
 * @ClassName:  Deque   
 * @Description:双端队列数组实现
 * @author: 长子科技 
 * @date:   2021年7月7日 下午11:03:32   
 *   
 * @param <E>  
 * @Copyright: 2021 www.tydic.com Inc. All rights reserved. 
 */
public class ArrayDeque<E> implements Deque<E> {
	private static final int DEFAULT_CAPACITY=10;
	private int size;
	private E[] data;
	private int head=-1;
	private int tail=-1;
	
	public ArrayDeque(int capacity){
		data=(E[])new Object[capacity];
		size=0;
	}
	public ArrayDeque(){
		this(DEFAULT_CAPACITY);
	}

	
	@Override
	public int size() {
		return size;
	}

	@Override
	public boolean empty() {
		return size==0;
	}
	
	private void grow(int capacity){
		if(capacity<=0){
			throw new IllegalArgumentException("新建数组长度非法");
		}
		if(capacity<DEFAULT_CAPACITY){
			return;
		}
		if(capacity>data.length){
			data=Arrays.copyOf(data, capacity);
		}else{
			E[] newdata=(E[])new Object[capacity];
			head=0;
			tail=0;
			for(int i=0;i<data.length;i++){
				if(data[i]!=null){
					newdata[tail++]=data[i];
				}
			}
			tail--;
			data=newdata;
		}
		
		
	}

	@Override
	public void addFirst(E e) {
		if(e==null){
			throw new IllegalArgumentException("插入参数为空！！");
		}
		if(size==0){
			data[0]=e;
			head=0;
			tail=0;
			size++;
			return;
		}
		if(size==data.length){
			grow(size*2);
		};
		if(head==0){
			E[] newdata=(E[])new Object[data.length];
			newdata[0]=e;
			for(int i=1;i<data.length;i++){
				newdata[i]=data[i-1];
			}
			data=newdata;
			tail++;
		}else{
			data[--head]=e;
		}
		size++;
	}

	@Override
	public void addLast(E e) {
		if(e==null){
			throw new IllegalArgumentException("插入参数为空！！");
		}
		if(size==0){
			data[0]=e;
			head=0;
			tail=0;
			size++;
			return;
		}
		if(size==data.length){
			grow(size*2);
		};
		if(tail<data.length-1){
			data[++tail]=e;
		}else{
			E[] newdata=(E[])new Object[data.length];
			newdata[tail]=e;
			for(int i=data.length-1;i>0;i--){
				newdata[i-1]=data[i];
			}
			data=newdata;
			head--;
		}
		size++;
	}

	@Override
	public E removeFirst() {
		if(size==0){
			throw new RuntimeException("空队列！");
		}
		E result=data[head];
		data[head]=null;
		head++;
		size--;
		if(size<data.length/2){
			grow(data.length/2);
		}
		
		return result;
	}

	@Override
	public E removeLast() {
		if(size==0){
			throw new RuntimeException("空队列！");
		}
		E result=data[tail];
		data[tail]=null;
		tail--;
		size--;
		if(size<data.length/2){
			grow(data.length/2);
		}
		
		return result;
	}

	@Override
	public E peekFirst() {
		if(size==0){
			throw new RuntimeException("空队列！");
		}
		return data[head];
	}

	@Override
	public E peekLast() {
		if(size==0){
			throw new RuntimeException("空队列！");
		}
		return data[tail];
	}

	public static void main(String[] args) {
		Deque<Integer> test=new ArrayDeque<Integer>();
		for(int i=1;i<6;i++){
			test.addFirst(i);
		}
		System.out.println(test.size());
		for(int i=1;i<6;i++){
			test.addLast(i);
		}
		System.out.println(test.size());
		for(int i=1;i<6;i++){
			test.addFirst(i);
		}
		System.out.println(test.size());
		for(int i=1;i<6;i++){
			test.addLast(i);
		}
		System.out.println(test.size());
		for(int i=1;i<6;i++){
			test.removeFirst();
		}
		System.out.println(test.size());
		for(int i=1;i<6;i++){
			test.removeLast();
		}
		System.out.println(test.size());
		for(int i=1;i<6;i++){
			test.removeFirst();
		}
		System.out.println(test.size());
		for(int i=1;i<6;i++){
			test.removeLast();
		}
		System.out.println(test.size());
	}
}

2，链表实现方式1：

package com.dzlijian.utils.comments;
/**
 * 
 * @ClassName:  Deque   
 * @Description:双端队列链表实现1
 * @author: 长子科技 
 * @date:   2021年7月7日 下午11:03:32   
 *   
 * @param <E>  
 * @Copyright: 2021 www.tydic.com Inc. All rights reserved. 
 */
public class LinkedDeque<E> implements Deque<E> {
	private int size;
	private Node<E> head;
	private Node<E> tail;
	
	private static class Node<E>{
		private Node<E> front;
		private E data;
		private Node<E> next;
		
		public Node(Node<E> front,E e,Node<E> next){
			this.front=front;
			this.data=e;
			this.next=next;
		}
	}
	
	public LinkedDeque(){
		size=0;
		head=null;
		tail=null;
	}

	@Override
	public int size() {
		return size;
	}

	@Override
	public boolean empty() {
		return size==0;
	}

	@Override
	public void addFirst(E e) {
		if(e==null){
			throw new IllegalArgumentException("插入参数为空！！");
		}
		if(size==0){
			head=new Node<E>(null,e,null);
			tail=head;
			size++;
			return;
		}
		Node<E> pre=head;
		head=new Node<E>(null,e,head);
		pre.front=head;
		size++;
	}

	@Override
	public void addLast(E e) {
		if(e==null){
			throw new IllegalArgumentException("插入参数为空！！");
		}
		if(size==0){
			head=new Node<E>(null,e,null);
			tail=head;
			size++;
			return;
		}
		Node<E> pre=tail;
		tail=new Node<E>(tail,e,null);
		pre.next=tail;
		size++;
	}

	@Override
	public E removeFirst() {
		if(size==0){
			throw new RuntimeException("空队列！");
		}
		Node<E> result=head;
		head=result.next;
		if(head!=null){
			head.front=null;
		}
		
		size--;
		if(size==0){
			head=null;
			tail=null;
		}
		return result.data;
	}

	@Override
	public E removeLast() {
		if(size==0){
			throw new RuntimeException("空队列！");
		}
		Node<E> result=tail;
		tail=result.front;
		if(tail!=null){
			tail.next=null;
		}
		size--;
		if(size==0){
			head=null;
			tail=null;
		}
		return result.data;
	}

	@Override
	public E peekFirst() {
		if(size==0){
			throw new RuntimeException("空队列！");
		}
		return head.data;
	}

	@Override
	public E peekLast() {
		if(size==0){
			throw new RuntimeException("空队列！");
		}
		return tail.data;
	}
	
	public static void main(String[] args) {
		Deque<Integer> test=new LinkedDeque<Integer>();
		
		for(int i=1;i<6;i++){
			test.addLast(i);
		}
		
		System.out.println(test.size());
		
		for(int i=1;i<6;i++){
			test.addFirst(i);
		}
		System.out.println(test.size());
		
		for(int i=1;i<6;i++){
			test.removeLast();
		}
		System.out.println(test.size());
		
		for(int i=1;i<6;i++){

			test.removeFirst();
		}
		System.out.println(test.size());
		
		
	}

}

3，链表实现Deque2:
package com.dzlijian.utils.comments;
/**
*

  • @ClassName: Deque

  • @Description:双端队列链表实现2

  • @author: 长子科技

  • @date: 2021年7月7日 下午11:03:32

  • @param

  • @Copyright: 2021 www.tydic.com Inc. All rights reserved.
    */
    public class LinkedDeque2 implements Deque {
    private int size;
    private Node head;
    private Node tail;

    private static class Node{
    private E data;
    private Node next;

     public Node(E e,Node<E> next){
 	this.data=e;
 	this.next=next;
 }

    }

    public LinkedDeque2(){
    size=0;
    head=null;
    tail=null;
    }

    @Override
    public int size() {
    return size;
    }

    @Override
    public boolean empty() {
    return size==0;
    }

    @Override
    public void addFirst(E e) {
    if(enull){
    throw new IllegalArgumentException(“插入参数为空！！”);
    }
    if(size    0){
    head=new Node(e,null);
    tail=head;
    size++;
    return;
    }
    head=new Node(e,head);
    size++;
    }

    @Override
    public void addLast(E e) {
    if(enull){
    throw new IllegalArgumentException(“插入参数为空！！”);
    }
    if(size    0){
    head=new Node(e,null);
    tail=head;
    size++;
    return;
    }

     Node<E> pre=tail;
 tail=new Node<E>(e,null);
 pre.next=tail;
 size++;

    }

    @Override
    public E removeFirst() {
    if(size0){
    throw new RuntimeException(“空队列！”);
    }
    Node result=head;
    head=head.next;
    size–;
    if(size    0){
    head=null;
    tail=null;
    }
    return result.data;
    }

    @Override
    public E removeLast() {
    if(size==0){
    throw new RuntimeException(“空队列！”);
    }
    Node result=tail;
    //使用单向节点，此时需要循环查找，非常耗时。
    Node i=head;
    while(i.next!=tail&&i.next!=null){
    i=i.next;

     }
 tail=i;
 i.next=null;
 size--;
 if(size==0){
 	head=null;
 	tail=null;
 }
 return result.data;

    }

    @Override
    public E peekFirst() {
    if(size==0){
    throw new RuntimeException(“空队列！”);
    }
    return head.data;
    }

    @Override
    public E peekLast() {
    if(size==0){
    throw new RuntimeException(“空队列！”);
    }
    return tail.data;
    }

    public static void main(String[] args) {
    Deque test=new LinkedDeque2();
    for(int i=1;i<6;i++){
    test.addFirst(i);
    }
    System.out.println(test.size());
    for(int i=1;i<6;i++){
    test.addLast(i);
    }

     System.out.println(test.size());
 
 for(int i=1;i<6;i++){
 	test.removeFirst();
 }
 System.out.println(test.size());
 
 for(int i=1;i<6;i++){
 	test.removeLast();
 }
 System.out.println(test.size());

    }

}
,
链表实现的2中方式，区别在于，节点是否有前一个和后一个的节点的地址指针。

一截木化石
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
数据结构之deque双端队列
hanwangyyds的博客
03-09 554
下标随机访问，效率不错，但是跟vector有差距中间插入删除，效率差头插、头删、尾插、尾删效率很不错。所以在容器适配的选择上，什么情况选择deque呢，在头插、头删、尾插、尾删比较多的情况下，可以选择deque。但是如果对中间位置访问比较多，比如优先级队列（本质是堆），就不能选择deque，应该选择vector（性能上差很多！
Java实现循环队列
weixin_30902251的博客
05-03 308
一、分析 　　队列是一种先进先出的线性表，它只允许在表的一端进行插入，而在另一端删除元素。允许插入的一端称为队尾，允许删除的一端称为队头。 　　循环队列是一种以顺序存储结构表示的队列，为了解决“假溢出”问题而将它设计成头尾相接的循环结构，它的基本操作如下： 　　　　1、初始化循环队列 　　　　2、销毁循环队列 　　　　3、清空循环队列 　　　　4、检测循环队列是否为空 　　　　5、返...
C++_deque：deque的数据结构特点
Lvision2的博客
06-03 966
deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。总得来说，deque就像vector和list的结合体，它的尾插与尾删总体上比较好，同时也能头删和头插deque的逻辑结构。
【数据结构】双端队列
SWELER的博客
05-22 851
定义 deque（double-ended queue，双端队列）是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出。 结构示意图 首先每个节点包含一个存储的元素和一个指向下一节点的指针。整个双端队列则只包含一个头（head）节点的指针和一个尾（tail）节点的指针。头节点指向链表的第一个元素，尾节点指向最后一个元素。 定义的代码 struct Node{ T elem; struct Node * next; }; typedef struct Deque{ struct Node
Java数据结构之Deque
qq_44717657的博客
05-11 8706
Java中的Deque、ArrayDeque类详解
【C++STL】deque的结构和使用
weixin_52958292的博客
11-08 595
deque是由一块一块的固定大小的连续空间构成（块与块之间是不连续的）。一旦有必要在deque的前端或者尾端增加新的空间，便配置一块固定大小的连续空间，串接在整个deque的头端或者尾端。deque 的最大任务，便是在这些分块的固定大小连续空间上，维护其整体连续的假象，并提供随机存取的接口(随机迭代器)，代价则是迭代器架构较为复杂。deque 采用一块所谓的_M_map(不是STL的map容器）作为主控。
常见数据结构.zip
最新发布
06-16
同时，C++支持STL（Standard Template Library），其中的容器如vector、list、deque、set、map等都实现了各种数据结构，提供了丰富的操作接口，极大地提高了开发效率。 Java作为一种跨平台的面向对象语言，其数据...
C++数据结构实现之Queue.zip
06-04
在这个"C++数据结构实现之Queue"的主题中，我们将深入探讨队列这种线性数据结构的C++实现。 队列是一种先进先出（First-In-First-Out, FIFO）的数据结构，它在实际应用中广泛用于任务调度、打印队列等场景。在C++中...
python数据结构与算法
01-03
1. **列表(List)**：Python中最常用的数据结构之一，它是一个有序的元素集合，可以容纳不同类型的数据，支持索引和切片操作，通过`append()`、`insert()`、`remove()`等方法进行动态管理。 2. **元组(Tuple)**：...
C++数据结构实现之Stack.zip
06-04
在这个"C++数据结构实现之Stack"的压缩包中，我们主要关注的是栈（Stack）这一基本数据结构的C++实现。 栈是一种后进先出（Last In First Out, LIFO）的数据结构，它的操作类似于一个堆叠物品的过程，新添加的元素...
Java数据结构实现之Stack.zip
06-04
在编程领域，数据结构是组织、管理和存储数据的方式，它为算法的设计和分析提供了坚实的基础。Java作为一种广泛使用的面向对象的编程语言，提供了丰富的数据结构支持。本篇将重点讨论Java中栈（Stack）这一重要数据...
Deque：使用C ++实现数据结构Deque的实现
02-17
双端队列 使用C ++实现数据结构双端队列的实现。 详细信息可以在deque.hpp中查看。 除了该文件之外，还有一些测试示例可以验证双端队列的可靠性和时间效率。 自己检查。
[数据结构] [C++ STL] deque使用详解
m0_73482095的博客
01-25 382
deque（双端队列）是由一段一段的定量连续空间构成，可以向两端发展，因此不论在尾部或头部安插元素都十分迅速。在中间部分安插元素则比较费时，因为必须移动其它元素。#include <deque> // deque属于std命名域的，因此需要通过命名限定，例如using std::deque;// 定义一个int类型的双端队列a// 定义一个int类型的双端队列a，并设置初始大小为10// 定义一个int类型的双端队列a，并设置初始大小为10且初始值都为1// 定义并用双端队列a初始化双端队列b。
数据结构-Dequeue
qq_29286967的博客
07-11 9858
Deque        deque（也称为双端队列）是与队列类似的项的有序集合。它有两个端部，首部和尾部，并且项在集合中保持不变。deque 不同的地方是添加和删除项是非限制性的。可以在前面或后面添加新项。同样，可以从任一端移除现有项。如下展示了一个 Python 数据对象的 deque 。    deque 抽象数据类型由以下结构和操作定义。如上所述，deque 被构造为项的有序集合，其中项从...
数据结构与算法_deque、list、map
刘同学的博客
06-28 567
deque-----双向队列 采用动态数组的方式管理元素，提供随机存储 deque与vector优劣比较： deque头尾两端开放，可以进行快速的删除和插入（vector只能在尾部进行快速的插入和删除） dequed的内部结构相比vector多一个间接过程，元素的存取相比较vector而言会慢一些 dequed 得到迭代器需要一个智能指针，因为裂缝的存在 在对内存区块有限制的系统当中， de...
深入剖析deque容器实现
Keep Moving~
05-02 4542
本文主要深入讲解了deque的内部实现方式，主要介绍了deque中的中控器、迭代器的概念。
STL学习——Deque篇
没有最好，只有更好！
05-06 1905
STL学习——Deque篇 deque概述deque是一种双向开口的连续线性空间。双向开口指可以在头尾两端分别做元素的插入和删除操作。虽然vector也可以在头尾两端进行操作，但是其头部操作效率极差，无法被接受。deque与vector最大差异：1）deque允许于常数时间内对起头端进行元素的插入或移除操作；2）deque没有所谓的容量概念，因为它是动态地以分段连续空间组合而成，随时可以增加一段新的
C++数据结构deque代码
05-17
下面是一个简单的 C++ deque 数据结构实现的示例代码： ``` #include #include <deque> using namespace std; int main() { deque<int> d; // 在队列末尾插入元素 d.push_back(1); d.push_back(2); d.push...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一截木化石

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值