数据结构基础——顺序表及其增删查改

最新推荐文章于 2024-07-18 10:40:43 发布
最新推荐文章于 2024-07-18 10:40:43 发布
阅读量678 收藏 7
点赞数 9
分类专栏： java数据结构 文章标签： java ide 经验分享 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57950108/article/details/121618533
版权

每日一句

世界只有一种英雄主义，就是认清生活真相之后依然热爱生活

目录

1.数据结构

2.线性表

3.顺序表

创建类以及成员属性和成员方法

创建对象

1.打印顺序表： public void display()

2.返回顺序表数据个数：public int size()

3.在pos位置添加data数据：public void add(int pos,int data)

4.判定是否包含某个元素：public boolean contains(int toFind) 

 5.查找某个元素对应的位置：public int search(int toFind)

6.获取 pos 位置的元素：public int getPos(int pos)

7.给 pos 位置的元素设为 value：public void setPos(int pos, int value)

8.删除第一次出现的关键字key：public void remove(int toRemove)

9.清空顺序表：public void clear()

4.源码

1.数据结构

数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。

2.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。

线性表是一种在实际中广泛使用的数据结构，常见 的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。

但是在物理结构上并不一定是连续的，线性表在物理上存储 时，通常以数组和链式结构的形式存储。

数组

012345

 线性表(链表)

3.顺序表

3.1 概念及结构

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

顺序表一般可以分为：

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

静态顺序表适用于确定知道需要存多少数据的场景. 静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用

相比之下动态顺序表更灵活, 根据需要动态的分配空间大小。

顺序表的底层就是一个数组，不过我们知道数组的大小及内容。

创建类以及成员属性和成员方法

public class MyArrayList {
    public int[] elem;
    public int usedSize;

    public MyArrayList(){
        this.elem = new int[10];
    }
}

数组名elem，usedSize表示有效的数据个数，数组初始化this.elem = new int[10];

创建对象

public class MAIN {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();

    }
}

1.打印顺序表： public void display()

利用for循环打印即可

 public void display(){
        for (int i = 0; i < this.usedSize; i++) {
            System.out.println(this.elem[i]+" ");
        }
        System.out.println();
    }

2.返回顺序表数据个数：public int size()

直接return usedSize

public int size(){
        return this.usedSize;
    }

3.在pos位置添加data数据：public void add(int pos,int data)

首先，判断pos位置的合法性：

  1. pos < 0,则位置不合法，是因为数组的下标从0开始，在该位置不能添加新元素；
  2. pos > usedSize，位置不合法，因为数组数据个数是usedSize，顺序表只能连着存放数据，故当pos > usedSize, 在该位置不能添加新元素；

其次，判断顺序表是否放满：

public boolean isFull(){
        return this.usedSize == this.elem.length;
    }

若顺序表已经放满，需要对顺序表进行扩容，实际上就是对数组进行扩容，可用Arrays.copyOf()进行扩容 ：this.elem = Arrays.copyOf(this.elem,2*this.elem.length);

注意Arrays.copyOf()返回的是新数组，这里我们需要用原来的数组进行接收。

public void add(int pos,int data){
        if(pos < 0||pos > usedSize){
            return;
        }
        if(isFull()){
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }

    }
    public boolean isFull(){
        return this.usedSize == this.elem.length;
    }

最后，进行数据的添加：
在pos位置进行添加数据，需要把顺序表中pos位置后面的数据（包括pos位置）向后挪一位，然后在pos位置添加数据，最后usedSize++。

for (int i = this.usedSize; i >= pos ; i--) {
    this.elem[i+1] = this.elem[i];
}
this.elem[pos] = data;
this.usedSize++:

这样就完成了public void add(int pos,int data)

public void add(int pos,int data){
    if(pos < 0||pos > usedSize){
        return;
    }
    if(isFull()){
        this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
    }
    for (int i = this.usedSize; i >= pos ; i--) {
        this.elem[i+1] = this.elem[i];
    }
    this.elem[pos] = data;
    this.usedSize++:
}
public boolean isFull(){
    return this.usedSize == this.elem.length;
}

这时，我们简单测试以下前面写的数据添加以及顺序表的打印

public class MAIN {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,11);
        myArrayList.add(1,22);
        myArrayList.add(2,33);
        myArrayList.add(3,44);
        myArrayList.add(4,55);
        myArrayList.display();
    }
}

运行结果：

4.判定是否包含某个元素：public boolean contains(int toFind) 

利用for循环即可完成

public boolean contains(int toFind){
    for (int i = 0; i < this.usedSize; i++) {
        if(this.elem[i] == toFind){
            return true;
        }
    }
    return false;
}

 5.查找某个元素对应的位置：public int search(int toFind)

找到返回下标，找不到返回-1（因为数组下标没有负数），利用for循环即可完成，                      逻辑与public boolean contains(int toFind)相似

public int search(int toFind){
    for (int i = 0; i < this.usedSize; i++) {
        if(this.elem[i] == toFind){
            return i;
        }
    }
    return -1;
}

6.获取 pos 位置的元素：public int getPos(int pos)

