数据结构之【顺序表的实现（详解）】

已于 2022-03-22 16:47:54 修改
阅读量4.9k 收藏 31
点赞数 13
分类专栏： 数据结构 文章标签： 数据结构
于 2021-10-06 17:45:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52433890/article/details/120438488
版权

文章目录

线性表

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

顺序表

本质就是一个数组，但它是动态增长的，并且要求里面存储的数据必须是从左往右连续的。
顺序表的物理结构和逻辑结构是一致的都是连续的。
顺序表存在着一定的缺陷：
1.0 动态增容存在性能消耗
2.0 需要头部插入数据，需要挪动数据

数据结构本质就是为了存储数据

顺序表的实现

在这里插入图片描述

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

  1. 静态顺序表：使用定长数组存储。
  2. 动态顺序表：使用动态开辟的数组存储。

静态的顺序表(相当于一个数组，数组长度固定的，存储有效个数据) 

#define N 100
struct Seqlist
{	
 int a[N];  //定向数组
 int size;  //有效数据的个数
};

动态的顺序表 

typedef int SeqDataType;
//方便可以让我们存储其他类型的数据（只需要将int改成其他类型即可）

typedef struct SeqList
{
	SeqDataType *a; //指向动态开辟的数组
	int size;       //记录有效数据
	int  capacity;  //容量空间大小
}SeqList,SEQ;

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

接口的实现（内存中管理数据的结构增删查改的接口）

通常有以下几种接口（接口其实就是实现功能的函数，数据结构以接口称之）

void SeqListInit(SeqList *pq);  //初始化
void SeqListDestory(SeqList *pq); //销毁
void SeqlistPushBack(SeqList *pq, SeqDataType x);  //尾插
void SeqlistPushFront(SeqList *pq, SeqDataType x); //头插
void SeqlistPopBack(SeqList *pq); //尾删
void SeqlistPopFront(SeqList *pq); //头删
void SeqListPrint(SeqList* pq); //打印
int SeqListFind(SeqList* pq, SeqDataType x); //查找

但是需要特别注意所传的参数例如以下几种

这几种就是典型的错误写法

//初始化与销毁
void SeqListInit(SeqList seq);
void SeqListDestory(SeqList seq);
//头插头删，尾插尾删
//void SeqlistPushBack(SEQ seq, SeqDataType x);  等价
void SeqlistPushBack( SeqList seq, SeqDataType x);
void SeqlistPushFront(SeqList seq, SeqDataType x);   
void SeqlistPopBack( SeqList seq);
void SeqlistPopFront(SeqList seq);

形参只是实参的拷贝，形参的改变不会影响实参，要改变就得传他们的地址，要用指针（类比交换两个数字传地址）

断言的好处

这里在实现接口中用到了断言assert
如果有人不小心调用这样一个接口

void TestSeqList1()
{
	SeqList* p = NULL;
	SeqListInit(p);
}

在这里插入图片描述
直接报错并且告诉我们第几行出错了

在这里插入图片描述
如果没有断言，编译器并没有报错，则很难发现我们的错误，你得去分析程序

初始化的实现

void TestSeqList1()
{
	SeqList s = {NULL,0,0};
	//SeqListInit(&s);
}

这种初始化只能在结构体定义的地方，但在顺序表中不建议这样初始化，我们采用接口的方式实现

void  SeqListInit(SeqList *pq)
{
  //assert(pq!=NULL);  两者等价，如果指针空报错
    assert(pq);
    pq->a = NULL;
    pq->capacity = pq->size = 0;
}

销毁的实现

void  SeqListDestory(SeqList *pq)
{
    assert(pq);
    free(pq->a);
    pq->a = NULL;
    pq->capacity = pq->size = 0;
}

动态增容的实现

如果我们想要实现动态增长，就必须写一个接口检测容量是否满了，满了就增容，没满就继续

void SeqCheckCapacity(SeqList*pq)
{
    if (pq->size == pq->capacity) //数据满了
    {
        int newcapacity = pq->capacity == 0 ? 4 : pq->capacity * 2;
        SeqDataType* newA = realloc(pq->a, sizeof(SeqDataType) * newcapacity);
        if (newA == NULL)
        {
            printf("realloc fail\n");
            exit(-1);
        }

        pq->a = newA;
        pq->capacity = newcapacity;
    }
}

