数据结构-静态链表

已于 2022-05-03 15:37:50 修改
阅读量879 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 c语言
于 2022-05-03 15:24:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/usiehheu/article/details/124553845
版权

文章目录

一、静态链表定义

静态链表的数据储存在一块指定的内存空间中，数据元素在这块内存空间中随机储存。换句话说，静态链表是用数组来实现链式储存的，方便一些没有指针类型的高级语言来使用链式结构。

数据存放到数组中时，给每个数据元素都配备一个整形变量，该变量用于指明各个元素的直接后继元素所在数组中的位置下标，如图 :
在这里插入图片描述

二、操作

1.定义节点

typedef struct StaticLinkNode
{
	char data;
	int next; //存的是下一个数据在数组中的位置下标 
}*NodePtr;

typedef struct  StaticLinkList
{
	NodePtr nodes; //nodes是存储节点 
	int *used; //used表示空间使用情况，0表示空闲，1表示占用 
}*ListPtr;

2.初始化

a[0]存的是头节点，可以不赋值。刚开始没有元素，所以令a[0]->next=-1。
在这里插入图片描述

ListPtr initList()
{
	ListPtr tempPtr=(ListPtr)malloc(sizeof(struct StaticLinkList));
	
	tempPtr->nodes=(NodePtr)malloc(sizeof(struct StaticLinkNode)*MAX_SIZE);
	tempPtr->used=(int*)malloc(sizeof(int)*MAX_SIZE);
	
	tempPtr->nodes[0].data='\0';
	tempPtr->nodes[0].next=-1; //-1表示NULL 
	
	tempPtr->used[0]=1;
	int i;
	for(i=0;i<MAX_SIZE;i++)
	{
		tempPtr->used[i]=0;
	}
	
	return tempPtr;
}

3.打印链表

void printList(ListPtr pListPtr)
{
	int p=0;
	while(p!=-1)
	{
		printf("%c",pListPtr->nodes[p].data);
		p=pListPtr->nodes[p].next;
	}
	printf("\r\n");
}

4.插入

这里是尾插，当每插入一个元素时，需要更改前一个节点的next,使他们链接起来。
在这里插入图片描述

void insertElement(ListPtr pListPtr,char pchar,int pos)
{
	int p,q,i;
	
	p=0;
	if(pos<0)
	{
		printf("插入位置不合法！\n");
		return; 
	}
	for(i=0;i<pos;i++)
	{
		p=pListPtr->nodes[p].next;
		if(p==-1)
		{
			printf("该位置超出列表范围！\n");
			return;
		}
	}
	
	for(i=1;i<MAX_SIZE;i++)
	{
		if(pListPtr->used[i]==0)
		{
			printf("位置（%d）已被分配空间！",i);
			pListPtr->used[i]=1;
			q=i;
			break;
		}
	
	}
	if(i==MAX_SIZE)
	{
		printf("空间已耗尽，无法插入!\n");
		return;
	}
	
	pListPtr->nodes[q].data=pchar;
	
	pListPtr->nodes[q].next=pListPtr->nodes[p].next;
	pListPtr->nodes[p].next=q;
	printf("插入成功！\n");
}

5.删除

void deleteElement(ListPtr pListPtr,char pchar)
{
	int p,q;
	p=0;
	while((pListPtr->nodes[p].next!=-1)&&(pListPtr->nodes[pListPtr->nodes[p].next].data!=pchar))
	{
		p=pListPtr->nodes[p].next; 
	} 
	if(pListPtr->nodes[p].next==-1)
	{
		printf("元素(%c)不存在于链表中！\n",pchar);
		return;
	}
	q=pListPtr->nodes[p].next;
	pListPtr->nodes[p].next=pListPtr->nodes[q].next;
	pListPtr->used[q]=0;
}

6.定位

void locateElement(ListPtr pListPtr,char pchar)
{
	int p,q,cnt=0;
	p=0;
	while((pListPtr->nodes[p].next!=-1) && (pListPtr->nodes[p].data!=pchar))
	{
		p=pListPtr->nodes[p].next;
		cnt++;
	}
	if(pListPtr->nodes[p].next==-1)
	{
		printf("元素(%c)不存在于链表中！\n",pchar);
		return;
	}
	printf("元素（%c）的位置：%d\n",pchar,cnt);
}

