栈——链式存储栈实现java

目录

目录：

1. 栈的定义
2. 栈的类创建
   1. 定义结点
   2. 成员变量和初始化（构造器constructor）
3. 栈的基本操作
   1. 非空判断（isEmpty）
   2. 数据入栈（push）
   3. 数据出栈（pop）
   4. 读取栈顶元素（peek）
4. 完整代码

---

栈的定义

WiKi是这么说的：

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素

简单理解：

栈就是一种只允许在表尾进行插入和删除操作的线性表

也可以这么理解:
先进后出，先进队的数据最后才出来。在英文的意思里，stack 可以作为一叠的意思，这个排列是垂直的，你将一张纸放在另外一张纸上面，先放的纸肯定是最后才会被拿走，因为上面有一张纸挡住了它。

---

栈的类创建

定义节点

链式存储首先定义一个结点类，这里我简单定义为下：

public class Node<T> {
    public T data;
    public Node<T> next;

    Node(){

    }
    Node(T data, Node<T> next){
        this.data = data;
        this.next = next;
    }

    Node(T data) {
        this.data = data;
        next = null;
    }

}

 成员变量和初始化（构造器constructor）

然后是基于这么一个个结点来创建我们的栈

    private Node<T> top;
    private int size = 0;

    public StackLinkedList() {
        top = null;
    }

    public int getSize() {
        return size;
    }

---

栈的基本操作

栈的基本操作分这几种：

1. 非空判断（isEmpty）
2. 数据入栈（push）
3. 数据出栈（pop）
4. 读取栈顶元素（peek）

需要注意的是，因为我们的栈是通过链式存储来实现的，而链式存储是动态存储，没有存储上限，所以我们的代码里不需要非满判断（isFull）

非空判断

    /**
     * 非空判断
     * @return 非空为true
     */
    public boolean isEmpty() {
        return top == null;
    }

数据入栈（push）

    /**
     * 数据入栈
     * @param data 入栈元素
     */
    public void push(T data) {
        if (isEmpty()) top = new Node<T>(data);
        else top = new Node<T>(data, top);
        size++;
    }

数据出栈（pop）

pop当栈为空时，返回null

    /**
     * 出栈
     * @return 出栈元素
     */
    public T pop() {
        if (isEmpty()) {
            System.out.println("Stack is empty!");
            return null;
        }
        T data = top.data;
        top = top.next;
        size--;
        return data;
    }

读取栈顶元素（peek）

    /**
     * 读取栈顶元素
     * @return 栈顶元素
     */
    public T peek() {
        if (isEmpty()) {
            System.out.println("Stack is empty!");
            return null;
        }
        return top.data;
    }

---

 完整代码

public class StackLinkedList<T>{
    private Node<T> top;
    private int size = 0;

    public StackLinkedList() {
        top = null;
    }

    public int getSize() {
        return size;
    }

    /**
     * 非空判断
     * @return 非空为true
     */
    public boolean isEmpty() {
        return top == null;
    }

    /**
     * 链表为动态存储，没有存储上限
     * @return true
     */
    public boolean isFull() {
        return false;
    }

    /**
     * 数据入栈
     * @param data 入栈元素
     */
    public void push(T data) {
        if (isEmpty()) top = new Node<T>(data);
        else top = new Node<T>(data, top);
        size++;
    }

    /**
     * 出栈
     * @return 出栈元素
     */
    public T pop() {
        if (isEmpty()) {
            System.out.println("Stack is empty!");
            return null;
        }
        T data = top.data;
        top = top.next;
        size--;
        return data;
    }

    /**
     * 读取栈顶元素
     * @return 栈顶元素
     */
    public T peek() {
        if (isEmpty()) {
            System.out.println("Stack is empty!");
            return null;
        }
        return top.data;
    }
}