Java实现栈和队列

最新推荐文章于 2024-01-19 20:48:16 发布
最新推荐文章于 2024-01-19 20:48:16 发布
阅读量500 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 栈和队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010723885/article/details/37925269
版权

一、  栈

 

1、概念

         栈是一种特殊的线性表，它只能在栈顶(top)进行插入(push)和删除(pop)操作。

 




栈的常用操作：

入栈(push)：向栈顶插入元素

出栈(pop):从栈顶删除元素

访问栈顶元素(peek)：访问栈顶元素

2、 栈的顺序结构的实现

public class SequenceStack<T> {

	private Object[] elementData; //数组用于承装元素 
	private int DEFAULT_SIZE = 20; //初始数组默认大小
	private int capacity;
	private int capacityIncrement = 5;
	private int size = 0; <span style="color:#009900;">//栈中当前容量
</span>	public SequenceStack(){
		capacity = DEFAULT_SIZE;
		elementData = new Object[capacity];
	}
	public SequenceStack(T element){
		this();
		elementData[0] = element;
		size++;
	}
	public int length(){     <span style="font-family: Arial, Helvetica, sans-serif;">//返回栈的长度</span></span>
		return this.size;
	}
	
	<span style="color:#009900;">//入栈操作</span>
	public void push(T element){
		this.ensureCapacity();
		elementData[size] = element;
		size++;
	}
	
	<span style="color:#009900;">//出栈操作</span>
	public T pop(){
		T popElement = (T)elementData[size-1];
		size--;
		return popElement;
	}
	
	<span style="color:#009900;">//访问栈顶元素</span>
	public T peek(){
		return (T)elementData[size-1];
	}
	
	<span style="color:#009900;">//判断是否为空</span>
	public boolean isEmpty(){
		boolean b = false;
		if(size == 0){
			b = true;
		}
		return b;
	}
	
	<span style="color:#009900;">//清空栈</span>
	public void clear(){
		for(Object o:elementData){
			o = null;
		}
		size = 0;
	}
	
	<span style="color:#009900;">//遍历栈</span>
	public void view(){
		System.out.print("当前栈中元素为：");
		for(int i = 0;i < size;i++){
			System.out.print(elementData[i] + " ");
		}
		System.out.println();
	}
	
	<span style="color:#009900;">//栈容量检测与扩充</span>
	public void ensureCapacity(){
		if(capacityIncrement > 0){
			while((size+1) > capacity){
				capacity+=capacityIncrement;
			}
		}
		else{
			while((size+1) > capacity){
				capacity = capacity * 2;
			}
		}
	}
	
	public static void main(String[] args) {
		SequenceStack<String> sequenceStack = new SequenceStack<> ();
		sequenceStack.push("hello");
		sequenceStack.push("world");
		sequenceStack.push("perfect");
		System.out.print("入栈操作后，");
		sequenceStack.view();
		sequenceStack.pop();
		System.out.print("出栈操作后，");
		sequenceStack.view();
		System.out.println("当前栈顶元素为：" + sequenceStack.peek());
		sequenceStack.clear();
		System.out.println("clear之后，栈是否为空：" + sequenceStack.isEmpty());
	}
}


3、栈的链式结构的实现：

public class LinkedStack<T> {

	private class Node{
		private T data;
		private Node next;
		public Node(){
			
		}
		public Node(T element,Node next){
			this.data = element;
			this.next = next;
		}
	}
	
	private Node top;
	private int size = 0;
	
	public LinkedStack(){

	} 
	
	public LinkedStack(T element){
		top = new Node(element,null);
		size++;
	}
	//获取栈大小
	public int length(){
		return size;
	}
	//入栈操作
	public void push(T element){
		Node newNode;
		newNode = new Node(element, top);
		top = newNode;
		size++;
	}
	//出栈操作
	public T pop(){
		Node oldNode = top;
		top = top.next;
		oldNode.next = null;
		size--;
		return oldNode.data;
	}
	
	//获取栈顶元素
	public T peek(){
		return top.data;
	}
	
	//清空栈
	public void clear(){
		top = null;
		size = 0;
	}
	
	public boolean isEmpty(){
		if(size == 0){
			return true;
		}
		return false;
	}
	
