线性表List

已于 2024-07-07 18:11:05 修改
阅读量352 收藏 10
点赞数 3
分类专栏： 数据结构 文章标签： list windows 数据结构
于 2024-07-07 00:40:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60751900/article/details/140236896
版权

一、线性表

定义：线性表是一种可以在任意位置进行插入和删除元素操作的、由n(n≥0)个相同类型元素组成的线性结构。其主要操作特点是可以在任意位置插入和删除一个数据元素。

线性表有顺序存储结构和链式存储结构存储。顺序存储的有顺序表，链式存储有单链表、循环单链表、双向循环链表。

二、顺序表

顺序表的存储结构：
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

（2.1）顺序表操作的实现

（2.1.1）定义顺序表结构体

//定义顺序表结构体
typedef struct {
	DataType list[MAXSIZE];	//DataType是抽象元素的数据类型：typedef int DataType
	int size;
}SeqList;

（2.1.2）初始化ListInitiate(L)

//初始化
void ListInitiate(SeqList *L)
{
	L->size=0;
}

（2.1.3）求当前元素个数ListLength(L)

int ListLength(SeqList L)
{
	return L.size;
}

（2.1.4)插入元素ListInsert（L,i,x）

//插入元素
int ListInsert(SeqList *L,int i,DataType x)
{
	int j;
	if(L->size>=MAXSIZE)
	{
		printf("List is full!\n");
		return 0; 
	}
	else if(i<0||i>L->size)
	{
		printf("Insert Param Error!\n");
		return 0;
	}
	else
	{
		for(j=L->size;j>i;j--)
		{
			L->list[j]=L->list[j-1];
		}
		L->list[i]=x;
		L->size++;
		return 1; 
	}
}

（2.1.5)删除元素ListDelete(L,i,x)

//删除元素
int ListDelete(SeqList *L,int i,DataType *x)
{
	int j;
	if(L->size<=0)
	{
		printf("List is null!\n");
		return 0;
	}
	else if(i<0||i>L->size-1)
	{
		printf("Param Error!\n");
		return 0;
	}
	else
	{
		*x=L->list[i];
		for(j=i+1;j<=L->size-1;j++)
		{
			L->list[j-1]=L->list[j];
		} 
		L->size--;
		return 1;
	}
}

（2.1.6）取元素ListGet(L,i,x)

int ListGet(SeqList L,int i ,DataType *x)
{
	if(i<0||i>L.size-1)
	{
		printf("Param Error!\n");
		return 0 ;
	}
	else
	{
		*x=L.list[i];
		return 1;
	}
}

完整的代码

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

//typedef int DataType;
#define DataType int
//using DataType=int
#define MAXSIZE 100 
typedef struct {
	DataType list[MAXSIZE];
	int size;
}SeqList;

void ListInitiate(SeqList *L)
{
	L->size=0;
}

int ListLength(SeqList L)
{
	return L.size;
}

int ListInsert(SeqList *L,int i,DataType x)
{
	int j;
	if(L->size>=MAXSIZE)
	{
		printf("List is full!\n");
		return 0; 
	}
	else if(i<0||i>L->size)
	{
		printf("Insert Param Error!\n");
		return 0;
	}
	else
	{
		for(j=L->size;j>i;j--)
		{
			L->list[j]=L->list[j-1];
		}
		L->list[i]=x;
		L->size++;
		return 1; 
	}
}

int ListDelete(SeqList *L,int i,DataType *x)
{
	int j;
	if(L->size<=0)
	{
		printf("List is null!\n");
		return 0;
	}
	else if(i<0||i>L->size-1)
	{
		printf("Param Error!\n");
		return 0;
	}
	else
	{
		*x=L->list[i];
		for(j=i+1;j<=L->size-1;j++)
		{
			L->list[j-1]=L->list[j];
		} 
		L->size--;
		return 1;
	}
} 

int ListGet(SeqList L,int i ,DataType *x)
{
	if(i<0||i>L.size-1)
	{
		printf("Param Error!\n");
		return 0 ;
	}
	else
	{
		*x=L.list[i];
		return 1;
	}
}

void main(int argc,int argv[])
{
	SeqList myList;
	int i,x;
	ListInitiate(&myList);
	for(i=0;i<10;i++)
	{
		ListInsert(&myList,i,i+1);
		//ListInsert(&myList,i,i++);//会报错 
	}
	ListDelete(&myList,4,&x);
	printf("%d\n",x);
	for(i=0;i<ListLength(myList);i++)
	{
		ListGet(myList,i,&x);
		printf("%d  ",x);
	}
}

