【数据结构与算法】顺序表的原理及实现

news2024/9/19 15:27:47

1.什么是顺序表

  • 顺序表是用一段物理地址连续的存储单元进行存储元素的线性结构，通常是以数组进行存储。
  • 通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。

在这里插入图片描述

2.顺序表的实现

判断顺序表是否为空表public boolean isEmpty()
判断顺序表是否满public boolean ifFull()
向顺序表中添加元素public void add(T ele)
删除指定位置的元素public void delete(int index)
删除指定的元素public void remove(T ele)
在指定的位置添加元素public void add(int index,T ele)
修改数据public void update(int index,T ele)
获取顺序表的长度public int size()
获取对应位置的元素public T getIndex(int index)
遍历输出顺序表public void show()

在这里插入图片描述

（1）定义构造方法

public class SequenceList<T> {

    /**
     * 定义默认的数组长度
     */
    private final static int DEFAULT_SIZE = 10;

    /**
     * 定义存储数组
     */
    private T[] list;

    /**
     * 定义顺序表的有效元素个数
     */
    private int num;

    /**
     * 定义数组的长度
     */
    private int size;

    /**
     * 无参构造方法，默认长度10
     */
    public SequenceList(){
        list = (T[]) new Object[DEFAULT_SIZE];
        this.size = DEFAULT_SIZE;
        this.num=0;
    }

    /**
     * 有参构造，长度为size
     * @param size
     */
    public SequenceList(int size){
        list = (T[]) new Object[size];
        this.size = size;
        this.num=0;
    }
}

（2）判断队列是否为空

    /**
     * 顺序表的判空实现
     * @return
     */
    public boolean isEmpty(){
        //如果num == 0的时候
        return num==0;
    }

（3）判断队列是否为满

    /**
     * 顺序表的判满实现
     * @return
     */
    public boolean isFull(){
        //如果num（当前顺序表元素个数 == 顺序表的长度时）
        return num==list.length;
    }

（4）遍历顺序表元素

    /**
     * 顺序表的遍历
     */
    public void show(){
        for(int i=0;i<num;i++){
            System.out.println(list[i]);
        }
    }

（5）向顺序表中添加元素

    /**
     * 顺序表添加元素，添加到指定的下标下
     * @param index
     * @param ele
     */
    public void add(int index,T ele){
        if(isFull()){
            //这块后续会加上扩容的方法
            System.out.println("当前集合元素已满");
        }
        //如果index 为 -1 表示直接插入末尾
        if(index == -1){
            list[num++]=ele;
            return;
        }
        //不为-1的话，则插入到指定的下标
        if(index<0 || index>num){
            System.out.println("参数不合法");
        }
        //把i的位置腾出来 i位置的元素全部向后移动一位
        if (num - index >= 0) System.arraycopy(list, index, list, index + 1, num - index);
        //直接插入元素
        list[i]=ele;
        num++;
    }

    /**
     * 顺序表添加元素，添加到末尾
     * @param ele
     */
    public void add(T ele){
        this.add(-1,ele);
    }

（6）获取元素的下标索引

    /**
     * 获取元素的下标索引
     * @param ele
     * @return
     */
    public int indexOf(T ele){
        for (int i = 0; i < list.length; i++) {
            if(list[i].equals(ele)){
                return i;
            }
        }
        return -1;
    }

（7）向顺序表中删除指定元素

    /**
     * 删除指定位置的元素
     * @param ele
     */
    public void delete(int index){
        if(index <0 || index>num){
            System.out.println("参数不合法");
        }
        //把每个元素向前移动一位
        if (num - (index + 1) >= 0) System.arraycopy(list, index + 1, list, index + 1 - 1, num - (index + 1));
        num--;
    }

    /**
     * 删除指定元素
     * @param ele
     */
    public void remove(T ele){
        //获取元素下标索引
        int index = this.indexOf(ele);
        if(index == -1){
            System.out.println("当前元素不存在:"+ele);
        }
        //删除元素
        this.delete(index);
    }

（8）修改指定下标元素

    /**
     * 修改指定下标元素
     * @param index
     * @param ele
     */
    public void update(int index,T ele){
        list[index]=ele;
    }

（9）获取有效元素个数

    /**
     * 获取元素个数
     * @return
     */
    public int getNum(){
        return num;
    }

