Java数据结构|队列（含代码）

最新推荐文章于 2024-07-27 23:42:05 发布
最新推荐文章于 2024-07-27 23:42:05 发布
阅读量671 收藏 1
点赞数 1
分类专栏： Java数据结构 文章标签： 数据结构 java 算法 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40418080/article/details/120178427
版权

Java数据结构|队列

队列介绍

  1. 队列是一个有序列表，可以用数组或是链表来实现；
  2. 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的的数据要后取出；
  3. 示意图：（使用数组模拟队列示意图）
    数组模拟队列示意图

数组模拟队列思路

  • 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如上图，其中maxSize是该队列的最大容量；
  • 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量front和rear来分别记录前后端的下标，front会随着数据的输出而改变，而rear则是随着数据输入而改变。
  • 当我们将数据存入队列是称为“addQueue”，addQueue的处理有两个步骤：
    1. 将尾指针往后移，rear+1，当front == rear时，判断列表为空；
    2. 若尾指针rear小于队列的最大下标maxSize-1，则将数据存入rear所指的数组元素中，否则无法存入数据。rear == maxSize是判断为队列满。

代码实现（非环形队列）

数组模拟队列类函数ArrayQueue

// 使用数组模拟队列编写一个ArrayQueue类
class ArrayQueue{
	private int maxSize; // 表示数组的最大容量
	private int front; // 指向队列头（队列第一个数据的前一个位置索引）
	private int rear; // 队列尾（包含队列最后一个数据的位置索引）
	private int[] arr; // 该数组用于存放数据，模拟队列
	
	// 创建队列的构造器
	public ArrayQueue(int arrMaxSize){
		maxSize = arrMaxSize;
		arr = new int[maxSize];
		front = -1; // 指向队列头部，分析出front是指向队列头的前一个位置
		rear = -1; // 指向队列尾，指向队列尾的数据也就是数组的最后一个数据
	}
	
	// 判断队列为空
	public boolean isEmpt(){
		return front == rear; 
	}
	
	// 判断队列是否满列
	public boolean isFull(){
		return rear == maxSize - 1;
	}
	
	// 入队列（添加数据到队列）
	public void addQueue(int data){
		// 先判断是否为满队列
		if(isFull()){
			System.out.println("队列满，无法加入数据！");
			return;
		}
		rear++;
		arr[rear] = data;
	}
	
	// 出队列（获取队列的数据）
	public int getQueue(){
		// 先判断是否为空队列
		if(isEmpt()){
			throw new RuntimeException("队列空，无法获取数据");
		}
		front++;
		return arr[front];
	}
	
	// 显示队列的所有数据（遍历实现）
	public void showQueue(){
		if(isEmpt()){
			System.out.println("空队列，无数据");
			return;
		}
		for(int i = 0; i<arr.length; i++ ){
		// i = front +1;
			System.out.printf("arr[%d]=%d\n", i, arr[i]);
		}
	}
	
	// 显示队列的头数据（注意不是取出数据）
	public int headQueue(){
		if(isEmpt()){
			throw new RuntimeException("空队列，无数据");
		}
		return arr[front + 1];
	}	
}

测试代码

package priv.wdragon.queue;
/*
 * 队列介绍
 * 数组模拟队列思路
 */
import java.util.Scanner;
public class ArrayQueueTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 测试arrayQueue
		// 首先创建一个队列
		ArrayQueue queue = new ArrayQueue(3);
		char key = ' ';// 接收用户的输入指令
		Scanner scanner = new Scanner(System.in);
		boolean loop = true;
		// 输出一个菜单
		while(loop){
			System.out.println("s(show)：显示队列");
			System.out.println("e(exit)：退出程序");
			System.out.println("a(add)：添加数据到队列");
			System.out.println("g(get)：从队列中取出数据");
			System.out.println("h(head)：显示队列头的数据");
			key = scanner.next().charAt(0);// 接收一个字符
			switch (key) {
			case 's':
				queue.showQueue();
				break;
			case 'e':
				scanner.close();
				loop = false;
				break;
			case 'a':
				System.out.println("请输入要加入队列的数（int):");
				int data = scanner.nextInt();
				queue.addQueue(data);
				break;
			case 'g':
				try {
					int result = queue.getQueue();
					System.out.printf("取出的数据是：%d\n", result);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case 'h':
				try {
					int result = queue.headQueue();
					System.out.printf("队列头的数据是：%d\n", result);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;

			default:
				break;
			}
		}
		System.out.println("程序已退出");	
	}

}

测试结果

