数据结构——线性表的顺序存储（优缺点及代码实现:C语言）

已于 2024-04-29 14:52:56 修改
阅读量428 收藏 3
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 c语言 考研
于 2024-04-08 13:52:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuckfunk/article/details/137502317
版权

目录

顺序存储

逻辑位置和内存中的物理位置相同，除第一个外都有且仅有一个直接前驱，除最后一一个元素外有且仅有一个直接后继。

*优点：

  1. 存储密度大，
  2. 存储空间利用率高，
  3. 可以实现随机存取，即直接通过地址访问元素

缺点：

  1. 插入和删除操作需要在物理上移动大量元素，这可能会导致效率低下，
  2. 需要预先分配连续的存储空间，这可能导致存储空间的浪费

综上：这种结构适合于频繁查找和访问元素的场景

代码实现

定义顺序表

#define MaxSize 100
typedef int DataType;                 //将DataType 设为int型
typedef   struct
{
  DataType data[MaxSize ];            // int data[100]
  int length;                          //表示当前长度
}SeqList;                     //结构体的别名，引用Seqlist=引用上述结构体

初始化

void InitSeqList（SeqList *L）
{
  L->length=0;
}

求表长

int GetLength（SeqList *L）
{
   return L->length;
}

按位查找

时间复杂度 O(1)

int GetElem(SeqList  *L, int i, DataType *x)
{  /*获取顺序表中第i位中元素函数*/
   if (i<1 || i>L->Length)
        return  0;
   else
   { 
	  *x = L->data[i-1];  //返回元素值
      return  1;
   }
}

按值查找

时间复杂度O(n)
ASL(平均查找长度)： （n+1）/2

int Locate(SeqList *L,DataType x)
{
	int j=0;
	while(j<L->length && L->data[j]!=x)
		j++;
	if(j>=L->length)
		return 0;
	else
		return j+1;   /*返回的是元素位置*/
}

插入

  1. 判表满
  2. 判插入位置是否规范
  3. 后续元素循环后移
  4. 插入元素
  5. 表长+1

时间复杂度O(n)
ASL(平均查找长度)： n/2

int InsElem(SeqList *L,int i,DataType x) /*插入位置i 插入元素x*/
{
	int j;
	if(L->length >= MaxSize)  //判表满
	{
		printf("顺序表已满");
		return -1;
	}
	if(i<1 || i > L->length+1)
	{
		printf("插入位置错");
		return 0;
	}
	for (j=L->Length-1; j>=i-1; j--)     /*结点移动*/ 
        L->data[j+1]=L->data[j];
    L->data[i-1]=x;                      /*新元素插入*/
    L->Length++;                         /*顺序表长度增1 */
    return 1;                           /*插入成功，返回*/
}

删除

  1. 判表空
  2. 判删除位置
  3. 后续元素前移
  4. 表长-1

时间复杂度: O(n)
ASL: (n-1)/2

int DelElem (SeqList *L, int i,  DataType *x)  
{   /*在顺序表L中删除第i位元素函数*/
	int  j;
    if (L->Length==0)
    {  printf ("顺序表为空！");
       return 0;                 /*表空，不能删除*/
    }
    if (i<1 || i>L->Length)           /*检查是否空表及删除位置的合法性*/
    {  printf ("不存在第i个元素");
       return 0;
    }
    *x= L->data[i-1];                /*用指针变量*x返回删除的元素值*/
    for(j=i;j<L->Length;j++)         
       L->data[j-1]=L->data[j];		  /*结点依次前移*/
    L->Length--;                     /*顺序表长度减1*/
    return 1;                        /*删除成功，返回*/
}

完整示例(C语言实现)：

/*顺序表的各种操作程序*/
#include <stdio.h>
#include <stdlib.h> // 包含stdlib.h以使用malloc

#define  MAXLEN  100           /*定义常量MAXLEN为100表示存储空间总量*/
typedef  int  DataType;          /*定义ElemType为int类型*/ 
typedef  struct                  /*顺序表存储类型*/
{  /* DataType   data[MAXLEN];     存放线性表的数组*/
	DataType  *data;  
    int  Length;                 /*Length是顺序表的长度*/
}SeqList;

void  InitList( SeqList  *L )
{   /*初始化顺序表L函数*/ 
 	L->Length=0;                     /*初始化顺序表为空*/
}

