数据结构-顺序表的顺序存储

最新推荐文章于 2025-06-02 14:22:30 发布
最新推荐文章于 2025-06-02 14:22:30 发布
阅读量3.7k 收藏 7
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 自学-数据结构（java实现） 文章标签： 数据结构 顺序表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/junLe_come_on/article/details/103005534
本文介绍了数据结构中的顺序表，它使用连续的存储单元存储线性表的数据元素，以此来体现元素间的逻辑关系。内容包括顺序表的特点、存储位置的计算方式，以及顺序表的插入、删除、获取值、定位元素和遍历等操作的代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

定义：

  • 用一组地址连续的存储单元依次存储线性表中每个数据元素，这种存储结构称为线性表的顺序存储结构，用这种结构表示的线性表称为顺序表。

特点：

  • 用数据元素在计算机内物理位置相邻来表示线性表中数据元素之间的逻辑关系。

存储位置：

  • 线性表中第i个数据元素ai的存储位置

    在这里插入图片描述

  • 线性表的顺序存储结构为随机存储结构

  • 存储结构内存视图
    在这里插入图片描述

代码表示：

  • 顺序表的插入
	/**
     * 顺序表的插入
     *
     * @param arr   数组
     * @param pos   插入的位置
     * @param value 插入的值
     * @return
     */
    public static boolean listInsert(int[] arr, int pos, int value) {
        if (arr.length > MaxSize) {
            System.out.println("顺序表已满，无法继续插入数据！");
            return false;
        }

        if (pos < 1 || pos > arr.length + 1) {
            System.out.println("插入数据的位置无效，无法插入");
            return false;
        }

        // 因为在java中数组的大小不能动态变化的，所以只能使用新数组
        int[] newArr = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }

        for (int i = newArr.length - 1; i >= pos; i--) {
            newArr[i] = newArr[i - 1];
        }
        newArr[pos - 1] = value;
        listTraverse(newArr);
        return true;
    }
  • 顺序表的删除
	/**
     * 顺序表的删除
     *
     * @param arr   数组
     * @param pos   删除的位置
     * @param value 删除的值
     * @return
     */
    public static boolean listDelete(int[] arr, int pos, int value) {
        if (arr.length == 0) {
            System.out.println("顺序表为空表，无法删除");
            return false;
        }

        if (pos < 1 || pos > arr.length) {
            System.out.println("删除的位置无效");
            return false;
        }

        for (int i = pos - 1; i < arr.length; i++) {
            if (i != arr.length - 1) {
                arr[i] = arr[i + 1];
            }
        }
        arr[arr.length - 1] = 0;
        listTraverse(arr);
        return true;
    }
  • 获取顺序表上指定位置上的值
	/**
     * 获取顺序表上指定位置上的值
     *
     * @param arr 数组
     * @param pos 元素的位置
     * @return
     */
    public static int listFindByPos(int[] arr, int pos) {
        if (pos < 1 || pos > arr.length) {
            System.out.println("获取的位置无效");
            return -1;
        }
        return arr[pos - 1];
    }
  • 获取顺序表上指定元素的位置
	/**
     * 获取顺序表上指定元素的位置
     *
     * @param arr   数组
     * @param value 查找的值
     * @return
     */
    public static int listFindByValue(int[] arr, int value) {
        if (arr.length == 0) {
            System.out.println("顺序表为空表，无法获取元素的位置");
            return -1;
        }

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == value) {
                return i + 1;
            }
        }

        return -1;
    }
  • 遍历顺序表
	/**
     * 遍历顺序表
     *
     * @param arr 数组
     */
    public static void listTraverse(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }
  • main方法
public static void main(String[] args) {
        // 固定演示的数组的长度
        int[] arr = new int[7];
        // 添加测试的数据
        testData(arr);
        // 遍历
        listTraverse(arr);
        // 插入数据
        listInsert(arr, 3, 100);
        // 删除数据
        //listDelete(arr, 3, 50);
        // 获取指定位置的值
        System.out.println(listFindByPos(arr, 5));
        System.out.println(listFindByValue(arr, 20));

        System.out.println();
    }

    public static void testData(int[] arr) {
        arr[0] = 30;
        arr[1] = 10;
        arr[2] = 50;
        arr[3] = 20;
        arr[4] = 60;
        arr[5] = 70;
        arr[6] = 90;
    }