尾插的实现

思路：先检查空间是否足够，接着，直接在尾部插入即可
在这里插入图片描述

void SeqlistPushBack(SeqList* pq, SeqDataType x)
{
    assert(pq);
    SeqCheckCapacity(pq);  //检测容量
    pq->a[pq->size] = x;
    pq->size++;

}

头插的实现

找到最后一个数据的下标，依次将数据向后挪动，最后再在开端插入你想插入的数据

图解：
在这里插入图片描述

代码的实现：

void SeqlistPushFront(SeqList* pq, SeqDataType x)
{
    assert(pq);
    SeqCheckCapacity(pq);
    int end = pq->size - 1;
    while (end >= 0)
    {
        pq->a[end + 1] = pq->a[end];
        end--;
    }
    pq->a[0] = x;
    pq->size++;   
}

尾删的实现

首先得有数据才能删除，将有效数据减减即可实现

void SeqlistPopBack(SeqList* pq)
{
    assert(pq);
    assert(pq->size>0);
    pq->size--;
}

头删的实现

将后一个数据覆盖前一个数据
图解：
在这里插入图片描述

void SeqlistPopFront(SeqList* pq)
{
    assert(pq);
    assert(pq->size > 0);
    int begin = 0;
    while (begin < pq->size-1)
    {
        pq->a[begin] = pq->a[begin + 1];
        begin++;
    }
    pq->size--;
}

查找的实现

思路：只需要将a里面的数据遍历一遍即可

int SeqListFind(SeqList* pq, SeqDataType x)
{
    assert(pq);
    for (int i = 0;i < pq->size;i++)
    {
        if (x==pq->a[i])
        {
            return x;
        }
    }

    return -1;
}

打印的实现

思路：很简单，遍历一遍数组即可（顺序表本质就是数组）

void SeqListPrint(SeqList* pq)
{
    assert(pq);
    for (int i = 0;i < pq->size;i++)
    {
        printf("%d ", pq->a[i]);
        
    }

    printf("\n");
}

到此顺序表的基本结构已经实现，下面实现几个其他有趣的接口

void SeqListInsert(SeqList* pq, int pos, SeqDataType x);   //在指定处插入数据
void SeqListErase(SeqList* pq, int pos);                   //在指定处删除数据
void SeqListModify(SeqList* pq, int pos, SeqDataType x);   //修改数据

指定处插入数据的实现

pos代表着插入的位置（必须大于0且小于等于最后一个数据的下标）
在任意一处插入数据，就要找到最后一个数据的下标，把pos后面的数据依次向后挪动，最后在pos处赋予你想插入的数据即可。

图解：
在这里插入图片描述

代码如下：

void SeqListInsert(SeqList* pq, int pos, SeqDataType x)
{
    assert(pq);
    assert(pos >= 0 && pos <= pq->size);  // 这里<=pq->size相当于尾插
    int end = pq->size-1;
    SeqCheckCapacity(pq);

    while (end >= pos)
    {
        pq->a[end + 1] = pq->a[end];
        end--;
    }

    pq->a[pos] = x;
    pq->size++;
}

指定处删除数据的实现

与插入数据相反，删除pos处的数据后，需要将pos后的数据依次向前挪动
图解：
在这里插入图片描述

代码如下：

void SeqListErase(SeqList* pq, int pos)
{
    assert(pq);
    assert(pos >= 0 && pos < pq->size );  //注意这里不能用 <=pq->size ，因为这个地方啥也没有
    while (pos <= pq->size - 1)
    {
        pq->a[pos] = pq->a[pos + 1];
        pos++;
    }
    pq->size--;

}

修改数据的实现

修改很简单，只要把pos处的数据换成你想要的数据即可

void SeqListModify(SeqList* pq, int pos, SeqDataType x)
{
    assert(pq);
    assert(pos >= 0 && pos <=  pq->size - 1);
    pq->a[pos] = x;
}

