详解顺序表

已于 2023-10-06 11:34:19 修改
阅读量553 收藏
点赞数
文章标签： 算法
于 2023-10-02 20:53:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/D3540987120/article/details/133498531
版权

一.线性表的定义

线性表的顺序表示又称为顺序存储结构或顺序映像。

1.顺序表简介：

百度百科：顺序表是在计算机内存中以数组的形式保存的线性表，线性表的n是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

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

顺序存储定义：逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构。

总之：逻辑上相邻，物理上也相邻。

线性表（A1,A2,A3.....An-1,An）

线性表的第一个数据元素A1的存储位置，称作线性表的起始位置或基地址。

存储结构：依次存储，地址连续，中间没有空出存储单元

259ea9c3c8db477798d0e335119ab531.png​

顺序表的特点：以物理位置相邻表示逻辑关系。任意元素可随机存取

顺序表元素：地址连续、依次存放、随机存取、类型相同

2.定义总结：

​

二.顺序表分类

分为静态顺序表与动态顺序表（如上图所示）

静态顺序表：使用定长数组存储元素。

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

优缺点：

1.随机访问

2.存储密度高

3.扩展容量不方便

4.插入、删除数据元素不方便

三.代码实现

3.1 【1】定义顺序表的最大长度和动态顺序表的初始默认最大容量

/*需要包含的头文件*/
#include <stdlib.h>
#include <stdio.h>


/*【1】定义顺序表的最大长度和动态顺序表的初始默认最大容量*/
#define MaxSize  10
#define InitSize 10


/*程序演示开头展示*/
char welcome[] = "~~~~~~~~~~~欢迎光临本程序~~~~~~~~~如有问题~~~~~~~请选择帮助联系开发人员\n顺序表初始化中......";

3.2  【2】自定义C语言的bool变量

/*【2】自定义C语言的bool变量*/
#define bool char
#define true 1
#define false 0

3.3  【3】自定义数据元素的数据类型

/*【3】自定义数据元素的数据类型*/
typedef int Elemtype;

3.4  【4】顺序表的结构体定义

/*【4】顺序表的结构体定义*/
//<1>静态顺序表的数据元素结构体
 typedef struct SqList
 {

    /*使用静态数组存放数据元素 */
    Elemtype data[MaxSize];
    /*顺序表的当前长度*/
    int length;

 }SqList;
  
//<2>动态顺序表的数据元素结构体
 typedef struct SeqList
 {

    /*使用动态指针分配数组 */
    Elemtype *data;
    /*顺序表的当前长度*/
    int length;
    /*顺序表的当前长度*/
    int maxsize;

 }SeqList;

3.5  【5】顺序表的初始化（这里初始化长度均为5，方便后面代码测试）

/*【5】顺序表的初始化*/
//<1>静态顺序表初始化
bool InitSqList(SqList *L){
    //初始化表长
    L->length = 5;

    return true;

}
//<2>动态顺序表初始化
bool InitSeqList(SeqList *L){
    //初始化表长
    L->length = 5;

    //初始化最大容量
    L->maxsize = InitSize;

    //给指针分配一片空间，空间大小依据maxsize决定
    L->data = (Elemtype *)malloc(sizeof(Elemtype) * InitSize);

    return true;
}

3.6  【6】顺序表的元素插入

/*【6】顺序表的元素插入*/
//<1>静态顺序表的插入
bool SqListInsert(SqList *L, int i, Elemtype e){  //在顺序表的第i个位置插入新元素e

    //[1]判断插入操作是否合法
    if (i<1 || i>L->length+1)
    {
        printf("【10001】这个位置插入不合法!\n");
        return false;
    }
    if (L->length >= MaxSize)
    {
        printf("【10002】这张表已经满了!\n");
        return false;
    }
    
    //[2]将第i位和之后的元素位置往后移动一位
    for (int j = L->length; j >= i; j--)
    {
        L->data[j] = L->data[j-1];
    }

    //[3]将新元素插入到指定位置---区分数组下标和元素位序的排列
    L->data[i - 1] = e;
    //[4]表长加一
    L->length++;
    return true;
    
}
//<2>动态顺序表的插入
bool SeqListInsert(SeqList *L, int i, Elemtype e){
     //[1]判断插入操作是否合法
     if (i<1 || i>L->length+1)
     {
        printf("【10003】这个位置插入不合法!\n");
        return false;       
     }

     if(L->length >= L->maxsize){
        printf("【10004】这张表已经满了!\n");
        return false;       
     }

     //[2]将第i位和之后的元素位置往后移动一位
     for (int j = L->length; j >= i; j--)
     {
        L->data[j] = L->data[j-1];
     }

     //[3]将新元素插入到指定位置
     L->data[i-1] = e;

     //[4]表长加一
     L->length++;
     return true;
     
     
}