	//遍历栈中元素
	public void view(){
		Node currentNode = top;
		System.out.print("栈中元素为：");
		while(currentNode != null){
			System.out.print(currentNode.data + " ");
			currentNode = currentNode.next;
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
		LinkedStack<String> linkedStack = new LinkedStack<>();
		linkedStack.push("hello");
		linkedStack.push("world");
		linkedStack.push("perfect");
		System.out.print("入栈操作后，");
		linkedStack.view();
		linkedStack.pop();
		System.out.print("出栈操作后，");
		linkedStack.view();
		System.out.println("当前栈顶元素为：" + linkedStack.peek());
		linkedStack.clear();
		System.out.println("clear之后，栈是否为空：" + linkedStack.isEmpty());
	}
}


二、        队列 

1、概念

队列是一种被限制的线性表，它只允许在表的前端(front，即队尾)进行删除操作，只允许在表的后端(rear，即队头)进行插入操作

 

 

 

常用操作：

加入元素：向队列rear端插入元素

删除元素：从队列的front端删除元素

访问队列front端元素：

2、队列的顺序存储结构及实现

public class SequenceQueue<T> {

	private int DEFAULT_SIZE = 20;
	private int capacity;
	private int front = 0; 
	private int rear = 0;
	private Object[] elementData;
	public SequenceQueue(){
		capacity = DEFAULT_SIZE;
		elementData = new Object[capacity];
	}
	public SequenceQueue(T element){
		this();
		elementData[0] = element;
		rear++;
	}
	<span style="color:#009900;">// 获取队列长度</span>
	public int length(){
		return rear-front;
	}
	
	<span style="color:#009900;">//向队列尾添加元素</span>
	public void add(T element){
		if(rear > capacity-1){
			throw new IndexOutOfBoundsException("队列已满");
		}
		elementData[rear++] = element;
	}
	
	<span style="color:#009900;">//删除队列头元素</span>
	public T remove(){
		if((rear-front) == 0){
			throw new IndexOutOfBoundsException("队列为空，不能删除");
		}
		T remove = (T)elementData[front];
		elementData[front++] = null;
		return remove;
	}
	
	<span style="color:#009900;">//获取队列头部元素</span>
	public T getElement(){
		return (T)elementData[front];
	}
	
	<span style="color:#009900;">//判断队列是否为空</span>
	public boolean isEmpty(){
		return (rear-front) == 0;
	}
	
	<span style="color:#009900;">//清空队列</span>
	public void clear(){
		Arrays.fill(elementData, null);
		front = 0;
		rear = 0;
	}
	
	<span style="color:#009900;">//遍历队列</span>
	public void view(){
		System.out.print("队列中元素为：");
		for(int i = front;i < rear; i++){
			System.out.print(elementData[i] + " ");
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
		SequenceQueue<String> sequenceQueue = new SequenceQueue<> ();
		sequenceQueue.add("hello");
		sequenceQueue.add("world");
		sequenceQueue.add("perfect");
		sequenceQueue.view();
		System.out.println("执行remove删除的元素为：" + sequenceQueue.remove());
		System.out.println("队列头部元素为：" + sequenceQueue.getElement());
		sequenceQueue.clear();
		System.out.println("clear之后队列长度：" + sequenceQueue.length());
		
	}

}

3、顺序存储结构的循环队列

public class LoopSequenceQueue<T> {

	private int DEFAULT_SIZE = 5;
	private int capacity;
	private int front = 0;
	private int rear = 0;
	private Object[] elementData;
	
	public LoopSequenceQueue(){
		capacity = DEFAULT_SIZE;
		elementData = new Object[capacity];
	}
	
	public LoopSequenceQueue(T element){
		this();
		elementData[0] = element;
		rear++;
	}
	
	<span style="color:#009900;">//获取队列长度</span>
	public int length(){
		if(isEmpty()){
			return 0;
		}
		return rear > front?rear-front:(capacity-(front-rear));
	}
	
	<span style="color:#009900;">//向队列中插入元素</span>
	public void add(T element){
		if(rear == front && elementData[front] != null){
			throw new IndexOutOfBoundsException("队列已满");
		}
		elementData[rear] = element;
		rear = (rear+1) > (capacity-1)?0:(++rear);
	}
	
	<span style="color:#009900;">//从队列头删除元素</span>
	public T delete(){
		if(isEmpty()){
			throw new IndexOutOfBoundsException("队列为空");
		}
		T del = (T)elementData[front];
		elementData[front] = null;
		front = (front+1) > capacity?0:++front;
		return del;
	}
	
