手写数据结构-栈

已于 2022-07-17 17:18:55 修改
阅读量287 收藏
点赞数
分类专栏： # 手写数据结构与算法 文章标签： 数据结构 java 大数据
于 2022-07-17 15:37:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiqiren1994/article/details/125832387
版权
本文详细介绍了如何手写数据结构中的栈，从基础接口设计开始，逐步实现V1、V2、V3三个版本。每个版本不仅包含了栈的基本功能，如可扩容和使用Optional返回数据，还逐步增加了迭代器扩展和泛型支持。在代码实现中，重点解释了栈顶指针的管理以及在不同版本中新增功能的设计思路。
摘要由CSDN通过智能技术生成

一、基础接口设计

接口是考虑到扩展性以及规范化而准备的，我们设计的栈主要有以下这些接口，完成基本功能即可。


public interface stack {
    int size();

    boolean isEmpty();

    void clear();

    Optional<Object> pop();

    Optional<Object> peek();

    boolean push(Object data);
}

二、V1版本

2.1 功能简介

  1. 栈的基本功能满足
  2. 可扩容
  3. 使用Optional返回数据

2.2 代码

注意：我们使用top作为栈的栈顶指针，默认值为0，也就是空栈时指向0。存入数据后指向下一个位置，取数据时需要top-1来处理，也就是说我们的top始终高真实数据一个位置。

public class StackV1 implements stack {

    private int top;
    private int capacity = DEFAULT_SIZE;
    private double expand = DEFAULT_EXPAND;

    private static final int DEFAULT_SIZE = 16;
    private static final double DEFAULT_EXPAND = 1.5;

    Object[] data = new Object[DEFAULT_SIZE];

    public StackV1() {
    }

    public StackV1(int capacity) {
        if (capacity > 16) {
            this.data = new Object[capacity];
        }
    }

    public StackV1(int capacity, double expand) {
        this.capacity = capacity;
        this.expand = expand;
        if (capacity > 16) {
            this.data = new Object[capacity];
        }
    }

    private void expand() {
        this.capacity *= this.expand;
        // 复制数组
        this.data = Arrays.copyOf(this.data, this.capacity);
    }

    @Override
    public int size() {
        return this.top;
    }

    @Override
    public boolean isEmpty() {
        return this.top == 0;
    }

    @Override
    public void clear() {
        this.top = 0;
    }

    @Override
    public Optional<Object> pop() {
        if (this.top <= 0) {
            return Optional.empty();
        }
        return Optional.of(this.data[--this.top]);
    }

    @Override
    public Optional<Object> peek() {
        if (this.top <= 0) {
            return Optional.empty();
        }
        return Optional.of(this.data[this.top - 1]);
    }

    @Override
    public boolean push(Object data) {
        if (this.top >= this.capacity) {
            expand();
        }
        this.data[this.top++] = data;
        return true;
    }

    public static void main(String[] args) {
        StackV1 stack = new StackV1();
        for (int i = 0; i < 20; i++) {
            stack.push("test" + i);
        }
        for (int i = 0; i < 20; i++) {
            System.out.println("isEmpty:" + stack.isEmpty() + ":" + stack.pop());
        }
        System.out.println("isEmpty:" + stack.isEmpty() + ":" + stack.pop());
    }

二、V2版本

2.1 功能简介

  1. 栈的基本功能满足
  2. 可扩容
  3. 使用Optional返回数据
  4. 完成迭代器扩展

2.2 代码

注意：增加迭代器，对于栈的功能没有帮助


public class StackV2 implements stack, Iterable {

    private int top;
    private int capacity = DEFAULT_SIZE;
    private double expand = DEFAULT_EXPAND;

    private static final int DEFAULT_SIZE = 16;
    private static final double DEFAULT_EXPAND = 1.5;

    Object[] data = new Object[DEFAULT_SIZE];

    public StackV2() {
    }

    public StackV2(int capacity) {
        if (capacity > 16) {
            this.data = new Object[capacity];
        }
    }

    public StackV2(int capacity, double expand) {
        this.capacity = capacity;
        this.expand = expand;
        if (capacity > 16) {
            this.data = new Object[capacity];
        }
    }

    private void expand() {
        this.capacity *= this.expand;
        // 复制数组
        this.data = Arrays.copyOf(this.data, this.capacity);
    }