但是这里有人可能就会说为什么不用结构体的性质来修改数据而要多写一个接口?
因为如果超出数组的范围直接用结构体性质修改，编译器不会报错，而接口会直接检查出错误

    SeqListModify(&s, 0, -1);
	s.a[0] = -1;   //这种虽然是正确的，但不如接口好


	SeqListModify(&s, 15, -1);  //直接检查出错误
	s.a[15] = -1;           //编译器检查不出错误

到此一个完整的顺序表已经实现。

但是我们可以发现头插头删，尾插尾删都可以用SeqListInsert SeqListErase这两个接口来实现，这就是接口的复用。大大减少了我们的代码量，我们用两个接口实现了四个接口的工作。

void SeqlistPushBack(SeqList* pq, SeqDataType x)
{
    SeqListInsert(pq, pq->size, x);  //复用
}
void SeqlistPushFront(SeqList* pq, SeqDataType x)
{
    SeqListInsert(pq, 0, x);  //复用
}

void SeqlistPopBack(SeqList* pq)
{
    SeqListErase(pq, pq->size - 1);  //复用
}
void SeqlistPopFront(SeqList* pq)
{
    SeqListErase(pq,0); //复用
}

以下是完整代码

头文件部分

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

typedef int SeqDataType;
//方便可以让我们存储其他类型的数据（只需要将int改成其他类型即可）
typedef struct SeqList
{
	SeqDataType *a;
	int size;  //记录有效数据
	int  capacity;  //容量空间大小
}SeqList,SEQ;

void SeqListInit(SeqList *pq);
void SeqListDestory(SeqList *pq);
void SeqlistPushBack(SeqList *pq, SeqDataType x);
void SeqlistPushFront(SeqList *pq, SeqDataType x);
void SeqlistPopBack(SeqList *pq);
void SeqlistPopFront(SeqList *pq);
void SeqListPrint(SeqList* pq);
int SeqListFind(SeqList* pq, SeqDataType x);
void SeqListInsert(SeqList* pq, int pos, SeqDataType x);
void SeqListErase(SeqList* pq, int pos);
void SeqListModify(SeqList* pq, int pos, SeqDataType x);

源文件部分

#include "Seqlist.h"


void  SeqListInit(SeqList *pq)
{
  //assert(pq!=NULL);  两者等价，如果指针空报错
    assert(pq);
    pq->a = NULL;
    pq->capacity = pq->size = 0;
}

void  SeqListDestory(SeqList *pq)
{
    assert(pq);
    free(pq->a);
    pq->a = NULL;
    pq->capacity = pq->size = 0;
}

void SeqCheckCapacity(SeqList*pq)
{
    if (pq->size == pq->capacity) //数据满了
    {
        int newcapacity = pq->capacity == 0 ? 4 : pq->capacity * 2;
        SeqDataType* newA = realloc(pq->a, sizeof(SeqDataType) * newcapacity);
        if (newA == NULL)
        {
            printf("realloc fail\n");
            exit(-1);
        }

        pq->a = newA;
        pq->capacity = newcapacity;
    }
}

void SeqlistPushBack(SeqList* pq, SeqDataType x)
{
    assert(pq);
    //if (pq->size == pq->capacity) //数据满了
    //{
    //    int newcapacity = pq->capacity == 0 ? 4 : pq->capacity * 2;
    //    SeqDataType* newA = realloc(pq->a, sizeof(SeqDataType) * newcapacity);
    //    if (newA == NULL)
    //    {
    //        printf("realloc fail\n");
    //        exit(-1);
    //    }

    //    pq->a = newA;
    //    pq->capacity = newcapacity;
    //}   
    /*SeqCheckCapacity(pq);
    pq->a[pq->size] = x;
    pq->size++;*/

    SeqListInsert(pq, pq->size, x);  //复用

}
void SeqListPrint(SeqList* pq)
{
    assert(pq);
    for (int i = 0;i < pq->size;i++)
    {
        printf("%d ", pq->a[i]);
        
    }

    printf("\n");
}