（10）顺序表扩容

    /**
     * 扩充顺序表容量
     * 私有方法，不对外提供，在插入元素时，判断是否已经满的情况下调用
     * 如果顺序表的元素已经满了，则调用扩容方法
     * @param size
     */
    private void reList(int size){
        //保存之前的顺序表
        T []temp=list;
        //创建新的顺序表
        list = (T[]) new Object[size];
        //拷贝元素
        System.arraycopy(temp, 0, list, 0, temp.length);
    }

# 修改add方法中判断元素是否已经满了的逻辑
# 如果元素已经满了，则进行扩容原长度的2倍
# 同时修改容量的大小
if(isFull()){
    this.size = list.length*2;
    reList(this.size);
}

（11）获取顺序表的最大容量

    /**
     * 返回顺序表容量大小
     * @return
     */
    public int size(){
        return size;
    }

（12）整体顺序表实现代码

/**
 * @description 顺序表数据结构实现
 * @author lixiang
 * @param <T>
 */
public class SequenceList<T> {

    /**
     * 定义默认的数组长度
     */
    private final static int DEFAULT_SIZE = 10;

    /**
     * 定义存储数组
     */
    private T[] list;

    /**
     * 定义顺序表的有效元素个数
     */
    private int num;

    /**
     * 定义数组的长度
     */
    private int size;

    /**
     * 无参构造方法，默认长度10
     */
    public SequenceList(){
        list = (T[]) new Object[DEFAULT_SIZE];
        this.size = DEFAULT_SIZE;
        this.num=0;
    }

    /**
     * 有参构造，长度为size
     * @param size
     */
    public SequenceList(int size){
        list = (T[]) new Object[size];
        this.size = size;
        this.num=0;
    }

    /**
     * 顺序表的判空实现
     * @return
     */
    public boolean isEmpty(){
        return num==0;
    }

    /**
     * 顺序表的判满实现
     * @return
     */
    public boolean isFull(){
        return num==list.length;
    }

    /**
     * 顺序表的遍历
     */
    public void showNum(){
        for(int i=0;i<num;i++){
            System.out.println(list[i]);
        }
    }

    /**
     * 顺序表添加元素，添加到指定的下标下
     * @param index
     * @param ele
     */
    public void add(int index,T ele){
        if(isFull()){
            //这块后续会加上扩容的方法
            this.size = list.length*2;
            reList(this.size);
        }
        //如果index 为 -1 表示直接插入末尾
        if(index == -1){
            list[num++]=ele;
            return;
        }
        //不为-1的话，则插入到指定的下标
        if(index<0 || index>num){
            System.out.println("参数不合法");
        }
        //把i的位置腾出来 i位置的元素全部向后移动一位
        if (num - index >= 0) System.arraycopy(list, index, list, index + 1, num - index);
        //直接插入元素
        list[index]=ele;
        num++;
    }

    /**
     * 顺序表添加元素，添加到末尾
     * @param ele
     */
    public void add(T ele){
        this.add(-1,ele);
    }

    /**
     * 删除指定位置的元素
     * @param ele
     */
    public void delete(int index){
        if(index <0 || index>num){
            System.out.println("参数不合法");
        }
        //把每个元素向前移动一位
        if (num - (index + 1) >= 0) System.arraycopy(list, index + 1, list, index + 1 - 1, num - (index + 1));
        num--;
    }

    /**
     * 删除指定元素
     * @param ele
     */
    public void remove(T ele){
        //获取元素下标索引
        int index = this.indexOf(ele);
        if(index == -1){
            System.out.println("当前元素不存在:"+ele);
        }
        //删除元素
        this.delete(index);
    }

    /**
     * 获取元素的下标索引
     * @param ele
     * @return
     */
    public int indexOf(T ele){
        for (int i = 0; i < list.length; i++) {
            if(list[i].equals(ele)){
                return i;
            }
        }
        return -1;
    }

    /**
     * 修改指定下标元素
     * @param index
     * @param ele
     */
    public void update(int index,T ele){
        list[index]=ele;
    }

    /**
     * 获取元素个数
     * @return
     */
    public int getNum(){
        return num;
    }

    /**
     * 扩充顺序表容量
     * 私有方法，不对外提供，在插入元素时，判断是否已经满的情况下调用
     * 如果顺序表的元素已经满了，则调用扩容方法
     * @param size
     */
    private void reList(int size){
        //保存之前的顺序表
        T []temp=list;
        //创建新的顺序表
        list = (T[]) new Object[size];
        //拷贝元素
        System.arraycopy(temp, 0, list, 0, temp.length);
    }

