栈和队列

栈

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

栈简单实现:

import java.util.Arrays;

public class MyStack {
    private int[] array = new int[10];
    private int top = 0;

    private void ensureCapacity() {
        if (top < array.length) {
            return;
        }

        array = Arrays.copyOf(array, 2 * array.length);
    }

    public int push(int element) {
        ensureCapacity();
        array[top++] = element;
        return element;
    }

    public int pop() {
        return array[--top];
    }

    public int peek() {
        return array[top - 1];
    }

    public boolean empty() {
        return top == 0;
    }

    public int size() {
        return top;
    }

    public int search(int element) {
        for (int i = 0; i < top; i++) {
            if (array[i] == element) {
                return i;
            }
        }

        return -1;
    }
 }

队列

队列(Queue)是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头

队列简单实现:

public class MyQueue {
    static class Node {
        int value;
        Node next = null;

        Node(int value) {
            this.value = value;
        }
    }

    private Node front = null;
    private Node rear = null;
    private int size = 0;

    public void push(int element) {
        // 尾插
        size++;
        if (rear != null) {
            rear.next = new Node(element);
            rear = rear.next;
        } else {
            front = rear = new Node(element);
        }
    }
    public int pop() {
        int element = front.value;
        size--;
        front = front.next;
        if (front == null) {
            rear = null;
        }

        return element;
    }

    public int rear() {
        return rear.value;
    }
    public int front() {
        return front.value;
    }

    public int size() {
        return size;
    }

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

栈和队列的相同点:
1.都是线性结构
2.插入操作都限定在表尾进行
3.都可以通过顺序结构和链式结构实现
4.插入和删除时间复杂度相同O(1),空间复杂度两者也一样

栈和队列的不同点;
1.删除数据元素的位置不同,栈在栈在表尾,队列在表头
2.应用场景不同.常见的栈应用在:括号问题求解,表达式的转换与求值,函数的调用和递归和递归实现,深度优先搜索遍历.
常见的队列应用在:计算机系统各种资源的管理,消息缓冲器的管理,广度优先搜索遍历
3.顺序栈可以做到空间共享,顺序队列不行
4.栈先进后出.队列先进先出

两种数据结构各有各的特点另外他们可以互相实现对方
栈实现队列:

import java.util.Stack;

public class MyQueueWithStack {
    private Stack<Integer> stack1 = new Stack<>();
    private Stack<Integer> stack2 = new Stack<>();
    public void push(int x) {
        stack1.push(x);
    }
    public int pop() {
        if (stack2.empty()) {
            while (!stack1.empty()) {
                int v = stack1.pop();
                stack2.push(v);
            }
        }

        return stack2.pop();
    }
    public int peek() {
        if (stack2.empty()) {
            while (!stack1.empty()) {
                int v = stack1.pop();
                stack2.push(v);
            }
        }

        return stack2.peek();
    }
    public boolean empty() {
        return stack1.empty() && stack2.empty();
    }
}

队列实现栈:

import java.util.LinkedList;
import java.util.Queue;

public class MyStackWithQueue {
    private Queue<Integer> queue = new LinkedList<>();

    public void push(int x) {
        queue.add(x);
    }

    public int pop() {
        // 先把前 size - 1 个数，处理
        int size = queue.size();
        for (int i = 0; i < size - 1; i++) {
            int v = queue.poll();
            queue.add(v);
        }

        return queue.poll();
    }
    public int top() {
        int size = queue.size();
        for (int i = 0; i < size - 1; i++) {
            int v = queue.poll();
            queue.add(v);
        }

        int v = queue.poll();
        queue.add(v);

        return v;
    }

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