实现一个简单的栈（底层链表）

栈的特点

1. 先进后出（FILO）或者  后进先出（LIFO）
2. 增删元素皆是在栈顶操作
3. 一次只能删除一个数据项：当前栈顶元素
4. 只允许访问一个数据项：当前栈顶元素

---

所需条件

1. 一个链结点类Link，里面包含了需要存储的数据data和一个Link类型的引用变量next
2. 一个封装了链表操作元素的行为类MyLinkList，里面包含了一个Link类型的引用变量first和若干个方法

---

分析实现

　确定栈具有的功能：入栈push()、出栈pop()、查看栈顶元素getTop()、判空isEmpty()、判长length()、清空clear()

---

代码实现

1. Link类

public class Link {

    public Object data;
    public Link next;

    public Link(Object data) {
        this.data = data;
        this.next = null;
    }

    public void displayLink() {
        System.out.print(data + "	");
    }
}

2. MyLinkList类

public class MyListList {

    private Link first;

    /**
     * 判断链表是否为空
     * @return
     */
    public boolean isEmpty() {
        return (first == null);
    }

    /**
     * 在头结点处插入元素
     * @param data
     */
    public void insertFirst(Object data) {
        Link newLink = new Link(data);
        newLink.next = first;
        first = newLink;
    }

    /**
     * 删除头结点
     * @return
     */
    public Object deleteFirst() {
        if (isEmpty()) {
            return null;
        }
        Link temp = first;
        first = first.next;
        return temp.data;
    }

    /**
     * 获得头结点存储的数据
     * @return
     */
    public Object getFirstData() {
        return first.data;
    }
    
    /**
     * 获得链表的长度
     * @return
     */
    public int length() {
        Link current = first;
        int count = 0;
        while (current != null) {
            count++;
            current = current.next;
        }
        return count;
    }

    /**
     * 清空链表
     */
    public void clearList() {
        Link current = first;
        while (current != null) {
            deleteFirst();
            current = current.next;
        }
    }
}

3. 链栈类

public class LinkStack {

    private MyListList myListList;

    public LinkStack() {
        this.myListList = new MyListList();
    }

    public boolean isEmpty(){
        return myListList.isEmpty();
    }

    public void push(Object data) {
        myListList.insertFirst(data);
    }

    public Object pop() {
        return myListList.deleteFirst();
    }

    public void clear() {
        myListList.clearList();
    }

    public int length() {
        return myListList.length();
    }

    public Object getTop() {
        return myListList.getFirstData();
    }
}

4. 测试

public class LinkStackTest {

    public static void main(String[] args) {

        LinkStack linkStack = new LinkStack();

        System.out.println( "栈是否为空? " + linkStack.isEmpty());

        linkStack.push(10);
        linkStack.push(20);
        linkStack.push(30);
        linkStack.push(0);

        System.out.println("栈长: " + linkStack.length());

        System.out.println("栈顶元素: " + linkStack.getTop());

        // 清空栈
        linkStack.clear();

        System.out.println( "栈是否为空? " + linkStack.isEmpty());

        linkStack.push(2);
        linkStack.push(1);
        linkStack.push(6);
        linkStack.push(3);
        linkStack.push(5);
        // 取出栈元素，并打印
        while(!linkStack.isEmpty()){
            Object pop = linkStack.pop();
            System.out.print(pop + "	");
        }
        System.out.println();
    }
}

5. 结果

栈是否为空? true
栈长: 4
栈顶元素: 0
栈是否为空? true
5    3    6    1    2    

---

总结

1. 使用链表作为底层实现，可以任意扩容，这一点比用数组实现好太多；
   
2. 插入、查找、删除所需时间都是O(1)，因为都是对栈顶元素操作。

---

对比链接：使用数组实现栈

---