	<span style="color:#009900;">//清空队列</span>
	public void clear(){
		Arrays.fill(elementData, null);
		front = 0;
		rear = 0;
	}
	
	<span style="color:#009900;">//遍历队列</span>
	public void view(){
		System.out.print("队列中元素为：");
		if(front < rear){
			for(int i = front;i < rear;i++){
				System.out.print(elementData[i] + " ");
			}
		}
		else{	
			for(int i = front;i < capacity;i++)
				System.out.print(elementData[i] + " ");
			for(int i = 0;i < rear;i++)
				System.out.print(elementData[i] + " ");
		}
	}
	
	<span style="color:#009900;">//判断队列是否为空</span>
	public boolean isEmpty(){
		if(front == rear && elementData[front] == null){
			return true;
		}
		return false;
	}
	
	public static void main(String[] args) {
		LoopSequenceQueue<String> loopSequenceQueue = new LoopSequenceQueue<>();
		loopSequenceQueue.add("hello");
		loopSequenceQueue.add("world");
		loopSequenceQueue.add("perfect");
		loopSequenceQueue.add("3333333");
		loopSequenceQueue.delete();
		loopSequenceQueue.add("4444444444");
		loopSequenceQueue.add("555555555");
		loopSequenceQueue.view();
		System.out.println("当前队列长度为：" + loopSequenceQueue.length());
		
		
	}

}


4、队列的链式存储结构

public class LinkedQueue<T> {

	private class Node{
		private T data;
		private Node next;
		public Node(){
			
		}
		
		public Node(T element,Node next){
			this.data = element;
			this.next = next;
		}
	}
	
	private Node front;
	private Node rear;
	private int size = 0;
	public LinkedQueue(){
		this.front = null;
		this.rear = null;
	}
	
	public LinkedQueue(T element){
		rear = new Node(element,null);
		front = rear;
		size++;
	}
	<span style="color:#009900;">//获取队列长度</span>
	public int length(){
		return size;
	}
	
	<span style="color:#009900;">//从队尾插入元素</span>
	public void add(T element){
		Node newNode = new Node(element,null);
		if(rear == null){
			rear = newNode;
			front = rear;
		}
		else{
			rear.next = newNode;
			rear = newNode;
		}
		
		size++;
	}
	<span style="color:#009900;">//删除队头元素</span>
	public T remove(){
		if(size == 0){
			throw new IndexOutOfBoundsException("队列为空，不能删除");
		}
		Node delNode = front;
		front = front.next;
		delNode.next = null;
		size--;
		return delNode.data;
	}
	
	<span style="color:#009900;">//清空队列</span>
	public void clear(){
		front = null;
		rear = null;
		size = 0;
	}
	
	<span style="color:#009900;">//遍历队列元素</span>
	public void view(){
		System.out.print("队列中元素为：");
		Node currentNode = front;
		while(currentNode != null){
			System.out.print(currentNode.data + " ");
			currentNode = currentNode.next;
		}
		System.out.println();
	}
	
	
	public static void main(String[] args) {
		LinkedQueue<String> linkedQueue = new LinkedQueue<> ();
		linkedQueue.add("hello");
		linkedQueue.add("world");
		linkedQueue.add("perfect");
		linkedQueue.add("3333333");
		linkedQueue.remove();
		linkedQueue.add("4444444444");
		linkedQueue.add("555555555");
		linkedQueue.view();
		System.out.println("当前队列长度为：" + linkedQueue.length());
		
	}

}

三、二者之间的相互转换

1、用两个栈模拟一个队列

//用栈A和栈B模拟队列Q，A为插入栈，B为弹出栈。
//入队列：入栈A。
//出队列：(1)如果栈B不为空，直接弹出B数据.(2)如果B为空，依次弹出A的数据，放入栈B中，再弹出栈B的数据。
public class StacksToQueue<E>
{
	Stack<E> stack1 = new Stack<> ();
	Stack<E> stack2 = new Stack<> ();
	
	//向队列尾部添加元素
	public void add(E element)
	{
		stack1.add(element);
	}
	
	//从队列头删除元素
	public E poll()
	{
		if(stack2.isEmpty())	//先检查stack2是否为空
		{
			if(stack1.isEmpty())	//stack2为空时，检查stack1是否为空
			{
				System.out.println("队列为空，poll操作失败！");
				return null; 
			}
			while(!stack1.isEmpty())
				stack2.push(stack1.pop());
		}
		return stack2.pop();
	}
	
