Java数据结构-栈

栈是一个运算受限的先进后出的线性表。仅限在表的一端进行运算操作操作

代码实现

接口

java 复制代码
public interface Stack<E> {

    /**
     * 进栈
     *
     * @param e 元素
     * @throws NullPointerException 不允许空元素
     */
    void push(E e);

    /**
     * 退栈
     *
     * @return 返回弹出元素
     * @throws java.util.NoSuchElementException 没有元素错误
     */
    E pop();

    /**
     * 取栈顶
     *
     * @return 返回栈顶元素
     * @throws java.util.NoSuchElementException 没有元素错误
     */
    E getTop();

    /**
     * 是否空栈
     *
     * @return 返回结果
     */
    boolean isEmpty();

    /**
     * 检查元素是否为空指针
     * @param e 元素
     */
    default void check(E e) {
        if (e == null) {
            throw new NullPointerException();
        }
    }
}

顺序表实现

java 复制代码
public class StackSequence<E> implements Stack<E> {

    private Object[] elementData;

    /**
     * 游标
     */
    private int top;

    public StackSequence(int initialCapacity) {
        this.top = -1;
        if (initialCapacity <= 0) {
            elementData = new Object[10];
            return;
        }
        elementData = new Object[initialCapacity];
    }

    @Override
    public void push(E e) {
        check(e);
        ++top;
        if (top == elementData.length) {
            grow();
        }
        elementData[top] = e;
    }

    private void grow() {
        // 当前值的1.5倍
        elementData = Arrays.copyOf(elementData, (elementData.length + 1) / 2 * 3);
    }

    @Override
    @SuppressWarnings("unchecked")
    public E pop() {
        if (top < 0) {
            throw new NoSuchElementException();
        }
        Object elementDatum = elementData[top];
        elementData[top] = null;
        top--;
        return (E) elementDatum;
    }

    @Override
    @SuppressWarnings("unchecked")
    public E getTop() {
        if (top < 0) {
            throw new NoSuchElementException();
        }
        return (E) elementData[top];
    }

    @Override
    public boolean isEmpty() {
        return top < 0;
    }

    public int size() {
        return elementData.length;
    }
}

栈链表实现

java 复制代码
public class QueueLink<E> implements Queue<E> {

    protected Node<E> head;
    protected Node<E> rear;

    public QueueLink() {
        this.rear = new Node<>(null, null);
        this.head = new Node<>(null, this.rear);
    }

    @Override
    public void enqueue(E e) {
        check(e);
        rear.element = e;
        Node<E> node = new Node<>(null, null);
        rear.next = node;
        rear = node;
    }

    @Override
    public E dequeue() {
        Node<E> next = head.next;
        check(next.element);
        head.next = next.next;
        return next.element;
    }

    @Override
    public boolean isEmpty() {
        return head.next.element == null;
    }

    @Override
    public E getHead() {
        E element = head.next.element;
        check(element);
        return element;
    }

    protected static class Node<E> {
        private E element;
        private Node<E> next;

        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }

        public E getElement() {
            return element;
        }

        public void setElement(E element) {
            this.element = element;
        }

        public Node<E> getNext() {
            return next;
        }

        public void setNext(Node<E> next) {
            this.next = next;
        }
    }
}

代码测试

Java 复制代码
/**
 * @author DawnStar
 * @since 2025/8/2
 */
public class StackTest {
    public static void main(String[] args) {

        // 顺序表实现
        StackSequence<String> stack = new StackSequence<>(3);
        System.out.print("栈顺序表:");
        stack.push("A");
        System.out.print(stack.pop());
        stack.push("B");
        stack.push("C");
        System.out.print(" " + stack.pop());
        stack.push("D");
        stack.push("E");
        System.out.print("、" + stack.pop());
        System.out.print("、" + stack.pop());
        System.out.print("、" + stack.pop() + "\n");
        System.out.println("栈顺序表大小:" + stack.size());


        Stack<String> linkStack = new StackLink<>();
        List<String> elements = List.of("A", "B", "C", "D", "E");
        System.out.println("栈链表进栈:" + String.join("、", elements));
        for (String element : elements) {
            linkStack.push(element);
        }
        System.out.print("出栈顺序:");
        while (!linkStack.isEmpty()) {
            System.out.print(" " + linkStack.pop());
        }
    }
}
相关推荐
红豆怪怪3 分钟前
[LeetCode 热题 100] 32. 最长有效括号
数据结构·python·算法·leetcode·动态规划·代理模式
AI 嗯啦20 分钟前
计算机的排序方法
数据结构·算法·排序算法
小薛博客28 分钟前
22、Jenkins容器化部署Java应用
java·运维·jenkins
西贝爱学习32 分钟前
如何在 IntelliJ IDEA 中进行全局替换某个字段(或文本)
java·ide·intellij-idea
南部余额35 分钟前
Spring 基于注解的自动化事务
java·spring·自动化
alf_cee36 分钟前
通过Idea 阿里插件快速部署java jar包
java·ide·intellij-idea
_Coin_-1 小时前
算法训练营DAY58 第十一章:图论part08
数据结构·算法·图论
坚持每天敲代码1 小时前
【教程】IDEA中导入springboot-maven工程
java·maven·intellij-idea
CodeCraft Studio1 小时前
国产化PDF处理控件Spire.PDF教程:如何在 Java 中通过模板生成 PDF
java·python·pdf·spire.pdf·java创建pdf·从html创建pdf
阿方.9181 小时前
《数据结构全解析:栈(数组实现)》
java·开发语言·数据结构