s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
a
请输入要加入队列的数（int):
14
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
s
arr[0]=14 arr[1]=0 arr[2]=0 s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
g
取出的数据是：14
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
s
空队列，无数据
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
a
请输入要加入队列的数（int):
12
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
s
arr[0]=14 arr[1]=12 arr[2]=0 s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
a
请输入要加入队列的数（int):
4
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
s
arr[0]=14 arr[1]=12 arr[2]=4 s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
a
请输入要加入队列的数（int):
4
队列满，无法加入数据！
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
g
取出的数据是：12
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
s
arr[0]=14 arr[1]=12 arr[2]=4 s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
g
取出的数据是：4
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
s
空队列，无数据
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据

测试结果分析

我们发现此时用数组模拟的队列，当数据出队列之后，之前的位置不能再利用了，当判断队列为空的时候，实际上数组还是有数据的。当所有数据全部出队列以后，此时rear == front 同时也满足rear == maxSize - 1，也就是及判断为空队列，又是满队列。
因此，接下来利用这个数组改进成一个循环队列，取模：%。

数组模拟环形队列

对前面的数组模拟队列的优化，充分利用数组，因此将数组看成是一个环形的。通过取模的方式来实现。

分析思路

  1. front变量的含义调整为：头队列数据所处的位置索引；初始化front = 0；
  2. rear变量的含义调整为：尾队列数据的后一个位置的索引。因为希望空出一个空间作为约定。初始化rear = 0；
  3. 满队列的判断条件：(rear + 1) % maxSize == front；
  4. 空队列的判断条件：rear == front；
  5. 此时，队列中的有效数据的个数：(rear - front + macSize) % macSize；
    循环队列

代码实现（环形队列）

数组模拟环形队列类函数CircleArrayQueue

class CircleArrayQueue {
	private int maxSize; // 表示数组的最大容量
	private int front; // 指向队列头数据的位置索引
	private int rear; // 队列尾数据的后一个位置的索引，默认空余出来一个空间
	private int[] arr; // 该数组用于存放数据，模拟循环队列

	// 创建队列的构造器
	public CircleArrayQueue(int arrMaxSize) {
		maxSize = arrMaxSize;
		arr = new int[maxSize];
		front = 0; // 指向队列头数据的位置索引
		rear = 0; // 队列尾数据的后一个位置的索引，默认空余出来一个空间
		// 已经初始化，front = 0 和 rear = 0 可以不写
	}

	// 判断队列为空
	public boolean isEmpt() {
		return front == rear;
	}

	// 判断队列是否满列
	public boolean isFull() {
		return (rear + 1) % maxSize == front;
	}

	// 入队列（添加数据到队列）
	public void addQueue(int data) {
		// 先判断是否为满队列
		if (isFull()) {
			System.out.println("队列满，无法加入数据！");
			return;
		}
		arr[rear] = data;
		// 先直接加数据至rear处，然后rear再后移，此时因为是循环队列，所以考虑取模
		rear = (rear + 1) % maxSize;
	}

	// 出队列（获取队列的数据）
	public int getQueue() {
		// 先判断是否为空队列
		if (isEmpt()) {
			throw new RuntimeException("队列空，无法获取数据");
		}
		// 要先将头部的数据暂存位一个变量，因为循环队列front的含义导致先取数据然后再后移，
		// 如果先取出来（return）的话，front就没有机会后移了，front后移也要注意取模
		int value = arr[front];
		front = (front + 1) % maxSize;
		return value;
	}

	// 获取队列中有效数据的个数
	public int validSize() {
		return (rear - front + maxSize) % maxSize;
	}

	// 显示队列的所有数据（遍历实现，循环队列是注意取模）
	public void showQueue() {
		if (isEmpt()) {
			System.out.println("空队列，无数据");
			return;
		}
		for (int i = front; i < front + validSize(); i++) {
			System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
		}
	}

	// 显示队列的头数据（注意不是取出数据）
	public int headQueue() {
		if (isEmpt()) {
			throw new RuntimeException("空队列，无数据");
		}
		return arr[front];
	}
}

测试代码

import java.util.Scanner;

