循环队列和循环双端队列

最新推荐文章于 2021-07-26 17:59:45 发布
最新推荐文章于 2021-07-26 17:59:45 发布
阅读量560 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 队列 queue deque 循环队列 循环双端队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44096670/article/details/109470606
版权

循环队列（Circular Queue）

在这里插入图片描述

  • 循环队列底层用数组实现。
  • 队列底层也可以使用动态数组实现，并且各项接口也可以优化到O(1)的时间复杂度这个用数组实现优化之后的队列也叫做：循环队列。
    在这里插入图片描述
  • 上述图示：
    ①、front == tail时队列为空
    ②、front==(tail + 1) % c队列为满
    ③、capacity中，浪费一个空间
package com.mj.circle;

public class CircleQueue<E> {
	private int front;
	private int size;
	private E[] elements;
	private static final int DEFAULT_CAPACITY = 10;
	
	@SuppressWarnings("unchecked")
	public CircleQueue() {
		elements = (E[]) new Object[DEFAULT_CAPACITY];
	}
	/* 元素的数量 */
	public int size() {
		return size();
	}
	
	/* 是否为空 */
	public boolean isEmpty() {
		return size==0;
	}
	
	/* 入队 */
	public void enQueue(E element) {
		ensureCapacity(size + 1);
		
		elements[(front + size) % elements.length] = element;
		size++;
	}
	
	private void ensureCapacity(int capacity) {
		int oldCapacity = elements.length;
		if (oldCapacity >= capacity) return;
		
		// 新容量为旧容量的1.5倍
		int newCapacity = oldCapacity + (oldCapacity >> 1);
		E[] newElements = (E[]) new Object[newCapacity];
		for (int i = 0; i < size; i++) {
			newElements[i] = elements[(i + front) % elements.length];
		}
		elements = newElements;
	}
	/* 出队 */
	public E deQueue() {
		E frontElement = elements[front];
		elements[front] = null;
		front = (front + 1) % elements.length;
		size--;
		return frontElement;
	}
	
	/* 获取队列的头元素 */
	public E front() {
		return elements[front];
	}
	
	/* 清空 */
	public void clear() { 
		for (int i = 0; i < size; i++) {
			elements[index(i)] = null;
		}
		front = 0;
		size = 0;
	}
	
	@Override
	public String toString() {
		StringBuilder string = new StringBuilder();
		string.append("capcacity=").append(elements.length)
		.append(" size=").append(size)
		.append(" front=").append(front)
		.append(", [");
		for (int i = 0; i < elements.length; i++) {
			if (i != 0) {
				string.append(", ");
			}
			
			string.append(elements[i]);
		}
		string.append("]");
		return string.toString();
	}
}

测试：

import com.mj.circle.CircleQueue;
public class Main {

	static void test2() {
		CircleQueue<Integer> queue = new CircleQueue<Integer>();
		// 0 1 2 3 4 5 6 7 8 9
		for (int i = 0; i < 10; i++) {
			queue.enQueue(i);
		}
		System.out.println(queue);
		// null null null null null 5 6 7 8 9
		for (int i = 0; i < 5; i++) {
			queue.deQueue();
		}
		System.out.println(queue);
		// 15 16 17 18 19 5 6 7 8 9
		for (int i = 15; i < 20; i++) {
			queue.enQueue(i);
		}
		System.out.println(queue);
		while (!queue.isEmpty()) {
			System.out.print(queue.deQueue()+" ");
		}
		System.out.println();
		System.out.println(queue);
	}
	public static void main(String[] args) {
		test2();
	}
}

运行结果：

capcacity=10 size=10 front=0, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
capcacity=10 size=5 front=5, [null, null, null, null, null, 5, 6, 7, 8, 9]
capcacity=10 size=10 front=5, [15, 16, 17, 18, 19, 5, 6, 7, 8, 9]
5 6 7 8 9 15 16 17 18 19 
capcacity=10 size=0 front=5, [null, null, null, null, null, null, null, null, null, null]

循环队列（Circular Queue）

  • 循环双端队列：可以进行两端添加、删除操作的循环队列
@SuppressWarnings("unchecked")
public class CircleDeque<E> {
	private int front;
	private int size;
	private E[] elements;
	private static final int DEFAULT_CAPACITY = 10;
	
	public CircleDeque() {
		elements = (E[]) new Object[DEFAULT_CAPACITY];
	}
	
	public int size() {
		return size;
	}

	public boolean isEmpty() {
		return size == 0;
	}

	public void clear() {
		for (int i = 0; i < size; i++) {
			elements[index(i)] = null;
		}
		front = 0;
		size = 0;
	}

	/**
	 * 从尾部入队
	 * @param element
	 */
	public void enQueueRear(E element) {
		ensureCapacity(size + 1);
		
		elements[index(size)] = element;
		size++;
	}

