栈-线性表-数据结构和算法(Java)

gaog2zh

已于 2022-10-29 21:07:27 修改

阅读量171

点赞数

分类专栏：数据结构和算法文章标签：栈数据结构和算法

于 2022-10-29 21:05:56 首次发布

本文链接：https://blog.csdn.net/gaogzhen/article/details/127592046

版权

数据结构和算法专栏收录该内容

58 篇文章 3 订阅

订阅专栏

文章目录

1 概述

栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。

栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。栈也称为先进后出表。

栈的典型结构如下图1-1所示：在这里插入图片描述

2 栈的实现

这里我们使用链表来实现栈，线程非安全的。当然也可以使用数组实现，有兴趣的小伙伴自己去尝试。

2.1 API

栈：public class Stack<E> implements Iterable<E>

类属性

修饰符	类型	名称	描述
private	class	Iter	内部迭代器
private	class	Node<E>	内部节点类
private	Node<E>	first	栈顶指针
private	int	size	栈元素个数

类方法

修饰符	返回值类型	名称	描述
public	boolean	isEmpty()	判断栈是否为空
public	Iterator<E>	iterator()	获取迭代器
public	E	peek()	获取栈顶元素
public	E	pop()	弹出栈顶元素
public	void	push(E e)	压入栈顶元素
public	int	size()	获取栈元素个数

内部节点类Node：private class Node<E>，见下方代码实现。

内部迭代器，见下方代码实现。

2.2 实现代码

完整代码实现：

import java.util.EmptyStackException;
import java.util.Iterator;

/**
 * @author Administrator
 * @version 1.0
 * @description 栈
 * @date 2022-10-28 20:38
 */
public class Stack<E> implements Iterable<E> {

    /**
     * 栈顶指针
     */
    private Node<E> first;

    /**
     * 栈元素数量
     */
    private int size;

    /**
     * 判断栈是否为空
     * @return      是否为空
     */
    public boolean isEmpty() { return size == 0; }

    /**
     * 栈元素个数
     * @return  栈元素个数
     */
    public int size() { return  size; }

    /**
     * 压栈
     * @param e 元素e
     */
    public void push(E e) {
        Node<E> f = first;
        first = new Node<>(e, f);
        size++;
    }

    /**
     * 获取栈顶元素
     * @return  栈顶元素
     */
    public E peek() {
        if (size == 0) {
            throw new EmptyStackException();
        }
        return first.item;
    }


    /**
     * 弹栈
     * @return  栈顶元素
     */
    public E pop() {
        if (size == 0) {
            throw new EmptyStackException();
        }
        Node<E> f = first;
        first = first.next;
        E old = f.item;
        f.item = null;
        f.next = null;
        return old;
    }

    /**
     * 迭代器
     * @return  迭代器
     */
    @Override
    public Iterator<E> iterator() {
        return new Itr();
    }


    private class Node<E> {
        E item;
        Node<E> next;

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

    private class Itr implements Iterator<E> {

        private Node<E> cur = first;

        @Override
        public boolean hasNext() {
            return cur != null;
        }

        @Override
        public E next() {
            E item = cur.item;
            cur = cur.next;
            return item;
        }

        /**
         * 栈只有顶弹出元素，所有此处不实现删除迭代删除
         */
        @Override
        public void remove() {}
    }
}