3.7  【7】顺序表的元素删除

/*【7】顺序表的元素删除*/
//<1>静态顺序表的删除
//将第i位元素删除
bool SqListDetele(SqList *L,int i,Elemtype *e){

    //[1]判断操作合法性
    if (i<1 || i>L->length+1)
    {
        printf("【10005】这个位置删除不合法!\n");
        return false;          
    }
    if (L->length <= 0)
    {
        printf("【10006】这张表是空的!\n");
        return false;   
    }
    
    //[2]将要删除的值赋值给e
    *e = L->data[i-1];
    //[3]移动元素，将第i位和之后的元素赋值给前一位
    for (int j = i; j < L->length; j++)
    {
        L->data[j-1] = L->data[j];
    }
    
    //[4]表长减一
    L->length--;
    //[5]返回TRUE
    return true;

    
}
//<2>动态顺序表的删除
bool SeqListDetele(SeqList *L,int i,Elemtype *e){

    //[1]判断操作合法性
    if (i<1 || i>L->length+1)
    {
        printf("【10005】这个位置删除不合法!\n");
        return false;          
    }
    if (L->length <= 0)
    {
        printf("【10006】这张表是空的!\n");
        return false;   
    }
    
    //[2]将要删除的值赋值给e
    *e = L->data[i-1];
    //[3]移动元素，将第i位和之后的元素赋值给前一位
    for (int j = i; j < L->length; j++)
    {
        L->data[j-1] = L->data[j];
    }
    
    //[4]表长减一
    L->length--;
    //[5]返回TRUE
    return true;

    
}

3.8  【8】顺序表的查询(按值查询)

/*【8】顺序表的查询(按值查询)*/
//<1>静态顺序表的查询
int SqListSelect(SqList L,Elemtype e){

    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] == e)
        {
            return i+1;
        }       
    }
    return 0;    
}
//<2>动态顺序表的查询
int SeqListSelect(SeqList L,Elemtype e){

    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] == e)
        {
            return i+1;
        }      
    }
    return 0;    
}

3.9  【9】动态顺序表的扩容

/*【9】动态顺序表的扩容*/
bool IncreaseSize(SeqList *L,int len){
    //[1]生成指向原来顺序表存储空间的指针
    Elemtype *p = L->data;

    //[2]开辟空间
    L->data = (Elemtype *)malloc(sizeof(Elemtype) * (L->maxsize + len));

    //[3]转移数据
    for (int i = 0; i < L->length; i++)
    {
        L->data[i] = p[i];
    }
    
    //[4]修改顺序表长，值加len
    L->maxsize += len;

    //[5]释放空间
    free(p);

    return true;

}

3.10 【10】顺序表的输出

/*静态顺序表的输出*/
bool SqListPrint(SqList L){

    //判空
    if (L.length == 0)
    {
        printf("This sequence table is emply!(空表)\n");
    }else{
        printf("SqList===");
    }

    
    for (int i = 0; i < L.length; i++)
    {
        printf("%d、",L.data[i]);
        
    }
    printf("\n");
    printf("end\n");
    
}

/*动态顺序表的输出*/
bool SeqListPrint(SeqList L){

    //判空
    if (L.length == 0)
    {
        printf("This sequence table is emply!(空表)\n");
    }else{
        printf("SeqList===");
    }

    for (int i = 0; i < L.length; i++)
    {
        printf("%d、",L.data[i]);
        
    }
    printf("\n");
    printf("end\n");
}

3.11  【11】main方法

