队列（Queue）

于 2023-11-16 20:44:42 发布
阅读量47 收藏
点赞数
分类专栏： # 恋上数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54088234/article/details/134450443
版权

队列

简介

队列是一种特殊的线性表，只能在头尾两端进行操作

  • 队尾 (rear) : 只能从队尾添加元素，一般叫做 enQueue，入队
  • 队头 (front) : 只能从队头移除元素，一般叫做 deQueue，出队
  • 先进先出的原则，First In First Out，FIFO

接口设计

优先考虑双向链表

在这里插入图片描述

代码实现

public class Queue<E> {
	private List<E> list = new LinkedList<>();
	
	public int size() {
		return list.size();
	}

	public boolean isEmpty() {
		return list.isEmpty();
	}
	
	public void clear() {
		list.clear();
	}

	public void enQueue(E element) {
		list.add(element);
	}

	public E deQueue() {
		return list.remove(0);
	}

	public E front() {
		return list.get(0);
	}
}

Queue 源码分析

入队：boolean offer(E, e)

出队：E poll()

获取队头元素：E peek()

对比 LinkedList 和 Queue

	java.util.LinkedList<Interger> linkedList;
	java.util.Queue<Integer> queue;

其实 LinkedList 实现了 Deque 接口，而 Deque 接口又实现了 Queue 接口

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
}

总结：

根据源码，不难发现，队列(Queue) 就是通过 LinkedList 来实现的

双端队列(Deque)

双端队列是能在头尾两段添加、删除的队列

deque（double ended queue）

接口设计

在这里插入图片描述

代码实现

基于链表实现接口功能

public class Deque<E> {
	private List<E> list = new LinkedList<>();
	
	public int size() {
		return list.size();
	}

	public boolean isEmpty() {
		return list.isEmpty();
	}
	
	public void clear() {
		list.clear();
	}

	public void enQueueRear(E element) {
		list.add(element);
	}

	public E deQueueFront() {
		return list.remove(0);
	}

	public void enQueueFront(E element) {
		list.add(0, element);
	}

	public E deQueueRear() {
		return list.remove(list.size() - 1);
	}

	public E front() {
		return list.get(0);
	}

	public E rear() {
		return list.get(list.size() - 1);
	}
}

循环队列

循环队列 底层用 动态数组 实现的写法如下（也可用链表）

代码实现

public class CircleQueue<E> {
	private int front;
	private int size;
	private E[] elements;
	private static final int DEFAULT_CAPACITY = 10;
	
	public CircleQueue() {
		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;
	}

	public void enQueue(E element) {
		ensureCapacity(size + 1);
		
		elements[index(size)] = element;
		size++;
	}

	public E deQueue() {
		E frontElement = elements[front];
		elements[front] = null;
		front = index(1);
		size--;
		return frontElement;
	}

	public E front() {
		return elements[front];
	}
	
	@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;
		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;
	}
}

循环双端队列

循环双端队列：可以进行两端添加、删除操作的循环队列

代码

主要代码部分：

  • 从头部入队
  • 从尾部出队
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;
	}
}

模运算优化

尽量避免使用【乘*、除/、模%、浮点数】运算，效率低下

代码修改

	// 循环队列
	private int index(int index) {
		index += front;
		return index - (index >= elements.length ? elements.length : 0);
	}

  // 循环双端队列
	private int index(int index) {
		index += front;
		if (index < 0) {
			return index + elements.length;
		}
		return index - (index >= elements.length ? elements.length : 0);
	}

注意前提条件：

  • 已知 n >= 0，m > 0
  • n % m 等价于 n - (m > n ? 0 : m) 的前提条件: n < 2m

循环队列 clear 细节

	public void clear() {
		for (int i = 0; i < size; i++) {
       // 获取真实索引元素
			elements[index(i)] = null;
		}
		front = 0;
		size = 0;
	}

练习

232.用栈实现队列

力扣地址：232. 用栈实现队列 - 力扣（LeetCode）

思路：

准备 2 个栈: inStack、outStack

  1. 入队时，push 到 inStack 中

  2. 出队时

    • 如果 outStack 为空，将 inStack 所有元素逐一弹出，push 到 outStack，outStack 弹出栈顶元素

    • 如果 outStack 不为空，outStack 弹出栈顶元素

代码实现：

class MyQueue {

	private Stack<Integer> inStack;
	private Stack<Integer> outStack;

    public MyQueue() {
    	inStack = new Stack<>();
    	outStack = new Stack<>();
    }
    
    /** 入队 */
    public void push(int x) {
        inStack.push(x);
    }
    
    /** 出队 */
    public int pop() {
    	checkOutStack();
    	return outStack.pop();
    }
    
    /** 获取队头元素 */
    public int peek() {
    	checkOutStack();
    	return outStack.peek();
    }
    
    /** 是否为空 */
    public boolean empty() {
    	return inStack.isEmpty() && outStack.isEmpty();
    }
    
    private void checkOutStack() {
    	if (outStack.isEmpty()) {
        	while (!inStack.isEmpty()) {
        		outStack.push(inStack.pop());
        	}
        }
    }
}

225.用队列实现栈

力扣地址：225. 用队列实现栈 - 力扣（LeetCode）

checkOutStack();
	return outStack.peek();
}

/** 是否为空 */
public boolean empty() {
	return inStack.isEmpty() && outStack.isEmpty();
}

private void checkOutStack() {
	if (outStack.isEmpty()) {
    	while (!inStack.isEmpty()) {
    		outStack.push(inStack.pop());
    	}
    }
}

}


### 225.用队列实现栈

