数据结构：栈和队列_queen.poll

数据结构

线性表：一次保存单个同类型元素，多个元素之间逻辑上连续

数组，链表，栈，队列，字符串(内部是char[])

栈和队列其实是操作受限的线性表

数组，链表，既可以在头部插入和删除，也能在尾部插入和删除，甚至在任意位置都可以插入和删除

“栈和队列”只能在一端插入元素和删除元素

栈(LIFO: Last in First Out)

1. 只能从一端插入元素，也只能从这一端取出元素(栈顶)类似水杯

将元素12345依次添加到栈中

最先添加的元素就在当前栈的最底端，最后添加的元素就在栈的最顶端

• 添加元素只能从栈顶添加
• 取出元素只能从栈顶取出

从栈中取出元素的顺序和栈中添加元素的顺序恰好相反

最后添加的元素最先取出 -> Last in First Out(LIFO)

栈的特点：先进后出，后进先出的线性表

添加元素和删除元素的一端称为栈顶，另一端称为栈底

栈的应用

1. undo(撤销)操作

在任何一个编辑器中输错了一个内容使用ctrl + Z就返回到了上一次输入的内容

在任何一个浏览器点击返回就能返回上一次浏览的网页

都是栈的应用

2. 操作系统栈

程序在执行过程中，从A函数调用B函数，从B函数调用C函数，返回执行时如何得知从哪里开始继续执行呢，其实背后就是栈这个结构

出栈后弹出func();

从funB()第二行开始执行，结束后funB()出栈，funB()弹出

funA()第三行开始执行，结束后funA()出栈，funA()弹出

栈的实现

基于数组实现的栈 - 顺序栈

栈只能在栈顶插入元素，在栈顶删除元素的结构

数组末尾插入和删除元素，数组末尾就是此时的栈顶！

基于链表实现的栈 - 链式栈

栈的三个核心操作

push(E e)：向栈中添加元素 -> 入栈，压栈

E pop()：出栈操作，弹出栈顶元素

E peek()：查看栈顶元素，但不出栈

public class StackTest {
    public static void main(String[] args) {
        MyStack<Integer> stack = new MyStack<>();
        stack.push(1);
        stack.push(3);
        stack.push(5);
        stack.push(7);
        stack.push(9);
        System.out.println(stack);
        // 9
        System.out.println(stack.pop());
        System.out.println(stack);
    }
}
//[1, 3, 5, 7, 9] top
//9
//[1, 3, 5, 7] top
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

队列(FIFO: First in First Out)

栈和队列是一码事，都是对只能在线性表的一端进行插入和删除

因此，栈和队列可以相互转换

队列：FIFO，先进先出的数据结构，元素从“队尾”添加到队列中，元素从“队首”出队列

push(E val)：将元素入队

peek()：查看队首元素

pop()：弹出队首元素

现实生活中，各式各样的“排队”操作

同样的，队列也有基于数组实现的队列和基于链表实现的队列

顺序队列 链式队列

问：对于队列来说，是基于链表比较好还是基于数组？

出队操作只能在队列的头部进行，若采用数组的方案，每次出队一个元素就得搬移剩下的所有元素向前移动一个单位

此时采用链表的方案更加适合队列的结构

出队列：删除头节点

添加元素：在链表的尾部添加

队列和栈的区别

队列的子类比较多：除了普通队列，还有优先级队列，循环队列。

栈结构比较简单，就是基于动态数组实现的顺序栈

相对于栈来说，队列的实现子类是比较多的，比如普通FIFO队列，双端队列Deque，循环队列LoopQueue，优先级队列 PriorityQueue

队列的三个核心操作

void offer(E val);// 入队操作

E poll();// 出队操作

E peek();// 查看队首元素

public interface Queue<E> {
    // 入队操作
    void offer(E val);
    // 出队操作
    E poll();
    // 查看队首元素
    E peek();
    boolean isEmpty();
}
1
2
3
4
5
6
7
8
9

//此处非java.util.Queue而是自己写的Queue LinkedQueue也是自己写的
Queue<Integer> queue = new LinkedQueue<>();
queue.offer(1);
queue.offer(3);
queue.offer(5);
queue.offer(7);
queue.offer(9);
// front [1,3,5,7,9] tail
System.out.println(queue);
queue.poll();
// front [3,5,7,9] tail
System.out.println(queue);
1
2
3
4
5
6
7
8
9
10
11
12

用队列模拟一个栈

//java.util.Queen            java.util.LinkedList
Queue<Integer> queue = new LinkedList<>();
queue.offer(1);
queue.offer(3);
queue.offer(5);
queue.offer(7);
queue.offer(9);
System.out.println(queue);
queue.poll();
System.out.println(queue);
//[1, 3, 5, 7, 9]
//[3, 5, 7, 9]
1
2
3
4
5
6
7
8
9
10
11
12

此处的Queue为java.util.Queue非自己写的

leetcode 栈实现队列

思路：s1永远是保存元素的栈

1. 先将s1中的所有元素依次弹出放入s2
2. 将新元素入s1 = 》此时这个新元素就变为了s1的栈底元素(队尾元素)
3. 将s2中的元素再依次弹回来(先进先出)

1

---

循环队列：长度固定的数组

循环队列：基本都是使用长度固定的数组来实现，数组在实现队列时，若从数组头部删除元素，需要频繁地移动后面的元素，带来效率比较低

出队和入队操作：使用两个引用，一个head，一个tail，添加元素在数组尾部添加，删除元素只需要移动head引用指向的地址即可(逻辑删除)

操作系统的生产消费者模型，MySQL数据库的InnoDB存储引擎中的redo日志都是采用循环队列的方式

循环队列就是使用长度固定的数组来实现，数组头部就是队首(head)，数组的尾部是队尾(tail)，数组[head..tail)是循环队列的有效元素

head永远指向循环队列的第一个元素

tail永远指向循环队列有效元素的后一个位置

循环队列出队一个元素

• 循环队列在删除元素时，不需要进行数据的搬移

• 当有新的元素在添加时就会覆盖掉之前的元素

• 所谓的循环队列指的是当head或者tail引用走到数组末尾时，下一次再继续向后移动，其实返回数组的头部继续操作

---

问题：当数组为空和数组为满时 head == tail，如何区分两种情况？

我们在循环队列中，若tail+1 == head 就认为循环队列已满

• 在循环队列中浪费一个空间，判断队列是否已满(之后tail就不会等于head了，而是判断tail + 1和head是否相等)
• 若此时(tail + 1) % n == head;认为此时循环队列已满
• head == tail认为队列为空

但是head和tail的移动不能简单的+1

使用取模%操作，取数组长度

tail = (tail + 1) % n

对数组长度取模的本质：head和tail走到数组最后一个索引位置时，下一次要返回数组头部，就必须使用+1对n取模

如：上图中tail = 4,tail+1 = 5，而数组长度为5，对数组长度取模得0，得到head

---

双端队列：Deque -> Queue的子接口

这个队列

既可以从尾插，头出

也可以从头插，尾出

双端队列的一个常用子类就是LinkedList

Deque<Integer> stack = new LinkedList<>();
stack.push(1);
stack.push(3);
stack.push(5);
System.out.println(stack.pop());
1
2
3
4
5

• 入栈叫push

• 入队列叫offer

• 出栈叫pop

• 出队列叫poll

Deque<Integer> queue = new LinkedList<>();
queue.offer(1);
queue.offer(3);
queue.offer(5);
System.out.println(queue.poll());
1
2
3
4
5