int main(){

    SqList L1;
    SeqList L2;
    int a,b,d,e,num,num1,choose;


    	for(int i=0;i<strlen(welcome);i++)
	    {
		    printf("%c",welcome[i]);
		    for(int m=0;m<10000;m++)
			    for(int n=0;n<2800;n++)
			    {
				    
			    }
	    }


    //对顺序表初始化
    
    if (InitSqList(&L1) == true && InitSeqList(&L2) == true)
    {
        printf("顺序表初始化成功！\n");
    }else{
        printf("初始化失败啦！快去找bug！\n");
    }




    while (choose != 9 )
    {
        printf("请选择需要调试的顺序表：\n");
        printf("静态顺序表：【1】\n");
        printf("动态顺序表：【2】\n");
        printf("更多：【3】\n");
        printf("帮助：【4】\n");
        printf("关闭：【9】\n");

        scanf("%d",&choose);
        //静态顺序表
        
        if (choose == 1)
        {
            while (num1 != 6)
                    {
                    printf("---------------------------------\n");
                    printf("打印静态顺序表【0】\n");
                    printf("设置静态顺序表的数据元素【1】\n");
                    printf("静态顺序表中插入数据元素【2】\n");
                    printf("静态顺序表中删除数据元素【3】\n");
                    printf("重新初始化静态顺序表【4】\n");
                    printf("按值查找元素位序【5】\n");

                    printf("退出【6】\n");
                    printf("---------------------------------\n");
                    printf("\n");

                    scanf("%d",&num1);
                    switch (num1)
                    {
                    //选项0
                    case 0:
                        printf("静态顺序表打印结果===》\n");
                        SqListPrint(L1);
                        break;

                    //选项1
                    case 1:
                        for (int i = 1; i <= L1.length; i++)
                        {
                            printf("请输入第%d个数字：",i);
                            scanf("%d",&a);
                            L1.data[i-1] = a;
                        
                        }

                        printf("设置成功！\n");
                        SqListPrint(L1);
                        break;

                    //选项2
                    case 2:
                        //静态顺序表插入元素
                        printf("请输入想要插入的位置====");
                        scanf("%d",&a);

                        printf("请输入想要插入的数字====");
                        scanf("%d",&b);

                        bool l = SqListInsert(&L1,a,b);
                        if (l == false)
                        {
                            printf("插入失败！\n");
                        }else{
                            printf("插入成功！\n");
                        }
                        
                        

                        
                        printf("静态顺序表打印结果===》\n");
                        SqListPrint(L1);

                        break;


                    //选项3
                    case 3:
                        printf("请输入想要删除的位置====");
                        scanf("%d",&a);

                        SqListDetele(&L1,a,&e);

                        printf("删除成功！已将%d删除\n",e);

                        printf("重新打印静态顺序表:\n");
                        SqListPrint(L1);
                        break;

                    //选项4
                    case 4:

                        //对顺序表初始化
                        printf("静态顺序表初始化中......\n");

                        if (InitSqList(&L1) == true)
                        {
                            printf("静态顺序表初始化成功！\n");
                        }else{
                            printf("初始化失败啦！快去找bug！\n");
                        }

                        break;

                    //选项5
                    case 5:
                        printf("请输入想要查找的元素====");
                        scanf("%d",&d);

                        printf("该值在第%d位第一次出现\n",SqListSelect(L1,d));
                        break;
                    //选项6
                    // case 6:
                    //     break;
                    }

            }
        

        }
        //动态顺序表
        else if(choose == 2)
        {
            while (num1 != 7){

            printf("---------------------------------\n");
            printf("打印动态顺序表【0】\n");
            printf("设置动态顺序表的数据元素【1】\n");
            printf("动态顺序表中插入数据元素【2】\n");
            printf("动态顺序表中删除数据元素【3】\n");
            printf("重新初始化动态顺序表【4】\n");
            printf("按值查找元素位序【5】\n");
            printf("动态顺序表扩容【6】\n");


            
            printf("退出【7】\n");
            printf("---------------------------------\n");
            printf("\n");
       

            scanf("%d",&num1);
            switch (num1)
            {
            //选项0
            case 0:
                printf("动态顺序表打印结果===》\n");
                SeqListPrint(L2);
                break;

            //选项1
            case 1:
                for (int i = 1; i <= L2.length; i++)
                {
                    printf("请输入第%d个数字：",i);
                    scanf("%d",&a);
                    L2.data[i-1] = a;
            
                }

                printf("设置成功！\n");
                SeqListPrint(L2);
                break;   


            //选项2
            case 2:

                //动态顺序表插入元素
                printf("请输入想要插入的位置====");
                scanf("%d",&a);

                printf("请输入想要插入的数字====");
                scanf("%d",&b);

                bool l = SeqListInsert(&L2,a,b);

                        if (l == false)
                        {
                            printf("插入失败！\n");
                        }else{
                            printf("插入成功！\n");
                        }
                        

                printf("动态顺序表打印结果===》\n");
                SeqListPrint(L2);

                break;


            //选项3
            case 3:
                printf("请输入想要删除的位置====");
                scanf("%d",&a);

                SeqListDetele(&L2,a,&e);

                printf("删除成功！已将%d删除\n",e);
                printf("重新打印动态顺序表:\n");
                SeqListPrint(L2);
                break;


            //选项4
            case 4:

                //对顺序表初始化
                printf("动态顺序表初始化中......\n");

                if (InitSeqList(&L2) == true)
                {   
                    printf("动态顺序表初始化成功！\n");
                }else{
                    printf("初始化失败啦！快去找bug！\n");
                }

                break;

            //选项5
            case 5:
                printf("请输入想要查找的元素====");
                scanf("%d",&d);

                printf("该值在第%d位第一次出现\n",SeqListSelect(L2,d));
                break;
            
            //选项6
            case 6:
                printf("空间大小：%d\n",L2.maxsize);
                printf("想要扩容的大小=====");
                scanf("%d",&d);
                IncreaseSize(&L2,d);

                printf("新的空间大小：%d\n",L2.maxsize);

                break;

            //选项7
                //case 7:
                //break;
            }
            }
        }else if (choose == 3)
        {
                printf("还没开发\n");
        }else if (choose == 4)
        {
            printf("~~~~~本程序由小露制作，用于了解顺序表的原理，并且示范两种顺序表的基本操作\n如有问题也没办法,程序员已经跑路了~~~~~\n");
        }
        
        else if (choose == 9)
        {
            break;
        }
               
        else{
            printf("输入不合法！请重新输入！\n");
        }
        
        

    }
      

}