void SeqlistPushFront(SeqList* pq, SeqDataType x)
{
    /*assert(pq);
    SeqCheckCapacity(pq);
    int end = pq->size - 1;
    while (end >= 0)
    {
        pq->a[end + 1] = pq->a[end];
        end--;
    }
    pq->a[0] = x;
    pq->size++;*/

    SeqListInsert(pq, 0, x);  //复用
}

void SeqlistPopBack(SeqList* pq)
{/*
    assert(pq);
    assert(pq->size>0);
    pq->size--;*/

    SeqListErase(pq, pq->size - 1);  //复用
}

void SeqlistPopFront(SeqList* pq)
{
   /* assert(pq);
    assert(pq->size > 0);
    int begin = 0;
    while (begin < pq->size-1)
    {
        pq->a[begin] = pq->a[begin + 1];
        begin++;
    }
    pq->size--;*/

    SeqListErase(pq,0);
}

int SeqListFind(SeqList* pq, SeqDataType x)
{
    assert(pq);
    for (int i = 0;i < pq->size;i++)
    {
        if (i==pq->a[i])
        {
            return i;
        }
    }

    return -1;
}

void SeqListInsert(SeqList* pq, int pos, SeqDataType x)
{
    assert(pq);
    assert(pos >= 0 && pos <= pq->size);  // 加一个等于相当于尾插
    int end = pq->size-1;
    SeqCheckCapacity(pq);

    while (end >= pos)
    {
        pq->a[end + 1] = pq->a[end];
        end--;
    }

    pq->a[pos] = x;
    pq->size++;
}


void SeqListErase(SeqList* pq, int pos)
{
    assert(pq);
    assert(pos >= 0 && pos < pq->size );
    while (pos <= pq->size - 1)
    {
        pq->a[pos] = pq->a[pos + 1];
        pos++;
    }
    pq->size--;

}

void SeqListModify(SeqList* pq, int pos, SeqDataType x)
{
    assert(pq);
    assert(pos >= 0 && pos <=  pq->size - 1);
    pq->a[pos] = x;
}

测试源文件部分

#include "Seqlist.h"



void TestSeqList1()
{
	SeqList s;
    SeqListInit(&s);
	SeqlistPushBack(&s, 1);
	SeqlistPushBack(&s, 2);
	SeqlistPushBack(&s, 3);
	SeqlistPushBack(&s, 4);
	SeqlistPushBack(&s, 5);
	SeqlistPushFront(&s, 0);
	SeqlistPushFront(&s, 0);
	SeqlistPushFront(&s, 0);
	SeqlistPushFront(&s, 0);
	SeqlistPushFront(&s, 0);
	SeqListPrint(&s);

	SeqlistPopBack(&s);
	SeqListPrint(&s);

	SeqlistPopFront(&s);
	SeqListPrint(&s);


    SeqListDestory(&s);
	
}
void TestSeqList2()
{
	SeqList s;
	SeqListInit(&s);
	SeqlistPushBack(&s, 1);
	SeqlistPushBack(&s, 2);
	SeqlistPushBack(&s, 3);
	SeqlistPushBack(&s, 4);
	SeqlistPushBack(&s, 5);
	SeqListPrint(&s);

	SeqListInsert(&s, 0, 3);
	SeqListPrint(&s);

	SeqListInsert(&s, 3, 35);
	SeqListPrint(&s);

	SeqListErase(&s, 3);
	SeqListPrint(&s);


	SeqListErase(&s, 5);
	SeqListPrint(&s);

	SeqListModify(&s, 0, -1);
	//s.a[0] = -1;   //这种虽然是正确的，但不如接口好
	SeqListPrint(&s);

	//SeqListModify(&s, 15, -1);  直接检查出错误
	//s.a[15] = -1;           编译器检查不出错误
	SeqListPrint(&s);
	
	SeqListDestory(&s);
}