void CreateList(SeqList *L,int n)
{  /*建立顺序表并输入多个元素函数*/
   int i;
   L->data = (DataType *)malloc(sizeof(DataType) * n);
   if(!L->data)
	   puts("error");
   printf("请输入%d个整数：",n);

   for(i=0;i<n;i++)
       scanf("%d",&L->data[i]);
   L->Length=i;                       /*设线性表的长度为i*/
}

int GetElem(SeqList  *L, int i, DataType *x)
{  /*获取顺序表中第i位中元素函数*/
   if (i<1 || i>L->Length)
        return  0;
   else
   { 
	  *x = L->data[i-1];
      return  1;
   }
}

int Locate(SeqList *L, DataType x)
{   /*在顺序表L中定位元素x函数*/
	int i=0;
    while(i<L-> Length && L->data[i]!= x)
        i++;
    if (i>=L->Length) 
       return 0;
    else
		return i+1;                     /*返回的是元素位置*/
}

int  InsElem(SeqList *L, int i, DataType x)
{   /*在顺序表L中在第i位中插入新元素x函数*/
	int j;
    if (L->Length>=MAXLEN)
    {   printf ("顺序表已满！"); 
        return -1;                      /*表满，不能插入*/
    }
    if (i<1 || i>L->Length+1)             /*检查给定的插入位置的正确性*/
    {   printf("插入位置出错！");
        return 0; 
    }
    if (i == L->Length+1)
    {   L->data[i-1]=x;
        L->Length++;
        return  1;             /*插入的位置为表尾，则不需移动直接插入即可*/ 
    }
    for (j=L->Length-1; j>=i-1; j--)     /*结点移动*/ 
        L->data[j+1]=L->data[j];
    L->data[i-1]=x;                      /*新元素插入*/
    L->Length++;                         /*顺序表长度增1 */
    return 1;                           /*插入成功，返回*/
}

int DelElem (SeqList *L, int i,  DataType *x)  
{   /*在顺序表L中删除第i位元素函数*/
	int  j;
    if (L->Length==0)
    {  printf ("顺序表为空！");
       return 0;                 /*表空，不能删除*/
    }
    if (i<1 || i>L->Length)           /*检查是否空表及删除位置的合法性*/
    {  printf ("不存在第i个元素");
       return 0;
    }
    *x= L->data[i-1];                /*用指针变量*x返回删除的元素值*/
    for(j=i;j<L->Length;j++)         /*结点移动*/
       L->data[j-1]=L->data[j];
    L->Length--;                     /*顺序表长度减1*/
    return 1;                        /*删除成功，返回*/
}

void DispList(SeqList *L)
{   /*显示输出顺序表L的每个元素函数*/
	int i;
    for(i=0;i< L->Length;i++)
       printf("%5d ", L->data[i]);
}

void  Menu()                                    
{   /*显示菜单子函数*/
	printf("\n                  顺序表的各种操作");
    printf("\n==================================================");  
    printf("\n|              1——建立顺序表                   |");
    printf("\n|              2——插入元素                     |");
    printf("\n|              3——删除元素                     |");
    printf("\n|              4——按位置查找元素               |");
    printf("\n|              5——按元素值查找其在表中位置     |");
    printf("\n|              6——求顺序表的长度               |");
    printf("\n|              0——返回                         |");
    printf("\n=================================================="); 
    printf("\n请输入菜单号（0-6）:"); 	
}

