带你搞定顺序表(java)

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量197 收藏 6
点赞数 9
分类专栏： JavaDS 文章标签： java 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60781793/article/details/128391626
版权

顺序表

文章目录

1.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储

image-20221220105935552

2.顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下使用数组来存储。在数组上进行数据的增删查改。

模拟实现

基本结构
public class MyArrayList {
    public int[] elem;
    public int useSize;
    //默认容量
    private static final int DEFAULT_SIZE = 10;
    public MyArraylist(){
        this.elem=new int[DEFAULT_SIZE];
    }
}

首先创建一个顺序表的类，类中有三个属性，一个elem数组(顺序表可看作数组)，一个int类型usesize(用来表示表中有效元素的个数)，一个私有的静态final变量DEFAULT_SIZE(表示数组的默认容量)

打印顺序表
public void display() {
    //1、数组为空打印[];
    if (usedSize == 0) {
        System.out.println("[]");
        return;
    }
    //数组不为空[1,2,3,4]
    StringBuilder sb = new StringBuilder();
    sb.append("[");
    for (int i = 0; i < usedSize; i++) {
        sb.append(this.elem[i]);
        if (i < usedSize - 1) {
            sb.append(",");
        }
    }
    sb.append("]");
    System.out.println(sb.toString());
}
元素的增加
public void add(int data) {
    //1、先判断数组是否需要扩容
    if (isFull()) {
        grow();
    }
    //2、增加元素
    this.elem[usedSize] = data;
    usedSize++;
}

在数组中增加元素时，首先要判断数组是否已满，否则无法添加新元素。需进行数组的扩容。

判断数组是否已满，以及扩容
//判断是否已满
public boolean isFull() {
    return usedSize == this.elem.length;
}
//扩容
public void grow() {
    this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);
}

扩容以数组长度的2倍进行扩容。

获取顺序表的长度
public int size() {
    return usedSize;
}

这里我们直接获取数组中有效元素个数即可。

在pos位置添加元素
public void add(int pos, int data) {
    //1、判断下标是否合法
    if (!checkPosInAdd(pos)) {
        throw new IndexOutOfBoundsException("传入的下标非法，pos=" + pos);
    }
    //整体往后移一位
    //判断是否需要扩容
    if (isFull()) {
        grow();
    }
    for (int i = usedSize; i > pos; i--) {
        this.elem[i] = this.elem[i - 1];
    }
    this.elem[pos] = data;
    usedSize++;
}

首先我们需要判断添加的元素是否合法(pos不能为负,pos不能大于数组的长度)，然后判断数组是否需要扩容，其次将最后一个元素依次往后移动一个位置，直到指针到达pos位置，最后进行赋值，usedSize++

这里通过画图能更好的理解

image-20221220231716861

开始向后移动

image-20221220231934414

如果是在useSize位置添加直接elem[pos]=val。

判定是否包含某个元素以及获取某个元素的位置
// 判定是否包含某个元素
public boolean contains(int toFind) {
    for (int i = 0; i < usedSize; i++) {
        if (this.elem[i] == toFind) {
            return true;
        }
    }
    return false;
}
// 查找某个元素对应的位置
public int indexOf(int toFind) {
    for (int i = 0; i < usedSize; i++) {
        if (this.elem[i] == toFind) {
            return i;
        }
    }
    return -1;
}

这里很好理解，通过遍历数组找到相应的位置或者元素。

获取pos位置的元素以及更新pos位置的元素
// 获取 pos 位置的元素
public int get(int pos) {
    if (!checkPosInAdd(pos)) {
        throw new IndexOutOfBoundsException("传入的下标非法，pos=" + pos);
    }
    return this.elem[pos];
}
// 给 pos 位置的元素设为 value
public void set(int pos, int value) {
    if (!checkPosInAdd(pos)) {
        throw new IndexOutOfBoundsException("传入的下标非法，pos=" + pos);
    }
    this.elem[pos] = value;
}

思路很简单，先判断pos的合法性，然后进行相应的操作

删除第一次出现的关键字key
public void remove(int key) {
    //查找元素的位置
    int index = indexOf(key);
    //没找到
    if (index == -1) {
        return;
    }
    //找到了，后面元素向前移
    for (int i = index; i < usedSize; i++) {
        this.elem[i] = this.elem[i + 1];
    }
    usedSize--;
}

这里首先我们需要找到key的所在位置(没找到返回-1)，如果所在位置index==useSize,直接删除即可，否则从index位置开始每个元素依次向前移动一个位置。

清空顺序表
public void clear() {
    //如果数据类型为引用类型，将每个元素置为null
    /*for (int i = 0; i < usedSize; i++) {
        this.elem[i]=null;
    }*/
    usedSize = 0;
}

如果数据类型为引用类型，将每个元素置为null

所有完整代码

public class MyArraylist {

    public int[] elem;
    public int usedSize;//0
    //默认容量
    private static final int DEFAULT_SIZE = 10;