	/**
	 * 从头部出队
	 * @param element
	 */
	public E deQueueFront() {
		E frontElement = elements[front];
		elements[front] = null;
		front = index(1);
		size--;
		return frontElement;
	}

	/**
	 * 从头部入队
	 * @param element
	 */
	public void enQueueFront(E element) {
		ensureCapacity(size + 1);
		
		front = index(-1);
		elements[front] = element;
		size++;
	}

	/**
	 * 从尾部出队
	 * @param element
	 */
	public E deQueueRear() {
		int rearIndex = index(size - 1);
		E rear = elements[rearIndex];
		elements[rearIndex] = null;
		size--;
		return rear;
	}

	public E front() {
		return elements[front];
	}

	public E rear() {
		return elements[index(size - 1)];
	}

	@Override
	public String toString() {
		StringBuilder string = new StringBuilder();
		string.append("capcacity=").append(elements.length)
		.append(" size=").append(size)
		.append(" front=").append(front)
		.append(", [");
		for (int i = 0; i < elements.length; i++) {
			if (i != 0) {
				string.append(", ");
			}
			
			string.append(elements[i]);
		}
		string.append("]");
		return string.toString();
	}
	
	private int index(int index) {
		index += front;
		if (index < 0) {
			return index + elements.length;
		}
		return index - (index >= elements.length ? elements.length : 0);
	}
	
	/**
	 * 保证要有capacity的容量
	 * @param capacity
	 */
	private void ensureCapacity(int capacity) {
		int oldCapacity = elements.length;
		if (oldCapacity >= capacity) return;
		
		// 新容量为旧容量的1.5倍
		int newCapacity = oldCapacity + (oldCapacity >> 1);
		E[] newElements = (E[]) new Object[newCapacity];
		for (int i = 0; i < size; i++) {
			newElements[i] = elements[index(i)];
		}
		elements = newElements;
		
		// 重置front
		front = 0;
	}
}

测试：

package com.mj;

import com.mj.circle.CircleDeque;
import com.mj.circle.CircleQueue;

public class Main {
	
	static void test3() {
		CircleDeque<Integer> queue = new CircleDeque<>();
		// 头5 4 3 2 1  100 101 102 103 104 105 106 8 7 6 尾
		
		// 头 8 7 6  5 4 3 2 1  100 101 102 103 104 105 106 107 108 109 null null 10 9 尾
		for (int i = 0; i < 10; i++) {
			queue.enQueueFront(i + 1);
			queue.enQueueRear(i + 100);
		}
		System.out.println(queue);
		// 头 null 7 6  5 4 3 2 1  100 101 102 103 104 105 106 null null null null null null null 尾
		for (int i = 0; i < 3; i++) {
			queue.deQueueFront();
			queue.deQueueRear();
		}
		System.out.println(queue);
		// 头 11 7 6  5 4 3 2 1  100 101 102 103 104 105 106 null null null null null null 12 尾
		queue.enQueueFront(11);
		queue.enQueueFront(12);
		System.out.println(queue);
		while (!queue.isEmpty()) {
			System.out.print(queue.deQueueFront()+" ");
		}
	}

	public static void main(String[] args) {
		test3();
	}
}

运行结果:

capcacity=22 size=20 front=20, [8, 7, 6, 5, 4, 3, 2, 1, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, null, null, 10, 9]
capcacity=22 size=14 front=1, [null, 7, 6, 5, 4, 3, 2, 1, 100, 101, 102, 103, 104, 105, 106, null, null, null, null, null, null, null]
capcacity=22 size=16 front=21, [11, 7, 6, 5, 4, 3, 2, 1, 100, 101, 102, 103, 104, 105, 106, null, null, null, null, null, null, 12]
12 11 7 6 5 4 3 2 1 100 101 102 103 104 105 106
bfhonor
关注
专栏目录
数据结构之循环双端队列
weixin_48492905的博客
11-04 1583
循环双端队列和循环队列在实现上几乎是一样的，需要注意的有以下几点： 1、定义循环变量 front 和 rear 。一直保持这个定义，到底是先赋值还是先移动指针就很容易想清楚了。 ① front：指向队列头部第 1 个有效数据的位置； ② rear：指向队列尾部（即最后 1 个有效数据）的下一个位置，即下一个从队尾入队元素的位置。 2、为了避免“队列为空”和“队列为满”的判别条件冲突，我们有意浪费了一个位置。浪费一个位置是指：循环数组中任何时刻一定至少有一个位置不存放有效元素。 上图所示情况，我们就可以判定
线性表（5）——队列——循环队列、链式队列、双端队列
波波鱼的博客
03-25 280
1.循环队列 C++实现： Queue.h #pragma once #ifndef QUEUE_H #define QUEUE_H template <typename T> class Queue { public: //Queue数据类型表 typedef T Value_Type; typedef T& Value_Reference; typedef ...
LeetCode 641. 设计循环双端队列
yj_coder的博客
05-02 275
题目描述 设计实现双端队列。 你的实现需要支持以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。 insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。 deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 true。...
【LeetCode】641. 设计循环双端队列（Java）
小楊同学的笔记本
10-12 180
设计实现双端队列。 你的实现需要支持以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。 insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。 deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 true。 deleteLast()：从双端队列尾部删除一个元素。如果操作成功返回 true。 getFront()：从双端队列头部获得一个
循环与循环双端队列
却把清梅嗅的博客
01-20 2418
循环队列 是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为 环形缓冲器。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。 为什么使用循环队列？ 这里我们先对 队列 的简单实现进行简单展示，队...
设计循环双端队列
12-21
设计循环双端队列（Circular Double-ended Queue，简称CircDeq）是一种特殊的线性数据结构，它允许在两端进行插入和删除操作。在实际应用中，如在数据缓存、队列操作优化等方面有着广泛用途。本题要求实现一个循环...
java-leetcode题解之第641题设计循环双端队列.zip
06-12
循环双端队列是一种线性数据结构，它允许我们在两端进行插入和删除操作。与普通队列不同，双端队列可以在前端（front）和后端（rear）进行操作，而且当队列为空或满时，不会发生溢出。在循环双端队列中，最后一个...
队列---双端队列与循环队列
m0_46657493的博客
03-23 502
接口与类的继承关系： 双端队列 双端队列：两端都可以进行入队和出队操作的队列 Deque接口—>LinkedList(实现类) 公共方法：isEmpty() / size() / contains() … 当栈使用时： 压栈：push(e) 查看栈顶元素：peek() 弹出栈顶元素：pop() 当单向队列使用时： 插入队列：add(e) 查看队首元素：element() 取出队首元素：remove() 方法： 方法 解释 addFirst(e) / ofterFirs
循环双端队列
AliceRainly的博客
03-30 127
用的是纯列表来做的，效果貌似不太好 class MyCircularDeque: def __init__(self, k: int): self.l=[] self.length=k def insertFront(self, value: int) -> bool: if self.isFull():...
吹牛必备之循环队列与双端循环队列
Demon_LMMan的博客
02-19 1033
循环队列 循环队列概念 所谓的循环队列，其实还是一个队列，从外部调用的接口和实际的功能上看和普通的队列完全没有区别，而之所以它叫循环队列而不是队列，是因为它用于实现的底层逻辑和一般队列不同，一般队列底层采用双向链表，而循环队列底层采用索引不断循环的数组实现。 循环队列操作图示 建立循环队列，势必要先建立一个数组： E elements=(E[]) new Object[8];//其中E表示泛型 假如向队列中入队11，22，33，44这四个元素，则其存储结构如图所示。 此时若将元素55入队列，则直接在尾元
设计：循环双端队列
qq_44793993的博客
07-26 326
文章目录JDK的deque接口实现循环双端队列基于双向链表实现基于循环数组实现 JDK的deque接口 JDK1.6提供了双向队列的接口，它规定了一种双向队列的行为例如：头部插入/删除、尾部插入/删除。如果我们仅仅看deque接口的话（不看collection继承下来的方法），你会发现提供的方法都是基于头尾的。 这个特点可以直接用于实现栈与队列。 Deque接口继承自queue接口，特提供了更多指明方向的方法例如offerFirst、offerLast，如果仅使用Queue接口去接收一个实现类（如Linke
循环队列(普通+双端)
cj1561435010的博客
02-24 495
一、普通循环队列 1、普通循环队列明细        循环队列是针对顺序队列中最大化利用内存空间的一种解决方法，可以解决当队列(数组)不可再插入新元素但队列的实际可用空间并未占满的问题。        相比普通的队列，多了个指向队头的索引，而且也是只能在头部删...
【leetcode】设计循环队列以及双端循环队列
爱科比的博客
04-08 186
1.设计循环队列 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。 你的实现应该支持如下操...
双端循环队列——Letcode641.Design Circular Deque
sHuXnHs
12-18 790
1.题目 设计实现双端队列。 你的实现需要支持以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。 insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。 deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 true。 dele...
java 双端队列_队列 - 双端队列 - 循环队列 - 循环双端队列
weixin_31920157的博客
02-21 329
队列是一种特殊的线性表，只能在头尾两端进行操作队尾(rear):只能从队尾添加元素，一般叫做 enQueue，入队队头(front):只能从队头移除元素，一般叫做 deQueue，出队先进先出的原则，First In First Out，FIFO普通队列 - java实现public class Queue {private LinkedList list = new LinkedList<...
双端队列是不是循环队列
最新发布
06-25
双端队列（deque，全称double-ended queue）和循环队列（circular buffer）都是线性数据结构，但它们有一些关键的区别。 1. 双端队列：deque支持在队列的两端进行插入和删除操作，也就是说，可以在头部（front）或...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值