【数据结构顺序表】小白也能学会的增删改查操作

已于 2024-09-18 18:37:03 修改
阅读量701 收藏 29
点赞数 11
分类专栏： 数据结构 文章标签： 数据结构 python 开发语言
于 2024-09-17 21:40:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fayifenjihuang/article/details/142319117
版权

在这里插入图片描述
首先:小编在这里祝大家中秋快乐!!!
在这里插入图片描述

数据结构(顺序表)

大家好呀,小编我中秋节闲着是闲着(母胎solo)
就写了顺序表的增删改查
让我们趁着这次中秋佳节
一起学习顺序表叭~

顺序表的定义

什么是顺序表?

顺序表是0个或多个具有相同数据类型的数据元素的有限序列
是一段物理地址连续的存储单元依次存储元素的线性结构.
例子:顺序表, 链表., 栈, 队列

别看上面一堆专业术语,看下面的~.

讲人话就是通俗来讲
顺序表就是数组,

顺序表本质上是一种连续的数组

所以顺序表的特点就两个:

  1. 连续
  2. 数组
    那我们怎么判断是否连续呢?

如图:

我们用一个int类型的整数计算表中的个数即可
在这里插入图片描述

顺序表的分类

  1. 静态顺序表:使用指定好长度的数组存储
  2. 动态顺序表: 使用动态数组存储的

顺序表的实现

1.新建一个顺序表

顺序表的初始化
第一步:
定义一个数组来存储顺序表

private int[] elem; //用这个数组来存储数据

第二步:
定义一个int类型的usedSize来计算表中的有效数据个数

private int usedSize; //用来计算表中的有效个数

第三步:
创建顺序表的无参构造方法
在无参构造方法中默认定义顺序表的个数是10个.

//无参构造方法中默认顺序表中为10个个数
		public MyArrayList(){
			this.elem = new int[10];
		}

第四步:
创建有参构造方法
该方法可以自行指定创建多大的顺序表.

//有参构造方法中指定顺序表的个数为num个
        public MyArrayList(int num){
		    this.elem = new int[num];
        }

新建顺序表的完整代码如下:

public class MyArrayList{
		private int[] elem; //用这个数组来存储数据
		private int usedSize; //用来计算表中的有效个数

		private static final  int DEFAULLT_SIZE = 10;

		//无参构造方法中默认顺序表中为10个个数
		public MyArrayList(){
			this.elem = new int[DEFAULLT_SIZE];
		}

        //有参构造方法中指定顺序表的个数为num个
        public MyArrayList(int num){
		    this.elem = new int[num];
        }

}

好啦,我们今天就讲到这里,下次见啦,
别急,还有亿点点没有讲完呐!!!
在这里插入图片描述

2.展示顺序表中的所有元素

我们只需要进行遍历打印输出即可~
So esay ~
是不是很简单呀?
别急,还有一个小tips:

顺序表是从零开始的,所以最大下标是uesdSize -1

//打印顺序表的所有元素
	public void display(){
		for(int i = 0; i < this.usedSize -1; i++){
			System.out.print(this.elem[i] + " ");
		}
		System.out.println();
	}

3.判断表中是否包含某个元素

在该方法中传入这个元素,看看是否存在

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

}

4.查找某个元素的位置并返回下标

和上面那个代码的逻辑一样的~
遍历查找
找到则返回元素的下标~.

//查找元素data的位置
public int search(int data){
	for(int i = 0; i < this.usedSize; i++){
			if(this.elem[i] == data){
				return i;
			}
	}
	return -1;

}

5.判断顺序表是否为空,以及判断顺序表是否已经满了

//是否为空
public boolean isEmpty(){
	return this.usedSize == 0;
}

//是否已经满了
public boolean isFull(){
	return this.usedSize == this.elem.length;
}

6.获取指定位置的元素

目的:
在该方法中传入这个下标~
返回该下标的元素
步骤:

  1. 检验是否为空表
  2. 检验这个下标是否合法
  3. 下标不能为负数~
  4. 下标也不能大于实际的元素个数(usedSize)
  5. 以上两个条件都满足则返回元素
//获取pos下标这个位置的元素
public int get(int pos){
	//检验是否为空表
	is(isEmpty()){
		System.out.println("这个表为空");
		return 0;
	}

	//检验下标是否合法
	if(pos < 0 || pos >= usedSize){
		System.out.println("这个下标不合法");
		return 0;
	}

	//以上都满足则可以返回元素了
	retrun this.elem[pos];
}