1.判断pos位置的合法性：

  1. pos < 0,则位置不合法，是因为数组的下标从0开始，在该位置不能添加新元素；
  2. pos > usedSize，位置不合法，因为数组数据个数是usedSize，顺序表只能连着存放数据，故当pos > usedSize, 在该位置不能添加新元素

2.判断顺序表是否为空：

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

3.返回pos位置元素

public int getPos(int pos){
    if(pos < 0||pos >= this.usedSize){
        return -1;
    }
    if(isEmpty()){
        return -1;
    }
    return this.elem[pos];
    }
public boolean isEmpty(){
    return this.usedSize == 0;
}

注意：前两个if语句返回-1是没有办法的（因为public int getPos(int pos)返回值类型为int，但顺序表中的元素也有可能为-1，这里现在写为return -1，后期学到更多知识，这里可以抛异常）

7.给 pos 位置的元素设为 value：public void setPos(int pos, int value)

1.判断pos位置的合法性：

  1. pos < 0,则位置不合法，是因为数组的下标从0开始，在该位置不能添加新元素；
  2. pos > usedSize，位置不合法，因为数组数据个数是usedSize，顺序表只能连着存放数据，故当pos > usedSize, 在该位置不能添加新元素

2.判断顺序表是否为空：

利用isEmpty()；

3.将pos位置元素更改为value：

    public void setPos(int pos, int value){
        if(pos < 0 || pos >=this.usedSize){
            return;
        }
        if(isEmpty()){
            return;
        }
        this.elem[pos] = value;
    }

8.删除第一次出现的关键字key：public void remove(int toRemove)

1.判断顺序表是否为空：

利用isEmpty()；

2.查找需要删除的数据toRemove，并返回其下标：

这里，我们利用之前已经写过的第5个方法search(int toFind)来完成

3.删除toRemove后，将后面的数据依次前移一位this.elem[i] = this.elem[i+1]

4.usedSize--

    public void remove(int toRemove){
        if(isEmpty()){
            return;
        }
        int index = search(toRemove)
        if(-1 == index){
            return;
        }
        for (int i = index; i < this.usedSize - 1; i++) {
            this.elem[i] = this.elem[i+1];
        }
        this.usedSize--;
    }

注意：for循环的边界是this.usedSize - 1,是因为若i = this.usedSize，则i+1会越界，导致程序报错

9.清空顺序表：public void clear()

1.对于仅含有普通类型（非引用类型）的顺序表，将usedSize的值置为0 即可

    public void clear(){
        this.usedSize = 0;
        return;
    }

2.对于引用类型顺序表，需要将顺序表中的每一个元素置为null，且usedSize置为0

    public void clear(){     
        for (int i = 0; i < usedSize; i++) {
            this.elem[i] = null;
        }
        this.usedSize = 0;
        return;
    }

4.源码

import java.util.Arrays;

public class MyArrayList {
    public int[] elem;
    public int usedSize;

    public MyArrayList(){
        this.elem = new int[10];
    }

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

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

