数据结构之栈和队列

栈

栈是比较常用的数据结构。栈的应用非常的广泛，比如说，递归函数的实现就是借助于栈保存相关的数据。操作系统中每个线程也会使用栈来保存函数调用涉及到的一些参数和其他变量等。栈最大的一个特点就是先进后出(First In Last Out)。

栈的实现

栈的实现通常有两种方式，即数组和链表。这里采用数组的方式来实现。

1. 定义

public class MyStack<E> {
    Object[] data;  //存放数据的数组
    int size;   //栈的大小，初始为0

    public  MyStack(){
        data = new Object[10];  //数组初始大小为10
    }
}

2. 判断栈空

/**
     * 判断栈空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }

3. 查看栈顶元素

/**
     * 查看栈顶元素
     * @return
     */
    public E peek(){
        if(isEmpty())
            return null;
        return (E)data[size - 1];
    }

4. 出栈

 /**
     * 出栈
     * @return
     */
    public E pop(){
        E e = peek();
        data[size - 1] = null;
        size--;
        return e;
    }

5. 扩容

/**
     * 数组扩容
     * @param size
     */
    private void ensureCapacity(int size) {
        int len = data.length;
        if(size>len)
        {
            //数组拷贝扩容
            data = Arrays.copyOf(data, size);
        }
    }

6. 入栈

/**
     * 入栈
     * @param element
     * @return
     */
    public E push(E element){
        ensureCapacity(size + 1);
        data[size++] = element;
        return element;
    }

队列

1. 队列和栈不同的是，队列是一种先进先出(FIFO—first in first out)的数据结构。
2. Java中是实现了Queue队列的接口，具体实例化的时候需要用到LinkedList等其他实例化类。
3. LinkedList本质是双向链表，但是它同时实现了栈和队列的操作。
   

队列的实现

这里采用链表的方式实现。

1. 定义

 //定义链表节点类型
    class Node<E>{
        E data;
        Node<E> next;

        public Node(E e){
            this.data = e;
        }
    }
    Node<E> head;   //头节点
    Node<E> tail;   //尾节点
    int size;   //长度

2. 判断队空

/**
     * 判断队空
     * @return
     */
    public boolean isEmpty(){
        if(head == null && tail == null){
            return true;
        }else {
            return false;
        }
    }

3. 读队头元素

/**
     * 读队头
     * @return
     */
    public E peek(){
        if(isEmpty())
            return null;
        return head.data;
    }

4. 出队

/**
     * 出队
     * @return
     */
    public E poll(){
        if(isEmpty())
            return null;
        E e = head.data;
        head = head.next;
        size--;
        return e;
    }

5. 入队

/**
     * 入队
     * @param e
     */
    public void offer(E e){
        Node<E> node = new Node<E>(e);
        if(isEmpty()){
            head = node;
            tail = node;
            size++;
        }else{
            tail.next = node;
            tail = node;
            size++;
        }
    }

扩展：
两个栈实现队列，两个队列实现栈 https://www.cnblogs.com/Leo_wl/p/5679661.html
栈获取最小值 https://www.jianshu.com/p/c32ceadaa428