    @Override
    public int size() {
        return this.top;
    }

    @Override
    public boolean isEmpty() {
        return this.top == 0;
    }

    @Override
    public void clear() {
        this.top = 0;
    }

    @Override
    public Optional<Object> pop() {
        if (this.top <= 0) {
            return Optional.empty();
        }
        return Optional.of(this.data[--this.top]);
    }

    @Override
    public Optional<Object> peek() {
        if (this.top <= 0) {
            return Optional.empty();
        }
        return Optional.of(this.data[this.top - 1]);
    }

    @Override
    public boolean push(Object data) {
        if (this.top >= this.capacity) {
            expand();
        }
        this.data[this.top++] = data;
        return true;
    }

    public static void main(String[] args) {
        StackV2 stack = new StackV2();
        for (int i = 0; i < 20; i++) {
            stack.push("test" + i);
        }
        for (Object data : stack) {
            System.out.println("data:" + data);
        }
    }

    @Override
    public Iterator iterator() {
        return new ArrayIterator();
    }

    private class ArrayIterator implements Iterator<Object> {
        private int j = 0;
        private boolean removable = false;

        public boolean hasNext() {
            return j < top;
        }

        public Object next() throws NoSuchElementException {
            if (j == top) throw new NoSuchElementException("No next element");
            removable = true;
            return data[j++];
        }

        public void remove() throws IllegalStateException {
            if (!removable) throw new IllegalStateException("nothing to remove");
            StackV2.this.pop();
            j--;
            removable = false;
        }
    }
}

三、V3版本

2.1 功能简介

  1. 栈的基本功能满足
  2. 可扩容
  3. 使用Optional返回数据
  4. 完成迭代器扩展
  5. 支持泛型

2.2 代码

注意：模仿ArrayList返回数据时才强转类型

public interface Istack<T> {
    int size();

    boolean isEmpty();

    void clear();

    Optional<T> pop();

    Optional<T> peek();

    boolean push(T data);
}

public class StackV3<T> implements Istack<T>, Iterable<T> {

    private int top;
    private int capacity = DEFAULT_SIZE;
    private double expand = DEFAULT_EXPAND;

    private static final int DEFAULT_SIZE = 16;
    private static final double DEFAULT_EXPAND = 1.5;

    Object[] data = new Object[DEFAULT_SIZE];

    public StackV3() {
    }

    public StackV3(int capacity) {
        if (capacity > 16) {
            this.data = new Object[capacity];
        }
    }

    public StackV3(int capacity, double expand) {
        this.capacity = capacity;
        this.expand = expand;
        if (capacity > 16) {
            this.data = new Object[capacity];
        }
    }

    private void expand() {
        this.capacity *= this.expand;
        // 复制数组
        this.data = Arrays.copyOf(this.data, this.capacity);
    }

    @Override
    public int size() {
        return this.top;
    }

    @Override
    public boolean isEmpty() {
        return this.top == 0;
    }

    @Override
    public void clear() {
        this.top = 0;
    }

    @Override
    public Optional<T> pop() {
        if (this.top <= 0) {
            return Optional.empty();
        }
        return Optional.of((T) this.data[--this.top]);
    }

    @Override
    public Optional<T> peek() {
        if (this.top <= 0) {
            return Optional.empty();
        }
        return Optional.of((T) this.data[this.top - 1]);
    }

    @Override
    public boolean push(T data) {
        if (this.top >= this.capacity) {
            expand();
        }
        this.data[this.top++] = data;
        return true;
    }

    public static void main(String[] args) {
        StackV3<String> stack = new StackV3<>();
        for (int i = 0; i < 20; i++) {
            stack.push("test" + i);
        }
        stack.forEach(data -> {
            System.out.println("forEach-data:" + data);
        });
        for (Object data : stack) {
            System.out.println("for-data:" + data);
        }
    }

    @Override
    public Iterator iterator() {
        return new ArrayIterator();
    }

    private class ArrayIterator implements Iterator<T> {
        private int j = 0;
        private boolean removable = false;

        public boolean hasNext() {
            return j < top;
        }

        public T next() throws NoSuchElementException {
            if (j == top) throw new NoSuchElementException("No next element");
            removable = true;
            return (T) data[j++];
        }

