java - 数据结构，顺序表

最新推荐文章于 2024-03-01 17:48:16 发布
最新推荐文章于 2024-03-01 17:48:16 发布
阅读量672 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ryy1999/article/details/128129639
版权

1、顺序表和链表都属于数据结构的一部分。
2、数据结构:C的数据结构和JAVA的数据结构有什么不一样啊?
数据结构只是一个单独的学科，和语言没有关系。
用不同的语言实现一样的逻辑。

一、线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储
在这里插入图片描述

二、顺序表 - ArrayList

2.1、概念及结构

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

顺序表一般可以分为：

  • 静态顺序表：使用定长数组存储。
  • 动态顺序表：使用动态开辟的数组存储

静态顺序表适用于确定知道需要存多少数据的场景.
静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用
相比之下动态顺序表更灵活, 根据需要动态的分配空间大小.
在这里插入图片描述

2.2、模拟实现顺序表 - MyArrayList

2.2.1、顺序表的属性

public class MyArrayList {
    //存储数据的数组
    public int[] elem;
    //usedSize 拿到的是 数组元素的有效个数
    public int usedSize;

    public MyArrayList(){
        //构造方法，初始化数组的大小为10
        this.elem = new int[10];
    }
}

在这里插入图片描述

2.2.2、顺序表的方法

打印顺序表
// 打印顺序表
    public void display() {
        for(int i = 0; i < usedSize; i++){
            System.out.print(elem[i] + " ");
        }
        System.out.println();
    }

在这里插入图片描述

获取顺序表长度
// 获取顺序表长度
    public int size() {
    	//usedSize 就是数组元素的有效数据个数，所以这就是顺序表的长度
        return usedSize;
    }
