文章目录
一、栈
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据在栈顶。
1.栈的实现
首先栈的实现方式有两种，一个是基于链表的实现，一个是基于数组的实现，这里我们采用数组的方式，也是一般采用的方式来实现一个stack(push入栈、pop出栈、peek返回栈顶元素)等功能。
//这里采用的是泛型类，当产生具体实例时，数据类型才可以确定
public class MyStack<E> {
//定义栈的长度
private int size;
private List<E> data=new ArrayList<>();
//出栈操纵
public E pop(){
if(isEmpty()){
throw new NoSuchElementException();
}
//这里使用的是List集合类，调用的是remove，默认是尾删
E val=data.remove(size-1);
size--;
return val;
}
//判断当前的数组也就是维护的栈是否为空
private boolean isEmpty() {
return size==0;
}
//入栈的操作
public void push(E e){
//同样这里也是调用List集合类里的add方法，默认为尾插
data.add(e);
size++;
}
//返回栈顶元素
public E peek(){
if(isEmpty()){
throw new NoSuchElementException("stack is null !cannot get peek!");
}
return data.get(size-1);
}
//复写了tostring方法，对栈的元素进行输出
@Override
public String toString() {
StringBuilder sb=new StringBuilder();
sb.append('[');
for (int i = 0; i < data.size(); i++) {
sb.append(data.get(i));
if(i!=data.size()-1){
sb.append(',');
}
}
sb.append("]front");
return sb.toString();
}
}
分析：a. 这里使用集合类List的 add方法与 remove方法，实现了尾插、尾删，这与出栈和入栈是一样的。b.其次使用了泛型类，这是得栈的使用更加的灵活。
二、队列
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
入队列：进行插入操作的一端称为队尾（Tail/Rear）
出队列：进行删除操作的一端称为队头
1.基础队列的实现
首先队列可以基于数组实现，也可以基于链表实现，但一般都是基于链表的实现。因为如果使用数组的话，要实现FIFO的操作，肯定要进行尾查和头删，我们知道对于数组来说，头删是很麻烦的一件事，如果使用链表，则可以直接head=head.next，相对于数组比较的便捷。
//定义一个Queue的泛型接口。
public interface Queue<E> {
void offer(E e);
E poll();
E peek();
boolean isEmpty();
}
//MyQueue类实现接口，依然选择保留泛型
public class MyQueue<E> implements Queue<E> {
//定义一个成员内部类Node
private class Node{
E val;
Node next;
public Node(E val) {
this.val = val;
}
}
private int size;
private Node head;
private Node tail;
//复写接口的入队方法
@Override
public void offer(E e) {
Node node =new Node(e);
//实现了尾插
if(head==null){
head=tail=node;
}else{
tail.next=node;
tail=node;
}
size++;
}
//出队操作，返回被删除元素
@Override
public E poll() {
if(isEmpty()){
throw new NoSuchElementException("Queue is empty! cannot poll!");
}
//头删操作
E val=head.val;
Node node=head;
head=head.next;
node.next=null;
size--;
return val;
}
//返回队首元素
@Override
public E peek() {
if(isEmpty()){
throw new NoSuchElementException("Queue is empty! cannot peek!");
}
return head.val;
}
@Override
public boolean isEmpty() {
return size==0;
}
@Override
public String toString() {
StringBuilder sb=new StringBuilder();
sb.append("front [");
for(Node node=head;node!=null;node=node.next){
sb.append(node.val);
if(node.next!=null){
sb.append(',');
}
}
sb.append(']');
return sb.toString();
}
}
分析：其实都是使用了一些基础的链表的操作，这里我使用了interface接口，因为后面还要写出循环队列的实现。
2.循环队列的实现
1.注意
a.循环队列通常使用数组实现。b.head：指向对首元素的索引、tail:指向队尾元素索引的下一个位置。c.队列为空的条件 head=tail ，队满的条件 head=(tail+1)%data.length d.head和tail的移动 head=(head+1)%data.length ,tail=(tail+1)%data.lenght. e.要空出一个空间，来区别队列空和队列满的条件。
2.代码
//这个代码的实现了泛型为Integer
public class LoopQueue implements Queue<Integer> {
private Integer[] data;
private int head;
private int tail;
private int size;
//此处要产生一个空位，注意在进行插入的过程中，这个空位置可能会变化的
public LoopQueue(int n){
data=new Integer[n+1];
}
//入队
@Override
public void offer(Integer val) {
if(isFull()){
throw new ArrayIndexOutOfBoundsException("queue is full cannot offer!");
}
data[tail]=val;
//tail往前移动一步
tail=(tail+1)%data.length;
size++;
}
//出队
@Override
public Integer poll() {
if(isEmpty()){
throw new NoSuchElementException("queue is empty cannot poll!");
}
Integer val= data[head];
//head向前走一步
head=(head+1)%data.length;
size--;
return val;
}
//返回对首元素
@Override
public Integer peek() {
if(isEmpty()){
throw new NoSuchElementException("queue is empty cannot peek!");
}
return data[head];
}
@Override
public boolean isEmpty() {
return head==tail;
}
public boolean isFull(){
return head==(tail+1)%data.length;
}
@Override
public String toString() {
StringBuilder sb=new StringBuilder();
//这个是获取循环队列最后一个元素的索引，注意和tail是不相等的
int lastIndex=tail==0?data.length-1:tail-1;
sb.append("head[");
for (int i = head; i !=tail;i=(i+1)% data.length ) {
sb.append(data[i]);
if(i!=lastIndex){
sb.append(',');
}
}
sb.append("]tail");
return sb.toString();
}
}
3.双端队列
双端队列（deque): 是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。 那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。
其主要的方法有：
| addFirst（） | addLast() |
| pollFirst() | pollLast() |
目前由于stack集合类是vector，线程安全，效率低，所以现在基本上使用Deque来实现栈的各种操作。
三、leetCode相关题目
1.Num_225 使用队列实现栈
首先思路：q1队列放元素，q2队列辅助。当放入一个元素时，如果开始时q1为空，则直接放入。 如果q1不为空时，先将q1的元素全部出队放入q2，在把新加的元素放入q1的对首，然后将q2 在出队全部放入q1，这样对元素就实现了先进后出，后进先出的栈的特性。
/**
* 双队列实现栈
*/
public class MyStack {
Queue<Integer> q1=new LinkedList<>();
Queue<Integer> q2=new LinkedList<>();
public MyStack() {
}
/**
* 时间复杂度比相对于下面的方式比较大
* @return
*/
// public void push(int x) {
// if(q1.isEmpty()){
// q1.offer(x);
// }else{
// while(!q1.isEmpty()){
// q2.offer(q1.poll());
// }
// q1.offer(x);
// while(!q2.isEmpty()){
// q1.offer(q2.poll());
// }
// }
// }
/**
* 这种就比较好的
* @return
*/
public void push(int x){
//将新的元素都依次放在q2里面
q2.offer(x);
while(!q1.isEmpty()){
q2.offer(q1.poll());
}
Queue<Integer> tmp=q1;
q1=q2;
q2=tmp;
}
public int pop() {
return q1.poll();
}
public int top() {
return q1.peek();
}
public boolean empty() {
return q1.isEmpty();
}
}
代码中对于出队入队等做了优化，通过转变q1与q2引用的值，就相当于省略了出队入队等的操作，比较实用。
2.Num_232 双栈实现队列
解题思路：首先s1存储元素，s2辅助。当s1为空时，则可以直接放入，当s1不为空时，先把s1的元素出栈放入s2，在把元素压入栈底，最后把s2里面的元素出队，放入s1。这样就实现了后入后出、先入先出的队列特性。
package stack_queue.leetcode;
import java.util.Stack;
/**
* 双栈实现队列NUm232问题
*/
public class MyQueue {
Stack<Integer> s1=new Stack<>();
Stack<Integer> s2=new Stack<>();
public MyQueue() {
}
public void push(int x) {
if(s1.isEmpty()){
s1.push(x);
}else{
while(!s1.isEmpty()){
s2.push(s1.pop());
}
s1.push(x);
while(!s2.isEmpty()){
s1.push(s2.pop());
}
}
}
public int pop() {
return s1.pop();
}
public int peek() {
return s1.peek();
}
public boolean empty() {
return s1.isEmpty();
}
}
通过以上两个题目，可以发现栈和队列的转换有很大的关系。
3.Num_155 最小栈
解题思路：首先还是有s1存储元素、s2记录相应的最小值。当栈都为空时，该元素同时入s1、s2两个栈 、当栈不为空时，该元素先入s1，然后判断该元素与s2队顶的元素的大小，如果该元素小于队顶的元素，则该元素入队s2，如果该元素大于队顶的元素，则队顶的元素再一次入栈s2，这样，就一直的维护了每一个阶段的最小值。
package stack_queue.leetcode;
import java.util.*;
public class Num155_MinStack {
//这里使用的是stack，不过懒得改了，推荐使用Deque<>
Stack<Integer> s1=new Stack<>();
Stack<Integer> s2=new Stack<>();
public Num155_MinStack() {
}
//入队
public void push(int val) {
s1.push(val);
if(s2.isEmpty()){
s2.push(val);
}
else {
int tmp=s2.peek();
s2.push(Math.min(tmp,val));
}
}
public void pop() {
s1.pop();
s2.pop();
}
public int top() {
return s1.peek();
}
public int getMin() {
return s2.peek();
}
}
4.Num_496 下一个更大元素
解题思路：我先说一下我的总体思路:先使用Map集合记录一下num2[] 中的元素及其对应的下一个更大元素，然后在遍历num1[],通过num[]里的元素及Map集合，找到对应的下一个更大元素。
/**
* 单调栈解决下一个更大元素
*/
public class Num496_NextGreaterNum {
private Stack<Integer> stack =new Stack<>();
private Map<Integer,Integer> map=new HashMap<>();
public int[] nextGreaterElement(int[] nums1, int[] nums2) {
//从后面遍历，解决正向问题
for (int i = nums2.length-1; i >=0 ; i--) {
//如果当前元素的大小，大于栈顶元素，则就可以把之前的元素出栈
//因为遍历下一个元素时，向前看，只会看到比他本身大的，而较小的元素出栈
//这实际上就是维护了一个单调递增栈
while(!stack.isEmpty()&&stack.peek()<=nums2[i]){
stack.pop();
}
//此时如果栈为空，说明没有比这个元素大的，返回-1
//栈不为空，说明遇到了一个比他大的元素，则找到下一个最大元素
int nextGreaterVal=stack.isEmpty()?-1:stack.peek();
stack.push(nums2[i]);
map.put(nums2[i],nextGreaterVal);
}
int[] ret=new int[nums1.length];
for (int i = 0; i < ret.length; i++) {
ret[i]=map.get(nums1[i]);
}
return ret;
}
}
具体的步骤我都在代码中详细的解释了。所以以后遇到类似的求 下一个更大.../更小...的问题时，不妨使用单调栈的思想来解决问题。
总结
栈和队列的题目相对与其他的数据结构来说，可能相对与比较的简单。但是他简单并不意味着不重要，所以对栈和队列的基础学习不容忽视，只有打好地基，才会建出好的房子！希望我们一起加油，最求更好的自己！！！
595
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