    //在pos位置添加data数据
    public void add(int pos,int data){
        if(pos < 0||pos > usedSize){
            return;
        }
        if(isFull()){
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        for (int i = this.usedSize; i >= pos ; i--) {
            this.elem[i+1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }
    public boolean isFull(){
        return this.usedSize == this.elem.length;
    }

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

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

    //获取 pos 位置的元素
    public int gotPos(int pos){
        if(pos < 0||pos >= this.usedSize){
            return -1;
        }
        if(isEmpty()){
            return -1;
        }
        return this.elem[pos];
    }
    public boolean isEmpty(){
        return this.usedSize == 0;
    }

    //给 pos 位置的元素设为 value
    public void setPos(int pos, int value){
        if(pos < 0 || pos >=this.usedSize){
            return;
        }
        if(isEmpty()){
            return;
        }
        this.elem[pos] = value;
    }

    //删除第一次出现的关键字key
    public void remove(int toRemove){
        if(isEmpty()){
            return;
        }
        int index = search(toRemove);
        if(-1 == index){
            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;
        return;
    }
}

噜噜噜噜鲁先生
关注
专栏目录
数据结构入门-顺序表的增删改查
m0_66654161的博客
03-04 463
目录 一、从数组入手，一步步构建动态顺序表 二、顺序表的增删改查 1.增 2.删 3.改 4.查 总结 前言 在学习数据结构的时候，课本上的代码与我们学习C语言的时候有较大出入，这是因为课本在很多地方都用define或者typedef重定义了，我在学习了很多相关视频的情况下，尝试写出一些自己的想法，新手一枚，如有错误，还希望各位大神不吝赐教。 阅读这篇文章需要的基础知识： define和typedef的使用。 malloc和realloc的用法。 指针的基础知识。 a..
数据结构 ——(无头)单链表的结构、功能（增删查改）。
wihkum
07-11 414
数据结构 ——(无头)单链表的结构、功能（增删查改）。
数据结构之顺序表的增删查改
普通大学生的博客
03-11 1639
数据结构之顺序表的增删查改，
【数据结构入门 】顺序表详解（增删改查功能的实现）
最新发布
KevinRay_0854的博客
07-18 773
介绍数据结构中的顺序表概念以及增删查改功能的实现。
数据结构-----顺序表的增删改查
abc_xixi111的博客
06-02 663
对于静态顺序表的增删改查，下面是头文件，其中声明了用到的函数 #pragma once #define N 20 typedef int DataType; typedef struct SeqList { DataType data[N]; int size; }SeqList; // 初始化 void SeqListInit(SeqList *pSeq); // ...
【数据结构初阶】顺序表的增删查改
Anton的博客
10-31 538
顺序表的增删查改分析问题解决问题代码实现（刚学习变成挤出时间写博客分享也希望大家点赞收藏） 分析问题 首先我们要知道顺序表增删查改四个实现功能的前提就是要先建立一个代表头的顺序表。（CreateLink）这里我用了malloc去开辟空间给定义顺序表的空间开辟这里我们先创建头结点建立一个挂一个链就后者则是前连后挂这样也就是尾结点指向空最后返回表头这样表就建立好了 其次创建完后我们需要前后的对比，所以我们需要一个打印的函数功能这里我们就可以打印将指针指向头p->next 然后但因next里边的data
数据结构顺序表增删查改操作
qq_43759329的博客
12-03 207
1、顺序表动态存储 typedef struct SeqList { SLDataType* a; // 指向动态开辟的数组 size_t size ; // 有效数据个数 size_t capicity ; // 容量空间的大小 }SeqList; 1、顺序表初始化 void SeqListInit(SeqList* ps) { assert(ps); ps-&g...
数据结构线性表——顺序表、链表
qq_64105689的博客
05-14 669
1.线性表 线性表(linear list)是有n个相同特性的元素组成的有限序列，在逻辑上是线性结构，也就是连续的一条直线；但是在物理结构上，不一定是连续的。 常见的线性表有： 顺序表、链表、栈、队列、字符串.... 2.顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的数据结构，一般采用数组存储，在数组上完成增删查改。 顺序表一般分为： 1.静态的顺序表：使用定长数组存储元素。 define N 6 typedef int SeqListDataType; t.
数据结构——顺序表和链表_顺序表和链表的结构体
2401_84165919的博客
04-27 1046
/存储数据int size;//当前存储个数//当前容量}SL;
数据结构与算法——顺序表 (完整代码)
zz137955的博客
10-31 2019
基于语言实现数据结构第一节——顺序表 增删查改
数据结构——顺序表和链表_顺序表和链表的结构体(1)
2401_84166811的博客
04-29 246
/存储数据int size;//当前存储个数//当前容量}SL;
顺序表的增删改查，顺序表
10-10
本程序的顺序表是利用数组实现的，能对数组元素进行增删改查的基本操作
线性表中顺序表的增删改查
06-21
顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查
数据结构-顺序表的增删改查
weixin_47750507的博客
07-11 300
数据结构顺序表的增删改查。注释写的很详细，如果看不懂的话可以评论会不定时回复的（考研人准备数据结构）
【数据结构】顺序表的增删改查
haonanren2bu2的专栏
02-13 1665
简单顺序表的增删改查实例： #include #define MAX 100typedef struct {int length;int data[MAX];}Sqlist,*PSqlist;void initList(PSqlist p);void insertList(PSqlist p,int elem);void deleteList(PSqlist p,int locate);void
数据结构 线性表之顺序表的增删改查
faith_girl的博客
04-24 182
#include<stdio.h> #include<stdlib.h> #define InitSize 10//顺序表的初试长度 typedef struct{ int *data; int MaxSize; int length; }SeqList; void InitList(SeqList &L){//顺序表 L.data=(int *)malloc(InitSize*sizeof(int)); L.length=0; L.MaxSize=InitSi
7.19 数据结构顺序表的增删改查
努力努力再努力
07-19 580
C语言数据结构中对顺序表的增删改查
数据结构:顺序表的基本操作: 增 删 查 改 扩容 动态分配内存
Mohican的博客
12-26 322
顺序表:           线性表    /* From:mohican Data:2018/12/26 */ /*SXList.h*/ #include&lt;stdio.h&gt; typedef struct SXList { int *elem; //指针 int usedsize; //有效元素个数 int length; //总长度 }SXList,*PList; ...
[数据结构]C语言对顺序表的接口实现（增删查改）
热门推荐
RMA515T的博客
03-31 2万+
线性表是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构。 顺序表则是线性表的一种，是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 1. 静态顺序表：使用定长数组存储。 #define N 100 typedef struct SeqList { SLDataType array[N]; // 定长数组 size_t size; // 有效数据的个...
顺序表增删查改的时间自由度
04-04
顺序表的增、删、查、改操作的时间复杂度取决于数据规模和操作的位置。 增操作：在顺序表的末尾进行插入操作的...因此，顺序表的增删查改操作的时间自由度相对较低，操作的时间复杂度取决于具体的操作位置和数据规模。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

噜噜噜噜鲁先生

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

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

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

打赏作者

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

抵扣说明：

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

余额充值