Java实现栈Stack和队列Queue

最新推荐文章于 2024-10-08 08:58:49 发布
最新推荐文章于 2024-10-08 08:58:49 发布
阅读量629 收藏 2
点赞数

目录

（1）栈的创建

（2）队列的创建

（3）两个栈实现一个队列

（4）两个队列实现一个栈

（5）设计含最小函数min()的栈，要求min、push、pop、的时间复杂度都是O(1)

（6）判断栈的push和pop序列是否一致

1、栈的创建：

我们接下来通过链表的形式来创建栈，方便扩充。

代码实现：

public class Stack {

public Node head;
 public Node current;

//方法：入栈操作
 public void push(int data) {
  if (head == null) {
   head = new Node(data);
   current = head;
  } else {
   Node node = new Node(data);
   node.pre = current;//current结点将作为当前结点的前驱结点
   current = node; //让current结点永远指向新添加的那个结点
  }
 }

public Node pop() {
  if (current == null) {
   return null;
  }

Node node = current; // current结点是我们要出栈的结点
  current = current.pre; //每出栈一个结点后，current后退一位
  return node;

}

class Node {
  int data;
  Node pre; //我们需要知道当前结点的前一个结点

public Node(int data) {
   this.data = data;
  }
 }

public static void main(String[] args) {

Stack stack = new Stack();
  stack.push(1);
  stack.push(2);
  stack.push(3);

System.out.println(stack.pop().data);
  System.out.println(stack.pop().data);
  System.out.println(stack.pop().data);
 }

}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

入栈操作时，14、15行代码是关键。

运行效果：

这里写图片描述

2、队列的创建：

队列的创建有两种形式：基于数组结构实现（顺序队列）、基于链表结构实现（链式队列）。

我们接下来通过链表的形式来创建队列，这样的话，队列在扩充时会比较方便。队列在出队时，从头结点head开始。

代码实现：

入栈时，和在普通的链表中添加结点的操作是一样的；出队时，出的永远都是head结点。

public class Queue {
 public Node head;
 public Node curent;

//方法：链表中添加结点
 public void add(int data) {
  if (head == null) {
   head = new Node(data);
   curent = head;
  } else {
   curent.next = new Node(data);
   curent = curent.next;
  }
 }

//方法：出队操作
 public int pop() throws Exception {
  if (head == null) {
   throw new Exception("队列为空");
  }

Node node = head; //node结点就是我们要出队的结点
  head = head.next; //出队之后，head指针向下移

return node.data;

}

class Node {
  int data;
  Node next;

public Node(int data) {
   this.data = data;
  }
 }

public static void main(String[] args) throws Exception {
  Queue queue = new Queue();
  //入队操作
  for (int i = 0; i < 5; i++) {
   queue.add(i);
  }

//出队操作
  System.out.println(queue.pop());
  System.out.println(queue.pop());
  System.out.println(queue.pop());

}
}


 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53

运行效果：

这里写图片描述

3、两个栈实现一个队列：

思路：

栈1用于存储元素，栈2用于弹出元素，负负得正。

说的通俗一点，现在把数据1、2、3分别入栈一，然后从栈一中出来（3、2、1），放到栈二中，那么，从栈二中出来的数据（1、2、3）就符合队列的规律了，即负负得正。

完整版代码实现：

import java.util.Stack;

/**
* Created by smyhvae on 2015/9/9.
*/
public class Queue {

private Stack<Integer> stack1 = new Stack<>();//执行入队操作的栈
 private Stack<Integer> stack2 = new Stack<>();//执行出队操作的栈

//方法：给队列增加一个入队的操作
 public void push(int data) {
  stack1.push(data);

}

//方法：给队列正价一个出队的操作
 public int pop() throws Exception {

if (stack2.empty()) {//stack1中的数据放到stack2之前，先要保证stack2里面是空的（要么一开始就是空的，要么是stack2中的数据出完了），不然出队的顺序会乱的，这一点很容易忘

while (!stack1.empty()) {
    stack2.push(stack1.pop());//把stack1中的数据出栈，放到stack2中【核心代码】
   }

}

if (stack2.empty()) { //stack2为空时，有两种可能：1、一开始，两个栈的数据都是空的；2、stack2中的数据出完了
   throw new Exception("队列为空");
  }

return stack2.pop();
 }

public static void main(String[] args) throws Exception {
  Queue queue = new Queue();
  queue.push(1);
  queue.push(2);
  queue.push(3);

System.out.println(queue.pop());

queue.push(4);

System.out.println(queue.pop());
  System.out.println(queue.pop());
  System.out.println(queue.pop());

}

}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