7.清空

void clear_list(ListPtr tempList)
{
	int q;
	for(q=0;tempList->nodes[q].next==0;q=tempList->nodes[q].next)
	{
		tempList->nodes[q].next=tempList->nodes[1].next;
		tempList->nodes[1].next=tempList->nodes[0].next;
		tempList->nodes[0].next=0; 
	}
	
	printf("完成清空！");
}

8.测试

void insert_delete_locate_clear_list_text()
{
	ListPtr tempList=initList();
	printList(tempList);
	
	
	insertElement(tempList, 'H', 0);
	insertElement(tempList, 'e', 1);
	insertElement(tempList, 'l', 2);
	insertElement(tempList, 'l', 3);
	insertElement(tempList, 'o', 4);
	
	insertElement(tempList, 'M', 6);
	insertElement(tempList, 'o', 4);
	printList(tempList);
	
	printf("Delete 'e'.\r\n");
	deleteElement(tempList, 'e');
	printList(tempList);
	printf("Delete 'a'.\r\n");
	deleteElement(tempList, 'a');
	printList(tempList);
	printf("Delete 'o'.\r\n");
	deleteElement(tempList, 'o');
	printList(tempList);
	insertElement(tempList, 'o', 2);
	printList(tempList);
	
	locateElement(tempList,'8');
	locateElement(tempList,'H');
	
	clear_list(tempList);
}

三.总代码

#include<stdio.h>
#include<malloc.h>
#define MAX_SIZE 6

typedef struct StaticLinkNode
{
	char data;
	int next; //存的是下一个数据在数组中的位置下标 
}*NodePtr;

typedef struct  StaticLinkList
{
	NodePtr nodes; //nodes是存储节点 
	int *used; //used表示空间使用情况，0表示空闲，1表示占用 
}*ListPtr;

ListPtr initList()
{
	ListPtr tempPtr=(ListPtr)malloc(sizeof(struct StaticLinkList));
	
	tempPtr->nodes=(NodePtr)malloc(sizeof(struct StaticLinkNode)*MAX_SIZE);
	tempPtr->used=(int*)malloc(sizeof(int)*MAX_SIZE);
	
	tempPtr->nodes[0].data='\0';
	tempPtr->nodes[0].next=-1; //-1表示NULL 
	
	tempPtr->used[0]=1;
	int i;
	for(i=0;i<MAX_SIZE;i++)
	{
		tempPtr->used[i]=0;
	}
	
	return tempPtr;
}

void printList(ListPtr pListPtr)
{
	int p=0;
	while(p!=-1)
	{
		printf("%c",pListPtr->nodes[p].data);
		p=pListPtr->nodes[p].next;
	}
	printf("\r\n");
}

void insertElement(ListPtr pListPtr,char pchar,int pos)
{
	int p,q,i;
	
	p=0;
	if(pos<0)
	{
		printf("插入位置不合法！\n");
		return; 
	}
	for(i=0;i<pos;i++)
	{
		p=pListPtr->nodes[p].next;
		if(p==-1)
		{
			printf("该位置超出列表范围！\n");
			return;
		}
	}
	
	for(i=1;i<MAX_SIZE;i++)
	{
		if(pListPtr->used[i]==0)
		{
			printf("位置（%d）已被分配空间！",i);
			pListPtr->used[i]=1;
			q=i;
			break;
		}
	
	}
	if(i==MAX_SIZE)
	{
		printf("空间已耗尽，无法插入!\n");
		return;
	}
	
	pListPtr->nodes[q].data=pchar;
	
	pListPtr->nodes[q].next=pListPtr->nodes[p].next;
	pListPtr->nodes[p].next=q;
	printf("插入成功！\n");
}

void deleteElement(ListPtr pListPtr,char pchar)
{
	int p,q;
	p=0;
	while((pListPtr->nodes[p].next!=-1)&&(pListPtr->nodes[pListPtr->nodes[p].next].data!=pchar))
	{
		p=pListPtr->nodes[p].next; 
	} 
	if(pListPtr->nodes[p].next==-1)
	{
		printf("元素(%c)不存在于链表中！\n",pchar);
		return;
	}
	q=pListPtr->nodes[p].next;
	pListPtr->nodes[p].next=pListPtr->nodes[q].next;
	pListPtr->used[q]=0;
}

