数据结构：线性表的顺序存储详解

数据结构：线性表的顺序存储详解

引用

CSDN

1.

https://m.blog.csdn.net/ccf3699f/article/details/145172942

线性表是数据结构中的基本概念，而顺序存储结构是实现线性表的一种常见方式。本文将详细介绍线性表的顺序存储结构的特点，并通过C语言代码示例展示其具体实现。

线性表

线性表是由n个任意类型的数据元素组成的有限序列。

顺序存储：顺序存储结构是用一段连续的存储单元依次存储线性表中的数据元素。

特点：

1. 物理位置与逻辑关系一致

在顺序存储结构中，数据元素的物理位置和逻辑关系是完全对应的。例如，对于一个线性表 L = {a1,a2,a3, … , an}，假设存储在数组 A 中，那么 A[i] 就是线性表中的第 i + 1 个元素。如果要访问线性表中的第 i 个元素，直接通过数组下标 i - 1 就可以快速定位，时间复杂度为 O(1)。这种直接通过下标访问元素的特性使得顺序存储结构在查找等操作中效率很高。

2. 存储空间连续性要求高

由于需要连续的存储空间，这就对内存的分配有一定的要求。在实际应用中，如果要存储一个很大的线性表，可能需要预先分配足够大的内存空间。而且在存储空间不足的情况下，很难动态地扩展存储空间，不像链式存储那样可以灵活地申请和释放内存，造成内存空间的浪费。

3. 访问速度快

由于数据元素在内存中是连续存储的，通过下标可以直接快速地访问任意位置的元素。这种高效的随机访问能力使得顺序存储结构在需要频繁查找元素的应用场景中表现出色。

4. 存储密度高

顺序存储结构除了存储数据元素本身外，不需要额外的存储空间来存储指针等信息（与链式存储结构相比）。这使得存储空间的利用率较高，对于存储空间有限的系统来说是一个很大的优势。

5. 插入和删除效率低

在顺序存储结构中进行插入和删除操作时，往往需要移动大量的元素来保持线性表的顺序性。这使得插入和删除操作的时间复杂度较高，为 O(n)。例如，当线性表很长时，在表头插入或删除一个元素，需要移动整个线性表的元素，效率非常低。

代码举例

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDataType;
#define INIT_CAPACITY 3
typedef struct SeqList
{
    SLDataType* a;
    SLDataType size;//有效数据个数
    SLDataType capacity;//空间的容量
}SL;//动态顺序表插入代码片

1. 内存空间初始化

void SLInit(SL* ps)//动态开辟一块空间
{
    assert(ps);
    ps->a = (SLDataType*)malloc(sizeof(SLDataType) * INIT_CAPACITY);
    if (ps->a == NULL)
    {
        perror("malloc fail");
        return;
    }
    ps->size = 0;
    ps->capacity = INIT_CAPACITY;
}

2. 空间销毁

void SLDestroy(SL* ps)
{
    assert(ps);
    free(ps->a);
    ps->capacity = ps->size = 0;
}

3. 空间扩容

void SLCheckCapacity(SL* ps)
{
    assert(ps);
    if (ps->capacity == ps->size)
    {
        SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->capacity*2);
        if (tmp == NULL)
        {
            perror("realloc fail");
            return;
        }
        ps->a = tmp;
        ps->capacity *=2;
    }
}

4. 代码的打印

void SLPrint(SL* ps)
{
    assert(ps);
    for (int i = 0; i < ps->size; i++)
    { 
        printf("%d ", ps->a[i]);
    }
    printf("\n");
}

5. 在尾部插入数据

1. 判断指向这一空间的指针是否位野指针
2. 判断空间是否足够，不够则需扩容
3. 插入数据

void SLPushBack(SL* ps, SLDataType x)//尾插
{
    assert(ps);
    SLCheckCapacity(ps);
    ps->a[ps->size++] = x;
}

6. 在尾部删除数据

1. 判断指向这一空间的指针是否位野指针
2. 判断是否有数据
3. 删除数据

void SLPopBack(SL* ps)//尾删
{
    assert(ps);
    assert(ps->size > 0);
    ps->size--;
}

7. 在头部插入数据

1. 判断指向这一空间的指针是否位野指针
2. 判断空间是否足够，不够则需扩容
3. 插入数据

void SLPushFront(SL* ps, SLDataType x)//头插
{
    assert(ps);
    SLCheckCapacity(ps);
    int end = ps->size - 1;
    while (end >= 0)
    {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[0] = x;
    ps->size++;
}

8. 头部数据的删除

1. 判断指向这一空间的指针是否位野指针
2. 判断是否有数据
3. 删除数据

void SLPopFront(SL* ps)//头删
{
    assert(ps);
    int begin = 1;
    assert(ps->size > 0);
    while (begin <= ps->size)
    {
        ps->a[begin - 1] = ps->a[begin];
        begin++;
    }
    ps->size--;
}

9. 在中间某位置插入数据

1. 判断指向这一空间的指针是否位野指针
2. 判断插入位置是否超出该空间
3. 插入数据

void SLInsert(SL* ps, int pos, SLDataType x)
{
    assert(ps);
    SLCheckCapacity(ps);
    assert(pos>0 && pos <= ps->size);
    int end = ps->size - 1;
    while (end >= pos)
    {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[pos] = x;
    ps->size++;
}

10. 删除中间某一位置数据

1. 判断指向这一空间的指针是否位野指针
2. 判断插入位置是否超出该空间
3. 删除数据

void SLErase(SL* ps, int pos)
{
    assert(ps);
    assert(pos > 0 && pos < ps->size);
    int begin = pos;
    while (begin < ps->size)
    {
        ps->a[begin - 1] = ps->a[begin];
        begin++;
    }
    ps->size--;
}

代码的测试

void testseqlist()
{
    SL s;
    SLInit(&s);//初始化
    SLPushBack(&s, 1);//尾插
    SLPushBack(&s, 2);
    SLPushBack(&s, 3);
    SLPushBack(&s, 4);
    SLPushBack(&s, 5);
    SLPushBack(&s, 6);
    SLPrint(&s);//打印
    SLPopBack(&s);//尾删
    SLPopBack(&s);
    SLPrint(&s);//打印
    //SLDestroy(&s);
    SLPushFront(&s, 3);//头插
    SLPushFront(&s, 3);
    SLPushFront(&s, 3);
    SLPushFront(&s, 3);
    SLPrint(&s);//打印
    SLPopFront(&s);//头删
    SLPopFront(&s);
    SLPopFront(&s);
    SLPopFront(&s);
    SLPrint(&s);//打印
    SLInsert(&s, 2, 9);//中间插入
    SLInsert(&s, 2, 9);
    SLInsert(&s, 2, 9);
    SLInsert(&s, 2, 9);
    SLInsert(&s, 2, 9);
    SLPrint(&s);
    SLErase(&s, 2);//中间删除
    SLErase(&s, 2);
    SLErase(&s, 2);
    SLErase(&s, 2);
    SLPrint(&s);
}
int main()
{
    testseqlist();
    return 0;
}