数据结构之顺序表

已于 2024-01-26 14:48:24 修改
阅读量1.7k 收藏 1
点赞数 2
分类专栏： 数据结构与算法 文章标签： c语言 数据结构
于 2022-10-29 23:35:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Thewei666/article/details/127588064
版权

顺序表就是数组，但是在数组的基础上，它要求数据是从头开始并且连续存储的，不能间隔存储

静态顺序表

静态顺序表中如果数据满了则不让继续存储，因此我们无法确定该给它多少内存

其头文件：

#pragma once
#define N 1000
typedef int SLDataType

//静态顺序表 
typedef struct SeqList
{
	SLDataType a[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 int SLDataType;

//动态顺序表 
typedef struct SeqList
{
	SLDataType* a;
	int size;//表示数组中存储了多少个数据 
	int capacity;//表示数组时间能存储多少个数据 
 }SL;

各接口函数实现

顺序表初始化：

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

顺序表销毁：

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

顺序表检查内存空间是否足够：

void SeqListCheckCapacity(SL* ps)//检查内存空间是否足够
{
    if (ps->size == ps->capacity)//没有空间或者空间不足的情况下
    {
        int newcapacity = ps->capacity = 0 ? 4 : ps->capacity * 2;
        SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));//没有空间则申请内存空间，有则进行扩容
        if (tmp == NULL)
        {
            printf("realloc fail \n");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity = newcapacity;
    }
}

顺序表尾插：

尾插时需考虑三种情况：

  1. 整个顺序表没有空间
  2. 空间不够，需要扩容
  3. 空间足够，直接插入数据
void SeqListPushBack(SL* ps, SLDataType x)//顺序表尾插
{
    SeqListCheckCapacity(ps);
    ps->a[ps->size] = x;
    ps->size++;
}

顺序表尾插：

void SeqListPopBack(SL* ps)//数据表尾删
{
    if(ps->size > 0)
    {
        ps->size--;
    }
}

顺序表头插：

void SeqListPushFront(SL* ps, SLDataType x)//顺序表头插
{
    SeqListCheckCapacity(ps);
    int end = ps->size - 1;
    while(end >= 0)//数据向后挪动
    {
        ps->a[end+1] = ps->a[end];
        --end;
    }
    ps->a[0] = x;
    ps->size++;
}

顺序表头删：

void SeqListPopFront(SL* ps)
{
    assert(ps->size > 0);//存储数据不能为零，否则会终止
    int begin = 1;
    while(begin < ps->size)//数据向前挪动
    {
        ps->a[begin-1] = ps->a[begin];
        begin++;
    }
    ps->size--;
}

使用assert方法时需导入assert库

顺序表中查找数据位置（找到了返回数据位置下标，没有找到则返回-1）：

int SeqListFind(SL* ps,SLDataType x)
{
    for(int i = 0;i < ps->size;i++)
    {
        if(ps->a[i] == x)
        {
            return i;
        }
    }
    return -1;
}

顺序表指定位置插入：

void SeqListInsert(SL* ps,int pos,SLDataType x)
{
    if(pos > ps->size || pos < 0)
    {
        printf("pos invalid \n")
        return ;
    }
    
    //assert(pos <= ps->size && pos => 0)//暴力方法不得输入非法pos
    SeqListCheckCapcaity(ps);
    int end = ps->size-1;
    while(end >= pos)
    {
        ps->a[end+1] = ps->a[end];
        end--;
    }
    ps->a[pos] = x;
    ps->size++;
}

顺序表指定位置删除：

void SeqListErase(SL* ps,int pos)
{
    if(pos > ps->size || pos < 0)
    {
        printf("pos invalid \n")
        return ;
    }
    int begin = pos + 1;
    while(begin < ps->size)
    {
        ps->a[begin-1] = ps->a[begin];
        begin++;
    }
    ps->size--;
}

通过顺序表的指定位置删除我们可以改善顺序表的头删

动态顺序表（完整版）

头文件：

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLDataType;

//动态顺序表
typedef struct SeqList
{
	SLDataType* a;
	int size;//表示数组中存储了多少个数据
	int capacity;//表示数组时间能存储多少个数据
}SL;

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

int SeqListFind(SL* ps,SLDataType x);
void SeqListInsert(SL* ps,int pos,SLDataType x);
void SeqListErase(SL* ps,int pos);

接口函数以及结构体的.c文件：

#include "SeqList.h"

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

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

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

void SeqListCheckCapacity(SL* ps)//检查内存空间是否足够
{
    if (ps->size == ps->capacity)//没有空间或者空间不足的情况下
    {
        int newcapacity = ps->capacity = 0 ? 4 : ps->capacity * 2;
        SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));//没有空间则申请内存空间，有则进行扩容
        if (tmp == NULL)
        {
            printf("realloc fail \n");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity = newcapacity;
    }
}

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