	public static void main(String[] args)
	{
		StacksToQueue<Integer> queue = new StacksToQueue<>();
		queue.add(2);
		queue.add(5);
		queue.add(3);
		queue.add(8);
		System.out.println(queue.poll());
		System.out.println(queue.poll());
		System.out.println(queue.poll());
		System.out.println(queue.poll());
	}
}

2、用两个队列模拟一个栈 

//先入栈：所有元素进入queue1.出栈的时候判断栈元素个数是否为1，如果为1，则queue1出队；如果不为1，queue1所有
//元素出队列，入queue2，最后一个元素不入queue2，输出该元素，然后queue2所有元素入queue1.实现了先进后出。
public class QueuesToStack<E>
{
	LinkedList<E> queue1 = new LinkedList<> ();
	LinkedList<E> queue2 = new LinkedList<> ();
	
	public void push(E element)
	{
		queue1.add(element);
	}
	
	public E pop()
	{
		if(queue1.size() == 0)
		{
			System.out.println("栈为空，pop失败！");
			return null;
		}
		while(queue1.size() != 1)
		{
			queue2.offer(queue1.poll());
		}
		E element = queue1.poll();
		while(!queue2.isEmpty())
			queue1.offer(queue2.poll());
		return element;
	}
	
	public static void main(String[] args)
	{
		QueuesToStack<Integer> stack = new QueuesToStack<>();
		stack.push(5);
		stack.push(4);
		stack.push(3);
		stack.push(2);
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		stack.push(1);
		System.out.println(stack.pop());
		System.out.println(stack.pop());	
	}
}


 