7.给指定下标的元素更新为value

前提:依旧要去判断这个下标是否合法~

public void set(int pos, int value){
	if(pos < 0 || pos >= this.usedSize){
		System.out.println("pos位置不合法");
	}
	//pos位置合法,直接更新为value
	this.elem[pos] = value;

}

8.在顺序表中新增一个元素

  1. 在新增之前必须先去判断这个顺序表是否已经满了
  2. 如果已经满了,就要进行扩容的操作了
  3. 而且,新增一个元素都是在末尾增加一个
  4. 元素增加完成之后,别忘了usedSize还要加一
//新增一个data元素
public void add(int data){
			//先判满
			if(isFull()){
				this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
			
			}
			this.elem[this.usedSize] =  data;
			this.usedSize++;
	}

9.在pos位置处插入一个元素

小tips:

  1. 在插入之前依旧要先去判满
  2. 同时还要去判断pos这个下标是否合法
  3. 插入操作的逻辑演示如下图:
    在这里插入图片描述

小tips:

  1. 插入之前也要先去判断pos下标的合法性
  2. 还要判断表中数据是否已经满了,若满了,要扩容
  3. 记得在最后usedSize要加一
//在pos位置新增元素,但是要先去挪数据(从后向前挪,因为从前向后挪会覆盖数据)
	//照样要去判满
	public void add(int data, int pos){
	//判断pos这个下标(要插入数据的这个下标)的位置合不合法
		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 = this.UsedSize - 1; i >= pos; i--){
		//把i下标的值给到i+1下标处
				this.elem[i+1] = this.elem[i];
		
		}
		//挪好了之后在pos处放数据
		this.elem[pos] = data;
		//计数器加一
		this.usedSize++;
		
	
	}

10.删除某个元素

小前提:

删除之前要先去表中查看是否存在该元素
而且找到该元素的下标

我们活学活用,用刚刚才学的返回某个元素的下标这个方法~

int index = search(int data);

元素存在着返回下标,不存在则返回-1

我们一箭双雕,一石二鸟!!!
完美解决以上的两个小前提~

注意别忘了最后的usedSize要减一
顺序表中删除数据的逻辑如图:

在这里插入图片描述

//删除一个数据data
	//删除之前要先去找这个数据
	//找到之后,让后面的数据向前覆盖就可以删除这个数据了
	//   当i为usedSize - 1 时,i+1 的值为null,所以i必须小于usedSize - 1
	public void remove(int data){
		//先去找一找这个元素是不是存在,找到了,就返回下标
		int index =  indexof(data);
		if(index == -1){
			//没有找到这个下标,说明该表中没有这个数据
			System.out.println("表中没有这个数据");
			return;
		}
		//找到啦,而且下标是index
		for(int i = index; i < usedSize - 1; i++){
				this.elem[i] = this.elem[i + 1];
		}
	
		//删除了之后计数器就减一
		this.usedSize--;
	}

11.获取顺序表的长度

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

12.清空顺序表

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

}

好啦,关于顺序表的操作就到此为止吧~
今天,看到这里,辛苦你啦,你真厉害!!!
祝你中秋快乐呀~
晚安~
在这里插入图片描述

最后,完整代码如下:

public class MyArrayList {  
    private int[] elem; //用这个数组来存储数据  
    private int usedSize; //用来计算表中的有效个数  
  
    private static final int DEFAULLT_SIZE = 10;  
  
    //无参构造方法中默认顺序表中为10个个数  
    public MyArrayList() {  
        this.elem = new int[DEFAULLT_SIZE];  
    }  
  
    //有参构造方法中指定顺序表的个数为num个  
    public MyArrayList(int num) {  
        this.elem = new int[num];  
    }  
  
  
    //打印顺序表的所有元素  
    public void display() {  
        for (int i = 0; i < this.usedSize - 1; i++) {  
            System.out.print(this.elem[i] + " ");  
        }  
        System.out.println();  
    }  
  
  
    //判断表中是否包含元素data  
    public boolean contains(int data) {  
        for (int i = 0; i < this.usedSize; i++) {  
            if (this.elem[i] == data) {  
                return true;  
            }  
        }  
        return false;  
  
    }  
  
  
    //查找元素data的位置  
    public int search(int data) {  
        for (int i = 0; i < this.usedSize; i++) {  
            if (this.elem[i] == data) {  
                return i;  
            }  
        }  
        return -1;  
  
    }  
  