    public MyArraylist() {
        this.elem = new int[DEFAULT_SIZE];
    }

    /**
     * 打印顺序表:
     * 根据usedSize判断即可
     */
    public void display() {
        //1、数组为空打印[];
        if (usedSize == 0) {
            System.out.println("[]");
            return;
        }
        //数组不为空[1,2,3,4]
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < usedSize; i++) {
            sb.append(this.elem[i]);
            if (i < usedSize - 1) {
                sb.append(",");
            }
        }
        sb.append("]");
        System.out.println(sb.toString());
    }

    //扩容
    public void grow() {
        this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);

    }

    // 新增元素,默认在数组最后新增
    public void add(int data) {
        //1、先判断数组是否需要扩容
        if (isFull()) {
            grow();
        }
        //2、增加元素
        this.elem[usedSize] = data;
        usedSize++;
    }

    /**
     * 判断当前的顺序表是不是满的！
     *
     * @return true:满   false代表空
     */
    public boolean isFull() {
        return usedSize == this.elem.length;
    }

    //检查数据合法性
    private boolean checkPosInAdd(int pos) {
        //throw new IndexOutOfBoundsException("传入的下标非法，pos="+pos);
        return pos >= 0 && pos < usedSize;//合法
    }

    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        //1、判断下标是否合法
        if (!checkPosInAdd(pos)) {
            throw new IndexOutOfBoundsException("传入的下标非法，pos=" + pos);
        }
        //整体往后移一位
        //判断是否需要扩容
        if (isFull()) {
            grow();
        }
        for (int i = usedSize; i > pos; i--) {
            this.elem[i] = this.elem[i - 1];
        }
        this.elem[pos] = data;
        usedSize++;
    }

    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if (this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }

    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }

    // 获取 pos 位置的元素
    public int get(int pos) {
        if (!checkPosInAdd(pos)) {
            throw new IndexOutOfBoundsException("传入的下标非法，pos=" + pos);
        }
        return this.elem[pos];
    }

    private boolean isEmpty() {
        return this.usedSize == 0;
    }

    // 给 pos 位置的元素设为【更新为】 value
    public void set(int pos, int value) {
        if (!checkPosInAdd(pos)) {
            throw new IndexOutOfBoundsException("传入的下标非法，pos=" + pos);
        }
        this.elem[pos] = value;
    }

    /**
     * 删除第一次出现的关键字key
     *
     * @param key
     */
    public void remove(int key) {
        //查找元素的位置
        int index = indexOf(key);
        //没找到
        if (index == -1) {
            return;
        }
        //找到了，后面元素向前移
        for (int i = index; i < usedSize; i++) {
            this.elem[i] = this.elem[i + 1];
        }
        usedSize--;
    }

    // 获取顺序表长度
    public int size() {
        return usedSize;
    }

    // 清空顺序表
    public void clear() {
        //如果数据类型为引用类型，将每个元素置为null
        /*for (int i = 0; i < usedSize; i++) {
            this.elem[i]=null;
        }*/
        usedSize = 0;
    }

}

3.缺陷

  • 时间上：当我们进行数据增加和删除时，需要移动位置，大大增加了时间复杂度
  • 空间上：当我们进行数组扩容时，每次都以数组长度的2倍进行扩容，当数组长度特别大时，2倍扩容会消耗大量的空间

那这种缺陷可以消除吗?答案是可以的，利用链表可以有效的消除上述的缺陷。至于链表，期待我的下篇文章吧。如果有什么问题以及建议，欢迎大家评论和私信，谢谢支持！！！

image-20221220235632990