    /**
     * 返回顺序表容量大小
     * @return
     */
    public int size(){
        return size;
    }

}

3.顺序表功能验证

（1）验证顺序表初始化

public class Main {
    public static void main(String[] args) {
        SequenceList<Integer> sequenceDefaultSizeList = new SequenceList<>();
        SequenceList<Integer> sequenceCustomSizeList = new SequenceList<>(5);
        System.out.println("默认定义顺序表容量大小:"+sequenceDefaultSizeList.size());
        System.out.println("自定义顺序表容量大小:"+sequenceCustomSizeList.size());
    }
}

在这里插入图片描述

（2）验证添加元素

public class Main {
    public static void main(String[] args) {
        SequenceList<Integer> sequenceDefaultSizeList = new SequenceList<>();
        //添加1 2 3 元素
        sequenceDefaultSizeList.add(1);
        sequenceDefaultSizeList.add(2);
        sequenceDefaultSizeList.add(3);
        //输出
        sequenceDefaultSizeList.show();
    }
}

在这里插入图片描述

（3）验证修改元素

public class Main {
    public static void main(String[] args) {
        SequenceList<Integer> sequenceDefaultSizeList = new SequenceList<>();
        //添加1 2 3 元素
        sequenceDefaultSizeList.add(1);
        sequenceDefaultSizeList.add(2);
        sequenceDefaultSizeList.add(3);
        //输出
        sequenceDefaultSizeList.show();

        sequenceDefaultSizeList.update(0,9);
        sequenceDefaultSizeList.show();
    }
}

在这里插入图片描述

（4）验证删除元素

public class Main {
    public static void main(String[] args) {
        SequenceList<Integer> sequenceDefaultSizeList = new SequenceList<>();
        //添加1 2 3 元素
        sequenceDefaultSizeList.add(1);
        sequenceDefaultSizeList.add(2);
        sequenceDefaultSizeList.add(3);
        //输出
        sequenceDefaultSizeList.show();

        sequenceDefaultSizeList.delete(0);
        sequenceDefaultSizeList.show();
    }
}

在这里插入图片描述

（5）验证集合扩容

public class Main {
    public static void main(String[] args) {
        SequenceList<Integer> sequenceDefaultSizeList = new SequenceList<>(2);
        System.out.println("扩容前："+sequenceDefaultSizeList.size());
        //添加1 2 3 元素
        sequenceDefaultSizeList.add(1);
        sequenceDefaultSizeList.add(2);
        sequenceDefaultSizeList.add(3);
        //输出
        System.out.println("扩容后："+sequenceDefaultSizeList.size());
    }
}

在这里插入图片描述

（6）验证获取元素的下标索引

public class Main {
    public static void main(String[] args) {
        SequenceList<Integer> sequenceDefaultSizeList = new SequenceList<>(2);//添加1 2 3 元素
        sequenceDefaultSizeList.add(1);
        sequenceDefaultSizeList.add(2);
        //输出
        System.out.println("元素index："+sequenceDefaultSizeList.indexOf(2));
    }
}

在这里插入图片描述

（7）获取当前集合有效元素个数