四.运行结果

1.静态顺序表：

23ad5f16fe8149b5954c09ed4c6ab5b7.png​

3.动态顺序表：

8da19f0086c44c1f9208bf246fb0bfe8.png​

五.小结

顺序表是一种常见的线性表数据结构，它通过数组实现，有固定的大小并且元素在内存中是连续存储的。下面是顺序表的小结：

特点：顺序表的元素在内存中是连续存储的，可以通过索引直接访问元素，具有随机访问的特性。它的大小是固定的，一旦定义了大小，就无法动态调整。
缺点：顺序表的大小固定，一旦初始化就无法改变，当元素数量超过顺序表大小时，需要重新申请更大的内存空间，并将元素复制到新的空间中。这个过程比较耗时。
插入和删除：在顺序表中插入和删除元素需要移动元素的位置，这可能涉及到大量的数据搬移操作，特别是在顺序表的中间位置插入或删除元素时，效率较低。
查找：在顺序表中查找元素的时间复杂度为O(n)，需要遍历整个顺序表，直到找到匹配的元素。如果需要经常进行查找操作，顺序表可能不是最佳选择。
动态扩展：由于顺序表的大小固定，当元素数量增加时，可能需要重新申请更大的内存空间。这个过程可能比较耗时，需要考虑内存分配和数据迁移的开销。

总之，顺序表是一种简单且常用的数据结构，适用于对元素随机访问频繁、元素数量固定且不需要频繁插入和删除的场景。但对于元素数量动态变化、插入和删除较频繁的情况，顺序表的性能可能不如链表等动态分配内存的数据结构。选择使用何种数据结构需要根据具体的需求和场景来进行权衡。
 