public class CircleArrayQueueTest {

public static void main(String[] args) {
	// TODO Auto-generated method stub
	// 测试CircleArrayQueue
	// 首先创建一个循环队列
	CircleArrayQueue queue = new CircleArrayQueue(4);
	// 因为我们定义循环队列的时候默认了一个空余的空间，所以实际有效数据最多为3
	char key = ' ';// 接收用户的输入指令
	Scanner scanner = new Scanner(System.in);
	boolean loop = true;
	// 输出一个菜单
	while (loop) {
		System.out.println("s(show)：显示队列");
		System.out.println("e(exit)：退出程序");
		System.out.println("a(add)：添加数据到队列");
		System.out.println("g(get)：从队列中取出数据");
		System.out.println("h(head)：显示队列头的数据");
		key = scanner.next().charAt(0);// 接收一个字符
		switch (key) {
		case 's':
			queue.showQueue();
			break;
		case 'e':
			scanner.close();
			loop = false;
			break;
		case 'a':
			 System.out.println("请输入要加入队列的数（int):");
			 int data = scanner.nextInt();
			 queue.addQueue(data);
			break;
		case 'g':
			try {
				int result = queue.getQueue();
				System.out.printf("取出的数据是：%d\n", result);
			} catch (Exception e) {
				// TODO: handle exception
				System.out.println(e.getMessage());
			}
			break;
		case 'h':
			try {
				int result = queue.headQueue();
				System.out.printf("队列头的数据是：%d\n", result);
			} catch (Exception e) {
				// TODO: handle exception
				System.out.println(e.getMessage());
			}
			break;

		default:
			break;
		}
	}
	System.out.println("程序已退出");

}

}

测试结果

s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
a
请输入要加入队列的数（int):
4
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
a
请输入要加入队列的数（int):
6
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
a
请输入要加入队列的数（int):
8
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
a
请输入要加入队列的数（int):
9
队列满，无法加入数据！
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
s
arr[0]=4
arr[1]=6
arr[2]=8
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
g
取出的数据是：4
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
s
arr[1]=6
arr[2]=8
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
g
取出的数据是：6
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
g
取出的数据是：8
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
g
队列空，无法获取数据
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
s
空队列，无数据
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
a
请输入要加入队列的数（int):
8
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据
s
arr[3]=8
s(show)：显示队列
e(exit)：退出程序
a(add)：添加数据到队列
g(get)：从队列中取出数据
h(head)：显示队列头的数据

测试结果分析

如上图测试结果展示，我们完成了一个循环队列的创建，充分利用了数组的位置，队列对应于数组的索引达到了动态改变的效果。

收获

实现了数组模拟队列和循环的创建和增删改等一系列操作，这里注意一些算法的技巧，比如取模（也就是正数取余）可以实现环形数组，以后类似的题目可以凭经验很快给出解题方案。