public class Main {
    public static void main(String[] args) {
        SequenceList<Integer> sequenceDefaultSizeList = new SequenceList<>(4);//添加1 2 3 元素
        sequenceDefaultSizeList.add(1);
        sequenceDefaultSizeList.add(2);
        //输出
        System.out.println("当前集合有效元素个数为："+sequenceDefaultSizeList.getNum());
    }
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/165759.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

excel功能小技巧：自动求和的注意事项

excel功能小技巧：自动求和的注意事项

在EXCEL里有个非常方便的按钮&#xff0c;叫做自动求和。不需要输入公式&#xff0c;直接一点&#xff0c;即可得出求和结果。由于它操作上的便利&#xff0c;所以深受小白喜爱。不过看着简单的自动求和按钮&#xff0c;实际上却藏着不少暗坑&#xff0c;稍不留神&#xff0c;可…
阅读更多...
juc系列（2）--线程的使用及原理

juc系列（2）--线程的使用及原理

目录线程创建线程ThreadRunnableCallable线程方法APIrun startsleep yieldjoininterrupt打断线程打断 park终止模式daemon不推荐线程原理运行机制线程调度未来优化线程状态查看线程线程 创建线程 Thread Thread 创建线程方式&#xff1a;创建线程类&#xff0c;匿名内部类方…
阅读更多...
R-P-Faster R-CNN day65 读论文：高分辨率遥感影像综合地理空间目标检测框架

R-P-Faster R-CNN day65 读论文：高分辨率遥感影像综合地理空间目标检测框架

An Efficient and Robust Integrated Geospatial Object Detection Framework for High Spatial Resolution Remote Sensing Imagery 1. Introduction3. Overview of the Proposed R-P-Faster R-CNN Framework3.1. 有效集成区域建议网络与目标检测Faster R-CNN框架3.1.2. RPN与…
阅读更多...
java反射在spring ioc和aop中的应用

java反射在spring ioc和aop中的应用

java反射在spring ioc和aop中的应用 反射&#xff1a; 1.反射是什么&#xff1f; 程序运行时&#xff0c;通过类名能够获得类的属性和方法。使用方式如下 Class clazz Class.ForName(“Student”)Class clazz Student.class;Class clazz student.getClass(); 获取到claz…
阅读更多...
java JUC 中 Object里wait()、notify() 实现原理及实战讲解

java JUC 中 Object里wait()、notify() 实现原理及实战讲解

1.Object中的wait()实现原理 在进行wait()之前&#xff0c;就代表着需要争夺Synchorized&#xff0c;而Synchronized代码块通过javap生成的字节码中包含monitorenter和monitorexit两个指令。 当在进加锁的时候会执行monitorenter指令&#xff0c;执行该指令可以获取对象的mon…
阅读更多...
前端与HTML

前端与HTML

本节课程围绕“前端要解决的基本问题”及“什么是 HTML ”两个基本问题展开&#xff0c;了解 HTML 高效的编写原则。 什么是前端 使用web技术栈解决多端的人机交互问题 技术栈 html&#xff08;内容&#xff09; css &#xff08;样式&#xff09;javascript &#xff08;行…
阅读更多...
linux部署KubeSphere和k8s集群

linux部署KubeSphere和k8s集群

上一篇文章讲述了在单个节点上安装 KubeSphere和k8s&#xff0c;这节主要讲解k8s多节点集群部署 准备环境&#xff1a;Alibaba Cloud Linux系统3台机器第一步&#xff1a;设置主机名称hostname--(3台机器都设置) hostnamectl set-hostname master hostnamectl set-hostname nod…
阅读更多...
智云通CRM：为什么你总是在请客，但业绩却上不来？

智云通CRM：为什么你总是在请客，但业绩却上不来？

王总是一位企业老板&#xff0c;社会资源比较好&#xff0c;在过去的一年里&#xff0c;他新代理的一个保健品的项目&#xff0c;需要销售产品和招募合伙人。他想利用自己的人脉资源做销售&#xff0c;但他的销售过程并不顺利&#xff0c;在连续主动邀约之后效果不佳。 于是他…
阅读更多...
2023/1/15 JS-变量提升与函数提升 执行上下文

2023/1/15 JS-变量提升与函数提升 执行上下文

1 变量提升与函数提升 变量声明提升 通过 var 声明的变量&#xff0c;在声明语句之前就可以访问到 - 值: undefined <script>console.log(a); // undefinedvar a 10 </script>函数声明提升 通过 function 声明的函数, 在声明语句之前就可以直接调用 - 值: 函数…
阅读更多...
走近软件生态系统

走近软件生态系统

生态系统&#xff08;Ecosystem&#xff09;原本是一个生物学术语&#xff0c;意思是由一些生命体相互依存、相互制约而形成的大系统&#xff0c;就像我们学生时代在生物学课堂上学到的那样。隐喻无处不在&#xff0c;人们把这个术语移植到了 IT 领域中来&#xff0c;比如我们常…
阅读更多...
计算机基础（六）：静态链接与动态链接

计算机基础（六）：静态链接与动态链接

上一篇文章简单概括了 C语言程序经过编译&#xff0c;生成汇编语言、机器语言的基本过程。今天主要介绍其中链接阶段的实现思路。 静态链接 静态链接是将被依赖的代码片段复制到执行程序中&#xff0c;进行代码整合。因为我们在汇编代码中看到的是具体的符号&#xff0c;而且…
阅读更多...
电路方案分析（十七）TI远程声控参考设计

电路方案分析（十七）TI远程声控参考设计

远程声控参考设计 描述 CC2650远程控制设计为基于ZigBeeRF4CE™兼容的软件架构RemeTI™或蓝牙低能耗软件堆栈的快速测试、评估和开发远程控制应用程序提供了最佳基础。 该方案设计包含了CC2560远程控制的原理图和布局文件&#xff0c;以及一个演示了使用RF4CE和低能耗蓝牙的…
阅读更多...
层次分析法和熵值法经典实操案例+数据

层次分析法和熵值法经典实操案例+数据

1、数据来源&#xff1a;无 2、时间跨度&#xff1a;无 3、区域范围&#xff1a;无 4、指标说明&#xff1a; 层次分析法&#xff08;Analytic Hierarchy Process&#xff0c;简称AHP&#xff09;是美国运筹学家、匹兹堡大学T. L. Saaty教授在20世纪70年代初期提出的&#…
阅读更多...
《Buildozer打包实战指南》第二节 安装Kivy和Buildozer

《Buildozer打包实战指南》第二节 安装Kivy和Buildozer

目录 2.1 安装Kivy 2.2 安装Buildozer 2.3 验证安装 2.4 一点建议 Python是Ubuntu系统中自带的&#xff0c;我们在桌面上右键打开终端&#xff0c;然后输入python3 --version就可以看到Ubuntu系统中的Python版本了。 可以看到&#xff0c;Python的版本是3.10.6。虽然Python…
阅读更多...
【Go基础】结构体

【Go基础】结构体

1. 结构体引入 Golang也支持面向对象编程&#xff0c;但是和传统的面向对象有区别&#xff0c;并不是像Java、C那样纯粹的面向对象语言&#xff0c;而是通过特别的手段实现面向对象特点。 Golang没有类(Class)的概念&#xff0c;但是提供了结构体(struct)&#xff0c;和其他编…
阅读更多...
Nacos的学习

Nacos的学习

Nacos的学习 1、下载地址 https://github.com/alibaba/nacos/releases/tag/2.1.1 在bin目录中输入命令 startup.cmd -m standalone 输入localhost:8848/nacos 账号&#xff1a;nacos&#xff0c;密码&#xff1a;nacos 2、Spring与Nacos &#xff08;1&#xff09;新增一个配…
阅读更多...
100天精通Python（数据分析篇）——第72天：Pandas文本数据处理方法之判断类型、去除空白字符、拆分和连接

100天精通Python（数据分析篇）——第72天：Pandas文本数据处理方法之判断类型、去除空白字符、拆分和连接

文章目录每篇前言一、Python字符串内置方法1. 判断类型2. 去除空白字符3. 拆分和连接二、Pandas判断类型1. str.isspace()2. str.isalnum()3. str.isalpha()4. str.isdecimal()5. str.isdigit()6. str.isnumeric()7. str.istitle()8. str.islower()9. str.isupper()三、Pandas去…
阅读更多...
音视频技术开发周刊 | 279

音视频技术开发周刊 | 279

每周一期&#xff0c;纵览音视频技术领域的干货。新闻投稿&#xff1a;contributelivevideostack.com。基于NeRF的APP上架苹果商店&#xff01;照片转3D只需一部手机这个名叫Luma AI的“NeRF APP”&#xff0c;正式上架App Store后爆火。反 AiArt 运动中两件匪夷所思的蠢事Redd…
阅读更多...
Elastic：使用 Postman 来访问

Elastic：使用 Postman 来访问

Elastic&#xff1a;使用 Postman 来访问 学习资料 Elastic&#xff1a;使用 Postman 来访问 Elastic Stack 当我们配置好elasticsearch的SSL之后&#xff0c;我们用网页https访问&#xff0c;输入账户及密码之后&#xff0c;可以成功访问数据。 但是用postman时&#xff0c;我…
阅读更多...
2023/1/15 JS-闭包问题研究

2023/1/15 JS-闭包问题研究

1 举个栗子分析执行上下文 1: let a 3 2: function addTwo(x) { 3: let ret x 2 4: return ret 5: } 6: let b addTwo(a) 7: console.log(b)为了理解 JavaScript 引擎是如何工作的&#xff0c;让我们详细分析一下&#xff1a; 在第 1 行&#xff0c;我们在全局执行上…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023