MyQueue＜ T ＞

最新推荐文章于 2024-06-06 20:34:35 发布
最新推荐文章于 2024-06-06 20:34:35 发布
阅读量233 收藏
点赞数
分类专栏： 数据结构 文章标签： java 数据结构 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Coffee_M/article/details/118914515
版权
本文介绍了两种实现方式的MyQueue：MyLinkedQueue使用链表，支持自动扩容；MyCircularQueue基于数组，循环存储并动态调整容量。展示了如何在Java中操作这些队列并进行扩容和循环处理。
摘要由CSDN通过智能技术生成

MyQueue< T >

  在 MyStack 的基础上，仿写了MyQueue。其中基于Array实现的Queue即是循环队列，又实现了队列满后自动增加容量。

  人生苦短，未言自明。

1. MyLinkedQueue

  链表实现更简单，先写链表的实现。双链表的实现是显然的，单链表在实现时，注意到enqueue中的tail。先令tail引用的节点的next链指向新建的节点，然后再让tail去引用新建的节点，就实现了tail变为新增的节点。tail是对象变量，这里充分利用了其引用的特性——我既然单链找不到tail前的节点，那tail就改变自己，再以tail的身份修改了当前的链后，就“不讲道义的变节”，去引用其后的节点。

package MyQueue;

import java.util.NoSuchElementException;

/**
 * 2021/7/20.
 * 
 * @author CatInCoffee.
 */
public class MyLinkedQueue<T> {

	private static class Node<T> {
		public T data;
		public Node<T> next;

		public Node(T paraData) {
			data = paraData;
			next = null;
		} // of Node's first constructor

		public Node(T paraData, Node<T> paraNext) {
			data = paraData;
			next = paraNext;
		} // of Node's second constructor
	} // of class Node<T>

	private Node<T> frontMarker = new Node<>(null);
	private Node<T> rear;
	private int theSize;

	// *****************************************************************************************

	public MyLinkedQueue() {
		clear();
	}// Of the first constructor

	public void clear() {
		rear = frontMarker;
		theSize = 0;
	}// of clear()

	// O(N)
	public MyLinkedQueue(T[] paraArray) {
		this();

		for (int i = 0; i < paraArray.length; i++) {
			enqueue(paraArray[i]);
		} // Of for i

	}// Of the second constructor

	// *****************************************************************************************

	public int size() {
		return theSize;
	}// of size()

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

	// *****************************************************************************************

	public boolean enqueue(T x) {
		Node<T> newNode = new Node<>(x);

		rear.next = newNode;
		rear = newNode;
		theSize++;

		return true;
	}// of enqueue(T)

	public T dequeue() {
		if (!isEmpty()) {
			T old = frontMarker.next.data;
			frontMarker.next = frontMarker.next.next;
			
			if(frontMarker.next == null) {
				rear = frontMarker;
			} // of if

			theSize--;
			return old;
		} else {
			throw new NoSuchElementException();
		} // of if-else

	}// of dequeue()

	// *****************************************************************************************

	public String toString() {
		String s = "It's an empty queue.";

		if (!isEmpty()) {
			s = "{ ";

			Node<T> temp = frontMarker.next;
			while (temp.next != null) {
				s += temp.data + ", ";
				temp = temp.next;
			} // of while
			s += temp.data + " }";

//			for (Node<T> temp = frontMarker.next; temp != null; temp = temp.next) {
//				s += temp.data + " ";
//			} // of for temp
//			s += "}";

		} // of if

		return s;
	}// of toString()

	public static void main(String args[]) {
		Character[] ch = { 't', 'e', 's', 't' };
		MyLinkedQueue<Character> tempQueue = new MyLinkedQueue<>(ch);
		System.out.println("Initialized, the list is: " + tempQueue.toString());

		Character tempValue;
		for (int i = 0; i < 5; i++) {
			try {
				tempValue = tempQueue.dequeue();
				System.out.println("Looped dequeue: " + tempValue + ", the new queue is: " + tempQueue);
			} catch (NoSuchElementException e) {
				System.out.println("Nothing to dequeue.");
				tempQueue.clear();
			} // of try-catch
		} // Of for i

		for (char c = 'a'; c < 'f'; c++) {
			tempQueue.enqueue(Character.valueOf(c));
		} // Of for i
		System.out.println("Enqueued a to e successively, the queue is: " + tempQueue);
		tempQueue.dequeue();
		tempQueue.dequeue();
		System.out.println("Dequeued twice, the queue is: " + tempQueue);

		for (char c = 'f'; c < 'i'; c++) {
			tempQueue.enqueue(Character.valueOf(c));
		} // Of for i
		System.out.println("Enqueued, the queue is: " + tempQueue);
		System.out.println();

		for (int i = 0; i < 4; i++) {
			tempValue = tempQueue.dequeue();
			System.out.println("Looped dequeue: " + tempValue + ", the new queue is: " + tempQueue);
		} // Of for i

		tempQueue.enqueue('?');
		tempQueue.enqueue('!');
		System.out.println("Enqueued: '?' '!', the queue is: " + tempQueue);

	} // Of main

}// of class MyLinkedQueue<T>

  结果：

