顺序表的定义，初始化，加工（插入，删除，修改），引用（遍历，查找）,实例

最新推荐文章于 2023-11-20 12:25:48 发布
最新推荐文章于 2023-11-20 12:25:48 发布
阅读量1.7k 收藏 12
点赞数 4
分类专栏： C语言 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/frozen122/article/details/115417351
版权

线性表

抽象数据类型定义形式：

ADT List
{
数据对象 ；
数据关系;
基本操作；{初始化操作；销毁操作；引用类型操作；加工型操作；}
}

顺序储存

用一组连续的储存空间存放线性表中的各个数据元素，用位置相邻的储存空间关系白哦是线性表中数据元素的前驱和后继关系；

建立

定义时需包括：

  1. 一片连续的存储空间（数组或数组的起始位置）
  2. 容量（数组的大小，防止溢出）
  3. 长度（已存入数据个数）
//方一，直接定义数组    常用！需掌握！
#define MAX 100
typedef struct
{
    ElemType data[MAX];    //ElemType表示数据元素的抽象类型
    int listSize;
    int length;
}SqList;    //顺序表，结构体数据类型

//方二：定义数组起始地址的指针变量    更灵活！难理解一些学有余力建议使用！
typedef struct
{
    ElemType *data;
    int size;
    int length;
} SqList;

当你的顺序表存储的东西比较复杂，比如一组学生数据时，你可以这样做：

//先定义学生数据的数据类型
typedef struct
{
    char name[20];    //姓名
    char no[20];    //学号
    float score;    //成绩
}STD;
//再定义顺序表数据类型
// typedef STD ElemType;    有时候会将STD重命名为ElemType
typedef struct
{
    STD *data;    //这里的STD就是上面的ElemType对应的实际数据类型
    int listsize;
    int length;
}SqList;    //现在顺序表里的一个元素就是一个指向STD类型的指针变量

使用：

SqList L, *p = &L;    //p指向L

在访问结构体变量的成员时，有两种访问方式：结构体变量访问（L.data[i]），和指针变量访问（p->data[i]）
顺序表建立好后，我们对其进行操作就是在通过参数进行数据的传递，同样两种情况

  • 调用函数只读不影响实参
  • 调用函数改变实参

