知识点（5）——使用LinkedList实现栈和队列

前言

LinkedList是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。

LinkedList 实现 List 接口，能对它进行队列操作。

LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。

LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。

LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。

LinkedList 是非同步的。

一、LinkedList可以作为LIFO(后进先出)的栈，作为LIFO的栈时，下表的方法等价：

栈方法        等效方法
push(e)      addFirst(e)
pop()        removeFirst()
peek()       peekFirst()

/**
  * 将LinkedList当作 LIFO(后进先出)的堆栈
  */
private void useLinkedListAsLIFO() {       
    // 新建一个LinkedList
    LinkedList stack = new LinkedList();

       // 将1,2,3,4添加到堆栈中
      stack.push("1");
      stack.push("2");
      stack.push("3");
      stack.push("4");

      // 打印“栈”
      System.out.println("stack:"+stack);

      // 删除“栈顶元素”
      System.out.println("stack.pop():"+stack.pop());
        
      // 取出“栈顶元素”
      System.out.println("stack.peek():"+stack.peek());

      // 打印“栈”
      System.out.println("stack:"+stack);
}

输出结果：

stack:[4, 3, 2, 1]
stack.pop():4
stack.peek():3
stack:[3, 2, 1]

二、LinkedList可以作为FIFO(先进先出)的队列，作为FIFO的队列时，下表的方法等价：

队列方法       等效方法
add(e)        addLast(e)
offer(e)      offerLast(e)
remove()      removeFirst()
poll()        pollFirst()
element()     getFirst()
peek()        peekFirst()

/**
  * 将LinkedList当作 FIFO(先进先出)的队列
  */
private void useLinkedListAsFIFO() {
      // 新建一个LinkedList
      LinkedList queue = new LinkedList();

      // 将10,20,30,40添加到队列。每次都是插入到末尾
      queue.add("10");
      queue.add("20");
      queue.add("30");
      queue.add("40");

      // 打印“队列”
      System.out.println("queue:"+queue);

      // 删除(队列的第一个元素)
      System.out.println("queue.remove():"+queue.remove());
  
      // 读取(队列的第一个元素)
      System.out.println("queue.element():"+queue.element());

      // 打印“队列”
      System.out.println("queue:"+queue);
 }

输出结果：

queue:[10, 20, 30, 40]
queue.remove():10
queue.element():20
queue:[20, 30, 40]

三、使用两个栈实现一个队列

public class MyQueue {

    /*入队栈*/
    private final Stack inStack = new Stack<>();
    /*出队栈*/
    private final Stack outStack = new Stack<>();

    /**
     * 入队
     *
     * @param e
     */
    public void offer(E e) {
        while (!outStack.isEmpty()) {
            inStack.push(outStack.pop());
        }
        inStack.push(e);
    }

    /**
     * 出队
     */
    public void poll() {
        while (!inStack.isEmpty()) {
            outStack.push(inStack.pop());
        }
        outStack.pop();
    }

    /**
     * 判断队列是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return inStack.isEmpty() && outStack.isEmpty();
    }

    /**
     * 获取队列中的第一个元素
     *
     * @return
     */
    public E peek() {
        while (!inStack.isEmpty()) {
            outStack.push(inStack.pop());
        }
        return outStack.peek();
    }

}

四、用两个队列实现栈

思路：队列是先进先出，栈是先进后出。要想用队列实现栈，则需要两个队列。定义一个是用来存放元素的队列，再定义一个辅助的队列。两个队列的功能需要不停的更换。即现在queue1用来存放元素，但进行完某操作后，queue1可能就用了作为辅助了。

public class MyStack {
    /*存放元素的队列*/
    private Queue queue1 = new LinkedList<>();
    /*辅助队列*/
    private Queue queue2 = new LinkedList<>();

    /**
     * 压栈（将元素e 压入栈顶）
     */
    public void push(E e) {
        queue1.offer(e);
    }

    /**
     * 弹栈（移除并返回栈顶元素）
     *
     * @return
     */
    public E pop() {
        for (int i = 0; i < queue1.size() - 1; i++) {
            queue2.offer(queue1.poll());
        }
        E lastE = queue1.poll();

        Queue temp = queue1;
        queue1 = queue2;
        queue2 = temp;
        return lastE;
    }

    /**
     * 获取栈顶元素
     *
     * @return
     */
    public E peek() {
        for (int i = 0; i < queue1.size() - 1; i++) {
            queue2.offer(queue1.poll());
        }
        E lastE = queue1.poll();
        queue2.offer(lastE);

        Queue temp = queue1;
        queue2 = queue1;
        queue1 = temp;

        return lastE;
    }

    /**
     * 判断栈内是否有元素
     *
     * @return
     */
    public boolean isEmpty() {
        return queue1.isEmpty() && queue2.isEmpty();
    }
}

五、Java实现栈

(1)方式一：数组的方式实现：

public class ArrayStack {

    /*默认初始大小*/
    private final int DEFAULT_SIZE = 10;
    private Object[] elementArray;
    private int usedSize;

    public ArrayStack() {
        elementArray = new Object[DEFAULT_SIZE];
    }

    /**
     * 压栈
     *
     * @param e
     */
    public E push(E e) {
        if (isFull()) {
            elementArray = Arrays.copyOf(elementArray, 2 * elementArray.length);
        }
        elementArray[usedSize] = e;
        usedSize++;
        return e;
    }

    /**
     * 弹栈
     *
     * @return
     */
    public E pop() {
        if (usedSize == 0) throw new EmptyStackException();
        E topE = (E) elementArray[usedSize - 1];
        usedSize--;
        elementArray[usedSize] = null;
        return topE;
    }

    /**
     * 获取栈顶元素
     */
    public E peek() {
        if (usedSize == 0) throw new EmptyStackException();
        return (E) elementArray[usedSize - 1];
    }

    /**
     * 数组是否已满
     *
     * @return
     */
    private boolean isFull() {
        return usedSize == elementArray.length;
    }

    /**
     * 栈中是否有元素
     *
     * @return
     */
    public boolean isEmpty() {
        return usedSize == 0;
    }

}

(2)方式二：链表的方式实现：

public class LinkStack {

    private Node head;

    /**
     * 压栈
     *
     * @param e
     * @return
     */
    public E push(E e) {
        Node node = new Node<>(e);
        node.next = head;
        head = node;
        return e;
    }

    /**
     * 弹栈
     *
     * @return
     */
    public E pop() {
        if (head == null) throw new EmptyStackException();
        E val = head.val;
        Node oldHead = head;
        head = head.next;
        oldHead.next = null;
        return val;
    }

    /**
     * 获取栈顶元素
     *
     * @return
     */
    public E peek() {
        if (head == null) throw new EmptyStackException();
        return head.val;
    }

    /**
     * 获取栈中元素的个数
     *
     * @return
     */
    public int size() {
        if (head == null) return 0;
        Node temp = head;
        int size = 0;
        while (temp != null) {
            size++;
            temp = temp.next;
        }
        return size;
    }

    /**
     * 栈中是否有元素
     *
     * @return
     */
    public boolean isEmpty() {
        return head == null;
    }

    public static class Node {
        public E val;
        public Node next;

        public Node(E val) {
            this.val = val;
        }
    }
}