Initialized, the list is: { t, e, s, t }
Looped dequeue: t, the new queue is: { e, s, t }
Looped dequeue: e, the new queue is: { s, t }
Looped dequeue: s, the new queue is: { t }
Looped dequeue: t, the new queue is: It's an empty queue.
Nothing to dequeue.
Enqueued a to e successively, the queue is: { a, b, c, d, e }
Dequeued twice, the queue is: { c, d, e }
Enqueued, the queue is: { c, d, e, f, g, h }

Looped dequeue: c, the new queue is: { d, e, f, g, h }
Looped dequeue: d, the new queue is: { e, f, g, h }
Looped dequeue: e, the new queue is: { f, g, h }
Looped dequeue: f, the new queue is: { g, h }
Enqueued: '?' '!', the queue is: { g, h, ?, ! }

2. MyCircularQueue

  这是一个基于数组的、实现了自动扩容和循环存储的循环队列。

  自动扩容和循环存储都利用了一个功能，那就是 ensureCapacity(int)，即保证容量。

  首先怎么扩容？
  一般来说，给定一个常数用于给出初始数组大小，如果存放的队列元素个数theSize和数组大小length相同了，那么创建一个大小翻倍的数组，并将原数组拷贝进新数组。

  那在循环存储的时候，队头front在数组中间时enqueue队满了，像贪吃蛇一样尾碰到头了，这时候该怎么扩容？
  ensureCapacity(int)方法就是实现上面的功能（同时可用于初始化），参数如果不小于给定数组规模，那么创建参数大小的数组，并 有条件 的复制。该条件是基于循环数组的特性而产生的，因为循环数组队头front可以为任意位置，所以不能直接复制，而是从front开始；同时数组下标超过length后，要%求模回到循环的前面。特别的，复制扩容后要 重置队头和队尾的位置。

package MyQueue;

import java.util.NoSuchElementException;

/**
 * 2021/7/20.
 * 
 * @author CatInCoffee.
 */
public class MyCircularQueue<T> {

	private static final int DEFAULT_CAPACITY = 5;

	// Sometimes we don't use 'theSize', but it helps to make the code more clear
	// while it costs little.
	private T[] theItems;
	private int theSize;
	private int front;
	private int rear;

	// *****************************************************************************************

	public MyCircularQueue() {
		clear();
	} // Of the first constructor

	public void clear() {
		theSize = 0;
		ensureCapacity(DEFAULT_CAPACITY);
	} // of clear()

	// O(N)
	public MyCircularQueue(T[] paraArray) {
		this();
		rear = paraArray.length - 1;
		theSize = paraArray.length;
		theItems = (T[]) (new Object[DEFAULT_CAPACITY]);

		for (int i = 0; i < paraArray.length; i++) {
			theItems[i] = paraArray[i];
			// enqueue(paraArray[i]);
		} // Of for i
	} // Of the second constructor

	// O(N)
	private void ensureCapacity(int newCapacity) {
		if (newCapacity < DEFAULT_CAPACITY || newCapacity < size()) {
			return;
		} // if

		T[] old = theItems;
		theItems = (T[]) new Object[newCapacity];
		for (int i = 0; i < size(); i++) {
			theItems[i] = old[(front + i) % size()];
		} // of for i
		front = 0;
		rear = size() - 1;
	} // of ensureCapacity(int)

	// *****************************************************************************************

	public int size() {
		return theSize;
	} // of size()

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

	// *****************************************************************************************

	public boolean enqueue(T x) {
		if (theItems.length == size()) {
			ensureCapacity(2 * size() + 1);
		} // of if

		rear++;
		if (rear == theItems.length) {
			rear = 0;
		} // of if
		theItems[rear] = x;

		// The codes above equal to the next one.
//		theItems[(rear++ == theItems.length) ? 0 : rear] = x;

		theSize++;
		return true;
	}// of enqueue(T)

	public T dequeue() {
		if (!isEmpty()) {
			if (front == theItems.length) {
				front = 0;
			} // of if

			T old = theItems[front++];
			theSize--;

			return old;
		} else {
			System.out.print(" !!!Nothing to dequeue!!!  ");
			clear();
			return null;
			// throw new NoSuchElementException();
		} // of if-else

	}// of dequeue()

	// *****************************************************************************************