void SeqListPopBack(SL* ps)//数据表尾删
{
    if(ps->size > 0)
    {
        ps->size--;
    }
}

void SeqListPushFront(SL* ps, SLDataType x)//顺序表头插
{
    SeqListCheckCapacity(ps);
    int end = ps->size - 1;
    while(end >= 0)//数据向后挪动
    {
        ps->a[end+1] = ps->a[end];
        --end;
    }
    ps->a[0] = x;
    ps->size++;
}

void SeqListPopFront(SL* ps)
{
    assert(ps->size > 0);//存储数据不能为零，否则会终止
    int begin = 1;
    while(begin < ps->size)//数据向前挪动
    {
        ps->a[begin-1] = ps->a[begin];
        begin++;
    }
    ps->size--;
}

int SeqListFind(SL* ps,SLDataType x)
{
    for(int i = 0;i < ps->size;i++)
    {
        if(ps->a[i] == x)
        {
            return i;
        }
    }
    return -1;
}

void SeqListInsert(SL* ps,int pos,SLDataType x)
{
    if(pos > ps->size || pos < 0)
    {
        printf("pos invalid \n");
        return ;
    }

    //assert(pos <= ps->size && pos => 0)//暴力方法不得输入非法pos
    SeqListCheckCapacity(ps);
    int end = ps->size-1;
    while(end >= pos)
    {
        ps->a[end+1] = ps->a[end];
        end--;
    }
    ps->a[pos] = x;
    ps->size++;
}

void SeqListErase(SL* ps,int pos)
{
    if(pos > ps->size || pos < 0)
    {
        printf("pos invalid \n");
        return ;
    }
    int begin = pos + 1;
    while(begin < ps->size)
    {
        ps->a[begin-1] = ps->a[begin];
        begin++;
    }
    ps->size--;
}

测试顺序表的.c文件：

#include "SeqList.h"

void TestSeqList1() {
	SL s1;
	SeqListInit(&s1);
	SeqListPushBack(&s1, 1);
	SeqListPushBack(&s1, 2);
	SeqListPushBack(&s1, 3);
	SeqListPopBack(&s1);
	SeqListPopBack(&s1);

	SeqListPrint(&s1);
	SeqListDestory(&s1);
}

void TestSeqList2()
{
    SL s1;
	SeqListInit(&s1);
    SeqListPushBack(&s1,1);
    SeqListPushBack(&s1,2);
    SeqListPushBack(&s1,3);
    SeqListPushBack(&s1,4);
    SeqListPushBack(&s1,5);

    SeqListPushFront(&s1,10);
    SeqListPushFront(&s1,20);
    SeqListPushFront(&s1,30);
    SeqListPushFront(&s1,40);
    SeqListPushFront(&s1,50);
    SeqListPushFront(&s1,60);
    SeqListPushFront(&s1,70);

    SeqListPopFront(&s1);
    SeqListPopFront(&s1);
    SeqListPopFront(&s1);
    SeqListPopFront(&s1);

    SeqListPrint(&s1);
	SeqListDestory(&s1);
}

void TestSeqList3()
{
    SL s1;
	SeqListInit(&s1);
    SeqListPushBack(&s1,1);
    SeqListPushBack(&s1,2);
    SeqListPushBack(&s1,3);
    SeqListPushBack(&s1,4);
    SeqListPushBack(&s1,5);

    SeqListInsert(&s1,1,10);
    SeqListInsert(&s1,2,200);
    SeqListErase(&s1,5);
    SeqListErase(&s1,2);

    SeqListPrint(&s1);

    int pos = SeqListFind(&s1,5);
    printf("%d",pos);

	SeqListDestory(&s1);
}