注意第22行和第30行代码的顺序，以及注释，需要仔细理解其含义。

运行效果： 
这里写图片描述

4、两个队列实现一个栈：

思路：

将1、2、3依次入队列一， 然后最上面的3留在队列一，将下面的2、3入队列二，将3出队列一，此时队列一空了，然后把队列二中的所有数据入队列一；将最上面的2留在队列一，将下面的3入队列二。。。依次循环。

代码实现：

import java.util.ArrayDeque;
import java.util.Queue;

/**
* Created by smyhvae on 2015/9/9.
*/
public class Stack {

Queue<Integer> queue1 = new ArrayDeque<Integer>();
 Queue<Integer> queue2 = new ArrayDeque<Integer>();

//方法：入栈操作
 public void push(int data) {
  queue1.add(data);
 }

//方法：出栈操作
 public int pop() throws Exception {
  int data;
  if (queue1.size() == 0) {
   throw new Exception("栈为空");
  }

while (queue1.size() != 0) {
   if (queue1.size() == 1) {
    data = queue1.poll();
    while (queue2.size() != 0) { //把queue2中的全部数据放到队列一中
     queue1.add(queue2.poll());
     return data;
    }
   }
   queue2.add(queue1.poll());
  }
  throw new Exception("栈为空");//不知道这一行的代码是什么意思
 }

public static void main(String[] args) throws Exception {
  Stack stack = new Stack();

stack.push(1);
  stack.push(2);
  stack.push(3);

System.out.println(stack.pop());
  System.out.println(stack.pop());
  stack.push(4);
 }
}


 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

运行效果：

这里写图片描述

5、设计含最小函数min()的栈，要求min、push、pop、的时间复杂度都是O(1)。min方法的作用是：就能返回是栈中的最小值。【微信面试题】

普通思路：

一般情况下，我们可能会这么想：利用min变量，每次添加元素时，都和min元素作比较，这样的话，就能保证min存放的是最小值。但是这样的话，会存在一个问题：如果最小的元素出栈了，那怎么知道剩下的元素中哪个是最小的元素呢？

改进思路：

这里需要加一个辅助栈，用空间换取时间。辅助栈中，栈顶永远保存着当前栈中最小的数值。具体是这样的：原栈中，每次添加一个新元素时，就和辅助栈的栈顶元素相比较，如果新元素小，就把新元素的值放到辅助栈中，如果新元素大，就把辅助栈的栈顶元素再copy一遍放到辅助栈的栈顶；原栈中，出栈时，

完整代码实现：

import java.util.Stack;

/**
* Created by smyhvae on 2015/9/9.
*/
public class MinStack {

private Stack<Integer> stack = new Stack<Integer>();
 private Stack<Integer> minStack = new Stack<Integer>(); //辅助栈：栈顶永远保存stack中当前的最小的元素

public void push(int data) {
  stack.push(data); //直接往栈中添加数据

//在辅助栈中需要做判断
  if (minStack.size() == 0 || data < minStack.peek()) {
   minStack.push(data);
  } else {
   minStack.add(minStack.peek()); //【核心代码】peek方法返回的是栈顶的元素
  }
 }

public int pop() throws Exception {
  if (stack.size() == 0) {
   throw new Exception("栈中为空");
  }

int data = stack.pop();
  minStack.pop(); //核心代码
  return data;
 }

public int min() throws Exception {
  if (minStack.size() == 0) {
   throw new Exception("栈中空了");
  }
  return minStack.peek();
 }

public static void main(String[] args) throws Exception {
  MinStack stack = new MinStack();
  stack.push(4);
  stack.push(3);
  stack.push(5);

System.out.println(stack.min());
 }
}


 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

运行效果： 
这里写图片描述

6、判断栈的push和pop序列是否一致：

通俗一点讲：已知一组数据1、2、3、4、5依次进栈，那么它的出栈方式有很多种，请判断一下给出的出栈方式是否是正确的？

例如：

数据：

1、2、3、4、5

出栈1：

5、4、3、2、1（正确）

出栈2：

4、5、3、2、1（正确）

出栈3：

4、3、5、1、2（错误）

完整版代码：