int main()
{
	TestSeqList2();

	return 0;
}
数据结构——顺序表的实现
2301_78912147的博客
03-01 975
int size;//有效数据//capacity表示空间的容量}SL;注：typedef int SLDataType;这个语句中，将int类型重命名为SLDataType。通过这个typedef声明，可以在代码中使用SLDataType来代替int类型。在后续的代码中，将直接使用SLDataType来声明变量，而不必再使用int类型。这里命名了一个名为SeqList的顺序表，其中size表示此顺序表内的数据个数，capacity表示此顺序表所能容纳的数据个数。
数据结构 顺序表的实现（c语言版）
06-05
数据结构 顺序表的实现（c语言版）
【数据结构】顺序表的实现
jhj9201633的博客
09-16 731
顺序表的相关知识
顺序表的实现
weixin_53316121的博客
03-13 3022
目录 1.顺序表的概念 2.静态顺序表 分析： 3.动态顺序表 分析： 4.顺序表初始化 5.顺序表尾部操作 5.1尾插 空间检查函数实现 分析： 5.2尾删 分析： 6.顺序表的头部操作 6.1头插 分析： 6.2头删 分析： 7.固定位置操作 7.1固定位置插入 分析： 7.2固定位置删除 分析： 8.查找及打印 9.销毁顺序表 10.我的菜单及主函数 直接上代码： 1.顺序表的概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素...
数据结构顺序表的实现
weixin_62981548的博客
05-05 1322
文章目录 前言 一、顺序表是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 在我们生活当中我们所用的QQ，vx，它们所展示的界面（如群的名字，人的昵称）这些就是一组数据，这些数据都被保存在内存当中，界面是去内存当中将这些数据拿出来然后展示在这个界面上，所以它的底层可以用顺序表，或者链表来进行存储这些数据。 一、顺序表是什么？ 顺序表是在计算机内存中以数组的形式保存的线性表，顺序表是简单的一种线性结构，逻辑上相邻的数据在计算机内的存储位置也是相邻的，可...
C#数据结构之顺序表(SeqList)实例详解
09-03
顺序表是一种常见的线性数据结构，它在计算机科学中扮演着重要角色。在C#中，顺序表通常通过数组来实现，因为数组在内存中是连续分配的，这使得我们可以快速地访问任意位置的元素，实现所谓的“随机存取”。 顺序表...
基于Python实现顺序表的数据结构及其操作详解（包含详细的完整的程序和数据）
最新发布
10-08
本文详细介绍了顺序表作为一种常见的数据结构，在实际项目开发的应用案例，首先概述了线性表的具体实现方法：即利用连续地址进行线性的元素排列方式来完成顺序表的设计，并通过Python进行了具体的编码实现，讲解并...
数据结构实验报告1-顺序表实现简易的学生信息管理系统(C语言)
04-07
本实验通过C语言实现了基于顺序表的学生信息管理系统，涵盖了学生信息的基本操作，如添加、删除、查找等功能，对于理解数据结构的基础概念和实践操作具有很好的帮助作用。此外，本实验还提供了一个良好的平台来探索...
数据结构——顺序表（定义详解及建立顺序表与实现其操作）
Three__Curry的博客
01-26 8374
数据结构——顺序表（定义详解及创立顺序表并操作） 顺序表定义：顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 简单来说，顺序表存储有两个特点： 1.逻辑顺序和物理顺序一致。 2.数据元素之间的关系
数据结构顺序表实现
qq_43620838的博客
09-03 476
数据结构之顺序表欢迎使用Markdown编辑器顺序表基本算法实现 欢迎使用Markdown编辑器 最近在做一些考研题目，发现有些同学不会去实现数据结构的代码，我就将李春葆老师的数据结构第5版中的算法实现了一些基础的功能给同学们参考，大家可以在此基础上实现新的功能并验证，代码可以直接运行，编译器我用的是dev C++. 顺序表基本算法实现 //参考书籍：李春葆数据结构教程第5版 #include<iostream> #include<cstdlib> using namespace
顺序表
weixin_45309293的博客
10-19 213
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成据的增删查改。 顺序表一般可分为：静态顺序表（使用定长数组存储）；动态顺序表（使用动态开辟的数组存储）。 静态顺序表适用于确定知道需要存多少数据的场景. 静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用，相比之下动态顺序表更加灵活，根据需要动态分配内存大小。 动态顺序表的实现： public class MyArrayList { public int[] elem; publi
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值