int main() {
    TestSeqList1();
    TestSeqList2();
	TestSeqList3();

	return 0;
}

顺序表缺点：

  1. 空间不够时需要扩容，而扩容需要付出代价。扩容时当内存后面有足够空间时会原地扩容，没有足够空间时会重新找一块内存申请空间
  2. 为了避免频繁扩容，当内存空间满了时，基本都是扩容两倍，这就可能导致内存一定空间的浪费
  3. 顺序表要求从头开始连续存储数据，因此我们在头部或中间插入删除数据时就需要挪动数据，效率不高

顺序表优点：

  1. 存储密度大
  2. 可随机存取某一元素

魏大橙
关注
专栏目录
顺序表结构(就是动态数组)
qq_51491080的博客
12-03 233
/* 线性结构：顺序表 数组结构 顺序表有两个特性： 1.顺序表的内存 2.顺序表的索引（就像数组下标），顺序表就是根据索引去做事情 */ #include<stdio.h> #include<stdlib.h> struct linerList { char*element; /存储char类型的数据为例，因为索引是整形的/ int arrayLengt; /顺序表的最大长度/ int listSize; /顺序表当前的元素个数/ }; /创建一个顺
数据结构之顺序表（数组）
epleone的专栏
03-12 1377
本学期带数据结构，那就索性复习下C语言，把所写的代码记录下来 题目如下： 1. 两个有序的顺序表A和B，包含的元素个数分别为m与n，设计一算法实现B=AUB 2. 设计一个算法从顺序表中删除重复的元素，并使剩余元素间的相对次序保持不变 3. 设计一高效算法删除顺序表中值为x的所有元素 代码如下： 写惯了JAVA，Python，要注意C语言没法动态构建数组，必须先申请数组空间，其次声明要写
顺序表与数组的区别和联系
李昊的博客
04-06 5065
来源链接：https://www.cnblogs.com/longshiyVip/p/5232250.html 顺序表是在计算机内存中以数组的形式保存的线性表。 顺序表是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表，顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。线性表采用指针链接的方式存储就称之为链表。 线性表是从逻辑结构的...
数据结构-顺序表（2）详细解析
最新发布
2301_80157824的博客
09-26 176
上期我们讲了顺序表的尾插、头插、尾删、头删，接下来我们继续讲关于顺序表的其他操作，来彻底把顺序表讲明白。在最后我会把整个顺序表的代码都附上。我们自己在写代码的时候，需要注意for循环中i的结束条件，我建议大家可以自己画个图，再带入条件自然就出来了。test.c: 这个就是测试你写的功能对不对，可以自己测试各个函数的功能！这些大概就是所有顺序表的内容，下面我把整个顺序表的代码放到下面。接下来我会继续更新数据结构的知识，下一个专题就到链表啦！3.10 在顺序表中删除某个位置的数据。
数组和顺序表的区别
叫我小秦就好了的博客
05-07 9326
看到很多人直接将顺序表等同于数组，认为顺序表就是数组，但这样做容易造成概念混淆。下面就对这两个概念进行解释，帮助大家进行区分。
顺序表 (数组) 详解
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
10-16 2532
1. 顺序表的`位序`和`元素下标`是两个不同概念，位序从1开始，元素下标从0开始。位置为i的元素，它的下标为i-1 2.当i的值在[1，L->length+1]区间内时，都是有效的插入位置。1表示待插入元素取代第1个元素，L->length+1表示插入到最后一个元素的后面。<font color=blue>记得，i是位序，不是下标，它的有效插入位置是(i < 1 || i > L->length + 1)，不要写成(i < 0 || i > L->length)，i为下标时才是这种写法。
【数据结构之顺序表】附源码【收藏】
哆啦A梦_PJYA的博客
10-29 1588
文章目录????引言1️⃣静态顺序表静态 VS 动态2️⃣动态顺序表????实现接口目录????初始化????打印数据????空间销毁????尾部插入????尾部删除????头部插入????头部删除????任意位置插入????任意位置删除????查找数据????查找某数据并插入数据????查找某数据并将其删除????头部插入（调用任意位置插入接口实现）????尾部插入 （调用任意位置插入接口实现）????头部删除（调用任意位置删除接口实现）????尾部删除（调用任意位置删除接口实现）????自动扩容????
超详细讲解数据结构之顺序表
bit_xwg的博客
03-15 2866
超详细讲解数据结构之顺序表顺序表概念静态顺序表动态顺序表动态循序表的概念及构造动态顺序表接口的实现检查顺序表的容量尾插与尾删头插与头删 顺序表 概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。 顺序表一般分为静态顺序表和动态顺序表。 静态顺序表 静态顺序表是使用定长数组存储元素。 简单静态顺序表结构体的初始化： #define N 7 typedef int SLDataType; struct Seqlist { SLDataTy
数据结构——顺序表
qq_58330935的博客
11-04 254
顺序表
顺序表 结构体的动态数组实现
08-19
顺序表 结构体的动态数组c++指针实现 typedef struct{/*动态顺序表*/ int last,max;/*尾元下标和预留表长*/ DataType *data;/*动态数组的基址*/ }SeqList;
c语言 顺序表：结构体+数组
talouo的博客
08-05 3554
#include <stdlib.h> #include <stdio.h> #include <string.h> #define ListSize 100 //最大允许长度 //#define LISTINCREMENT 10 //线性表存储空间的分配增量 //typedef int ListData; struct SquList { int dat...
顺序表与数组
热门推荐
Wayne_y的博客
04-28 1万+
顺序表是在计算机内存中以数组的形式保存的线性表。顺序表是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表，顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。线性表采用指针链接的方式存储就称之为链表。线性表是从逻辑结构的角度来说的，除了头和尾之外，它的每一个元素都只有一个前驱元素和一个后驱元素。各种队列（单向、双向、循环队列），栈等都...
顺序表与数组的关系
weixin_42649639的博客
01-14 7843
顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 从顺序表的定义上可以看出，顺序表就是数组。二者只是不同领域中的称呼。 顺序表是数据结构中的专有名词，而数组是在C语言或者其它编程语言中的一种数据类型。 可以说，数组是顺序表在实际编程...
【数据结构】顺序表的结构体和建立
m0_63036258的博客
12-10 3978
数据结构的基本内容
C语言数据结构结构体数组（顺序表）的增删改查软件代码
m0_45384394的博客
02-01 1557
/* 关于数组顺序表的初始化增删改 */ #include <stdlib.h> #include <stdio.h> #include <iostream> using namespace std; #define ERROR 0 #define OK 1 #define overflow -2 #define MAXSIZE 50 #define ADDS...
数据结构学习——数组与顺序表
菜鸡上路的博客
06-06 1500
首先明确定义： 数组：一段固定物理地址上储存的一串连续的元素，他们是同数据类型。 顺序表：线性表中内存地址连续存放，并且除了首位元素之外，每个元素均有一个前驱与一个后继。 二者在定义上基本相同，可以这么理解： 顺序表是在计算机内存中以数组的形式保存的线性表。 数组在本质上是一个更大的概念，其中的包括线性表中的顺序结构即顺序表。
【C数据结构】什么是顺序表？一文迅速搞懂！
weixin_43607192的博客
10-23 1024
顺序表的创建与常见接口函数一、什么是线性表？二、如何创建一个顺序表？三、接口函数容量审查函数：初始化函数：销毁函数：尾插函数:尾删函数：头插函数：头删函数：寻找函数:指定下标插入：删除指定下标元素：小结 线性表是数据结构中最常见的 一种数据存储方式。线性表分为顺序表与链表。本文将会从简单的顺序表开始，一点一点揭开C数据结构的神秘面纱。 一、什么是线性表？ 线性表，顾名思义，其会呈现出一种线性进行存储。这和我们所学过的数组的概念很像，回顾一下数组的基本知识：数组的各个元素连续存放在内存中，并按照数组类型为每一
数据结构之顺序表操作详解-以C语言为例
"顺序表操作的典型例子-C语言数据结构课件【比较清晰】" 在计算机科学中，数据结构是编程的重要组成部分，它涉及到如何有效地组织和存储数据，以便进行高效的检索、插入和删除等操作。这个课件特别关注的是顺序表的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

魏大橙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值