栈和队列的学习

1.基础概念

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

 

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

 2.栈的模拟实现

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

import java.util.Arrays;

public class MyStack {
    int[] array;
    int size;

    public MyStack() {
        array = new int[5];//初始化栈,初始容量为5
    }

    //入栈,从栈顶入栈
    public int push(int e) {
        ensureCapacity();//确保栈有足够的容量,如果不够就会扩容
        array[size++] = e;
        return e;
    }

    //元素出栈,也从栈顶出栈,并不是将元素直接删除,而是将size减小,让栈不包含这个元素,以后再次入栈直接覆盖即可
    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);
        }
    }
}

3.栈的使用场景

1. 改变元素的序列

后进先出的特点可以明显地改变元素的顺序
2.. 将递归转化为循环

先进后出类似于递归里面,递归的深度不断增加,栈的大小增加,然后最后进入栈的递归函数先回溯,最开始的函数后回溯

比如下面的递归函数,绿色代表递归,黄色表示回归

转换成栈是:

 

代码如下

//用递归函数实现阶乘
    public static int factorial1(int n) {
        if (n == 1) {
            return 1;
        }
        return n * factorial1(n - 1);
    }

    //用栈实现递归阶乘
    public static int factorial2(int n) {
        if (n == 1) {
            return 1;
        }
        Stack<Integer> stack = new Stack<>();
        //将1到n进栈,类似递归
        for (int i = n; i > 0; i--) {
            stack.push(i);
        }
        int ret = 1;
        //依次出栈类似回溯,然后用ret记录每次回溯的结果,最后元素出栈ret就是结果了
        while (!stack.empty()) {
            ret = ret * stack.pop();
        }
        return ret;
    }

4.栈的使用

javaAPI库有Stack这个类,可以直接使用

public static void main(String[] args) {
        Stack<Integer> s = new Stack();
        s.push(1);
        s.push(2);
        s.push(3);
        s.push(4);
        System.out.println(s.size()); // 获取栈中有效元素个数---> 4
        System.out.println(s.peek()); // 获取栈顶元素---> 4
        s.pop(); // 4出栈，栈中剩余1 2 3，栈顶元素为3
        System.out.println(s.pop()); // 3出栈，栈中剩余1 2 栈顶元素为3
        if(s.empty()){
            System.out.println("栈空");
        }else{
            System.out.println(s.size());
        }
    }

5.队列的模拟实现

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 -1;
        } 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 -1;
        }
        return first.value;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return first == null;
    }
}

6.队列的使用

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

注意：Queue是个接口，在实例化时必须实例化LinkedList的对象，因为LinkedList实现了Queue接口
 

public static void main(String[] args) {
        Queue<Integer> q = new LinkedList<>();
        q.offer(1);
        q.offer(2);
        q.offer(3);
        q.offer(4);
        q.offer(5); // 从队尾入队列
        System.out.println(q.size());
        System.out.println(q.peek()); // 获取队头元素
        q.poll();
        System.out.println(q.poll()); // 从队头出队列，并将删除的元素返回
        if (q.isEmpty()) {
            System.out.println("队列空");
        } else {
            System.out.println(q.size());
        }
    }

7.循环队列和双端队列

实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。
环形队列通常使用数组实现

数组下标循环的小技巧
1. 下标最后再往后(offset 小于 array.length): index = (index + offset) % array.length
 2. 下标最前再往前(offset 小于 array.length): index = (index + array.length - offset) % array.length

如何区分空与满
1. 通过添加 size 属性记录
2. 保留一个位置
3. 使用标记

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

Deque是一个接口，使用时必须创建LinkedList的对象。

 在实际工程中，使用Deque接口是比较多的，栈和队列均可以使用该接口

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