    public boolean isEmpty() {  
        return this.usedSize == 0;  
    }  
  
  
    //获取pos下标这个位置的元素  
    public int get(int pos) {  
        //检验是否为空表  
        if (isEmpty()) {  
            System.out.println("这个表为空");  
            return 0;  
        }  
  
  
        //检验下标是否合法  
        if (pos < 0 || pos >= usedSize) {  
            System.out.println("这个下标不合法");  
            return 0;  
        }  
  
        //以上都满足则可以返回元素了  
        return this.elem[pos];  
    }  
  
  
    //将指定元素更新为value  
    public void set(int pos, int value) {  
        if (pos < 0 || pos >= this.usedSize) {  
            System.out.println("pos位置不合法");  
        }  
        //pos位置合法,直接更新为value  
        this.elem[pos] = value;  
  
    }  
  
    //是否已经满了  
    public boolean isFull() {  
        return this.usedSize == this.elem.length;  
    }  
  
  
    //新增一个data元素  
    public void add(int data) {  
        //先判满  
        if (isFull()) {  
            this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);  
  
        }  
        this.elem[this.usedSize] = data;  
        this.usedSize++;  
    }  
  
  
    //在pos位置新增元素,但是要先去挪数据(从后向前挪,因为从前向后挪会覆盖数据)  
    //照样要去判满  
    public void add(int data, int pos) {  
        //判断pos这个下标(要插入数据的这个下标)的位置合不合法  
        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 = this.usedSize - 1; i >= pos; i--) {  
            //把i下标的值给到i+1下标处  
            this.elem[i + 1] = this.elem[i];  
  
        }  
        //挪好了之后在pos处放数据  
        this.elem[pos] = data;  
        //计数器加一  
        this.usedSize++;  
  
  
    }  
  
  
    //删除一个数据data  
    //删除之前要先去找这个数据  
    //找到之后,让后面的数据向前覆盖就可以删除这个数据了  
    //   当i为usedSize - 1 时,i+1 的值为null,所以i必须小于usedSize - 1  
    public void remove(int data) {  
        //先去找一找这个元素是不是存在,找到了,就返回下标  
        int index = search(data);  
        if (index == -1) {  
            //没有找到这个下标,说明该表中没有这个数据  
            System.out.println("表中没有这个数据");  
            return;  
        }  
        //找到啦,而且下标是index  
        for (int i = index; i < usedSize - 1; i++) {  
            this.elem[i] = this.elem[i + 1];  
        }  
  
        //删除了之后计数器就减一  
        this.usedSize--;  
    }  
  
  
    //获取顺序表的长度  
    public int size() {  
        return this.usedSize;  
  
    }  
  
  
    //清空顺序表  
    public void clear() {  
        this.usedSize = 0;  
  
    }  
  
  
}
浪前大学
关注
专栏目录
【数据结构】线性表—顺序表与链表的基本操作（增删改查）
m0_63425312的博客
04-18 1407
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？1.引入库二、使用步骤1.引入库2.读入数据总结 前言 线性表的存储结构分为顺序存储和链式存储，顺序存储需要一组地址连续的存储单元依次存储线性表的数据结构，而链式存储结构使用一组任意的存储单元存储线性表的数据元素。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 1.引入库 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import p.
单链表创建及增删改查（c语言实现）
chengxuyuanlee的博客
10-26 1232
作者为转行小白，刚接触数据结构算法，如有错误虚心接受批评指正。希望能够在计算机的学习过程中得到进步。 链表为线性表的一种，是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。地址空间是可以不连续的。将整体分为数据域和指针域两部分。 图片来自于 王道考研 头插法建立单链表 链表建立与插入类似，头插法即在头结点之后插入，输出结果与输入结果相反，如下图想得到 a,b,c,d,,e应输入e，d，c，b，a 头插法核心代码 图片来自于 bilibili 青岛大学..
【数据结构】顺序表（增、删、查、改）的实现 [初阶篇_ 复习专用]
Dream_Y.ocean的博客
04-13 6340
线性表是n个具有相同特性的数据元素的有限序列线性表是一种在实际中广泛使用的数据结构，常见的线性表顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的【线性表在物理上存储时，通常以数组和链式结构的形式存储】❗对于数据结构,C语言提供了结构体类型给我们使用，让我们更方便的整合一个结构，去利用结构体实现数据结构🥯Ⅱ.✨综上就是线性表的概念啦~➡️简单来说线性表是一种常见的数据结构，它在逻辑结构上呈连续直线结构，但物理上就不一定是。...
Java数据结构————顺序表（增删改查详细实现）
2401_83916241的博客
05-05 746
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
【线性表】—动态顺序表的增删查改实现
热门推荐
诺诺的包包
11-27 1万+
线性表—动态顺序表的完整实现，用动态图演示与代码相结合，更容易理解！
数据结构之链表增删查改（最详细注释和最清晰思路，附完整代码）
include520的博客
07-23 3006
本文通过结构体指针实现链表的增删查改，适合新手入门
期末复习总结【MySQL】库和表的基本操作 + 增删改查CURD
yzhcjl_的博客
05-23 1742
小白必看!!期末复习必看!!详细总结 MySQL 中如何创建删除数据库, 创建删除表, 以及的增删改查命令, 条件查询最为重要!!
【通关MySQL】MySQL增删改查(CRUD)详解
冲击大厂之路!!!
11-13 4422
MySQL增删改查基础！
链表学习-小白也能学会的链表
2202_75468818的博客
11-27 1058
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
vue-cli+node搭建简单的增删改查
wenxiukeke的博客
02-28 1692
vue-cli+node搭建简单的增删改查 首先先声明一下，本人对vue并不是很熟悉，尚且在学习中，由于特别好奇vue这个框架是怎么和后端进行数据交互的，所以我查询了很多资料去搭建，这里只能把我知道的记录一下，至于细节，我也尚在研究。首先呢vue前端框架和后端进行数据交互少不了webpack这个东西，webpack如果想了解，就直接去官网吧！这里我不多说，因为我了解的也不够深刻，怕误导别人和自己。...
时间复杂度&&空间复杂度&&顺序表&&链表&&顺序表和链表的区别以及优缺点对比
qq_54626677的博客
08-03 1029
顺序表（逻辑结构和物理结构是一致的）- 本质是数组，动态增长，并且要求里面存储的数据必须从左往右是连续的。实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这。空间复杂度 - 空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。链表（逻辑结构和物理结构是不一致的）- 空间按需所取，头部空间不需要挪动数据。时间复杂度 - 算法中的基本操作的执行次数，为算法的时间复杂度。总结：这两个数据结构是相辅相成的。里我们使用大O的渐进表示法。...
c语言顺序表插入输入删除查找功能（附完整代码）
m0_66371731的博客
09-26 2182
小白浅试一下c语言的顺序表的一些基本功能，供你们参考，更希望希望指出修改意见😊
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 226
【代码】数据结构-线性表-课设实验-手机销售。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1046
本文介绍了数据结构中的AVL树，给出了C++的代码实现
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 221
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
数据结构（栈和队列的实现）
2301_80475151的博客
09-30 792
这里介绍了栈的实现和队列的实现，还有栈和队列的OJ题例如用栈实现队列和用队列实现栈等‘；
深入理解 C# 中的集合与数据结构
最新发布
qq_45728381的博客
10-02 896
在日常开发中，集合与数据结构是处理数据的基础工具。C# 提供了一系列强大而灵活的集合类型，帮助我们存储、访问和管理数据。这篇文章将带你了解 C# 中常用的数组、列表、字典、队列、栈、集合和链表的特性和用法。
数据结构——初识树和二叉树
weixin_74209413的博客
09-26 1109
树是由根和子树组成，子树又是由子树的根和子树的子树组成，是一个递归的（嵌套的）结构。示意图如下：树的其他表现方式为何要重点研究每结点最多只有两个的树?二叉树的结构最简单，规律性最强;可以证明，所有树都能转为唯一对应的二又树，不失一般性。普通树(多又树)若不转化为二又树，则运算很难实现二叉树在树结构的应用中起着非常重要的作用，因为对二叉的许多操作算法简单，而任何树都可以与二叉树相互转换，这样就解决了树的存储结构及其运算中存在的复杂性。二叉树。
C++实现数据结构线性表：顺序表与单链表操作
"该资源是一个关于C++实现数据结构中线性表的教程，主要涵盖了顺序表和单链表的基本操作，包括增删改查，以及如何合并两个有序线性表。提供了完整的C++代码实现，并附有注释。代码已在Dev-C++5.4.0环境下测试通过，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值