> 力扣地址：[225. 用队列实现栈 - 力扣（LeetCode）](https://leetcode.cn/problems/implement-stack-using-queues/)
沉梦听雨.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
消息队列 Queue与Topic区别.docx
02-23
消息队列 Queue与Topic区别
C++队列queue基本用法
jiuguaqiao6494的博客
07-13 2171
C++队列queue基本用法定义常用函数 定义 queue <TreeNode*> q; 常用函数 q.push(u) 入队列 q.empty() 判断队列是否为空 q.front() 取队列第一个数的值 q.pop() 删除队列第一个数
Java队列 Queue
赵彦军
10-18 985
Queue 队列（Queue）是一种经常使用的集合。Queue实际上是实现了一个先进先出（FIFO：First In First Out）的有序表。它和List的区别在于，List可以在任意位置添加和删除元素，而Queue只有两个操作： 把元素添加到队列末尾； 从队列头部取出元素。 超市的收银台就是一个队列： 在Java的标准库中，队列接口Queue定义了以下几个方法： int size()：获取队列长度； boolean add(E)/boolean offer(E)：添加元素到队尾； E rem
C++队列queue用法详解
顺其自然~专栏
06-01 4万+
queue是一种容器转换器模板，调用#include< queue>即可使用队列类。初始化时必须要有数据类型，容器可省略，省略时则默认为deque 类型 注意：不能用vector容器初始化queue 因为queue转换器要求容器支持front()、back()、push_back()及 pop_front()，说明queue的数据从容器后端入栈而从前端出栈。所以可以使用deque（double-ended queue，双端队列）和list对queue初始化，而vector因其缺少po
python队列长度_[python模块]队列queue
weixin_39721853的博客
12-03 1945
一、队列queue队列queue 多应用在多线程场景，多线程访问共享变量。对于多线程而言，访问共享变量时，队列queue的线程安全的。因为queue使用了一个线程锁(pthread.Lock())，以及三个条件变量(pthread.condition()),来保证了线程安全。总结：队列提供了一个安全可靠的共享数据使用方案。队列内置控制安全的几个参数，非用户使用名称作用self.mutex互斥锁任何...
Python队列Queue详解，超详细
热门推荐
小鱼干儿的博客
07-08 5万+
python队列实现与用法，queue块是Python内置的标准模块，模块实现了三种类型的队列，它们的区别仅仅是条目取回的顺序，分别由3个类进行表示，Queue，LifoQueue，PriorityQueue先进先出队列
python队列queue模块详解
09-20
主要为大家详细介绍了python队列queue模块的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C#队列Queue用法实例分析
12-31
本文实例分析了C#队列Queue用法。分享给大家供大家参考。具体分析如下： 队列（Queue）在程序设计中扮演着重要的角色，因为它可以模拟队列的数据操作。例如，排队买票就是一个队列操作，后来的人排在后面，先来的人...
c#队列Queue学习示例分享
09-04
队列Queue,先进先出，先生产的货物先出货，后生产的货物后出货，下面看示例学习c#队列Queue
ZooKeeper实现分布式队列Queue
03-03
现在硬件越来越便宜，一台非品牌服务器，2颗24核CPU，配48G内存，2T的硬盘，已经降到2万块人民币以下了。这种配置如果简单地放几个web应用，显然是奢侈的浪费。就算是用来实现单节点的hadoop，对计算资源浪费也是...
python 队列Queue的使用 python2例程展示了队列Queue的使用过程，供学习参考使用
最新发布
08-18
队列：Queuequeue_test.py  put()函数主动改变队列  get()函数阻塞，代替查询  Produser & Consumer  定期生产，一有货就被抢购 from multiprocessing import Process, Pipe def f(conn): conn.send(...
C#队列Queue多线程用法实例
09-03
主要介绍了C#队列Queue多线程用法,实例分析了队列的相关使用技巧,需要的朋友可以参考下
python队列Queue的详解
09-19
主要介绍了python队列Queue，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
设一循环队列Queue，只有头指针front，不设尾指针，另设一个内含元素个数的计数器，试写出相应的进队、出队算法。
04-04
设一循环队列Queue，只有头指针front，不设尾指针，另设一个内含元素个数的计数器，试写出相应的进队、出队算法。
python程序 线程队列queue使用方法解析
09-18
主要介绍了python程序 线程队列queue使用方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
jquery队列queue与原生模仿其实现方法分享
10-26
jquery中的queue和dequeue是一组很有用的方法，他们对于一系列需要按次序运行的函数特别有用。特别animate动画，ajax，以及timeout等需要一定时间的函数
python数据结构：队列Queue
01-20
1.抽象数据类型Queue 1.1 1.2 2.Python实现ADT Queue 采用List来容纳Queue的数据项 将List首端作为队列尾端；List的末端作为队列首端 enqueue()复杂度为O(n) dequeue()复杂度为O(1) class Queue: #初始化 def _...
C语言队列queue.c
01-03
基于C语言的完整队列代码，包含队列的结构定义、判空、出入队、取队头和主函数，入队元素已写入，使用时只需在主函数中修改元素数量和内容即可，使用方便。C语言和数据结构中均可使用
线程安全队列Queue
01-17
在项目启动时，开一个单线程来专门处理巡检任务的下发给巡检服务组件。使用BlockingQueue阻塞算法。BlockingQueue作为线程容器，可以为线程同步提供有力的保障。
python消息队列Queue
07-27
Python中的消息队列可以使用内置的Queue模块来实现。Queue模块提供了多种队列实现，包括先进先出（FIFO）队列、后进先出（LIFO）队列和优先级队列。 要使用Queue模块，首先需要导入它： ```python from queue ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值