demo代码：

package test;

public class Test {

    private static final int MaxSize = 20;

    public static void main(String[] args) {
        // 固定演示的数组的长度
        int[] arr = new int[7];
        // 添加测试的数据
        testData(arr);
        // 遍历
        listTraverse(arr);
        // 插入数据
        listInsert(arr, 3, 100);
        // 删除数据
        //listDelete(arr, 3, 50);
        // 获取指定位置的值
        System.out.println(listFindByPos(arr, 5));
        System.out.println(listFindByValue(arr, 20));

        System.out.println();
    }

    public static void testData(int[] arr) {
        arr[0] = 30;
        arr[1] = 10;
        arr[2] = 50;
        arr[3] = 20;
        arr[4] = 60;
        arr[5] = 70;
        arr[6] = 90;
    }

    /**
     * 顺序表的插入
     *
     * @param arr   数组
     * @param pos   插入的位置
     * @param value 插入的值
     * @return
     */
    public static boolean listInsert(int[] arr, int pos, int value) {
        if (arr.length > MaxSize) {
            System.out.println("顺序表已满，无法继续插入数据！");
            return false;
        }

        if (pos < 1 || pos > arr.length + 1) {
            System.out.println("插入数据的位置无效，无法插入");
            return false;
        }

        // 因为在java中数组的大小不能动态变化的，所以只能使用新数组
        int[] newArr = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }

