[数据结构&Java]栈和队列——一种特殊的线性表

栈——先进后出

1.常用操作

1. 初始化
2. 压栈/弹栈
3. 查看当前栈顶元素
4. 判断为空
5. 返回元素个数

2.实现

链表可以实现

LinkedList
push/pop 头插/头删

顺序表可以实现

Strack（class） 尾插/尾删

自己实现

利用顺序表实现一个栈
class Strack{
private int[] size; ------top;
private int[] array;
}

public class MyStack {
    private int[] array;
    private  int top;
    public 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 void pop(){
        array[--top] = 0;
    }
    public  int peek(){
        return array[top-1];
    }
    public boolean empty(){
        return  top ==0;
    }
    public int size(){
        return top;
    }

}

队列——先进先出

Java中的队列：
Queue（interface）

1.常用操作

队首——front
队尾——rear

2.实现

1. 用链表实现（单向链表）

头删 pop
尾插 push
记录第一个和最后一个节点

public class MyQueue {
    static  class Node{
        int val;
        Node next = null;
        Node(int val){
            this.val = val;
        }
    }

    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.val;
        front = front.next;
        if(front == null){
            rear = null;
        }
        return  element;
    }

    public int front(){
        return front.val;
    }

    public  int val(){
        return  rear.val;
    }

    public int size(){
        return size;
    }

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

}

2. 用顺序表实现

如果使用顺序表，这时候每一次入队出队所需要的时间复杂的度都是o(n)，不是很理想，于是我们想到：
（1）如果不去每次不搬移，而只是将首尾下标进行变化就可以减少时间复杂度，但这样又会出现空间的浪费，即前面出队后有空间，后面入队空间满。于是我们又想到：
（2）只有rear走到最后才搬一次，这样虽然会解决一些问题，但同时无法判断队空队满。我们想到两种解决方法：
（3）加一个size属性，记录队中元素个数，size=0队空，size=容量 队满。这时，当rear进行循环后，有两种特殊的方式：
当rear走到最后一个位置，如何让其循环回队头：
rear = （rear + 1）% 容量
当rear循环一次到队头，如何找到其上一个在队尾元素下标
index = （rear - 1 + 容量） % 容量
（4）空一个节点位置不用即rear+1=front