数据结构之链表，使用链表实现栈以及使用链表实现队列

1、结合之前实现的链表这个数据结构，如果只对链表的头部进行增加和删除，时间复杂度是O(1)的，只对链表的头部进行查询的话，时间复杂度是O(1)的。那么，满足这样的数据结构是什么呢，就是栈，栈这种数据结构是后入先出的，或者先进后出的，只对栈的一端，就是栈顶进行操作，无论是添加元素、删除元素、查询元素，都是在栈顶进行的。所以对于链表来说，可以将链表的头部当作栈顶，用链表做为栈的底层实现来实现一个栈。

创建一个栈的接口，可以使用数组的方式或者链表的方式进行实现栈的功能哦！

 1 package com.stack;
 2 
 3 /**
 4  * @param <E> 使用泛型，可以接受任何数据类型的
 5  */
 6 public interface Stack<E> {
 7 
 8     /**
 9      * 获取到栈里面的大小
10      *
11      * @return
12      */
13     public int getSize();
14 
15     /**
16      * 判断栈是否为空
17      *
18      * @return
19      */
20     public boolean isEmpty();
21 
22     /**
23      * 向栈中添加一个元素，即入栈
24      *
25      * @param e
26      */
27     public void push(E e);
28 
29     /**
30      * 从栈中取出栈顶的元素，即出栈
31      *
32      * @return
33      */
34     public E pop();
35 
36     /**
37      * 查看栈顶的元素
38      *
39      * @return
40      */
41     public E peek();
42 
43 }

由于之前已经使用过数组实现栈，所以这里使用的是链表实现栈的功能，具体代码，如下所示：

  1 package com.linkedlist;
  2 
  3 import com.stack.Stack;
  4 
  5 /**
  6  *
  7  */
  8 public class LinkedListStack<E> implements Stack<E> {
  9 
 10     // 自己实现的LinkedList链表这种数据结构，私有的链表类对象。
 11     private LinkedList<E> linkedList;
 12 
 13     /**
 14      * 构造函数，创建一个LinkedList对象
 15      */
 16     public LinkedListStack() {
 17         linkedList = new LinkedList<>();
 18     }
 19 
 20     /**
 21      * 返回链表实现的栈的大小
 22      *
 23      * @return
 24      */
 25     @Override
 26     public int getSize() {
 27         return linkedList.getSize();
 28     }
 29 
 30     /**
 31      * 返回链表实现的栈是否为空
 32      *
 33      * @return
 34      */
 35     @Override
 36     public boolean isEmpty() {
 37         return linkedList.isEmpty();
 38     }
 39 
 40     /**
 41      * 向链表实现的栈中添加元素，即入栈操作，将元素添加到栈的栈顶
 42      *
 43      * @param e
 44      */
 45     @Override
 46     public void push(E e) {
 47         // 对链表的头部进行操作，时间复杂度是O(1)
 48         linkedList.addFirst(e);
 49     }
 50 
 51     /**
 52      * 从链表实现的栈中删除元素，即出栈操作
 53      *
 54      * @return
 55      */
 56     @Override
 57     public E pop() {
 58         // 对链表的头部取出元素操作，时间复杂度是O(1)
 59         return linkedList.removeFirst();
 60     }
 61 
 62     /**
 63      * 查看栈顶的元素
 64      *
 65      * @return
 66      */
 67     @Override
 68     public E peek() {
 69         // 对链表的头部查看元素操作，时间复杂度是O(1)
 70         return linkedList.getFirst();
 71     }
 72 
 73     @Override
 74     public String toString() {
 75         StringBuilder stringBuilder = new StringBuilder();
 76