数据结构-栈和队列【基础篇】

栈

概念

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

在底层结构中，栈是用动态的顺序表实现的，继承了与ArrayList类似的Vector类，不同的是Vector是线程安全的(什么是线程安全会在后续的学习中记录)。

栈的模拟实现

对于栈这个结构，核心操作有三个：
push： 入栈
pop： 出栈
peek： 查看栈顶元素。

 //入栈
    public void push(E val){
        data[size++] = val;
        if(size == data.length){
            //扩容
            data = Arrays.copyOf(data,data.length << 1);
        }
    }
    //出栈
    public E pop(){
        if(!isEmpty()){
            throw new NoSuchElementException("stack is error");
        }
        E val = (E) data[size - 1];
        size--;
        return val;

    }
    private boolean isEmpty(){
        return size == 0;
    }

    //返回栈顶元素
    private E peek(){
        if(!isEmpty()){
            throw new NoSuchElementException("stack is empty");
        }
        return (E) data[size - 1];
    }

队列

概念

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

在底层结构中，队列是通过链表实现的。

队列的链式模拟实现

对于队列这个结构，核心操作有三个：
offer： 入队
poll： 出队
peek： 查看队首元素。

 //入队，尾插
    @Override
    public void offer(E val) {
        Node node = new Node(val);
        if(head == null){
            head = tail = node;
        }
        tail.next = node;
        tail = node;
        size ++;
    }
    //出队
    @Override
    public E poll () {
        if(size == 0){
            throw new NoSuchElementException("queue is empty");
        }
        E oldval = head.val;
        head = head.next;
        size --;
        return oldval;

    }
    //查看队首元素
    @Override
    public E peek() {
        if(size==0){
            throw new NoSuchElementException("queue is empty");
        }
        return head.val;
    }

循环队列

循环队列通常使用数组实现。

循环队列最大的特点：
使用定长数组作为循环队列的长度，其中元素下标使用取模运算，实现从数组尾部走到数组头部的效果。
如何判断循环队列是空还是满？
在循环队列中，定义tail引用指向队列的最后一个有效元素的下一个位置。
判断为空： head == tail
判断为满： 在数组中浪费一个空间，当(tail + 1) % n == head,此时队列已满。

    //判满
    private boolean isFull(){
        return (tail + 1) % data.length == head;
    }
    //判空
    private boolean isEmpty(){
        return head==tail;
    }

双端队列

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

Deque是一个接口，有两个常用的子类：
基于双向链表实现的双端队列LinkedList；
基于数组实现的双端队列ArrayDeque；
若使用Deque作为栈，推荐使用ArrayDeque子类。

public class DequeUsage {
    public static void main(String[] args) {
        // 可以使用双端队列作为栈使用，API
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(1);
        stack.push(3);
        stack.push(5);
        // 5
        System.out.println(stack.pop());
        // 3
        System.out.println(stack.peek());
    }
}

public class DequeUsage {
    public static void main(String[] args) {
        // 可以使用双端队列作为队列使用，API
        Deque<Integer> stack = new LinkedList<>();
        stack.offer(1);
        stack.offer(3);
        stack.offer(5);
        // 1
        System.out.println(stack.poll());
        // 3
        System.out.println(stack.peek());
    }
}

栈和队列的相互实现

两个队列实现一个栈

    //定义两个队列
    //q1永远是储存元素的队列
    private Queue<Integer> q1 = new LinkedList<>();
    //q2永远保存新元素
    private Queue<Integer> q2 = new LinkedList<>();

    public void push(int x) {
        //新元素入q2；
        q2.offer(x);
        //将q1的所以元素依次出队再入q2
        while (!q1.isEmpty()){
            q2.offer(q1.poll());
        }
        //交换q1和q2
        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();
    }

一个队列实现一个栈

    private Queue<Integer> queue = new LinkedList<>();
    public void push(int x) {
        //暂存一下当前队列中的元素个数
        int size = queue.size();
        //新元素入栈
        queue.offer(x);
        //此时旧元素先出栈再入栈
        for (int i = 0; i < size; i++) {
            queue.offer(queue.poll());
        }
    }

    public int pop() {
        return queue.poll();
    }

    public int top() {
        return queue.peek();
    }

    public boolean empty() {
        return queue.isEmpty();
    }

两个栈实现一个队列

 //s1永远是存储元素的栈
    private Stack<Integer> s1 = new Stack<>();
    private  Stack<Integer> s2 = new Stack<>();
    public void push(int x) {
        //先将s1中的所有元素依次压入S2中
        while (!s1.isEmpty()){
            s2.push(s1.pop());
        }
        //此时s1空出，栈底存放新元素，就是队尾
        s1.push(x);
        //再将s2中的所有元素依次弹出压入s1中
        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();
    }