达卜六幺幺
关注
专栏目录
Java - 数据结构，队列
ryy1999的博客
02-25 946
普通队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(FirstIn First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头（Head/Front）双端队列：可以在对头或者队尾进行插入或者删除操作。普通队列和双端队列从上面知道双向列表可以当普通队列使用，也可以当双端队列使用，也可以当栈使用。
数据结构-队列(Queue)介绍和Java示例代码
07-01
队列是一种重要的线性数据结构，它遵循先进先出（FIFO）的规则，即最先插入的元素将最先被移除。在计算机科学中，队列广泛应用于各种算法和程序设计中，尤其在处理需要顺序处理任务的场景下。在Java中，队列可以借助...
java队列源码
09-25
实现多线程队列抢购等功能源码,Java多线程总结之线程安全队列Queue
数据结构队列Java代码实现
rotry11的博客
10-21 267
队列 队列介绍 ​ 1）队列是一个有序列表，可以用数组或是链表来实现 ​ 2）遵循先入先出的原则 ​ 3）示意图 数组模拟队列 ​ **思路分析：**当我们将数据存入队列时称为”addQueue“，addQueue的处理需要两个步骤： ​ 1）将尾部指针往后移动：rear + 1，当rear == front【空队列】 ​ 2）若尾部指针rear小于队列最大下标，则表示可以将数据存入队列中，否则无法存入数据。rear==maxSize-1【满队列】 ​ ​ 代码实现： //使用数组模拟队列
Java常见数据结构
最新发布
xycxycooo的博客
07-27 681
数组：固定大小，随机访问。链表：动态大小，插入和删除效率高。栈：后进先出（LIFO）。队列：先进先出（FIFO）。树：层次结构，常用二叉树、二叉搜索树等。图：复杂关系，常用有向图、无向图等。通过以上详细的概念解释和编程示例，相信大家已经对Java中常见的数据结构有了更深入的理解。在实际编程中，根据具体需求选择合适的数据结构，可以提高程序的性能和可维护性。
java队列的代码_java实现队列的详细代码
weixin_32820457的博客
02-28 754
一、什么是队列结构一种线性结构，具有特殊的运算法则【只能在一端(队头)删除，在另一端(队尾)插入】。分类：顺序队列结构链式队列结构基本操作：入队列出队列二：准备数据static final int QUEUELEN=15;class DATA{String name;int age;}class SQType{DATA date[]=new DATA[QUEUELEN];int head;in...
Java实现队列结构的详细代码
weixin_30352645的博客
04-06 127
一、什么是队列结构 一种线性结构，具有特殊的运算法则【只能在一端（队头）删除，在另一端（队尾）插入】。 分类： 顺序队列结构 链式队列结构 基本操作： 入队列 出队列 二、准备数据 1 static final int QUEUELEN = 15; 2 3 class DATA{ 4 5 String name;...
数据结构之队列的java实现
不忘初心
03-05 104
队列在计算机术语中使用queue,和list(排)其实是一个意思。队列也是一种数据结构，类似于栈，只是与栈相反，在队列中最先插入的数据也最先被移除，即先进先出(FIFO,First In First Out)。队列可以理解成排队，比如，食堂窗口排的队，越在前面的，越早得到服务而先离开。在银行大厅的排号的机器也许就用了队列这个数据结构。在打印的时候，有“添加到队列”的选项，队列应用是很广泛的。队列的...
java实现队列数据结构代码详解
08-28
"java实现队列数据结构代码详解" 本文主要介绍了 Java 实现队列数据结构的代码详解，包括队列结构的介绍、队列实现的代码和队列的应用场景。 队列结构是一种线性结构，具有特殊的运算法则：只能在一端（队头）删除...
Java数据结构之队列的简单定义与使用方法
08-29
Java数据结构之队列的简单定义与使用方法 Java数据结构之队列是计算机科学中的一种基本数据结构，具有先进先出的特点。队列是一种特殊的线性表，元素的添加和删除只能在队列的两端进行，即队头和队尾。Java中实现...
java编程队列数据结构代码示例
08-28
Java 编程队列数据结构代码示例主要介绍了 Java 编程队列数据结构代码示例，简单介绍了队列的相关基础知识，然后通过实例向大家展示其实现方法，具有一定参考价值，需要的朋友可以了解下。 队列是一种特殊的线性表...
JAVA队列代码
weixin_42660202的博客
09-29 174
//ArrayBlockingQueue数组队列与链表队列的使用的锁的形式不同,数组队列存入与取出都使用的同一把锁,链表队列存入使用一把锁,取出使用一把锁,两把锁相互独立,两种队列线程安全,链表队列的存入与取出性能更佳 private static BlockingQueue<Object> blockingQueue = new ArrayBlockingQueue(10000)...
数据结构 队列以及Java代码实现
Heqianqian的博客
07-14 764
1. 队列队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 队尾(rear)——允许插入的一端 队头(front)——允许删除的一端 队列特点：先进先出(FIFO)结构模型：2.顺序循环队列/** * Queue * 队列的基本操作 * （1）清空队列
Java数据结构 | 队列的代码实现
憨憨李四的博客
12-12 149
import java.util.Scanner; /** * @author lijia * @version 1.0 */ public class ArrayQueueTest { public static void main(String[] args) { //创建一个队列 ArrayQueue queue = new ArrayQueue(6); char value = ' '; //接受用户输入 Scann
【数据结构】队列及其Java代码实现
泡^泡
05-04 461
队列及其Java代码实现
Java数据结构-队列
Vampire的博客
04-04 1233
队列，循环队列
数据结构 - 队列（非环形队列，以及优化成环形队列）
chun的博客
09-29 2029
1）队列的定义与实现形式-方式 2）队列实现思路（非环形，下面进行优化） 3）代码实现（注意并不是环形） package DataStructures.queue; import java.util.Scanner; /** * 使用数组模拟队列 */ public class ArrayQueueDemo { public static void main(String []...
【Java数据结构】队列
程序猿之洞
12-14 1102
队列 先进先出的线性表，它只允许在一端(队尾)进行插入操作，在另一端（队首）进行删除操作。与栈的插入和删除都在栈顶进行不同。 1.普通队列 实例代码: 存储类型为long的队列 package cn.deu; public class Queue { //队列组合 private long [] arr; //数组最大值 private int Ma
Java数据结构：队列模型详解与Java实现
数据结构课程的核心内容是用Java语言来实现各种数据结构，包括但不限于数组、链表、队列、栈等。此外，还会涉及递归这一重要概念，以及数据类型，如基本数据类型（如整数、浮点数、字符和布尔值）和构造数据类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值