main()
{
   SeqList L;
   DataType x;
   int n,i,loc;
   char  ch1,ch2,a;
   ch1='y';
   while(ch1=='y'||ch1=='Y') 
   {  Menu();
   	  scanf("%c",&ch2);
   	  getchar();
   	  switch(ch2)
   	  {
   	  	 case  '1':   	  	 
             InitList( &L );
             printf("请输入建立线性表的个数：");
             scanf("%d",&n);
             CreateList(&L,n);
             printf("建立的线性表为:");
             DispList(&L);
             break;
         case  '2':
             printf("请输入要插入的位置：");
             scanf("%d",&i);
             printf("请输入要插入的元素值：");
             scanf("%d",&x);
             if(InsElem(&L,i,x))
             {
                printf("已成功在第%d的位置上插入%d，插入后的线性表为：\n",i,x);
                DispList(&L);
             }
             else
                printf("输入插入的参数错误!");
             break;
         case  '3':
             printf("请输入要删除元素的位置：");
             scanf("%d",&i);
             if(DelElem (&L, i,  &x))
             {
                printf("已成功在第%d的位置上删除%d，删除后的线性表为：\n",i,x);
                DispList(&L);
             }
             else
                printf("\n输入删除的参数错误!");
             break;
         case  '4':
             printf("请输入要查看表中元素位置(从1开始)：");
             scanf("%d",&i);
             if(GetElem(&L, i, &x))
                printf("当前线性表第%d个元素的值为：%d",i,x);
             else
                printf("输入的位置错误!");
             break;
         case  '5':
             printf("请输入要查找的元素值为：");
             scanf("%d",&x);
             loc=Locate(&L, x);
             if(loc)
                printf("查找元素值为%d的位置为：%d",x,loc);
             else
                printf("该表中无此元素!");
             break;
         case  '6':
             printf("当前线性表的长度为：%d",L.Length);
             break;
         case  '0':
             ch1='n';break;
         default:
             printf("输入有误，请输入0-4进行选择！");
   	  }
   	  if(ch2!='0')
   	  {   printf("\n按回车键继续，按任意键返回主菜单！\n");
   	  	  a=getchar();
   	  	  if(a!='\xA')
   	  	  {
   	  	  	 getchar();ch1='n';
   	  	  }
   	  }
   }
}

结语