import java.util.Stack;
/**
* Created by smyhvae on 2015/9/9.
*/
public class StackTest {

//方法：data1数组的顺序表示入栈的顺序。现在判断data2的这种出栈顺序是否正确
    public static boolean sequenseIsPop(int[] data1, int[] data2) {
        Stack<Integer> stack = new Stack<Integer>(); //这里需要用到辅助栈

for (int i = 0, j = 0; i < data1.length; i++) {
            stack.push(data1[i]);

while (stack.size() > 0 && stack.peek() == data2[j]) {
                stack.pop();
                j++;
            }
        }
        return stack.size() == 0;
    }

public static void main(String[] args) {

Stack<Integer> stack = new Stack<Integer>();

int[] data1 = {1, 2, 3, 4, 5};
        int[] data2 = {4, 5, 3, 2, 1};
        int[] data3 = {4, 5, 2, 3, 1};

System.out.println(sequenseIsPop(data1, data2));
        System.out.println(sequenseIsPop(data1, data3));
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

运行效果：

这里写图片描述

原文http://blog.csdn.net/shengmingqijiquan/article/details/73741223,谢谢作者.

10个demo
关注
Java 栈(Stack)和队列(Queue)的首选 - ArrayDeque
路的尽头在哪
04-09 5229
阅读 Java 版本为 1.8.0.25。 栈（Stack） 和 队列（Queue） 应该是大家非常熟悉的数据结构了。 Java 中有 栈（Stack） 的具体类， 队列（Queue） 只定义了接口，当然所有实现了这个接口的类都可以当作一个队列使用。
Java_Stack_Queue:Java中使用链表的堆栈和队列实现
07-03
通过提供的Java_Stack_Queue-master文件，你可以找到具体实现这些功能的示例代码，进一步学习和实践链表实现的堆栈和队列。这个项目可能包括了测试用例，展示了如何使用这些自定义的数据结构来处理不同的问题。在...
栈和队列的面试题Java实现
weixin_34088598的博客
03-31 172
2019独角兽企业重金招聘Python工程师标准>>> ...
java 队列_java中栈和队列的实现和API的用法(详解)
weixin_33402252的博客
02-12 427
在java中要实现栈和队列，需要用到java集合的相关知识，特别是Stack、LinkedList等相关集合类型。一、栈的实现栈的实现，有两个方法：一个是用java本身的集合类型Stack类型；另一个是借用LinkedList来间接实现Stack。1.Stack实现直接用Stack来实现非常方便，常用的api函数如下：boolean isEmpty() // 判断当前栈是否为空syn...
Java数据结构栈和队列(Stack和Queue详解)
最新发布
m0_75235246的博客
10-08 1203
栈和队列是数据结构中重要的存储方式，也是建立在Arrarylist和LinkedList之上的数据结构。本猿在C语言阶段就已经详细剖析过栈和队列，不熟悉的小伙伴可以翻看之前的博客内容！Java阶段一方面剖析Java中自带的Stack和Queue中的各种方法，另一方面也是重点重新再次实现栈和队列， 并发掘和C语言中的区别。
栈和队列的Java实现_栈和队列的java简单实现
weixin_31077513的博客
02-26 106
今天看了一本书《啊哈 算法》，书的内容不多，一共两章，第一章是常见的排序算法包括桶排序、冒泡排序和快速排序，这些事基础的排序算法网上有很多资料说明，这里主要说第二章栈，对列，链表，书上使用c语言实现的，这里用java代码自己实现下，可能略有不同栈：这是一个先进后出的数据结构，生活中类似的浏览器的返回上一页就可以利用此结构实现，代码如下：public class Stack{private Obje...
栈和队列(超详细Java实现)
qq_57735833的博客
07-30 1万+
可以看到,先入栈的元素要等后入栈的元素出栈后才能出栈,栈中的元素总是遵循后进先出LIFO（Last In First Out）的原则。生活中的例子:JVM : Java虚拟机Java标准库中提供的栈 可以看到，Stack继承了Vector，Vector是动态的顺序表,与ArrayList类似,不同的是,Vector是线程安全的.实现的方法 输出结果: 2. 入栈(push) 3. 出栈(pop) 4.获取栈顶元素(peek) 5.获取元素个数(getSize) 6.判断栈是否为空(isEm
Java中栈（stack）实现队列（Queue）
m0_66605858的博客
05-15 363
1
Java实现栈和队列面试题
09-03
以上就是Java实现栈和队列面试题的主要内容。理解和熟练掌握这些知识点对于Java开发者来说至关重要，因为它们涉及到基础数据结构的运用，能够反映候选人在解决实际问题时的逻辑思维和算法能力。在面试中，候选人可能...
java中栈和队列的实现和API的用法(详解)
08-30
java中栈和队列的实现和API的用法详解 java中的栈和队列是两种常用的数据结构，分别用于实现后进先出...java中栈和队列的实现可以通过Stack类型和LinkedList来实现，分别使用不同的API函数来进行栈和队列的操作。
Java模拟栈和队列数据结构的基本示例讲解
09-02
Java中的栈和队列是两种基本的数据结构，...总之，理解和掌握栈和队列的原理以及在Java中的实现方式，对于提升编程能力至关重要。通过实践和运用这些基本数据结构，可以解决很多复杂的问题，提高程序的效率和可读性。
Java实现 栈 和 队列
重庆李四
09-20 7252
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 实现 栈 队列_栈与队列的java实现
weixin_36256361的博客
02-12 132
1栈与队列栈的实现：特点，先进后出，每次只能操作最上面的数据;1.创建栈类；package cn.xiaobo.Stack;public class StackApp {private long maxsize;private long[] StackArr;private int top;public StackApp(int size) {this.maxsize=size;StackArr=...
java创建队列和栈和map
weixin_42559610的博客
02-03 1903
队列 Queue<Integer> queue = new LinkedList<>();//声明队列 queue.add(1);//添加数据 queue.offer(1);//添加数据 //add() offer()都是想队尾插入数据 区别是add()方法插入数据超出队列界限时候会抛出异常，而offer()方法是返回false queue.poll();//输出队列 qu...
Java用栈模拟队列
qq_55897122的博客
05-13 227
首先我们需要清楚：栈，是一种后进先出的数据结构，只能我们从栈顶（top）往栈中压入（push）元素，也只能从栈顶（top）往外弹出元素，所以最后进去的必须最早弹出（pop）： 而队列， 是一种先进先出的线性表结构，一般来说，它只允许在集合的前端进行删除操作，而在集合的后端进行插入操作： 清楚了栈和队列的思想， 那我们如果想要定义一个底层用栈来实现的队列应该怎么做呢？ 很明显我们需要两个栈来完成，其中一个栈（我们命名为in）...
java之“用栈Stack模拟队列Queue”
m0_59340907的博客
05-12 406
目录 前言 实现思路 实现代码 总结 前言 队列（Queue）的特点是先进先出(FIFO : Fitst In First Out),而栈（Stack）的特点是后进先出（FILO : Fitst In Last Out）二者的操作特点完全不同。 实现思路 首先，我们应该创建一个类MyQueue，这个类一定要有两个最重要的方法，offer()将元素入队，poll()将元素取出。由于栈的特点是先进后出，因此一个栈是无法实现队列先进先的特点的。 ...
数据结构 -栈和队列(Java实现)
cj13106811623的博客
02-29 2353
栈和队列是数据结构知识的基础知识，因此我们在学习数据结构的时候需要牢牢记住栈和队列的实现原理以及如何去调用他们各自对应的方法，大家在学习栈和队列的时候可以多敲敲代码来加深理解。
剑指Offer——Java实现栈和队列的互模拟操作
热门推荐
IT全栈 华强工作室
11-22 4万+
Java实现栈和队列的互模拟操作栈模拟队列  题目:JAVA实现用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。   思路：其实就是把队列正常入栈，出栈的时候先把栈里的内容按顺序搬到另一个栈里，负负得正，这样再按顺序出栈的时候，就成了入栈前队列的顺序package cn.edu.ujn.demo;import java.util.Stack;import org.
Java数据结构--栈和队列
xd__xy的博客
12-07 1237
如图所示，「双向队列 double-ended queue」提供了更高的灵活性，允许在头部和尾部执行元素的添加或删除操作。然而，数组和链表都可以在任意位置添加和删除元素，因此栈可以视为一种受限制的数组或链表。将把元素添加到栈顶的操作叫作“入栈”，删除栈顶元素的操作叫作“出栈”。如图所示，我们将队列头部称为“队首”，尾部称为“队尾”，将把元素加入队尾的操作称为“入队”，删除队首元素的操作称为“出队”。我们可以将链表的“头节点”和“尾节点”分别视为“队首”和“队尾”，规定队尾仅可添加节点，队首仅可删除节点。
Java实现栈和队列数据结构
"Java语言实现的栈和队列数据结构示例代码" 在这个Java代码示例中，我们有两个类：`Node` 和 `SqStack`。`Node` 类用于构建链表，代表了栈或队列中的元素节点，而 `SqStack` 类实现了基于数组的栈操作。 首先，`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值