栈和队列-详解

前言

本篇博客-叙述了以下关于栈和队列等的相关概念

1. 栈的概念及使用
2. 队列的概念及使用

栈

概念

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则

常用术语

Push -压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
Pop - 出栈：栈的删除操作叫做出栈。出数据在栈顶。

栈的使用

方法	解释
Stack()	构造一个空的栈
E push(E e)	将e入栈，并返回e
E pop()	将栈顶元素出栈并返回
E peek()	获取栈顶元素
int size()	获取栈中有效元素个数
boolean empty()	检测栈是否为空

栈的模拟实现

从上图中可以看到，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。

public class MyStack {
    
    
	int[] array;
	int size;
	public MyStack(){
    
    
		array = new int[3];
	}
	public int push(int e){
    
    
		ensureCapacity();
		array[size++] = e;
		return e;
	}
	public int pop(){
    
    
		int e = peek();
		size--;
		return e;
	}
	public int peek(){
    
    
		if(empty()){
    
    
			throw new RuntimeException("栈为空，无法获取栈顶元素");
		}
		return array[size-1];
	}
	public int size(){
    
    
		return size;
	}
	public boolean empty(){
    
    
		return 0 == size;
	}
	private void ensureCapacity(){
    
    
		if(size == array.length){
    
    
			array = Arrays.copyOf(array, size*2);
		}
	}
}

栈的应用场景

1. 改变元素的序列-如下

若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A: 1,4,3,2 B: 2,3,4,1 C: 3,1,4,2 D: 3,4,2,1

2. 将递归转化为循环

// 递归方式
void printList(Node head){
    
    
	if(null != head){
    
    
		printList(head.next);
		System.out.print(head.val + " ");
	}
}
// 循环方式
void printList(Node head){
    
    
	if(null == head){
    
    
			return;
	}
	Stack<Node> s = new Stack<>();
	// 将链表中的结点保存在栈中
	Node cur = head;
	while(null != cur){
    
    
		s.push(cur);
		cur = cur.next;
	}
}

3. 括号匹配
4. 逆波兰表达式求值
5. 出栈入栈次序匹配
6. 最小栈

栈、虚拟机栈、栈帧有什么区别呢？

栈是一种先进后出的数据结构。 虚拟机栈是JVM的一块内存空间。 栈帧是在函数的调用过程中，在java虚拟机栈上开辟的一块内存

单调栈

从名字上就听的出来，单调栈中存放的数据应该是有序的，所以单调栈也分为单调递增栈和单调递减栈

单调递增栈：单调递增栈就是从栈底到栈顶数据是从大到小
单调递减栈：单调递减栈就是从栈底到栈顶数据是从小到大

模拟实现

stack<int> st;
//此处一般需要给数组最后添加结束标志符，具体下面例题会有详细讲解
for (遍历这个数组)
{
    
    
	if (栈空 || 栈顶元素大于等于当前比较元素)
	{
    
    
		入栈;
	}
	else
	{
    
    
		while (栈不为空 && 栈顶元素小于当前元素)
		{
    
    
			栈顶元素出栈;
			更新结果;
		}
		当前数据入栈;
	}
}

队列(Queue)

概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO特性
入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为队头
（Head/Front）

队列的使用

在Java中，Queue是个接口，底层是通过链表实现的。

方法	解释
boolean offer(E e)	入队列
E poll()	出队列
peek()	获取队头元素
int size()	获取队列中有效元素个数
boolean isEmpty()	检测队列是否为空

队列模拟实现

public class Queue {
    
    
	// 双向链表节点
	public static class ListNode{
    
    
	ListNode next;
	ListNode prev;
	int value;
	ListNode(int value){
    
    
		this.value = value;
	}
	}
	ListNode first; // 队头
	ListNode last; // 队尾
	int size = 0;
	// 入队列---向双向链表位置插入新节点
	public void offer(int e){
    
    
		ListNode newNode = new ListNode(e);
		if(first == null){
    
    
			first = newNode;
			// last = newNode;
		}else{
    
    
			last.next = newNode;
			newNode.prev = last;
			// last = newNode;
		}
		last = newNode;
		size++;
	}
	// 出队列---将双向链表第一个节点删除掉
	public int poll(){
    
    
	// 1. 队列为空
		// 2. 队列中只有一个元素----链表中只有一个节点---直接删除
		// 3. 队列中有多个元素---链表中有多个节点----将第一个节点删除
		int value = 0;
		if(first == null){
    
    
			return null;
		}else if(first == last){
    
    
			last = null;
			first = null;
		}else{
    
    
			value = first.value;
			first = first.next;
			first.prev.next = null;
			first.prev = null;
		}
		--size;
		return value;
	}
	// 获取队头元素---获取链表中第一个节点的值域
	public int peek(){
    
    
		if(first == null){
    
    
			return null;
		}
		return first.value;
	}
	public int size() {
    
    
		return size;
	}
	public boolean isEmpty(){
    
    
		return first == null;
	}
}

循环队列

循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列通常使用数组实现

1. 下标最后再往后(offset 小于 array.length): index = (index + offset) % array.length
2. 下标最前再往前(offset 小于 array.length): index = (index + array.length - offset) % array.length

如何区分空与满

1. 通过添加 size 属性记录
2. 保留一个位置
3. 使用标记

设计循环队列

import java.util.*;
class MyCircularQueue {
    
    
//    设计循环队列
    /*
 MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。
* */
    private int[] elem;
    private int front;
    private int rear;
   // private int usedSize;//这样写太简单了
    public MyCircularQueue(int k) {
    
    
        elem=new int[k+1];
    }
    
    public boolean enQueue(int value) {
    
    
        if (isFull()){
    
    
            return false;
        }
        elem[rear]=value;
        rear=(rear+1)% elem.length;
       // usedSize++;
        return true;
    }
    
    public boolean deQueue() {
    
    
        if (isEmpty()){
    
    
            return false;
        }
        front=(front+1)%elem.length;
       // usedSize--;
        return true;
    }
    
    public int Front() {
    
    
        if (isEmpty()){
    
    
            return -1;
        }
        return elem[front];
    }
    
    public int Rear() {
    
    
        if (isEmpty()){
    
    
            return -1;
        }
        int index=rear!=0?rear-1:elem.length-1;
        return elem[index];

    }
    
    public boolean isEmpty() {
    
    
        //return usedSize==0;
        return rear==front;
    }
    
    public boolean isFull() {
    
    
        return (rear+1)%elem.length==front;
    }


}

双端队列 (Deque)

双端队列（deque）是指允许两端都可以进行入队和出队操作的队,deque 是 “double ended queue” 的简称。那就说明元素可以从队头出队和入队，也可以从队尾出队和入队

Deque<Integer> stack = new ArrayDeque<>();//双端队列的线性实现
Deque<Integer> queue = new LinkedList<>();//双端队列的链式实现