敬请各位大佬批评指正 日后也会持续更新数据结构相关内容，互相学习😊😊
芙蓉街烤猪蹄儿
关注
专栏目录
数据结构——线性表
weixin_52008431的博客
04-04 893
线性表 线性表概述 线性表（List）：零个或多个数据元素的有限序列 注意： （1）线性表是一个序列——>元素之间是有顺序的 （2）若元素存在多个，则第一个元素无前驱，最后一个元素无后继 （3）每个元素有且只有一个前驱和一个后继 （4）线性表的有限的 线性表的长度 线性表元素的个数n（n>=0)定义为线性表的长度 注意：当n=0时，定义为空表 线性结构举例： 一年的12个月份（只算一年，不算这一年过了是新的一年）就可以看成一个线性表，以一月为起始，12月为结尾，首先12
数据结构——线性表（c）
asheng_1202的博客
10-14 904
数据结构——线性表（c） 文章目录一、线性表的定义与特点二、线性表的顺序表示和实现1.顺序表2.实现三、线性表的链式表示和实现1.线性链表2.循环链表3.双向链表f 一、线性表的定义与特点 线性表：一个线性表是具有n个数据元素的有限序列。 线性表中元素之间的关系：线性关系 线性表的长度：线性表中元素的个数n（n>=0）,n=0时，称为空表。 位序：ai\displaystyle a_iai​是第 i 个元素，称 i 为数据元素ai\displaystyle a_iai​在线性表中的位序。
线性表的顺序存储代码
11-23
这是我亲手写的代码，经过了编译运行，完全正确，可以为学习数据结构的线性表的顺序存储实现的学生看看。。
数据结构与算法-总结线性表顺序存储结构的优缺点
raylee2007的专栏
10-12 307
这一章节主要总结线性表顺序存储结构的优缺点。 在总结之前，我们来讨论一下线性表顺序存储结构的执行方法的时间复杂度： 存储、读取：O（1） 插入、删除：O（n） 优点： 1.无需为表中的逻辑关系增加额外的存储空间 2.可以快速存取表中对象 缺点： 1.插入和删除需要移动大量的对象 2.存储设备的碎片化 3.当线性表过大的时候，很难确定长度 ...
小白眼中的线性表（中篇）---线性表的顺序存储及基础操作代码实现
qq_37068780的博客
08-12 346
线性表的顺序存储结构及基础操作代码实现 一、 在《小白眼中的线性表（上篇）》中我们介绍了线性表的基础，及线性表的顺序存储基础知识，今天我们来看看如何用代码实现线性表的基本操作。还记得线性表的基本操作吗？ 接下来，我们将一一实现。注意哦，这里的实现，是以顺序存储结构为基础进行实现的，在明天我们还会介绍线性表的链式存储结构，欢迎大家捧场。 二、代码实现 线性表的初始化 #includ...
C语言实现线性表—顺序存储（顺序表）
最新发布
m0_71494851的博客
11-24 312
线性表的顺序存储步骤(仅代表个人看法)： 1.根据需要实现的操作，确定创建的结构体是什么样的，里面需不需要记录长度等信息 2.然后逐个实现操作
线性表顺序存储结构代码
qq_37957854的博客
12-31 813
#include <stdio.h> #define MAXSIZE 1000 typedef struct LNode *List; typedef struct { int a[19]; int b[20]; }ElementType; struct LNode{ ElementType Data[MAXSIZE]; int last; }; struct ...
数据结构之线性表（三）——顺序存储结构（1定义与特点） 定义线性表节点的结构.pdf
04-18
数据结构之线性表（三）——顺序存储结构（1定义与特点） 数据结构之线性表的顺序存储结构是指将逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构。这种存储结构的特点是地址连续，即知道某个元素的...
线性表顺序存储完整代码
qq_45044542的博客
10-03 2131
** 线性表顺序存储完整代码 ** //顺序存储 #include<stdio.h> #include<stdlib.h> #include<malloc.h> #define MAXSIZE 20 #define ERROR -1 typedef int Position; typedef int ElementType; typedef struct LNo...
线性表的顺序存储C语言代码
04-11
线性表是数据结构中比较基础的一种，这里用C语言实现了它的顺序存储
数据结构之线性表的顺序存储结构介绍及源代码
06-20
哈工大软件设计与开发实践课程代码，自己编写的比较粗糙简单，仅供参考
数据结构代码--线性表的顺序存储结构
weixin_43218601的博客
03-15 1030
/** * 线性表的顺序存储结构 */ public class SqList { int[] data; int length; public SqList(int leng, int length) { this.data = new int[leng]; this.length = length; } public int[] getData() { return data; } pub.
第二课——线性表的顺序存储（代码版）
weixin_43622467的博客
10-25 303
#include <stdio.h> #include <malloc.h> //包含了malloc函数 #include <stdlib.h> //包含了exit函数 #include <bool.h> //包含了bool函数 //定义了一个数据类型，该数据类型的名字叫做struct Arr, 该数据类型含有三个成员，分别是pBase, le...
数据结构线性表的顺序存储(纯代码)
qq_43572325的博客
06-15 435
数据结构线性表的顺序存储(纯代码) #include<stdio.h> #include<stdlib.h> #define maxsize 100 typedef int datatype; //存储结构 typedef struct{ datatype data[maxsize]; int n; }Seqlist; //创建线性表 void ...
【数据结构复习|核心代码】线性表的顺序存储
qq_42286669的博客
05-01 245
顺序存储定义：把逻辑上相邻的数据元素存储在物理上也相邻的存储单元中的数据结构。 简单来说，就是：逻辑上相邻，物理上也相邻。 顺序存储方法：用一组地址连续的存储单元依次存储线性线性表的元素，可通过数组来实现。 地址计算：设首元素a1的存放地址为LOC（a1），称为首地址，设每个元素占用存储空间（地址长度）为L字节，则地址计算公式：LOC（a i）= LOC（a 1）+（i-1）*L。 结构定...
线性表实现顺序存储结构的完整代码(C语言)
热门推荐
weixin_45637300的博客
03-30 1万+
代码如下: #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAXSIZE 20 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType;...
线性表的顺序存储结构的结构代码
weixin_45275659的博客
08-18 402
线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。 #define MAXSIZE 20 typedef int ElemType; typedef struct { ElemType data [MAXSIZE]; int length; }SqList;
线性表的顺序存储c语言代码,【C语言实现】顺序存储结构线性表
weixin_42298760的博客
05-24 320
#include#include#include#define INISIZE 10#define Status int#define ERROR 0#define PASS 1#define OVERFLOW -1//抽象数据类型线性表--顺序存储结构表示typedef int ADT;typedef struct {ADT* Element;int Length;int Listsize;}L...
数据结构线性表顺序存储源代码
weixin_47357088的博客
04-13 1137
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 源代码如下 1读入数据 代码如下（示例）： #include<stdio.h> #include<stdlib.h> #define Maxsize 100 typedef struct SqList { //存储结构 int data[Maxsize]; int length; }SqList; int Init_List(SqList &L) //初始化线性表 { L = (SqList)mall.
线性探测法优缺点与C语言实现——数据结构入门
- 顺序存储的线性表在C语言中常用数组实现，优点在于快速访问任意节点，支持插入和删除操作。然而，它的缺点也很明显，包括插入和删除操作复杂（可能需要移动大量元素）、空间浪费（固定大小限制）以及难以动态扩展...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值