简单来说，就是前者只是分享数据，后者是需要修改main方法中的数据(比如我们现在要做的），后者通过指针传递实参地址来实现

初始化

//使用int定义函数，返回函数值可以提高操作的健壮性
int initList(SqList *L, int max)
{
   L->data = (STD* )malloc(max *sizeof(STD));
   //不改变数组大小的话
   //L->data = (STD* )malloc(sizeof(STD));
   //直接new一个数组也是可以的
   //L->data = new int[MAX];
   if(L->data == NULL)(printf("空间申请失败！");return 0;}
   L->listSize = max;
   L->length = 0;
   return 1;
}
//或者
int initList(SqList &L, int max)
{
   L.data = (STD* )malloc(max *sizeof(STD));
   ...
}

调用时：

int main()
{
    SqList L;
    if(initList(&L,10))printf("创建成功！");    //创建一个大小为10的顺序表
    else{
    printf("创建失败！");
    exit(0);    //创建失败就退出程序，不必要但是个好习惯
    }
}
//第二种
if(initList(L,10)printf("创建成功！");

这两种方法各有什么优缺点呢，还需要组织一下语言，争取下次更新的时候补上OTZ
初始化就是申请了一片连续的存储空间，给成员变量赋予了初值
理论上来说new 和malloc 都是可以的，但是一般都用malloc (要配合free()使用），同样下次更新分析

关于malloc函数的参考资料：
[1]https://www.cnblogs.com/Commence/p/5785912.html.
[2]https://blog.csdn.net/qq_27871973.

加工型操作

改变线性表本身
初始条件是线性表已存在

  • 置空
  • 插入
  • 删除
  • 修改
置空
插入

将新数据插入指定位置，线性表长度加一

int insertList(SqList *L,int i,ElemType e)    //传递数据的指针，插入位置，插入数据
{
    int k;
    if(i<1||i>L->length + 1) {printf("插入位置异常!\n");return 0;}    //判读插入位置是否合理
    if(L->length>=L->ListSize){printf("数据溢出！\n");return 0;}    //判断顺序表是否已满
    for(k = L->length;k>=i;k--)
        L->data[k] = L->data[k-1];    //将插入位置后的数据全部后移一位
    L->data[i-1] = x;    //插入数据
    L->length = L->length + 1;    //表长加一
    return 1;
}

排序插入，不指定位置

int insertList(SqList *L, ElemType e) {
	if (L->length == ListSize) 
	{
	    printf("数据溢出，无法操作！\n");
	    return 0;
	}    //判断是否已满
	else if(L->length== 0)
	{
		L->data[0] = e;    //第一个数据，不需要排序
		L->length++;
		return 1;
	}
	else {
		int j;
		j = p->length;
		p->elem[j] = e;
		while(j > 0 && p->elem[j-1].year > e.year){
			p->elem[j] = p->elem[j-1];
			p->elem[j-1] = e;
			j--;	
		}
		p->length++;
		return 1;                                                                                                                                                                                      
	}
}
删除

删除指定位置的数据

int deleteList(SqList *L,int i,ElemType e)    //传递数据的指针，插入位置，插入数据
{
    ...    //判断语句
    *e = L->data[i-1];
    for(int k = i;k<L->length;k++)
        L->data[k -1] = L->data[k];    //将删除位置前的数据全部前移一位，最后一位i = L->length-1删除不需要前移
    L->length = L->length - 1;    //表长减一
    return 1;
}

调用：

int main()
{ 
    ElemType e;
    if(deleteList(&L,2,&e))
       printf("删除的数据为:%s%s%d\n");
// 如果不需要打印，去掉参数e就好
    else
        printf("删除失败！");
}
修改

将指定位置的数据修改为新数据

int reviseList(SqList *L,int i,ElemType *e)
{
    ...   //判断
    L.data[i-1] = e;
    return 1;
}

调用：

int main()
{
    ElemType e = {"张三","007",99};   //不同的赋值方式
    e.name = "张三";
    strcpy(e.no,"007");    //这样给字符串赋值也可以
    e.score = 99;
    if(reviseList(&L,2,&x)) printf("修改成功！");
    else printf("修改失败！");
}

引用型操作

只使用线性表中的元素，但并没有改变线性表本身
初始条件是线性表已存在

  • 判断是否为空
  • 求长度
  • 按位读取
  • 按值求位
  • 遍历（输出）
判断是否为空&&求长度
L->length
按位获取
int getList(SqList *L,int i,ElemType *e)
{
    ...  //判断
    *e = L->data[i-1];
    return 1;
}

调用：

int main()
{
    ElemType e;
    if(getList(&L,2,&e))
       printf("获取的数据是%s %s %d\n",e.name,e.no,e.score);
    else ...
}
定位
int locationList(SqList *L,char *x)
{
    int i;
    if(L->length == 0) {printf("没有数据！");return 0;} 
    for(int i = 0;i<L->length;i++)
        if(strcmp(L->data[i].name,x) == 0)
            return i + 1;
    return 0;
}

调用：

int main()
{
    ElemType e;
    if(locationList(&L,e.name) != 0)
        printf("在第%d个位置上找到！",locationList(&L,e.name));
    else ...
}
遍历(打印）
int print(SqList *L）
{
    for(int i = 0;i<L->length;i++)
        printf("%s\n",L->data[i].name);
    return 1;
}
  • 时间复杂度
    T(n) = O(1)，没有涉及循环：初始化，修改、获取
    T(n) = O(n)：插入、删除、定位、遍历

实例

设计顺序表，实现中国超算发展历史知识的管理，功能可以包括：创建，查找，增加，删除，修改，遍历输出，初始化，等。

#include<stdio.h>
#include<string.h>
#define MAXSIZE 100
typedef struct
{
	char name[20];
	char people[30];
	int year;
}BOOK;
typedef BOOK ElemType;
typedef struct
{
	ElemType* elem;
	int length;
	int listsize;
}SqList;
//初始化创建一个空表
void InitList(SqList *p)
{
	p->elem = new ElemType[MAXSIZE];
	p->length = 0;
	p->listsize = 100;
}
//排序插入 
int  ListInsert(SqList *p, ElemType e) {
	if (p->length == MAXSIZE)
		return 0;
	else if (p->length == 0) {
		p->elem[0] = e;
		p->length++;
		return 1;
	}
	else {
		int j;
		j = p->length;
		p->elem[j] = e;
		while(j > 0 && p->elem[j-1].year > e.year){
			p->elem[j] = p->elem[j-1];
			p->elem[j-1] = e;
			j--;	
		}
		p->length++;
		return 1;
	}
}
//任意位置删除
int ListDelete(SqList *p, int n) {
	if ((n < 0) || (n >= p->length))
		return 0;
	else {
		for (int j = n; j <= p->length - 1; j++)
			p->elem[j - 1] = p->elem[j];
		p->length--;
		return 1;
	}
}
//定位
int locationList(SqList *p,char *x)
{
    int i;
    if(p->length == 0) {printf("没有数据！");return 0;} 
    for(int i = 0;i<p->length;i++)
        if(strcmp(p->elem[i].name,x) == 0)
            return i + 1;
    return 0;
}
//按指定位置查找
int LocateElem(SqList* p, int i, ElemType *e) {
	if (i < 0 || i > p->length)
		return 0;
	else
    {
    	*e = p->elem[i-1];
		return 1;	
    }
}
//修改某条记录
int ReviseElem(SqList* p,int i,ElemType e)
{
	if (i < 0 || i >= p->length)
		return 0;
	else
	{
		p->elem[i] = e;
		return 1;
	}
}
//输出顺序表
void PrintList(SqList *p) {
	for (int i = 0; i < p->length; i++) 
		printf("姓名 : %s 开发人员 : %s 年份 : %d\n", p->elem[i].name, p->elem[i].people, p->elem[i].year);
}
//创建
int creatList(SqList* L)
{
	int n = 0;
	ElemType e;
	char yn;
	InitList(L);
	do
	{
		printf("请输入超算发展历史数据,用空格隔开：");
		scanf("%s %s %d", &e.name, &e.people, &e.year);
		getchar();
		ListInsert(L, e);
		n++;
		printf("是否继续输入？Y/N");
		yn = getchar();
	} while (yn == 'Y' || yn == 'y');
}
int main()
{
	printf("欢迎使用超算历史发展知识管理系统！\n");
	SqList L;
	creatList(&L);
	/*可用以下代码代替creat函数
	InitList(&L);
	printf("初始化成功！\n");
	printf("请输入三条超算发展历史：\n");
	for (int i = 0; i < 3; i++) {
		ElemType x;
		scanf("%s %s %d", &x.name, &x.people, &x.year);
		ListInsert(&L, x);
	}
	printf("输入成功！\n");
	*/
	PrintList(&L);
	printf("\n请选择你要执行的操作\n");
	printf("1 : 插入新数据\n");
	printf("2 : 删除数据\n");
	printf("3 : 根据超算名称查找\n");
	printf("4 : 查询某条记录\n");	
	printf("5 : 记录某条修改\n");

	int op;
	while (scanf("%d", &op) && op) {
		if (op == 1) {
			printf("请输入数据：\n");
			ElemType x;
    		scanf("%s %s %d", &x.name, &x.people, &x.year);
			if(ListInsert(&L, x))
				printf("插入成功！\n");
			PrintList(&L);
		}
		else if (op == 2) {
			printf("请输入想要删除第几条数据：");
			int j;
			scanf("%d",&j); 
			if(ListDelete(&L, j-1))
				printf("删除成功！\n");
			PrintList(&L);
		}
		else if (op == 3) {
			printf("请输入超算名称：\n");
			char name[20];
            scanf("%s", &name);
			if (locationList(&L, name) != 0)
				printf("该超算是第%d条记录！\n", locationList(&L,name));
			else
				printf("没有查询到这台超算！\n");
		}
		else if(op == 4){
			printf("请输入想要查询的位置：\n");
		    int num;
		    ElemType e;
			scanf("%d",&num);
			if(LocateElem(&L,num,&e) != 0)
        		printf("姓名 : %s 开发人员 : %s 年份 : %d\n", e.name, e.people, e.year);
			else
				printf("位置有误！\n");
		} 
		else if (op == 5) {
			printf("请输入需要修改第几条数据：\n");
			int local;
			scanf("%d",&local); 
			printf("请输入准备修改的数据：\n");
			ElemType x;
			scanf("%s %s %d", &x.name, &x.people, &x.year);
			if(ReviseElem(&L,local-1, x))
				printf("插入成功！\n");
			PrintList(&L);
		}
		else
				printf("查询失败！\n");
		
	}
}```
frozen122
关注
  • 4
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++顺序表基本操作 初始化 插入 删除 输出 销毁
03-17
顺序表的基本操作主要包括初始化、插入、删除、输出和销毁，这些都是理解C++数据结构和算法的基础。 1. **初始化**： 初始化一个顺序表通常涉及到创建一个动态数组并设置其大小。在C++中，我们可以使用`new`运算符...
C++实现图的邻接表存储和广度优先遍历实例分析
09-03
它首先读取顶点数和边数，然后依次读取每个顶点的值，并为每个顶点初始化其边列表为空。接着，对于每一条边，创建两个`EdgeNode`，分别插入到两个端点的边列表中。这里采用了类似头插法的方式，将新创建的边节点插入...
【数据结构（C语言）】顺序表的定义，实现初始化、创建、插入、增、删、改、查等基本操作（详细）
DuFengYa的博客
05-21 1万+
顺序表是在计算机内内存中以数组的形式保存的线性表， 线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、 使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中， 即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系， 采用顺式存储结构的线性表通常称为顺序表。 相对于链式存储结构而言，顺式存储结构显得更为简单。 顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 顺序表的基本运算有： 初始化 查找 插入 删除 输.
数据结构例题代码及其讲解-顺序表
knighthood2001
08-26 693
数据结构例题代码及其讲解-顺序表
抽象数据类型线性表（顺序表）的定义构造
AKK188888881的博客
07-09 1843
抽象数据类型线性表（顺序表）的定义构造 main.cpp #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASALBE -1 #define OVERFLOW -2 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType int
(c语言)顺序表的定义、初始化、增删改查 超详细~ 超好懂~
西CSun
06-01 1728
顺序表的静态分配(看成数组) 顺序表的动态分配 初始化 用malloc函数在内存中开辟一整空间 增加动态数组的长度 1.让*p和L.data指向同一位置(记住起始地址) 2.开辟一块新空间L.data 3.*p赋值给新开辟的L.data 4.free§释放原来旧的空间 插入操作 注意位序是从1开始的，数组下标是从0开始的 删除操作
数据结构与算法编程题4
qq_41735476的博客
11-20 88
删除线性表中值在s与t之间的元素（s
C语言实现静态顺序表的实例详解
08-29
顺序表支持多种操作，例如插入、删除、查找等。下面我们将介绍一些常见的顺序表操作。 1. 插入操作 插入操作是指在顺序表中添加一个新的元素。我们可以使用以下代码来实现插入操作： ```c void PushBack(pSeqList ...
JavaScript 双向链表操作实例分析【创建、增加、查找、删除等】
10-15
在实际应用中，双向链表常用于实现高效的插入、删除和遍历操作，特别是在需要频繁进行这些操作且顺序访问不是主要需求的场景。通过理解并熟练运用这些操作，开发者可以更高效地处理动态数据集合。
顺序表的基本操作.zip
最新发布
03-16
这个压缩包“顺序表的基本操作.zip”可能包含了关于顺序表的各种基本操作的详细资料，包括创建、插入、删除、查找以及对顺序表的其他常见操作。让我们深入探讨一下顺序表及其基本操作。 顺序表是线性数据结构的一种...
数据结构的线性表-顺序表插入、删除、查找实现功能
Danlinglili的博客
09-20 5813
数据结构 | 线性表 |学习分享| 单链表输出、插入、删除、遍历操作
线性表的实现（C语言完整代码+详细注释版）【数据结构】
小賀のBlog
08-01 2万+
完整且健壮的两种线性表的表示代码 线性表的顺序表示： // // main.c // SQList // // Created by Eason on 2020/7/28. // Copyright © 2020 Eason. All rights reserved. // #include<stdio.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define maxsize 100 typedef i
顺序表的基本操作： 定义，初始化，取值，查询，插入，删除操作
weixin_73872850的博客
09-13 71
/动态数组：创建了一个Student类型的动态数组并将其指针赋值给L.elem。里面的i与j的取值搞不懂。为啥不是L.length-1。int GetElem(Sqlist L,int i,Student &e )//取值即用e返回元素的值即用&
顺序表的创建，插入，删除，查找，取值，输出，退出功能实现
naozibuok的博客
04-01 1436
顺序表的创建，插入，删除，查找，取值，输出，退出功能实现。
线性表的基本操作，顺序表的插入、删除、查找、遍历等基本操作，线性表的倒置操作的实现（c++ 数据结构 实验一） 20201115
weixin_44790790的博客
11-15 2808
运行结果如下： 一、要求 1.建立一个含有若干元素的顺序表 2.对已建立的顺序表进行插入、删除、按位查找、按值查找、遍历输出等操作 3.实现线性表的倒置 二、代码
顺序表的插入、删除以及查找等基本操作的实现（C语言）
热门推荐
派拉斯兔子的博客
04-21 2万+
一、顺序表（顺序存储） （一）、定义（如何用代码实现） 线性表是具有相同数据类型的n（n >= 0）个数据元素的有限序列。 顺序表：用顺序存储的方式实现线性表顺序存储。 把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。 C语言 sizeof(ElemType)：知道一个数据元素大小。ElemType 就是你的顺序表中存放的数据元素类型. 基本操作的实现 1. 顺序表的实现——静态分配
数据结构（C语言）—线性表中顺序表的基本操作以及实现
BaoITcore的博客
11-03 3736
一、什么叫做顺序表，顺序表通过什么来体现？ 顺序表就是两个在逻辑上相邻的元素，在顺序表中他们的位置也相同。字母A-Z就是一个顺序表。顺序表是由一个个的元素组成的，并且这些元素的类型是相同的。 我们可以用一个数组来表示这个顺序表，也就是在创建顺序表之前，我们可以给它一个固定大小的空间。 我们也可以用一个指针来表示不确定空间大小的数组，需要多大我们就申请多大的空间。 二、结构体的运用 在我看来，数据结构的意思就是我们在拿到一个问题时，可以定...
C语言学习笔记
qq_35732321的博客
04-12 374
#include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 typedef struct { int data[MAXSIZE]; int length; }SqList; SqList *InitList(SqList *L); // 初始化 void DestroyList(SqList *L); // 销毁 void ClearList(SqList *L)
数据结构与算法课程笔记（二）
Motseturtle的博客
11-01 9297
实验二 线性表的顺序存储结构实现一、实验目的二、实验内容 一、实验目的 熟悉VC++工程项目的文件组织方式； 线性表中数据元素间的关系及其顺序存储结构方式表示方法； 顺序表的操作方法与接口函数的设计方法。 二、实验内容 1． 利用本次实验提供的文件（listinarray.h、listinarray.cpp、content.cpp），创建并观察项目，回答下面问题。 文件说明： 【listinarray.h】顺序表的类型声明和操作接口声明 【listinarray.cpp】顺序表的操作实现代码 【con
顺序表操作详解：插入、删除、查找与合并
`InitList`函数初始化顺序表，`ListInsert`实现插入操作，`ListTraverse`用于遍历顺序表并调用用户指定的输出函数，如`output`函数，显示元素值。`input`函数用于从输入读取元素，`equals`函数用于比较两个元素是否...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值