 注：本文部分内容参考自《疯狂Java程序员的基本修养》

 

 

 

 

whc20011
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现栈和队列面试题
09-03
以上就是Java实现栈和队列面试题的主要内容。理解和熟练掌握这些知识点对于Java开发者来说至关重要，因为它们涉及到基础数据结构的运用，能够反映候选人在解决实际问题时的逻辑思维和算法能力。在面试中，候选人可能...
java中栈和队列的实现和API的用法(详解)
08-30
LinkedList是一个继承于AbstractSequentialList的双向链表，除了可以实现栈外，还可以被当作队列或双端队列进行操作。LinkedList实现了List接口，能对它进行队列操作，同时也实现了Deque接口，即能将LinkedList当作...
大话数据结构（五）——栈的两种java实现方式
Song's Blog
05-24 738
在我们生活当中经常会看到这样一种操作，比如我们往一个空羽毛球盒子里面放羽毛球（个人比较喜欢羽毛球，嘿嘿），放完后再将羽毛球一个一个取出的时候会发现，最先放进去的羽毛球往往最后才取出来，相反，最后放入的羽毛球往往最先取出。这个例子形象的说明了栈的操作方式，下面我们来看看什么是栈，以及栈的一些操作。     那么什么是栈呢？栈就是限定在表尾进行插入和删除操作的线性表。我们将允许插入和删除的一端称为栈
《Java数据结构》关于堆栈的两种不同实现：
qq727366586的博客
02-02 140
1.链接形式 package cn.com.Inf; public interface StackADT { public void push(T element);//头部添加 public T pop();//头部删除 public T peek();//头部元素查看 public boolean isEmpty();// public int size();// publi
java两个集合实现一个栈_《一起学习java和数据结构》系列-栈
weixin_28771751的博客
02-25 99
如何理解栈这种数据结构？关于栈，我们生活中有非常多的例子，比如手枪弹夹中的子弹，往弹夹中一颗一颗从下往上压子弹，相当于入栈；而发射子弹只能从上面往下一颗一颗弹出子弹，相当于出栈。我们不能通过任何手段发射弹夹中间的子弹。先进着后出，后进着先出，这种结构就是典型的栈。从上面的例子不难看出，栈是一种受限制的线性表，只允许在栈的顶端进行出栈和入栈操作。为什么会出现栈这种数据结构？我们前面学习过数组和链表，...
数据结构——Java实现栈和队列
2301_77116754的博客
01-19 761
Java实现栈，Java实现队列，以数组为底层来实现栈和队列，232.用栈实现队列，225.用队列实现栈
手把手教你Java实现栈和队列
weixin_73616913的博客
04-25 909
C选项是不可能做到的，因为如果按照31的顺序出栈，那么2必然先比1出栈。D选项则是先把12入栈，再将34轮流进行出栈入栈的操作后，再将12出栈。B选项是先将1入栈，再将234轮流入栈出栈，最后将1出栈得到的结果。：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出。我们可以发现，A选项中是先将1入栈再出栈，再将234依次入栈后出栈所得到的结果。综上，我们可以得知：通过栈的实现，我们可以将递归转化成循环。我们可以根据栈的先进后出的特性来对其进行分析。
栈和队列(超详细Java实现)
qq_57735833的博客
07-30 9358
可以看到,先入栈的元素要等后入栈的元素出栈后才能出栈,栈中的元素总是遵循后进先出LIFO（Last In First Out）的原则。生活中的例子:JVM : Java虚拟机Java标准库中提供的栈 可以看到，Stack继承了Vector，Vector是动态的顺序表,与ArrayList类似,不同的是,Vector是线程安全的.实现的方法 输出结果: 2. 入栈(push) 3. 出栈(pop) 4.获取栈顶元素(peek) 5.获取元素个数(getSize) 6.判断栈是否为空(isEm
【Java数据结构】实现栈和队列
yanxiang3306
10-04 6416
【Java数据结构】实现栈和队列
Java实现 栈 和 队列
重庆李四
09-20 7230
JAVA面试题编程题：请用JAVA实现两个类，分别实现堆栈（Stack)和队列（Queue）操作package com.lcx.interview; import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * 29. 请用JAVA实现两个类，分别实现堆栈（Stack)和队列（Queue）操...
java栈和队列的实现
qq_30136729的博客
11-16 1365
栈：后进先出 队列：先进先出 实现使用借助以下类实现： Stack：栈类 Queue：队列类 LinkedList：双端队列（栈操作建议使用） 一.栈的实现 栈的实现，有两个方法： 一个是用java本身的集合类型Stack类型；另一个是借用LinkedList来间接实现Stack。 Stack类 栈是Vector的一个子类，实现了一个标准的后进先出的栈，栈本身最重要的就是push和pop。 Stack<Integer> stack = new Stack<>(); St
如何使用两个栈实现队列Java
08-25
在计算机科学中，数据结构是程序设计的基础，队列和栈是两种常用的数据结构。队列遵循“先进先出”（FIFO）原则，而栈则遵循“后进先出”（LIFO）原则。本篇文章将深入探讨如何使用两个栈来实现一个队列，并在Java...
Java模拟栈和队列数据结构的基本示例讲解
09-02
Java中的栈和队列是两种基本的数据结构，...总之，理解和掌握栈和队列的原理以及在Java中的实现方式，对于提升编程能力至关重要。通过实践和运用这些基本数据结构，可以解决很多复杂的问题，提高程序的效率和可读性。
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
物联网工程_基于RFID的食堂食品安全监测系统设计.docx
07-20
物联网工程_基于RFID的食堂食品安全监测系统设计
VisualSVN-VS2022
最新发布
07-20
VisualSVN-VS2022-8.0.5.vsix SVNVS插件，使用VS自带更新速度太慢，可下载后直接安装即可
基于PSO优化的BP神经网络训练与测试matlab仿真，包括程序，注释，参考文献，操作步骤
07-20
1.版本：matlab2022A。 2.包含：程序，中文注释，参考文献，仿真操作步骤（使用windows media player播放）。 3.领域：PSO优化的BP神经网络 4.仿真效果：仿真效果可以参考博客同名文章《基于PSO优化的BP神经网络训练与测试matlab仿真》 5.内容：基于PSO优化的BP神经网络训练与测试matlab仿真。粒子群优化（Particle Swarm Optimization, PSO）结合BP（Backpropagation）神经网络是一种常见的优化方法，用于提升神经网络的学习能力和泛化能力。PSO不仅帮助BP神经网络找到了一个较好的初始解，从而可能加快了训练过程并提高了最终模型的质量，而且还能探索到更广泛的解空间，有助于避免局部最优解。 6.注意事项：注意MATLAB左侧当前文件夹路径，必须是程序所在文件夹位置，具体可以参考视频录。
超详细讲C++cout语句
07-20
超详细讲C++cout语句，专门为C++初学者录制。
使用java栈实现队列
05-16
想要使用Java栈实现队列，可以使用两个栈来模拟队列的操作，一个栈作为输入栈，一个栈作为输出栈。具体实现如下： 1. 定义两个栈inputStack和outputStack，用于模拟队列的操作。 2. 入队操作时，将元素压入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值