void locateElement(ListPtr pListPtr,char pchar)
{
	int p,q,cnt=0;
	p=0;
	while((pListPtr->nodes[p].next!=-1) && (pListPtr->nodes[p].data!=pchar))
	{
		p=pListPtr->nodes[p].next;
		cnt++;
	}
	if(pListPtr->nodes[p].next==-1)
	{
		printf("元素(%c)不存在于链表中！\n",pchar);
		return;
	}
	printf("元素（%c）的位置：%d\n",pchar,cnt);
}

void insert_delete_locate_clear_list_text()
{
	ListPtr tempList=initList();
	printList(tempList);
	
	
	insertElement(tempList, 'H', 0);
	insertElement(tempList, 'e', 1);
	insertElement(tempList, 'l', 2);
	insertElement(tempList, 'l', 3);
	insertElement(tempList, 'o', 4);
	
	insertElement(tempList, 'M', 6);
	insertElement(tempList, 'o', 4);
	printList(tempList);
	
	printf("Delete 'e'.\r\n");
	deleteElement(tempList, 'e');
	printList(tempList);
	printf("Delete 'a'.\r\n");
	deleteElement(tempList, 'a');
	printList(tempList);
	printf("Delete 'o'.\r\n");
	deleteElement(tempList, 'o');
	printList(tempList);
	insertElement(tempList, 'o', 2);
	printList(tempList);
	
	locateElement(tempList,'8');
	locateElement(tempList,'H');
	
	clear_list(tempList);
}

void clear_list(ListPtr tempList)
{
	int q;
	for(q=0;tempList->nodes[q].next==0;q=tempList->nodes[q].next)
	{
		tempList->nodes[q].next=tempList->nodes[1].next;
		tempList->nodes[1].next=tempList->nodes[0].next;
		tempList->nodes[0].next=0; 
	}
	
	printf("完成清空！");
}
int main()
{
	insert_delete_locate_clear_list_text();
	return 0;
}

运行结果：


位置（1）已被分配空间！插入成功！
位置（2）已被分配空间！插入成功！
位置（3）已被分配空间！插入成功！
位置（4）已被分配空间！插入成功！
位置（5）已被分配空间！插入成功！
该位置超出列表范围！
空间已耗尽，无法插入!
 Hello
Delete 'e'.
 Hllo
Delete 'a'.
元素(a)不存在于链表中！
 Hllo
Delete 'o'.
 Hll
位置（2）已被分配空间！插入成功！
 Hlol