	public String toString() {
		String s = "An empty queue.";

		if (!isEmpty()) {
			s = "{ ";

			for (int i = front; i <= (front > rear ? (rear + theItems.length) : rear); i++) {
				s += theItems[i % theItems.length] + " ";
			} // of for temp
			s += "}";

		} // of if

		return s;
	}// of toString()

	public int getLength() {
		return theItems.length;
	}// of getLength（）

	public static void main(String args[]) {
		Character[] ch = { 't', 'e', 's', 't' };
		MyCircularQueue<Character> tempQueue = new MyCircularQueue<>(ch);
		System.out.println("Initialized, the list is: " + tempQueue.toString());

		Character tempValue;
		for (int i = 0; i < 5; i++) {
			tempValue = tempQueue.dequeue();
			System.out.println("Looped dequeue: " + tempValue + ", the new queue is: " + tempQueue);
//			try {
//				tempValue = tempQueue.dequeue();
//				System.out.println("Looped dequeue: " + tempValue + ", the new queue is: " + tempQueue);
//			} catch (NoSuchElementException e) {
//				System.out.println("Nothing to dequeue.");
//				tempQueue.clear();
//			} // of try-catch
		} // Of for i

		for (char c = 'a'; c < 'f'; c++) {
			tempQueue.enqueue(Character.valueOf(c));
		} // Of for i
		System.out.println("Enqueued a to e successively, the queue is: " + tempQueue);
		System.out.println("The length of the array to store the queue is: " + tempQueue.getLength() + "\n");
		tempQueue.dequeue();
		tempQueue.dequeue();
		System.out.println("Dequeued twice, the queue is: " + tempQueue);

		for (char c = 'f'; c < 'i'; c++) {
			tempQueue.enqueue(Character.valueOf(c));
		} // Of for i
		System.out.println("Enqueued, the queue is: " + tempQueue);
		System.out.println("The length of the array to store the queue is: " + tempQueue.getLength());

		System.out.println();

		for (int i = 0; i < 4; i++) {
			tempValue = tempQueue.dequeue();
			System.out.println("Looped dequeue: " + tempValue + ", the new queue is: " + tempQueue);
		} // Of for i

		tempQueue.enqueue('?');
		tempQueue.enqueue('!');
		System.out.println("Enqueued: '?' '!', the queue is: " + tempQueue);

	} // Of main

}// of class MyCircularQueue<T>

  结果：

Initialized, the list is: { t e s t }
Looped dequeue: t, the new queue is: { e s t }
Looped dequeue: e, the new queue is: { s t }
Looped dequeue: s, the new queue is: { t }
Looped dequeue: t, the new queue is: An empty queue.
 !!!Nothing to dequeue!!!  Looped dequeue: null, the new queue is: An empty queue.
Enqueued a to e successively, the queue is: { a b c d e }
The length of the array to store the queue is: 5

Dequeued twice, the queue is: { c d e }
Enqueued, the queue is: { c d e f g h }
The length of the array to store the queue is: 11