小 王
关注
  • 9
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
c++ 顺序表
JIAN_ZANG1125的博客
11-15 1988
总结归纳 动态分配对内存有着更大的控制权，但也会花费相应的时间。 顺序表的查找时间复杂度为O(1)，这是单链表所不具备的。 顺序表的插入，要从后往前遍历，因为数据要后移；顺序表的删除，要从前往后遍历，因为数据要前移。 具体操作 #include<iostream> #include<algorithm> #include<string.h> #include<string> #include<numeric> #include<io
顺序表java实现
09-30
在这个项目中，我们看到一个用Java实现的顺序表，这涉及到接口定义、类的设计以及方法的实现。 首先，我们有接口`SequentialList`，它定义了顺序表应该具有的操作。这个接口可能包括添加元素（`add`）、删除元素（`...
Java模拟实现ArrayList顺序表
qq_45875349的博客
09-19 87
【代码】Java模拟实现ArrayList顺序表。
Java数据结构之链表
qq_64580912的博客
10-27 2098
小结:1)链表是以节点的方式来存储2)每个节点包含data域, next域:指向下一个节点.3)如图:发现链表的各个节点不一定是连续存储.4)链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。
java数据结构与算法第四课——链表
baijaiyu的博客
05-18 1022
一：引入 上一课中我们介绍了顺序表，由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。 为了解决这一问题，java集合中又引入了LinkedList，即链表结构。 二：链表 2.1链表的概念 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。 链表.........
史上最强 Java 学习路线图！
沉默王二
04-24 26万+
网上看到一首诗：“代码尽头谁为峰，一见秃头道成空。编程修真路破折，一步一劫渡飞升。”感觉还挺有意境的。 第一部分：Java 基础篇 这个阶段就是编程入门，掌握 Java 这门编程语言的基本语法，为后面的修行之路打好基础。 包括的知识点有： 环境搭建——Intellij IDEA 一站式搞定 Java 基础语法 面向对象——封装、继承、多态 数组 字符串 集合框架 IO 反射 注解 网络编程 并发编程 这方面的资源我给大家梳理下： 1）针对 Intellij IDEA，GitHub 上有一份简体中文版教
10万字208道Java经典面试题总结(附答案)
热门推荐
学Java，找哪吒
08-02 98万+
1、JDK 和 JRE 有什么区别？ JDK（Java Development Kit），Java开发工具包 JRE（Java Runtime Environment），Java运行环境 JDK中包含JRE，JDK中有一个名为jre的目录，里面包含两个文件夹bin和lib，bin就是JVM，lib就是JVM工作所需要的类库。 2、== 和 equals 的区别是什么？ 对于基本类型，==比较的是值； 对于引用类型，==比较的是地址； equals不能用于基本类型的比较； 如果没有重写equa
一篇文章带你彻底弄懂Java的==符号
Yong的博客
04-16 5194
在Java中==符号的作用分为两类：1：==符号在八种基本类型的作用是比较对应基本类型的数值是否相等2：==符号在对象类型的作用是比较两个对象是否相等在对象类型中又有两类特殊情况，一种是基本类型中包装类对象，一种是String对象。前者由于存在缓存导致，后缀则是有字符串常量池的存在导致。
搞定BAT Java面试题
xiangzhihong8的专栏
11-14 2246
下面就Java常见的面试题做一个简单的总结，一句话掌握这些面试题，搞定BAT不是梦。 基本概念 操作系统中 heap 和 stack 的区别； 什么是基于注解的切面实现； 什么是 对象/关系 映射集成模块； 什么是 Java 的反射机制； 什么是 ACID； BS与CS的联系与区别； Cookie 和 Session的区别； fail-fast 与 fail-safe 机制有...
10分钟搞定 Java 并发队列
程序猿DD
08-29 1352
前言如果按照用途与特性进行粗略的划分，JUC 包中包含的工具大体可以分为 6 类：执行者与线程池并发队列同步工具并发集合锁原子变量在【并发系列】中，主要讲解了执行者与线程池，同步工具，...
18_星仔带你学Java之IO操作②
华星详谈的博客
07-10 1万+
文件拷贝案例 - 拷贝指定目录的指定类型文件到指定目录分析: 比如把C:/java目录中所有的java文件拷贝到D:/text/把拷贝的所有文件的拓展名改为.txt.获取进程数据 - 编译和运行Java代码文件的字节流分为FileInputStream、FileOutputStream。文件的字符流分为FileReader、FileWriter。在使用字节流操作汉字或特殊的符号语言的时候，容易出现乱码，故建议使用字符流。在Java中是先有字节流，后有字符流。字符流是对字节流的补充。 使用记事
JAVA模拟新增顺序表及单链表
08-18
JAVA模拟新增顺序表及单链表 在计算机科学中，顺序表和单链表是两种基本的数据结构。顺序表是一种数组实现的数据结构，用于存储一系列的数据元素，每个元素都有其索引。单链表是一种链表结构，通过节点来存储数据...
java顺序表基本操作
04-02
Java顺序表是一种线性数据结构，它通过数组来存储元素，并按照元素的顺序进行访问和操作。在Java中，我们可以自定义一个顺序表类（如SeqList）来实现这一概念。以下是对标题和描述中所述知识点的详细说明： 1. **...
java顺序表实验报告.docx
10-11
在 Java 中，我们通常使用数组来实现顺序表。这个实验报告详细介绍了如何用 Java 编程语言构建一个基本的顺序表类，其中包括了核心的数据成员和方法。 首先，顺序表的概念是基于线性表的，它通过将元素存储在一个...
java顺序表的基本操作.docx
09-27
在 Java 中，顺序表是一种简单但实用的数据结构，它的实现基于数组。顺序表的主要特点是所有元素存储在一块连续的内存区域中，通过索引访问这些元素。以下是对 Java 顺序表的基本操作的深入探讨。 1. **创建顺序表*...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 978
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 748
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 726
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1276
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
java顺序表binsert
03-20
Java顺序表是一种线性数据结构，它按照元素在内存中的顺序存储数据。顺序表的插入操作是将一个元素插入到指定位置，而不改变其他元素的位置。binsert是一种二分插入排序算法，用于在有序的顺序表中插入一个元素。 ...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小 王

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值