        for (int i = newArr.length - 1; i >= pos; i--) {
            newArr[i] = newArr[i - 1];
        }
        newArr[pos - 1] = value;
        listTraverse(newArr);
        return true;
    }

    /**
     * 顺序表的删除
     *
     * @param arr   数组
     * @param pos   删除的位置
     * @param value 删除的值
     * @return
     */
    public static boolean listDelete(int[] arr, int pos, int value) {
        if (arr.length == 0) {
            System.out.println("顺序表为空表，无法删除");
            return false;
        }

        if (pos < 1 || pos > arr.length) {
            System.out.println("删除的位置无效");
            return false;
        }

        for (int i = pos - 1; i < arr.length; i++) {
            if (i != arr.length - 1) {
                arr[i] = arr[i + 1];
            }
        }
        arr[arr.length - 1] = 0;
        listTraverse(arr);
        return true;
    }

    /**
     * 获取顺序表上指定位置上的值
     *
     * @param arr 数组
     * @param pos 元素的位置
     * @return
     */
    public static int listFindByPos(int[] arr, int pos) {
        if (pos < 1 || pos > arr.length) {
            System.out.println("获取的位置无效");
            return -1;
        }
        return arr[pos - 1];
    }

    /**
     * 获取顺序表上指定元素的位置
     *
     * @param arr   数组
     * @param value 查找的值
     * @return
     */
    public static int listFindByValue(int[] arr, int value) {
        if (arr.length == 0) {
            System.out.println("顺序表为空表，无法获取元素的位置");
            return -1;
        }

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == value) {
                return i + 1;
            }
        }

        return -1;
    }

    /**
     * 遍历顺序表
     *
     * @param arr 数组
     */
    public static void listTraverse(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }
}
线性表之顺序表存储结构
XGamer
08-03 991
顺序表的存储结构适用于一些数据相对稳定的线性表，如：学生学籍，公司职工信息。       最基本的线性表操作：添加，删除，插入，清空，查找，判空，判满。      顺序表的存储结构一般用数组存储。      首先定义一个结构体，用于存储线性表的数据，线性表长度，以及线性表的中元素个数。 struct List { int *elem; //存储空间地址
顺序表的顺序存储
qq_45677669的博客
09-26 691
用于数据结构中顺序表的定义 typedef struct { ElemType data[MAXSIZE]; int length; }SeqList; Seqlist L;
顺序表（顺序存储结构）
weixin_63032791的博客
05-29 2112
顺序存储结构会申请一段连续的内存空间来存储数据，下面详解一下顺序表的各大使用 在此之前必须要了解一个知识点：当传参的时候，如果你需要改变这个参数的数值，则需要传递这个参数变量的地址，当你不需要改变它的数值的时候，只需要传递该参数就行，这个对于非常学习数据结构十分重要。 相关的头文件定义： #include "stdio.h" #include "stdlib.h" #include "math.h" #include "time.h" #define OK 1 #define E
【数据结构——顺序表】
最新发布
努力搬砖ing~
06-02 1116
数据结构——顺序表
顺序表的顺序存储表示
kxbdys的博客
03-08 2561
一、顺序表的存储表示 1、顺序表(元素)：地址连续、依次存放、随机存取、类型相同 数组(元素)：地址连续、依次存放、随机存取、类型相同 由于顺序表和数组具有相同的性质，则可以用一维数组表示顺序表。 但线性表长可变(删除)，则可以用一变量表示顺序表的长度属性。 2、模板一：最基本的顺序表模板 #define LIST_INIT_SIZE 100 // 线性表存储空间的初始分配量 typedef struct { ElemType elem[LIST INIT _SIZE]; //静...
顺序表_存储结构
JUSTfFUN的博客
02-07 502
/* * 时间：2021.01.28 * 内容：线性表的动态分配顺序存储结构 * 位置： * 严书P23 高书P11 */ /* 伪算法： #define MAXSIZE 100 // 顺序表可能达到的最大长度 typedef struct { ElemType * elem; // 储存空间的基地址 int length; // 当前长度 }SqList; // 顺序表的结构类型为SqList */ #define LIST_INIT_SIZE 10 //线性表存储空间的初始分
数据结构 - 顺序表(Contiguous-List)
10-23
**数据结构 - 顺序表(Contiguous-List)** 顺序表是数据结构中的一种基本类型，它是线性表的一种具体实现方式。在计算机科学中，数据结构的选择与操作直接影响到程序的效率和性能。理解并掌握顺序表的概念、特点以及...
C语言数据结构-顺序表版学生管理系统
09-26
顺序表是一种线性数据结构，它的特点是元素在内存中按顺序存储，相邻元素的地址也相邻。在C语言中，我们通常通过数组来实现顺序表。以下是对这个学生管理系统中涉及的几个核心知识点的详细阐述： 1. **数组**：在...
数据结构-顺序表的就地逆置.doc
07-11
顺序表是一种线性数据结构，其中元素在内存中是连续存储的，可以方便地通过索引来访问。这里，我们用C语言实现了一个顺序表的操作，包括初始化、输入元素、打印元素以及就地逆置操作。 1. **初始化顺序表**： 函数...
数据结构-顺序表的实现.pptx
02-15
数据结构-顺序表的实现 顺序表是数据结构中的一种基本数据结构，它的实现是通过数组来存储数据的。顺序表的实现需要实现基本运算，包括建立空表、置空表、判断表是否为空、求表长、取表中某个元素、定位运算、插入...
数据结构学习--线性表及其应用--顺序表
06-25
通过这样的实验，学习者能够更好地理解顺序表的特性和基本操作，为后续学习更复杂的数据结构如树、图等打下坚实的基础。同时，对顺序存储结构的熟悉也有助于提升对数组、指针等基础知识的运用能力。在实际编程中，...
顺序表存储结构
rv0p111
01-10 3929
线性表的顺序存储结构是一种随机存取的存储结构。比如存储一个多项式的系数和指数的线性表我们可以这么表示。#define MAXSIZE 100//多项式可能达到的最大长度 typedef struct//多项式的定义 { float coef;//系数 int expn;//指数 }Polynomial; typedef struct { Polynomial *elem;/
顺序存储（顺序表)
热门推荐
zhang21722668的博客
08-25 2万+
1.顺序存储方式 线性表的顺序存储结构，就是在内存中找到一块空间，通过占位的方式，把一定内存空间给占了，然后把相同数据类型的数据元素依次存放在这块空间中，既然线性表的每个数据元素的类型相同，所以C语言（其他语言也相同）用一维数组来实现顺序存储结构，即把第一个数据元素存到数组下标为0的位置中，接着把线性表相邻的元素存储在数组中相邻的位置。 2.顺序存储的属性 三个属性： 存储空间的起始...
顺序表（线性表的顺序存储结构）
DY_blog的专栏
06-04 1802
逻辑结构上呈线性分布的数据元素在实际的物理存储结构中也同样相互之间紧挨着，这种存储结构称为线性表的顺序存储结构。 也就是说，逻辑上具有线性关系的数据按照前后的次序全部存储在一整块连续的内存空间中，之间不存在空隙，这样的存储结构称为顺序存储结构。 使用顺序存储结构存储的数据，第一个元素所在的地址就是这块存储空间的首地址。通过首地址，可以轻松访问到存储的所有的元素，只要首地址不丢，数据永远能找到（...
线性表的顺序存储结构（顺序表）
byyunnk的专栏
08-10 2753
一、顺序表的定义：     在计算机内存中，开辟一片连续的存储空间，用一组连续的存储单元依次存放数据元素。这种存储方式就叫做线性表的顺序存储结构，也就是顺序表     顺序存储结构的特点，在逻辑上相邻的数据元素，它们的物理位置也是相邻的。即线性关系利用物理上的相邻关系来体现，第i个数据元素的存储位置可表示为： LOC(ai) = LOC(a1)+(i-1)*m; 其中，LOC(a1)是线
1.2、顺序表（顺序存储结构）
融码一生：专注 Python、C/C++、Linux、机器学习 & 深度学习、NLP、算法领域分享
04-13 973
● 顺序表（顺序存储结构）是线性表的一种。 ● 顺序表对数据的物理存储结构也有要求：顺序表存储数据时，会提前申请一整块足够大小的物理空间，然后将数据依次存储起来，存储时做到数据元素之间不留一丝缝隙。
数据结构——顺序表（线性表的顺序存储结构）
无聊人的博客
07-09 1904
顺序表定义顺序表上基本操作的实现结构体定义建立顺序表初始化顺序表销毁线性表判断线性表是否为空表求线性表的长度输出线性表求线性表中的某个数据元素的值按元素查找插入数据元素删除数据元素 定义 顺序表是用一组地址连续的存储单元依次存储线性表中的数据源元素，从而使得逻辑相邻的两个元素在物理位置上也相邻。特点是表中元素的逻辑顺序与其物理顺序相同 顺序表上基本操作的实现 结构体定义 #define MaxSize 100//定义一个整形常量 typedef struct { ElemType data[MaxSize
数据结构之线性表的顺序存储——顺序表
jiaomubai的博客
01-20 791
线性表 线性表即零个或多个数据元素的有限序列。首先它是一个序列，其次它的元素之间是有顺序的，若存在多个元素，则首个元素无前驱，末尾元素无后继，除此之外，每个元素都有一个前驱和一个后继。用n来表示线性表元素的个数，当n=0时，即表明线性表中无元素，称为空表。 线性表又可分为动态线性表和静态线性表。静态线性表的容量大小是固定的，而动态线性表的容量可根据表中元素实现自动扩容。 线性表的顺序存储结构——顺...
数据结构与算法＜6＞——线性表的顺序存储结构（顺序表的具体操作）
元气少女硕硕子的博客
08-05 2405
一.顺序表的示意图 #define LIST INIT SIZE 100 //线性表存储空间的初始分配量；就是数组多大，这里定义了100 typedef struct{ Elem Type elem[LIST INIT SIZE]; //用一维数组来装数据元素，这里是Elem类型，也可以是别的类型 int length; //当前长度 }SqList; 这个就相当于定义了一个顺序表 L，它是一个SqList型的变量
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值