Looped dequeue: c, the new queue is: { d e f g h }
Looped dequeue: d, the new queue is: { e f g h }
Looped dequeue: e, the new queue is: { f g h }
Looped dequeue: f, the new queue is: { g h }
Enqueued: '?' '!', the queue is: { g h ? ! }
Cat in Coffee
关注
专栏目录
C++算法刷题常用库函数
Daisy_Qw的博客
05-18 2104
常用库： #include<iostream> #include<sstream> #include<vector> #include<string> #include<stack> #include<queue> #include<map> #include<set> #include<algorithm> 1.<iostream><sstream> 见：牛客网输入
c++ STL： priority_queue优先队列
qq_42714490的博客
03-16 391
1. 概述 普通队列queue是一种先进先出的数据结构， priority_queue和queue的区别就在于，在优先队列priority_queue中，元素都被赋予优先级，出队是根据优先级出队，优先级高的先出队。 2. 原型说明 priority_queue优先队列在模板申明带3个参数： priority_queue<Type, Container, Functional>...
嵌入式循环队列-MyQueue
05-14
uC/OS2系统下的高效队列源码，稳定可靠，并优化了运行效率，支持批量插入和读取。开发环境：ads1.2 ads1.2-uC/OS2: systems efficient source queue, stable and reliable, and optimize operational efficiency and support the bulk insert and read.
MyQueue
qq_39286967的博客
06-23 608
public class MyQueue { private Queue> pFuncs = new Queue>(); private Queue pParmters = new Queue(); private Queue> pActions = new Queue>(); private Boolean isRun
MyQueue(队列)
zxx的博客
06-06 913
队列的简单实现
MyQueue Async
qq_39286967的博客
06-24 260
public class MyQueue { private Queue> pFuncs = new Queue>(); private Queue pParmters = new Queue(); private Queue> pActions = new Queue>(); private Boolean isRun
public class MyQueue<T>
05-20
private Stack<T> stack1; private Stack<T> stack2; public MyQueue() { stack1 = new Stack<T>(); stack2 = new Stack<T>(); } public void Enqueue(T item) { stack1.Push(item); } public T ...
IDEA的java代码：自己定义一个泛型类型的队列 MyQueue<T>，定义队列长度等成员变量，顶一个入队和出队等成员函数。写一个主类主函数，进行测试，建一个水果类Fruit类，定义若干个水果对象进行入队和出队操作。定义Student类，进行入队和出队测试。
最新发布
09-24
MyQueue<Student> studentQueue = new MyQueue<>(3); // 可能需要调整容量 studentQueue.enqueue(new Student()); studentQueue.enqueue(new Student()); // 同样尝试出队，验证是否正常工作 } } ``` 在这个...
java代码：自己定义一个泛型类型的队列 MyQueue<T>，定义队列长度等成员变量，顶一个入队和出队等成员函数。写一个主类主函数，进行测试，建一个水果类Fruit类，定义若干个水果对象进行入队和出队操作。定义Student类，进行入队和出队测试。
09-24
MyQueue<Student> studentQueue = new MyQueue<>(3); Student student1 = new Student(); studentQueue.enqueue(student1); // 同样进行入队操作 } } ``` 在这个例子中，我们创建了两个队列，一个用于存储`...
app_myqueue.c
05-23
消息队列 ，包括 消息队列初始化，消息队列出队入队。
力扣 232. 用栈实现队列 C++
ganlanA的博客
10-27 518
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列的支持的所有操作（push、pop、peek、empty）： 实现 MyQueue 类： void push(int x) 将元素 x 推到队列的末尾 int pop() 从队列的开头移除并返回元素 int peek() 返回队列开头的元素 boolean empty() 如果队列为空，返回 true ；否则，返回 false 说明： 你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和
MyQueue 用链表实现队列
LiAphrodite的博客
10-02 237
//自己用链表实现一个队列，一头进一头出 public class MyQueue { static class Node { int value; Node next; Node(int value) { this.value = value; } } private Node ...
MyQueue队列的 数组实现
woyixinyiyi的博客
03-04 2026
package implement; public class MyQueue&lt;T&gt; {//基于数组实现 private int size ;//记录队列的大小 private T [] queue ; private int head;//队头 private int end;//队尾 public MyQueue() { } public MyQueue(...
程序员面试金典--题目解析-3.5 实现一个MyQueue类，使用两个栈实现一个队列
GNin的博客
04-27 794
3.5 题目：实现一个MyQueue类，使用两个栈实现一个队列解法：使用一个new栈push数据，一个old栈pop或peek数据前提是保证把new栈pop出的所有数据，push进old栈，这样old栈的栈顶存放的就是最旧的数据。另外，为了提高效率，等需要peek或remove时，检测old栈是否为空，old栈为空时，把所有new栈中的数据弹出存入old栈。package Queue;    im...
java实现队列MyQueue，底层使用数组实现
Yangziqi_usst的博客
11-02 987
/** * 队列的接口 * 队列是一种先进先出的数据结构 * 队列支持的操作： * 判断队列是否为空 * 判断队列是否已经满了 * 查看队列已经有多少元素 * 将一个元素入队 * 将一个元素出队 * 查看队头的元素，但不出队 * 队列在底层可以用数组实现，也可以用链表实现 * 但不管实现方式如何，都必须满足此接口中的规定 */ public interface MyQueu...
java实现队列MyQueue，底层使用链表实现
Yangziqi_usst的博客
11-02 589
/** * 队列的接口 * 队列是一种先进先出的数据结构 * 队列支持的操作： * 判断队列是否为空 * 判断队列是否已经满了 * 查看队列已经有多少元素 * 将一个元素入队 * 将一个元素出队 * 查看队头的元素，但不出队 * 队列在底层可以用数组实现，也可以用链表实现 * 但不管实现方式如何，都必须满足此接口中的规定 */ public interface MyQueu...
【一】 并发容器基础 -- 1.7 模拟自己的阻塞队列MyQueue 代码
qiu7213的博客
01-30 110
手写模拟一个自己的 阻塞队列 MyQueue package com.example.demo.edu51; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; //定义一个 阻...
【Java】用两个栈实现一个队列Myqueue类
michellechouu的专栏
07-13 1352
栈的特性是先进后出，队列的特性是先进先出 用两个栈实现一个队列的remove（），就是要把第一个栈的元素反转压入第二个栈，再依次弹出即可 队列添加元素add（）要添加在第一个栈里 import java.util.Stack; public class MyQueue { Stack stackNewest, stackOldest; public MyQueue() { stac
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值