//输出结果
5
1  2  3  4  6  7  8  9  10

三、链表

（3.1）单链表

（3.1.1）单链表操作的实现

（3.1.1.1）单链表的结点结构体设计

typedef struct Node{
	DataType data;
	struct Node *next;
}SLNode;

（3.1.1.2）单链表的初始化ListInitiate(SLNode **head)

//初始化 
void ListInitiate(SLNode **head){
	//申请头结点 ，由head指示其地址 
	*head=(SLNode*)malloc(sizeof(SLNode));
	//置结束结点为空 
	(*head)->next=NULL;
}

（3.1.1.3）求当前元素个数ListLength(SLNode *head)

//求当前元素个数 
int ListLength(SLNode *head){
	//p指向头结点 
	SLNode *p=head;		
	//size初始为0 
	int size=0;
	//循环计数 
	while(p->next!=NULL){
		p=p->next;
		size++;
	}
	return size;
}

（3.1.1.4）向链表中插入元素ListInsert(SLNode *head,int i,DataType x)

//插入元素
int ListInsert(SLNode *head,int i,DataType x){
	//在带头结点的单链表head的第i（0~size）个结点前插入一个存放元素x的结点
	//插入成功返回 1，插入失败返回0
	SLNode *p,*q;
	int j;
	p=head;
	j=-1;
	while(p->next!=NULL&&j<=i-1){
	//最终让指针p指向第i-1个结点
		p=p->next;
		j++; 
	} 
	if(j!=i-1){
		printf("插入元素位置参数错误！\n");
		return 0; 
	}
	q=(SLNode*)malloc(sizeof(SLNode));
	q->data=x;
	
	q->next=p->next;
	p->next=q;
	return 1; 
}

（3.1.1.5）删除ListDelete(SLNode *head,int i,DataType *x)

//删除
int ListDelete(SLNode *head,int i,DataType *x){
	//删除带头结点单链表head的第i(0~size-1)个结点
	//被删除的结点的数据域值由x带回，删除成功返回1，删除失败返回0
	SLNode *p,*s;
	int j;
	p=head;
	j=-1;
	while(p->next!=NULL&&p->next->next!=NULL&&j<i-1){
		p=p->next;
		j++;
	} 
	if(j!=i-1){
		printf("删除元素位置参数错误！\n");
		return 0;
	}
	s=p->next;
	*x=s->data;
	p->next=p->next->next;
	free(s);
	return 1;
}

（3.1.1.6）取元素ListGet(SLNode *head,int i, DataType *x)

//取元素 
int ListGet(SLNode *head,int i,DataType *x){
	SLNode *p;
	int j;
	
	p=head;
	j=-1;
	while(p->next!=NULL&&j<i){
		p=p->next;
		j++;
	}
	if(j!=i){
		printf("取元素位置参数错误！\n");
		return 0;
	}
	*x=p->data;
	return 1;
}

（3.1.1.7）撤销单链表Destroy(SLnode **head)

//撤销单链表
void Destroy(SLNode **head){
	SLNode *p,*p1;
	
	p=*head;
	while(p!=NULL){
		p1=p;
		p=p->next;
		free(p1);
		
	}
	*head=NULL;
}

完整代码

#include<stdio.h>
#include<malloc.h>
typedef int DataType;
typedef struct Node{
	DataType data;
	struct Node *next;
}SLNode;
//初始化 
void ListInitiate(SLNode **head){
	//申请头结点 ，由head指示其地址 
	*head=(SLNode*)malloc(sizeof(SLNode));
	//置结束结点为空 
	(*head)->next=NULL;
} 
//求当前元素个数 
int ListLength(SLNode *head){
	//p指向头结点 
	SLNode *p=head;		
	//size初始为0 
	int size=0;
	//循环计数 
	while(p->next!=NULL){
		p=p->next;
		size++;
	}
	return size;
} 
//插入元素
int ListInsert(SLNode *head,int i,DataType x){
	//在带头结点的单链表head的第i（0~size）个结点前插入一个存放元素x的结点
	//插入成功返回 1，插入失败返回0
	SLNode *p,*q;
	int j;
	p=head;
	j=-1;
	while(p->next!=NULL&&j<=i-1){
	//最终让指针p指向第i-1个结点
		p=p->next;
		j++; 
	} 
	if(j!=i-1){
		printf("插入元素位置参数错误！\n");
		return 0; 
	}
	q=(SLNode*)malloc(sizeof(SLNode));
	q->data=x;
	
	q->next=p->next;
	p->next=q;
	return 1; 
} 
//删除
int ListDelete(SLNode *head,int i,DataType *x){
	//删除带头结点单链表head的第i(0~size-1)个结点
	//被删除的结点的数据域值由x带回，删除成功返回1，删除失败返回0
	SLNode *p,*s;
	int j;
	p=head;
	j=-1;
	while(p->next!=NULL&&p->next->next!=NULL&&j<i-1){
		p=p->next;
		j++;
	} 
	if(j!=i-1){
		printf("删除元素位置参数错误！\n");
		return 0;
	}
	s=p->next;
	*x=s->data;
	p->next=p->next->next;
	free(s);
	return 1;
} 
//取元素 
int ListGet(SLNode *head,int i,DataType *x){
	SLNode *p;
	int j;
	
	p=head;
	j=-1;
	while(p->next!=NULL&&j<i){
		p=p->next;
		j++;
	}
	if(j!=i){
		printf("取元素位置参数错误！\n");
		return 0;
	}
	*x=p->data;
	return 1;
} 
//撤销单链表
void Destroy(SLNode **head){
	SLNode *p,*p1;
	
	p=*head;
	while(p!=NULL){
		p1=p;
		p=p->next;
		free(p1);
		
	}
	*head=NULL;
} 