元素(8)不存在于链表中！
元素（H）的位置：1
完成清空！
卖菜不涨价
关注
专栏目录
数据结构之静态链表
m0_64365419的博客
08-20 1万+
静态链表：分配一整片连续的内存空间，各个结点集中安置，逻辑结构上相邻的数据元素，存储在指定的一块内存空间中，数据元素只允许在这块内存空间中随机存放，这样的存储结构生成的链表称为静态链表。也就是说静态链表是用数组来实现链式存储结构，静态链表实际上就是一个结构体数组举例：通过a[1]中存放的游标变量3可找到存放的数据元素5的后继元素为3，再通过a[3]中存放的游标变量2可找到存放数据元素3的后继数据为2，以此类推，直到某元素的游标变量为0即可停止（注：a[0]为头结点不存储数据元素）
数据结构 ---- 静态链表
m0_67509744的博客
05-03 1058
作为数据结构的一大难点，静态链表也为我们更好的理解数据结构这门课做了铺垫。记得老师告诉我们，数据结构是操作系统的核心，那静态链表也为我们理解操作系统等方面的工程起了很好的铺垫作用。对于静态链表，我个人的主观感受就是，比双链表要难许多，毕竟是涉及到数据更加基本的存储，静态链表其实更能反映其本质，也更能体现出C语言本身的魅力。 与此同时，静态链表带给我的直观感受是，它其实对于我们程序员来说，具有更强的自我操作性，对于我们来操作数据的时候，可控性更强，不再局限于操作系统了。可以以此实现更多的操作。 在我看来，
数据结构静态链表
chy2939960881的博客
05-03 571
（1）建立链表 （2）初始化链表 （3）打印链表 （4）在指定位置插入元素（功能实现） （5）删除指定元素（功能实现） （6）插入&删除 1.建立链表 typedef struct StaticLinkedNode{ char data; int next; } typedef struct StaticLinkedList{ NodePtr nodes; int* used; } 2.初始化链表 ListPtr initLinkedList(...
静态链表
java web 的专栏
03-19 1681
以前学习的各种链表都是由指针实现的，链表中结点的分配和回收(即释放)都是由系统提供的标准函数malloc和free动态实现的，故称之为动态链表。但是有的高级语言，如BASIC、FORTRAN等，没有提供”指针”这种数据类型，此时若想采用链表做存储结构，就必须使用”游标”来模拟指针，由程序员自己编写”分配结点”和”回收结点”的过程。    用游标实现链表，其方法是：定义一个较大的结构数组作为备用
【数据结构--静态链表】
qq_61719813的博客
05-05 3440
文章目录前言一、静态链表的定义结构描述代码描述二、静态链表的基本操作初始化打印链表静态链表的插入静态链表的删除三、完整代码及运行截图完整代码如下：运行截图四、闵版（略改） 前言 ​ C语言的指针能十分方便的描述链表，但在一些语言，如Basic、Fortran等早期语言中由于没有指针，链表结构就不能用指针来描述，因此便出现了用数组来代替指针来描述单链表的方法。 一、静态链表的定义 结构描述 ​ 此处用于描述链表的数组由两个数据域组成，data和next。即数组的每个下标都对应一个data和一个next。其中，
大学数据结构--静态链表算法CPP文件.doc
05-26
大学数据结构--静态链表算法CPP文件.doc
数据结构-基本算法-静态链表
05-21
数据结构-基本算法-静态链表（学生时代源码，调试可运行）
数据结构(C语言版)---静态链表
09-21
静态链表是一种特殊的链式数据结构，它与常规动态链表有所不同，主要在于存储方式和内存分配。 静态链表，顾名思义，与动态链表相对，其链表节点是在编译时静态分配的，而不是在运行时动态分配。这种设计减少了动态...
数据结构与算法 c语言 线性表-静态链表
最新发布
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
数据结构 —— 静态链表
Labrador_Katie的博客
08-25 630
静态链表静态链表静态链表中的节点备用链表静态链表的实现在静态链表中添加一个元素静态链表删除元素静态链表中查找元素静态链表中更改数据 静态链表 静态链表：        线性存储结构的一种，兼顾顺序表和链表的优点，是顺序表和链表的升级；        静态链表的数据全部存储在数组中(顺序表)，但存储的位置是随机的，数据直接的一对一关系是通过一个整型变量(称为“游标”，类似
【数据结构】静态链表
NCITS的专栏
10-23 3739
/* 实验2：输入一组整型元素序列，建立一个单链表， 实现该单链表的遍历；在该单链表中查找某一元素，查找成功返回1，否则返回0； 在该单链表中插入和删除某个元素。 */ #include #include #define OVERFLOW -2 #define OK 1 #define ERROR 0 #define NULL 0 typedef int ElemType; typede
数据结构：双向链表
m0_62600887的博客
05-03 449
照搬代码 #include <stdio.h> #include <malloc.h> /** * Double linked list of integers. The key is char. */ typedef struct DoubleLinkedNode{ char data; struct DoubleLinkedNode *previous; struct DoubleLinkedNode *next; } DLNode, *DLNodePtr; /
数据结构：静态链表
yy_0733的博客
08-04 260
1、对于没有指针的编程语言，可以用数组替代指针，来描述链表。让数组的每个元素由data和cur两部分组成，其中cur相当于链表的next指针，这种用数组描述的链表叫做静态链表，这种描述方法叫做游标实现法。我们对数组的第一个和最后一个元素做特殊处理，不存数据。让数组的第一个元素cur存放第一个备用元素（未被占用的元素）下标，而数组的最后一个元素cur存放第一个有值的元素下标，相当于头结点作用。 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值