在 pos 位置新增元素
// 在 pos 位置新增元素
    public void add(int pos, int data) {
        if(pos < 0 || pos > usedSize){
            System.out.println(pos + "位置不合法，增加失败！");
            return;
        }
        if(isFull()) {
            //扩容，如果顺序表满了，就扩容，没有满就不扩容
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        //向后移元素
        for (int i = usedSize - 1; i > pos ; i--) {
            this.elem[i+1] = this.elem[i];
        }
        //插入元素
        this.elem[pos] = data;
        //有效数据+1
        usedSize++;
    }

    //判断数组是否满了,如果满了返回true，没有满返回false
    public boolean isFull(){
        return this.usedSize == this.elem.length;
    }

在这里插入图片描述

判定是否包含某个元素
// 判定是否包含某个元素
    public boolean contains(int toFind) {
        for(int i = 0; i < usedSize; i++){
            if(elem[i] == toFind){
                return true;
            }
        }
        return false;
    }
查找某个元素对应的位置
 // 查找某个元素对应的位置,找到返回该元素下标，没找到返回-1
    public int search(int toFind) {
        for(int i = 0; i < this.usedSize; i++){
            if(elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }
获取 pos 位置的元素
// 获取 pos 位置的元素
    public int getPos(int pos) {
        if(pos < 0 || pos > this.usedSize){
            System.out.println("pos位置不合法！");
            return -1;
        }
        return this.elem[pos];
    }
给 pos 位置的元素设为 value
// 给 pos 位置的元素设为 value
    public void setPos(int pos, int value) {
        if(pos < 0 || pos > this.usedSize){
            System.out.println("pos位置不合法！");
            return;
        }
        this.elem[pos] = value;
    }
删除第一次出现的关键字
// 查找某个元素对应的位置,找到返回该元素下标，没找到返回-1
    public int search(int toFind) {
        for(int i = 0; i < this.usedSize; i++){
            if(elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }


    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        //判断顺序表是否为空
        if(this.usedSize == 0){
            System.out.println("顺序表为空，删除失败");
            return;
        }
        //index == -1,说明没有这个数据
        int index = search(toRemove);
        if(index == -1){
            System.out.println("没有你要找的数据");
            return;
        }
        //移动元素
        for(int i = index; i < this.usedSize-1; i++){
            this.elem[i] = this.elem[i+1];
        }
        //记录有效数据
        this.usedSize--;
    }
清空顺序表
public void clear() {
        this.usedSize = 0;
    }
测试

在进行测试的时候，两边中间都要测试


public class TestDome {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,55);
        myArrayList.add(1,30);
        myArrayList.add(2,5);
        myArrayList.add(3,5);
        myArrayList.display();

        myArrayList.remove(55);
        myArrayList.display();
        myArrayList.clear();
        myArrayList.display();

    }
}

模拟实现 - MyArrayList

public class MyArrayList {
    //存储数据的数组
    public int[] elem;
    //usedSize 拿到的是 数组元素的有效个数
    public int usedSize;

    public MyArrayList(){
        //构造方法，初始化数组的大小为10
        this.elem = new int[10];
    }

    // 打印顺序表
    public void display() {
        for(int i = 0; i < usedSize; i++){
            System.out.print(elem[i] + " ");
        }
        System.out.println();
    }

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

    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        if(pos < 0 || pos > usedSize){
            System.out.println(pos + "位置不合法，增加失败！");
            return;
        }
        if(isFull()) {
            //扩容，如果顺序表满了，就扩容，没有满就不扩容
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        //向后移元素
        for (int i = usedSize - 1; i > pos ; i--) {
            this.elem[i+1] = this.elem[i];
        }
        //插入元素
        this.elem[pos] = data;
        //有效数据+1
        usedSize++;
    }

    //判断数组是否满了,如果满了返回true，没有满返回false
    public boolean isFull(){
        return this.usedSize == this.elem.length;
    }

    //扩容，如果顺序表满了，就扩容
    public void dilatation(){
        if(this.usedSize == this.elem.length){
            this.elem = Arrays.copyOf(this.elem,this.elem.length*2);
        }
    }

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

    // 获取 pos 位置的元素
    public int getPos(int pos) {
        if(pos < 0 || pos > this.usedSize){
            System.out.println("pos位置不合法！");
            return -1;
        }
        return this.elem[pos];
    }
    // 给 pos 位置的元素设为 value
    public void setPos(int pos, int value) {
        if(pos < 0 || pos > this.usedSize){
            System.out.println("pos位置不合法！");
            return;
        }
        this.elem[pos] = value;
    }

    // 查找某个元素对应的位置,找到返回该元素下标，没找到返回-1
    public int search(int toFind) {
        for(int i = 0; i < this.usedSize; i++){
            if(elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }


    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        //判断顺序表是否为空
        if(this.usedSize == 0){
            System.out.println("顺序表为空，删除失败");
            return;
        }
        //index == -1,说明没有这个数据
        int index = search(toRemove);
        if(index == -1){
            System.out.println("没有你要找的数据");
            return;
        }
        //移动元素
        for(int i = index; i < this.usedSize-1; i++){
            this.elem[i] = this.elem[i+1];
        }
        //记录有效数据
        this.usedSize--;
    }

    // 清空顺序表
    public void clear() {
//        for(int i = this.usedSize - 1; i <= 0; i--){
//            this.elem[i] = 0;
//        }
        this.usedSize = 0;
    }
}
Später321
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构顺序表-存储学生信息(Java)
03-25
Java顺序表 作用：存储学生信息（学号、姓名、年龄） 类：MyArrayList、Student、Main 方法：增删改查
java数据结构实现顺序表示例
09-03
主要介绍了java数据结构实现顺序表示例,需要的朋友可以参考下
Java-数据结构课设-链表实现通讯录管理系统
10-07
第一个模块——主函数main()的功能是：根据选单的选项调用各函数，并完成相应的功能。 
　　 第二个模块——Menu()的功能是：显示提示选单。 
　　 第三个模块——Quit()的功能是：退出选单。 
　　 第四个模块——Create()的功能是：创建新的数据记录。 
　　 第五个模块——Add()的功能是：增加新的数据记录，并返回选单。 
　　 第六个模块——Find()的功能是：按要求查询相关的信息，如果找到了，则显示该信息，如果未找到，则提示文件中没有该信息，并返回选单。 
　　 第七个模块——Alter()[的功能是：修改某条记录的信息，如果未找到要修改的记录，则提示系统中无此记录，并返回选单。 
　　 第八个模块——Delete()的功能是：删除某条记录，如果未找到要删除的记录，则提示通讯录中没有，并返回选单。 
　　 第九个模块——List()的功能是：显示所有记录。 一、用链表或者顺序表实现以下系统，完成线性表的建立（至少包括10个结点），以及线性表中信息（结点）的插入、查找、删除、修改、输出等操作，具体的模块要求见上方的“总的模块要求”。建议用“文件”存储数据。 1.通讯录管理系统的设计与实现 （1）通讯者信息包括：编号（char num[10]）、姓名(char name[10])、性别(char sex[10])、电话(char phone[20]) （2）除了总的模块要求外，还需统计通讯录中男性人数及女性人数，并求出通讯录中的第一个模块——主函数main()的功能是：根据选单的选项调用各函数，并完成相应的功能。 
　　 第二个模块——Menu()的功能是：显示提示选单。 
　　 第三个模块——Quit()的功能是：退出选单。 
　　 第四个模块——Create()的功能是：创建新的数据记录。 
　　 第五个模块——Add()的功能是：增加新的数据记录，并返回选单。 
　　 第六个模块——Find()的功能是：按要求查询相关的信息，如果找到了，则显示该信息，如果未找到，则提示文件中没有该信息，并返回选单。 
　　 第七个模块——Alter()[的功能是：修改某条记录的信息，如果未找到要修改的记录，则提示系统中无此记录，并返回选单。 
　　 第八个模块——Delete()的功能是：删除某条记录，如果未找到要删除的记录，则提示通讯录中没有，并返回选单。 
　　 第九个模块——List()的功能是：显示所有记录。 一、用链表或者顺序表实现以下系统，完成线性表的建立（至少包括10个结点），以及线性表中信息（结点）的插入、查找、删除、修改、输出等操作，具体的模块要求见上方的“总的模块要求”。建议用“文件”存储数据。 1.通讯录管理系统的设计与实现 （1）通讯者信息包括：编号（char num[10]）、姓名(char name[10])、性别(char sex[10])、电话(char phone[20]) （2）除了总的模块要求外，还需统计通讯录中男性人数及女性人数，并求出通讯录中的男女比例。 男女比例。
数据结构顺序表操作示例
09-04
主要介绍了数据结构顺序表操作示例,其中有在第I个元素前插入数据x，元素从0开始计数、删除第i个元素，元素从0开始计数的方法,需要的朋友可以参考下
JavaScript数据结构-2-顺序表
01-20
class SqList {      //2020/1/10      //python有可变参数，js没有。。。      //js也没有重载      //我又想到JAVA里有构造函数，我设想的js的构造函数应该跟java类似，在构造函数里初始化      //找了半天，没找到，还是慢慢找吧      //卧槽，居然让我百度到了，还是MDN靠谱啊，CSDN和博客园搜索‘构造函数’都没有找到我想要的      //地址：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Classes/constructor
Java顺序表的实现
m0_64318128的博客
09-23 1579
Java顺序表中一些常用方法的实现
数据结构——顺序表
weixin_43899645的博客
06-08 832
线性表 线性表定义和基本操作 定义 线性表是具有相同数据类型的n(n>0)个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。 线性表的特点：元素的个数有限，表中元素具有逻辑上的顺序性，表中元素有其先后次序，表中元素都是数据元素，每个元素都是单个元素，表中元素的数据类型相同，这意味着每个元素占有相同大小的储存空间。 基本操作 InitList(&L),初始化线性表。 Length(L):求表长。 LocateElem(L,e):按置查找，e为查找的值 GetELem(L,i):按
JAVA语言手把手教你编程 —— 顺序表实现
m0_61787454的博客
10-05 696
JAVA语言手把手教你编程 —— 顺序表实现
【数据结构趣味多】顺序表基本操作实现（Java）
努力
12-02 1866
用java对顺序表的实现
Java中顺序表详解
软希网分享源码的博客
05-05 676
Java中顺序表详解
9.5顺序、链式表存储：求长度、查找、增加\删除
weixin_71111203的博客
09-08 910
顺序、链式表存储：求长度、查找、增加\删除
JAVA数据结构顺序表的实现（工程文件会上传至博客）
最新发布
cjmyydsds的博客
03-01 598
线性表在逻辑上是线性结构，也就是说连续的一条直线，但是在物理上不一定是连续的（链表），线性表在物理存储时，通常以数组和链表结构的形式存储。2.顺序表2.1引出顺序表1.疑问？为什么需要顺序表？顺序表是在数组中进行存储那么既然在数组中存储，为什么还需要线性表？图解：（1）定义一个elem类型的数组，数组中存入1，23，6，三个数字（2）我要求你知道数组的长度，你采取的方式估计是运用for循环来对数组进行便利，当便利到0数字的时候，就计算出来了数组的长度。
Java数据结构篇之顺序表
MasterJundarj的博客
09-15 221
/新增元素,默认在数组最后新增// 在 pos 位置新增元素// 判定是否包含某个元素// 查找某个元素对应的位置// 获取 pos 位置的元素// 给 pos 位置的元素设为 value 更新//删除第一次出现的关键字key// 获取顺序表长度// 清空顺序表// 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的super(msg);【说明】ArrayList是以泛型方式实现的，使用时必须要先实例化。
顺序、链式表存储：求长度、查找、增加\删除
lx_lx_lx_lx的博客
12-09 655
顺序、链式表存储：求长度、查找、增加\删除
数据结构 （一）顺序表
qq_42585108的博客
09-12 3912
顺序表一、顺序存储结构二、顺序表的初始化 一、顺序存储结构 顺序表，全名顺序存储结构，是线性表的一种。 线性表用于存储逻辑关系为“一对一”的数据，顺序表自然也不例外。 顺序表存储数据时，会提前申请一整块足够大小的物理空间，然后将数据依次存储起来，存储时做到数据元素之间不留一丝缝隙。 例如，使用顺序表存储集合 {1,2,3,4,5}，数据最终的存储状态如图 1 所示： 由此我们可以得出，将“具有 ‘一对一’ 逻辑关系的数据按照次序连续存储到一整块物理空间上”的存储结构就是顺序存储结构。 通过观察图 1 中数
C++数据结构之线性表——顺序表
m0_56398315的博客
09-07 1562
本文对线性表进行了介绍，并且对本文的关键顺序表进行了介绍以及实现
数据结构之顺序表
m0_62878102的博客
08-04 2870
顺序表在内存中以一段连续的地址存储，具有随机性，顺序性，动态性随机性，即首地址随机生成；顺序性，即各元素地址满足等距相邻；动态性，即存储空间可在程序运行时动态生成。
JAVA常见的8种数据结构
热门推荐
m554062212的博客
11-18 1万+
java中常见的8种数据结构，Array、Linked List、Stark、Hash、Queue、Tree、Heap、Graph
数据结构与算法--顺序表的表示及基本操作
SONG_YIH的博客
07-27 2352
一、线性表的定义和特点 1.线性表是具有相同特性的数据元素的一个有限序列 2.线性表由n(n>=0)个数据元素(结点)a1,a2,...an组成的有限序列 *其中数据元素的个数n定义为表的长度 *当n=0时称为空表 *将非空的线性表(n>0)记作:(a1,a2,...an) * 这里的数据元素ai(1<=i<=n)只是一个抽象的符号，其具...
数据结构顺序表的逆置Java
04-21
很高兴回答你的问题！顺序表的逆置可以通过交换表中元素的位置实现。具体方法如下： 1. 定义两个指针，分别指向顺序表的头尾元素。 2. 交换指针所指位置的元素。 3. 将头指针往后移动一位，尾指针往前移动一位。 4. 重复步骤2和3，直到头指针大于等于尾指针。 在Java中，可以用以下代码实现顺序表的逆置： ``` public void reverse(ArrayList<Integer> list) { int i = 0; int j = list.size() - 1; while (i < j) { int tmp = list.get(i); list.set(i, list.get(j)); list.set(j, tmp); i++; j--; } } ``` 这个函数接受一个ArrayList<Integer>作为参数，将其逆置。通过循环和get和set方法，我们可以实现对各个元素位置的交换。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Später321

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

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

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

打赏作者

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

抵扣说明：

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

余额充值