int main(int argc, char *argv[]) {
	SLNode *head;
	int i,x;
	ListInitiate(&head);
	for(i=0;i<10;i++){
		ListInsert(head,i,i+1);
	}
	ListDelete(head,4,&x);
	for(i=0;i<ListLength(head);i++){
		ListGet(head,i,&x);
		printf("%d ",x);
	}
	Destroy(&head);
	return 0;
}


//输出结果
1 2 3 4 6 7 8 9 10
一学就会~
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序线性表 ListInsert 插入法实现代码
FMsun的专栏
03-26 2358
顺序线性表 ListInsert 插入法实现代码 // sdsdf.cpp : Defines the entry point for the console application. // #include #include #include #include //malloc(),realloc() #include //exit() #define LIST_INIT
线性表（List） 一
蜗牛先生的博客
07-07 1574
线性表的基本概念，描述了线性表的抽象数据类型，八种基本操作组合成复杂的操作，线性表的顺序存储结构，数组实现，随机存取结构，可以直接根据数组的下标确定该元素的物理位置，查询操作很简单，但是插入和删除操作较为复杂，要移动数据元素来完成对应操作，例如插入是需要将该位置后面的元素向后移动一位，删除时需要将该位置后面的元素向前移动一位，最后指出顺序存储的优缺点。
线性表 List
Janetcsdn0的博客
03-27 205
前言 线性表是一个抽象的数据结构，简单来说它的定义就是： 1. 有唯一的头和尾。 2. 中间的元素有唯一的前驱和后驱。 线性表的分类 队列 栈 链表 单链表和数组 单链表中由于储存了下一个数据的地址，所以适合频繁的插入删除数据。 数组只要知道任意一个数据的位置，就能很容易的读取其中的数据，所以使用不经常改变数据的顺序，进行的数据查询操作。 ...
ADT线性表List的定义和顺序表示及实现
m0_53360850的博客
03-06 1933
线性表是最常用且最简单的一种数据结构。简言之，一个线性表是n个数据元素的有限序列。至于每个数据元素的具体含义，在不同的情况下各不相同，它可以是一个数字或者一个符号，也可以是一列数字的集合(例如二维数组)，亦或是一串字符(例如字符串数组)，甚至其他更复杂的信息。例如，26个英文字母的字母表：（A，B，C，···，Z）是一个线性表，表中的数据元素是单个字母字符。又如：(6, 17, 28, 50, 92, 188)表中的数据元素是整数。在稍微复杂的线性表中，一个数据元素可以又若干个数据项。
线性表（List）
Phybelife的博客
11-15 868
线性表 线性表（list）：零个或多个数据元素的有限序列 存在唯一 一个“第一个”元素 存在唯一 一个“最后一个”元素 除第一个元素外，每个元素都有且只有一个前驱 除最后一个元素外，每个元素都有且只有一个后驱 ...
【数据结构】线性表--list（详解建议收藏）
DreamSun的博客
03-24 1747
零个或多个数据元素的有限序列。线性表的数据集合为{a1,a2,…,an}，假设每个元素的类型均为DataType。其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。在较复杂的线性表中，一个数据元素可以由若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表又称为文件顺序表可以顺序存取,也可以随机存取,链表只能从表头顺序存取元素。
《数据结构与算法基础》学习笔记——第二章 线性表 List
鱼_丸 的 博客
09-02 530
内容摘要：2.1线性表的定义和特点、2.2案例引入、2.3线性表的类型定义、2.4线性表的顺序表示和实现、2.5链表、2.6顺序表和链表的比较、2.7线性表的应用
边学边记——Java数据结构☞List（线性表）的介绍及自我实现
lil_ghost_的博客
10-12 599
站在数据结构的角度来看，List就是一个线性表，即n个具有相同类型元素的有限序列，在该序列可以执行增删改查以及变量等操作。
线性表
樱桃小丸子
05-02 45
线性表 List MakeEmpty():初始化一个空的线性表 ElementType FindKth(int k,List L):根据位序列K，返回相应元素 int FInd(ElementType X, List L): 在线性表L中查找X的第一次出现的位置 void Insert(ElementType X, int i,List L):在位序i前插入一个新的元素X int Length(List L):返回线性表L的长度 实现方式 数组 连续性 可以随机访问 稀疏数据—克服数组的缺点 链表
线性表（Linear List）原理及实现
张先生和他的金毛的博客
06-06 2910
目录 前言 一、线性表概述 二、顺序存储结构 三、链式存储结构 3.1 单链表 3.2 循环链表 3.3 双向链表 四、顺序和链式对比 前言 编程的本质就是对数据的处理。由于实际业务的数据之间存在复杂的逻辑关系，应用程序则需要分析这些数据的逻辑结构，并采用合适的物理结构来存储这些数据，并以此为基础对这些数据进行响应的操作。 从数据的逻辑结构来分，数据元素之前存在的关联关系被称为数据的逻辑结构。归纳起来，大致有一下4类基本的逻辑结构： 集合：数据元素之间只有“同属于一个...
线性表list_array的源代码(c语言)
12-10
#ifndef __LIST_H__ #define __LIST_H__ struct list; struct list *list_init(); void list_free(struct list *list); int list_isempty(struct list *list); void list_clear(struct list *list); int list_...
线性表的认识
06-14
例如，`ListInsert` 函数首先检查线性表是否已满，然后检查插入位置是否在合法范围内。如果满足条件，函数会将所有元素向后移动一位，为新元素腾出位置，最后更新表长并插入元素。 - **删除操作**： 相反，`...
C++通过类实现线性表
08-19
list.cpp 文件中实现了线性表类的成员函数，包括构造函数、析构函数、ClearList()、ListEmpty()、ListLength()、GetElem()、LocateElem()、PriorElem()、NextElem()、ListTraverse()、ListInsert() 和 ListDelete() ...
基础线性表
10-11
线性表（linear_list）是最常用且最简单的一种数据结构
work_线性表_
09-29
6. **C++实现**："work.cpp" 文件中的实现可能包括了类的设计，如定义一个名为“LinearList”的类，包含元素数组或链表、长度等成员变量，以及构造函数、析构函数、插入、删除、查找等成员方法。类的封装和面向对象...
LinkedList与链表
最新发布
m0_63272315的博客
07-08 326
当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此：java 集合中又引入了LinkedList，即链表结构。
Redis 中 hash 和 List 类型
2302_82270778的博客
07-05 776
介绍了hash类型和list类型
LRU Cache 双向链表以及STL list实现----面试常考
qq_40872103的博客
07-05 342
主要用了迭代器，对于初学者可能难以理解。可以看我的下一篇博客，详细阐述了迭代器设计思想！手写双向链表版本比较简单，在纸上画一画就能想通！
移动端Vant-list的二次封装，查询参数重置
weixin_45886797的博客
07-08 337
场景：在写项目需求的时候，移动端有用到vant-list组件。后续需求更新说要对列表数据页加搜索和筛选的功能。发现每次筛选完得在页面内手动重置一次查询参数。不方便，所以封了一层。
java线性表List存储
05-30
Java中的List是一个有序的集合，可以用于存储一组元素，包括基本类型和对象类型。Java中提供了多种实现List接口的类，包括ArrayList、LinkedList、Vector等。 其中，ArrayList是基于数组实现的，它内部维护了一个Object类型的数组，当需要添加元素时，数组会自动扩容。LinkedList则是基于链表实现的，每个元素都有一个指向前一个元素和后一个元素的指针。Vector也是基于数组实现的，它与ArrayList类似，但是支持多线程并发访问。 List接口提供了多种方法，可以对集合进行增、删、改、查等操作，例如add、remove、set、get、indexOf等。可以根据具体的需求选择相应的实现类。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值