参考文献：

百度百科，CSDN，数据结构(C语言版)

Q3540987120
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
1-定长的顺序表&不定长顺序表
sunshine612的博客
03-17 233
存储结构 顺序存储结构：逻辑上连续，物理存储上也连续 链式存储结构：逻辑上连续，物理存储上不连续 顺序表–操作数据 顺序表是在计算机内存中以数组的形式保存的线性表。 顺序存储： 类似于数组，顺序表比数组多带一个元素来记录存储的元素个数count 定长顺序表 定长顺序表 —》类似于数组 不定长顺序表—》C++的STL vector 数组适用于值比较固定的情况 存储数据 数组没有成套的方法 计数法：(...
区别顺序表的位序和数组下标：为何判断插入位置是否合法时if语句中用length+1，而移动元素的for语句中只用length？
wei_weiyang_yang的博客
08-05 1509
区别顺序表的位序和数组下标：为何判断插入位置是否合法时if语句中用length+1，而移动元素的for语句中只用length？
顺序表中序号与对应数组下标区别详解
weixin_47219110的博客
07-27 3763
顺序表 数组下标 a1 0 a2 1 a3 2 … … an n-1 由上表可以直观看到，顺序表中的序号是从1开始的，而数组下标是从0开始的，所以，在代码的编写过程中，要格外注意这个区别。 下列顺序表中的插入元素e操作为例： bool ListInsert(SqList &L,int i,ElemType e) { if(i<1IIi>L.length+1) return false; if(L.length>MaxSize) return fa...
数据结构3——线性表2：线性表的顺序结构
m0_61787307的博客
03-08 656
线性表的顺序结构基本理解，线性表销毁、清空、查找、定位、插入、删除等C/C++实现
线性表——顺序表
Angelica030的博客
06-02 397
一、顺序表の定义 顺序表是线性表中一种（顺序）存储方式，是指利用一段连续的内存地址来储存线性表的数据元素（data）。在C语言当中，这常用数组来实现。 二、顺序表の基本操作 1、顺序表的初始化 （1）构造空顺序表 void InitZeroList(Student *l) { l->length=0; } （2）构造初始数据顺序表 void InitList(Student *l,int number)//初始数据的个数 { int i; l->length=number; for
详解顺序表-顺序表演示源文件
10-02
顺序表演示源文件
C语言实现静态顺序表的实例详解
08-29
C语言实现静态顺序表的实例详解 在计算机科学中，顺序表是一种基本的数据结构，它是由一系列元素组成的有序集合。静态顺序表是一种特殊的顺序表，它在内存中开辟了一段连续的存储空间，并给它一个名字进行标识。...
顺序表就地逆置
03-26
### 顺序表就地逆置知识点详解 #### 一、基础知识概述 在计算机科学与技术领域，数据结构作为一门基础且重要的学科，其研究对象主要包括数据的逻辑结构、存储结构以及对这些数据进行操作的算法。其中，顺序表是...
顺序表的基本操作详解.zip
最新发布
03-20
顺序表是一种常见的数据结构，它在计算机科学中扮演着重要的角色。在Python中，我们可以用列表（list）来实现顺序表。...通过阅读"顺序表的基本操作详解.pdf"等文档，你可以更深入地学习顺序表的细节和高级用法。
数据结构——顺序表的基本操作
wrncxcy的博客
10-10 610
数据结构中顺序表的静态存储和动态存储
顺序表的学习
qq_42080635的博客
08-09 528
顺序表是指在计算机中用一组地址连续的存储单元依次存储线性表的各个数据元素。它的元素之间的逻辑关系通过它的存储位置来反应。顺序表的优点在于随机存储。 用C语言描述顺序存储结构下的线性表（顺序表）如下： #define MIXSIZE 100 typedef struct C {   datatype  elem[MIXSIZE];   int last; }SeqList; 顺序表有三...
数据结构笔记（一）：顺序表的动态扩容、插入、删除、按值查找、按位查找操作
qq_45571006的博客
04-10 422
#include #include<stdlib.h> using namespace std; #define InitSize 10//默认的最大长度 //动态分配的算法 typedef struct { int *data;//指示动态分配数组的指针 int MaxSize;//顺序表的最大容量 int length;//顺序表的当前长度 }SeqList; //初始化一个顺序表 void InitList(SeqList &L) { L.data=(int *)malloc(I
C++实现顺序表、定义、初始化、增加长度操作
qq_42500148的博客
10-11 501
1.顺序表定义、初始化（静态分配） 运行结果： `@TOC 2.顺序表增加长度和再次初始化（动态分配） 运行结果： 说明：如果再增加长度后不再次进行顺序表值初始化，那数组的值就会自动识别为内存中原脏数据，例如：你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助
数据结构学习--第2章
qq_45351128的博客
09-11 810
线性表一、线性表的定义二、线性表的顺序表示静态分配与动态分配插入操作删除操作查找按位查找按位查找线性表的链式表示单链表节点类型描述（带头结点）建立头插法（单链表的逆置）(带头结点) 尾插法 一、线性表的定义 线性表是具有相同数据类型的n（n>=0）个数据元素的有限序列。 相同：各数据元素所占空间一样大。 有序序列：有先后次序 线性表和顺序表、链表关系： 线性表：是一种逻辑结构，表示元素之间一对一相邻的关系。 顺序表、链表：是指存储结构。 位序与数组下标的区别： 位序：从1开始 数据下标：从0开始
顺序表的查找(按位查找、按值查找)(数据结构与算法)
AII_IIA的博客
10-26 909
能够实现随机存储的基础就在于顺序表中所有的数据元素在内存里都是连续存放的，并且这些数据元素的数据类型相同，也就是说每个数据元素所占的内存空间一样大。所以我们只需要知道一个顺序表的起始地址，每个数据元素的大小，就可以立即找到第 i 个元素的位置。按值查找操作，在表L中查找具有给定关键字值的元素。GetElem(L, i) :按位查找，获取表L中第 i 个位置元素的值。如果换一个类型的指针，指向同一个地址，int *p;顺序表的按位查找---------动态分配。
数据结构2-顺序表
huangshulang1234的博客
04-10 595
数据结构2-顺序表 数据结构2-顺序表 顺序表就是一段有序的数组。  静态顺序表：就是顺序表的最大长度是有确定值的。  动态顺序表：相对于静态顺序表，最大长度命名为容量，容量可以在初始化顺序表时候给出，容量可以根据后续需求通过realloc函数进行动态分配改变。 举个栗子——–动态顺序表 //Seqlist.h #ifndef Seqlist_h_ #define
数据结构之顺序表
m0_62878102的博客
08-04 3005
顺序表在内存中以一段连续的地址存储，具有随机性，顺序性，动态性随机性，即首地址随机生成；顺序性，即各元素地址满足等距相邻；动态性，即存储空间可在程序运行时动态生成。
【C/C++】【数据结构】顺序表
乞木的博客
08-02 424
顺序表也是线性表，具有线性结构。线性结构分为两种，一是顺序存储，在内存中是连续的；二是链式存储，在内存中是不连续的。   顺序表的特点： (1) 除第一个元素外，其他所有元素都只有一个直接前驱。 (2) 除最后一个元素外，其他所有元素都只有一个直接后继。   顺序表有容量和长度两个属性。长度指的是，顺序表中有效元素的个数。容量指的是顺序表中最大的可能长度。 若顺序表中的有效元素为0，...
线性表之顺序表
katy_yuan的博客
08-30 1664
顺序表,它是用一组地址连续的存储单元，依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。第1个元素存储在线性表的起始位置，第i个元素的存储位置后面紧接着存储的是第i+1个元素。因此，顺序表的特点是表中元素的逻辑顺序与其物理顺序相同。假设线性表L存储的起始位置为LOC(A)，sizeof(ElemType)是每个数据元素所占用存储空间的大小，则表L所对应的顺序存储如图2-1所
线性表详解：顺序表与链表
1. 顺序存储：也称为顺序表，它将线性表的所有元素存储在一块连续的内存区域中。通过数组的方式，可以通过下标直接访问元素，具有较高的存取效率。例如，"0，1，2，…，9" 或 "A，B，C，…，Z" 可以看作是顺序表的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值