【数据结构与算法从0到1 - C实现】一、顺序表的解析与实现

RadomRen

已于 2022-11-16 17:02:46 修改

阅读量270

点赞数

分类专栏：数据结构与算法文章标签：数据结构链表

于 2022-11-14 14:27:48 首次发布

本文链接：https://blog.csdn.net/qq_40979995/article/details/127845437

版权

数据结构与算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

下一节：【数据结构与算法从0到1 - C实现】二、链表的解析与实现

本节要探讨的顺序表是线性表一种。

1 线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串……
线性表在逻辑上是线性结构，也就是说连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链表结构的形式存储。

2 顺序表

2.1 概念及结构

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

顺序表一般分为静态顺序表和动态顺序表

静态顺序表：使用定长数组存储元素。
- 特点：如果满了，就不让再插入
- 缺点：给多大的空间合适？这个很难确定。N给小了不够用，N给大了浪费

#pragma once

#define N 1000
typedef int SLDataType;

//静态顺序表
typedef struct SeqList
{
    SLDataType arr[N];
    int size;//表示数组中存储了多少个数据
}SL;

// 接口函数
void SeqListInit(SL* ps);
void SeqListPushBack(SL* ps, SLDataType x);
void SeqListPopBack(SL* ps);
void SeqListPushFront(SL* ps, SLDataType x);
void SeqListPopFront(SL* ps);

动态顺序表：使用动态开辟的数组存储，解决了静态顺序表的缺点。

//动态顺序表
typedef struct SeqList
{
    SLDtaSLDataTypetType *arr;
    int size;//表示数组中存储了多少个数据
    int capacity;//数组实际能存储的数据的空间容量时多大，单位是元素个数
}SL;

// 接口函数
void SeqListInit(SL* ps);
void SeqListPushBack(SL* ps, SLDataType x);
void SeqListPopBack(SL* ps);
void SeqListPushFront(SL* ps, SLDataType x);
void SeqListPopFront(SL* ps);

2.2 顺序表的实现

在项目中创建SeqList.h头文件，设计动态顺序表结构体，即各种功能接口函数的声明。

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//动态顺序表
typedef struct SeqList
{
    SLDataType *arr;
    int size;//表示数组中存储了多少个数据
    int capacity;//数组实际能存储的数据的空间容量时多大，单位是元素个数
}SL;

// 接口函数
//打印顺序表
void SeqListPrint(SL* ps);
//初始化顺序表
void SeqListInit(SL* ps);
//销毁顺序表
void SeqListDestroy(SL* ps);
//顺序表尾插
void SeqListPushBack(SL* ps, SLDataType x);
//顺序表尾删
void SeqListPopBack(SL* ps);
//顺序表头插
void SeqListPushFront(SL* ps, SLDataType x);
//顺序表头删
void SeqListPopFront(SL* ps);
//查找指定值，找到了返回下标，没找到，返回-1
int SeqListFind(SL* ps, SLDataType x);
//在指定位置插入一个元素
int SeqListInsert(SL* ps, int pos, SLDataType x);
//删除pos位置的数据
void SeqListErase(SL* ps, int pos);

在文件SeqList.c中完成接口的具体实现：

#define _CRT_SECURE_NO_WARNINGS
#include "SeqList.h"

// 接口函数

//打印顺序表
void SeqListPrint(SL* ps)
{
    int i = 0;
    for (i = 0; i < ps->size; i++)
    {
        printf("%d ", ps->arr[i]);
    }
    printf("\n");
}

//初始化顺序表
void SeqListInit(SL* ps)
{
    ps->arr = NULL;
    ps->size = ps->capacity = 0;
}

//销毁顺序表
void SeqListDestroy(SL* ps)
{
    if (ps->arr != NULL)
    {
        free(ps->arr);
        ps->arr = NULL;
        ps->capacity = ps->size = 0;
    }
}

void SeqListCheckCapacity(SL* ps)
{
    if (ps->size == ps->capacity)
    {
        int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
        SLDataType* ptr = (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));
        if (ptr == NULL)
        {
            perror("realloc");
            exit(-1);
        }
        ps->arr = ptr;
        ps->capacity = newcapacity;
    }
}

//顺序表尾插
void SeqListPushBack(SL* ps, SLDataType x)
{
    SeqListCheckCapacity(ps);
    ps->arr[ps->size] = x;
    ps->size++;
}

//顺序表尾删
void SeqListPopBack(SL* ps)
{
    assert(ps->size > 0);//对于空数组不能进行尾删
    ps->size--;
}

//顺序表头插
void SeqListPushFront(SL* ps, SLDataType x)
{
    SeqListCheckCapacity(ps);
    int i = 0;
    for (i = ps->size; i > 0; i--)
    {
        ps->arr[i] = ps->arr[i - 1];
    }
    ps->arr[0] = x;
    ps->size++;
}

//顺序表头删
void SeqListPopFront(SL* ps)
{
    assert(ps->size > 0);
    int i = 0;
    for(i = 0; i < ps->size - 1; i++)
    {
        ps->arr[i] = ps->arr[i + 1];
    }
    ps->size--;
}

//查找指定值，找到了返回下标，没找到，返回-1
int SeqListFind(SL* ps, SLDataType x)
{
    int i = 0;
    for (i = 0; i < ps->size; i++)
    {
        if (ps->arr[i] == x)
        {
            return i;
        }
    }
    return -1;
}

//在指定位置插入一个元素
int SeqListInsert(SL* ps, int pos, SLDataType x)
{
    assert(ps->size >= pos);
    SeqListCheckCapacity(ps);
    int i = 0;
    for (i = ps->size - 1; i >= pos; i--)
    {
        ps->arr[i + 1] = ps->arr[i];
    }
    ps->arr[pos] = x;
    ps->size++;
}

//删除pos位置的数据
void SeqListErase(SL* ps, int pos)
{
    assert(ps->size > pos);
    int i = 0;
    for (i = pos; i < ps->size - 1; i++)
    {
        ps->arr[i] = ps->arr[i + 1];
    }
    ps->size--;
}

2.3 几个需要了解的点

内存碎片：计算机内存中存储的数据并不都是物理相连的，我们姑且称连在一起的数据为数据块，那么不同数据块之间是有大小不一的空闲内存的，而我们在编写程序向内存申请空间（malloc/realloc）时，就是申请的碎片式的内存空间中的一个空闲碎片
顺序表扩展的两种情况：（假设当前顺序表的大小为8，要扩展为16，即增加8）
- 顺序表扩展是默认向后扩展的，如果当前顺序表后8个单位内存刚好都是空闲的，那么就直接向后扩展，不需要重新申请一块16单位的内存来扩展顺序表，也就不需要复制当前的顺序表的数据到新的顺序表
- 如果当前顺序表后的8个单位内存已经有被占用，那么就需要重新在其他的位置申请16个单位的空间来存放扩展后的顺序表数据，那么就需要将当前顺序表的所有数据拷贝到新的顺序表中