        public void remove() throws IllegalStateException {
            if (!removable) throw new IllegalStateException("nothing to remove");
            StackV3.this.pop();
            j--;
            removable = false;
        }
    }
}
jiqiren1994
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】手写链栈【纯c语言版】
weixin_43113381的博客
11-16 587
摘要：本章主要讲述链栈的实现 文章目录1. 链栈的存储结构2. 链栈的入栈出栈图解3. 链栈的代码实现3.1 定义链栈的结构3.2 栈的初始化3.3 创建新结点3.4 判断栈是否为空3.5 入栈操作3.6 出栈操作3.7 读栈顶操作3.8 清空栈3.9 销毁栈3.10 感悟源码链接(含测试代码)文章索引后记 1. 链栈的存储结构 链栈的结构与链表相似 插入与删除等操作都在链表的头部 即:链栈是一个以top为头结点、从栈顶指向栈底的单链表 2. 链栈的入栈出栈图解 3. 链栈的代码实现 3.1 定义
手写栈的数据结构
yu15163158717的博客
03-20 300
首先定义一个栈的接口：接口如下： public interface Stack<E> { int getSize();//栈的长度 boolean isEmpty();//栈是否为空 void push(E e);//往栈中添加元素 E pop();//从栈中删除元素 E peek();//从栈中获取元素 } 然后在定义一个Arr...
【数据结构】手写栈模型（顺序存储结构 & 链式存储结构）
不分解的单应矩阵
03-10 480
栈（Stack）是限定仅在表尾进行插入和删除的线性表
栈数据结构
weixin_45677987的博客
06-24 817
1： 栈数据结构: 1: 栈 (stack) 又名堆栈, 它是一种运算受限的线性表， 仅在表尾进行插入和删除操作, 这一端叫做栈顶, 另一端叫做栈底。 2: 向栈中插入新元素叫做进栈, 入栈, 或者压栈； 从栈中删除一个元素又叫做出栈或者退栈。 3: 后进先出的特点: 栈中元素, 最先进展的必定最后出栈， 后进栈的一定会出栈。栈结构特点: 就是先进后出的特点。 所有的插入元素, 删除操作只可以在一端进行。 这一端就是栈顶。 4：javascript 中, 栈可可以使用数组模拟, 只需要限制使用
【化解数据结构】什么是栈？手写实现一个栈结构
小丞同学
11-09 1049
关于栈数据结构你了解多少呢？入栈？出栈？如此简单，不如自己手写实现一个栈数据结构吧，那就从这篇文章开始栈的学习之旅吧~
java设计相应的数据结构和接口_漫谈Java程序设计中的接口应用
weixin_42139871的博客
02-26 270
理解并用好接口机制将帮助我们更好的掌握Java这种面向对象的编程语言。下面我们来讨论一下接口的使用规则以及相关的应用。一、接口的定义及实现定义接口和定义类相似，只是要把 class关键字换为 interface。定义方法时只需要方法名，返回类型和参数列表，不能有方法体。接口中可以定义字段，这些字段都被暗指为 static 和 final，因此应该根据需要先定好这些字段的值。例如：publicin...
如何设计接口
qq_36811160的博客
05-17 1355
1、单一职责原则 每个接口只负责一件事 2、定义协议规范 在设计接口时应明确接口协议，通常有一下几种： HTTP协议：适用于对安全性要求比较低的场景 HTTPS：HTTP+SSL，适用于对安全性要求较高的场景 3、命名规则 由于API获取的是一种资源，所以网址中尽量为名词 4、HTTP请求方式 符合RESTful风格 接口基本访问协议：get(获取)，post(新增)，put(修改)和delete(删除) get /users：列出所有用户 get /users/id：根据id获取用户
api接口设计
jasonhui512的博客
11-12 1万+
写过不少接口，不过一直没有去总结，网上搜了一下，大同小异，此文根据以下几个链接整理修改： https://segmentfault.com/a/1190000004051246 http://blog.sqrtthree.com/2015/09/08/api/ http://keeganlee.me/post/architecture/20160107 https://www.hutuse
Java数据传输结构设计 - 接口数据封包
简简单单Onlinezuozuo
07-13 6632
Java数据传输结构设计 - 接口数据封包#接口的数据结构* 接口应该有统一的数据格式* 接口应该具有良好的容错性* 接口应该具有安全性* 接口应该提供高可读性#接口数据返回的最外层结构{ "result": "8002", "msg": "Success", "data": "// 返回的数据", "sign": "// 数据签名" }接口的数据返回都封包在data字段下，resu
优秀的API接口设计原则及方法
u010006156的博客
07-13 2552
一旦API发生变化，就可能对相关的调用者带来巨大的代价，用户需要排查所有调用的代码，需要调整所有与之相关的部分，这些工作对他们来说都是额外的。如果辛辛苦苦完成这些以后，还发现了相关的bug，那对用户的打击就更大。如果API经常发生变化，用户就会失去对提供方失去信心，从而也会影响目前的业务。但是我们为什么还要修改API呢？为了API看起来更加漂亮？为了提供更多功能？为了提供更好的性能？还是仅仅觉得到了改变了时候了？对于用户来说，他们更愿意使用一个稳定但是看起来不那么时髦的API，这并不意味着我们不再改进API
Java——数据结构接口
一个努力学习的程序猿
10-02 1128
Java——数据结构接口基本结构：1）Collection集合接口：1.List接口:*LinkedList：链表类*ArrayList：数组列表类2.Set接口:*HashSet集合类*TreeSet集合类3.Map映射接口：*Hashtable散列表类*HashMap散列映射类2）Iterator迭代器接口：实现各种集合元素的读取。迭代器的作用：迭代器模式：由以下角色组成。迭代器模式给容器的应...
前端接口的数据结构
陈旭媛
07-28 3720
当用户进入相关页面的时候，会从后端拉一个全量的数据（全量数据：返回所有的数据）；当用户在该页面停留的时候，后端数据的变动会通过增量数据（增量数据：只返回改变的数据）返回(首期统一采用全量响应)。 对于每个请求，前端应带上一个时间戳（Long类型的毫秒数）参数t（为上一个后台响应带回来的时间戳，代表上一次数据更新的时间。如果是第一次请求，设置为-1），以便于服务端比较是否有更新的数据。
2018数据结构课程设计报告
热门推荐
不惧神风的博客
03-24 4万+
本文是一份数据结构课程设计报告，旨在为各位的课设设计提供一条思路。
rpc - 接口返回数据结构的设计
weixin_30918633的博客
01-17 512
方案一： 系统级状态 、业务级别的状态同用 code要特殊声明保留状态，如若不声明保留状态，一旦业务开发人员用到了系统级的状态，就有必要侵入的改动业务返回的code（新code与业务欲返回的code不一样，不好调试），不是很好 // --- 系统级状态 --- { 'code' : 20000, 'message' : '系统没有出错、登录检查过了、权限检查过...
JAVA 数据结构接口-对比分析
pomer_huang的博客
01-07 1045
JAVA 推荐面向接口编程，这样在代码重构时，只需替换掉具体的实现类而不影响现有的代码，因此，当我们在考虑数据结构时，第一步就是要选出一个合适的接口 JAVA 集合框架接口（继承体系） 哈希接口（散列表结构） 集合接口 Map 介绍 Map 散列表（哈希表），通过 Key 对象的哈希值来决定 Value 存储位置，但判断 Key 时需要同时保证 hashCode(...
408王道数据结构强化——应用题
JiangNan_1002的博客
07-21 7025
1.栈、数组和队列 2.树 3.图 4.查找 5.排序
【数据结构初阶】队列
最新发布
稻草人
08-10 1733
1、概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有的特性。进行插入操作的一端称为进行删除操作的一端称为队列也可以数组和链表的结构实现，使⽤链表的结构实现更优⼀些，因为如果使⽤数组的结构，出队列在数组头上出数据，效率会比较低。
常见8种数据结构
qq_43575301的博客
08-08 2059
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
数据结构（学习）2024.8.9（双向链表）
何物爱惜雨的博客
08-09 587
双向链表的创建，插入，遍历，删除
江南大学《数据结构》期末考试答案解析
7. **数据结构基础**：选择题和判断题涵盖了数据结构的基础概念，如栈、队列、数组等，考生需要对这些基本数据结构有深入理解。 通过这份试卷，我们可以看出《数据结构》课程的学习不仅要求学生掌握各种数据结构的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值