静态链表（c语言数据结构）

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

静态链表定：
逻辑结构上相邻的数据元素，存储在指定的一块内存空间中，数据元素只允许在这块内存空间中随机存放，这样的存储结构生成的链表称为静态链表。也就是说静态链表是用数组来实现链式存储结构，目的是方便在不设指针类型的高级程序设计语言中使用链式结构。它的优点是和动态链表一样，删除和插入元素时间复杂度低；不足是和数组一样，需要提前分配一块较大的空间。

老师代码如下：

#include <stdio.h>
#include <malloc.h>

#define DEFAULT_SIZE 5

typedef struct StaticLinkedNode{
	char data;

	int next;
} *NodePtr;

typedef struct StaticLinkedList{
	NodePtr nodes;
	int* used;
} *ListPtr;

/**
 * Initialize the list with a header.
 * @return The pointer to the header.
 */
ListPtr initLinkedList(){
	// The pointer to the whole list space.
	ListPtr tempPtr = (ListPtr)malloc(sizeof(struct StaticLinkedList));

	// Allocate total space.
	tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * DEFAULT_SIZE);
	tempPtr->used = (int*)malloc(sizeof(int) * DEFAULT_SIZE);

	// The first node is the header.
	tempPtr->nodes[0].data = '\0';
	tempPtr->nodes[0].next = -1;

	// Only the first node is used.
	tempPtr->used[0] = 1;
	int i;
	for (i = 1; i < DEFAULT_SIZE; i ++){
		tempPtr->used[i] = 0;
	}// Of for i

	return tempPtr;
}// Of initLinkedList

/**
 * Print the list.
 * @param paraListPtr The pointer to the list.
 */
void printList(ListPtr paraListPtr){
	int p = 0;
	while (p != -1) {
		printf("%c", paraListPtr->nodes[p].data);
		p = paraListPtr->nodes[p].next;
	}// Of while
	printf("\r\n");
}// Of printList

/**
 * Insert an element to the given position.
 * @param paraListPtr The position of the list.
 * @param paraChar The given char.
 * @param paraPosition The given position.
 */
void insertElement(ListPtr paraListPtr, char paraChar, int paraPosition){
	int p, q, i;

	// Step 1. Search to the position.
	p = 0;
	for (i = 0; i < paraPosition; i ++) {
		p = paraListPtr->nodes[p].next;
		if (p == -1) {
			printf("The position %d is beyond the scope of the list.\r\n", paraPosition);
			return;
		}// Of if
	} // Of for i

	// Step 2. Construct a new node.
	for (i = 1; i < DEFAULT_SIZE; i ++){
		if (paraListPtr->used[i] == 0){
			// This is identical to malloc.
			printf("Space at %d allocated.\r\n", i);
			paraListPtr->used[i] = 1;
			q = i;
			break;
		}// Of if
	}// Of for i
	if (i == DEFAULT_SIZE){
		printf("No space.\r\n");
		return;
	}// Of if

	paraListPtr->nodes[q].data = paraChar;

	// Step 3. Now link.
	printf("linking\r\n");
	paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = q;
}// Of insertElement

/**
 * Delete an element from the list.
 * @param paraHeader The header of the list.
 * @param paraChar The given char.
 */
void deleteElement(ListPtr paraListPtr, char paraChar){
	int p, q;
	p = 0;
	while ((paraListPtr->nodes[p].next != -1) && (paraListPtr->nodes[paraListPtr->nodes[p].next].data != paraChar)){
		p = paraListPtr->nodes[p].next;
	}// Of while

	if (paraListPtr->nodes[p].next == -1) {
		printf("Cannot delete %c\r\n", paraChar);
		return;
	}// Of if

	q = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = paraListPtr->nodes[paraListPtr->nodes[p].next].next;
	
	// This statement is identical to free(q)
	paraListPtr->used[q] = 0;
}// Of deleteElement

/**
 * Unit test.
 */
void appendInsertDeleteTest(){
	// Step 1. Initialize an empty list.
	ListPtr tempList = initLinkedList();
	printList(tempList);

	// Step 2. Add some characters.
	insertElement(tempList, 'H', 0);
	insertElement(tempList, 'e', 1);
	insertElement(tempList, 'l', 2);
	insertElement(tempList, 'l', 3);
	insertElement(tempList, 'o', 4);
	printList(tempList);

	// Step 3. Delete some characters (the first occurrence).
	printf("Deleting 'e'.\r\n");
	deleteElement(tempList, 'e');
	printf("Deleting 'a'.\r\n");
	deleteElement(tempList, 'a');
	printf("Deleting 'o'.\r\n");
	deleteElement(tempList, 'o');
	printList(tempList);

	insertElement(tempList, 'x', 1);
	printList(tempList);
}// Of appendInsertDeleteTest

/**
 * The entrance.
 */
void main(){
	appendInsertDeleteTest();
}// Of main

我的代码如下：

typedef struct StaticLinkedNode{
	char data;
	int next;
} *NodePtr;

typedef struct StaticLinkedList{
	NodePtr nodes;
	int* used;
} *ListPtr;

//创建空链表 （初始化）

ListPtr initLinkedList(){
	ListPtr tempPtr = (ListPtr)malloc(sizeof(struct StaticLinkedList));

	tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * MAXSIZE);
	tempPtr->used = (int*)malloc(sizeof(int) * MAXSIZE);

	tempPtr->nodes[0].data = '\0';
	tempPtr->nodes[0].next = -1;

	tempPtr->used[0] = 1;
	int i;
	for (i = 1; i < MAXSIZE; i ++){
		tempPtr->used[i] = 0;
	}
	return tempPtr;
}

//打印链表

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

//插入元素

void insertElement(ListPtr paraListPtr, char paraChar, int paraPosition){
	int p, q, i;
    
    //判断位置是否合法 
	p = 0;
	for (i = 0; i < paraPosition; i ++) {
		p = paraListPtr->nodes[p].next;
		if (p == -1) {
			printf("%d的位置超出列表范围！\n", paraPosition);
			return;
		}
	}

	// 创建新结点 
	for (i = 1; i < MAXSIZE; i ++){
		if (paraListPtr->used[i] == 0){
			printf("已分配空间%d.\n", i);
			paraListPtr->used[i] = 1;
			q = i;
			break;
		}
	}
	if (i == MAXSIZE){
		printf("没有空间.\r\n");
		return;
	}

	paraListPtr->nodes[q].data = paraChar;

	//链接 
	paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = q;
}

//删除元素

void deleteElement(ListPtr paraListPtr, char paraChar){
	int p, q;
	p = 0;
	while ((paraListPtr->nodes[p].next != -1) && (paraListPtr->nodes[paraListPtr->nodes[p].next].data != paraChar)){
		p = paraListPtr->nodes[p].next;
	}

	if (paraListPtr->nodes[p].next == -1) {
		printf("不能删除%c\n", paraChar);
		return;
	}

	q = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = paraListPtr->nodes[paraListPtr->nodes[p].next].next;

	paraListPtr->used[q] = 0;
}

//测试代码

void appendInsertDeleteTest(){
	//初始化一个空列表 
	ListPtr tempList = initLinkedList();
	printList(tempList);

	//插入元素 
	insertElement(tempList, 'H', 0);
	insertElement(tempList, 'e', 1);
	insertElement(tempList, 'l', 2);
	insertElement(tempList, 'l', 3);
	insertElement(tempList, 'o', 4);
	insertElement(tempList, 'w', 5);
	insertElement(tempList, 'o', 6);
	insertElement(tempList, 'r', 7);
	insertElement(tempList, 'l', 8);
	insertElement(tempList, 'd', 9);
	insertElement(tempList, '!', 10);
	printList(tempList);

	//删除元素 
	printf("Deleting 'e'.\n");
	deleteElement(tempList, 'e');
	printf("Deleting 'a'.\n");
	deleteElement(tempList, 'a');
	printf("Deleting 'o'.\n");
	deleteElement(tempList, 'o');
	printf("Deleting 'w'.\n");
	deleteElement(tempList, 'w');	
	printList(tempList);
	printf("Deleting '!'.\n");
	deleteElement(tempList, '!');
	printf("Deleting 'l'.\n");
	deleteElement(tempList, 'l');
	printList(tempList)	;
	insertElement(tempList, '0', 1);
	insertElement(tempList, '5', 5);
	insertElement(tempList, '4', 17);
	printList(tempList);
}

完整代码：

#include <stdio.h>
#include <malloc.h>

#define MAXSIZE 10

typedef struct StaticLinkedNode{
	char data;
	int next;
} *NodePtr;

typedef struct StaticLinkedList{
	NodePtr nodes;
	int* used;
} *ListPtr;

//创建空链表 
ListPtr initLinkedList(){
	ListPtr tempPtr = (ListPtr)malloc(sizeof(struct StaticLinkedList));

	tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * MAXSIZE);
	tempPtr->used = (int*)malloc(sizeof(int) * MAXSIZE);

	tempPtr->nodes[0].data = '\0';
	tempPtr->nodes[0].next = -1;

	tempPtr->used[0] = 1;
	int i;
	for (i = 1; i < MAXSIZE; i ++){
		tempPtr->used[i] = 0;
	}
	return tempPtr;
}

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

//插入元素 
void insertElement(ListPtr paraListPtr, char paraChar, int paraPosition){
	int p, q, i;
    
    //判断位置是否合法 
	p = 0;
	for (i = 0; i < paraPosition; i ++) {
		p = paraListPtr->nodes[p].next;
		if (p == -1) {
			printf("%d的位置超出列表范围！\n", paraPosition);
			return;
		}
	}

	// 创建新结点 
	for (i = 1; i < MAXSIZE; i ++){
		if (paraListPtr->used[i] == 0){
			printf("已分配空间%d.\n", i);
			paraListPtr->used[i] = 1;
			q = i;
			break;
		}
	}
	if (i == MAXSIZE){
		printf("没有空间.\r\n");
		return;
	}

	paraListPtr->nodes[q].data = paraChar;

	//链接 
	paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = q;
}

//删除元素 
void deleteElement(ListPtr paraListPtr, char paraChar){
	int p, q;
	p = 0;
	while ((paraListPtr->nodes[p].next != -1) && (paraListPtr->nodes[paraListPtr->nodes[p].next].data != paraChar)){
		p = paraListPtr->nodes[p].next;
	}

	if (paraListPtr->nodes[p].next == -1) {
		printf("不能删除%c\n", paraChar);
		return;
	}

	q = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = paraListPtr->nodes[paraListPtr->nodes[p].next].next;

	paraListPtr->used[q] = 0;
}

//测试代码 
void appendInsertDeleteTest(){
	//初始化一个空列表 
	ListPtr tempList = initLinkedList();
	printList(tempList);

	//插入元素 
	insertElement(tempList, 'H', 0);
	insertElement(tempList, 'e', 1);
	insertElement(tempList, 'l', 2);
	insertElement(tempList, 'l', 3);
	insertElement(tempList, 'o', 4);
	insertElement(tempList, 'w', 5);
	insertElement(tempList, 'o', 6);
	insertElement(tempList, 'r', 7);
	insertElement(tempList, 'l', 8);
	insertElement(tempList, 'd', 9);
	insertElement(tempList, '!', 10);
	printList(tempList);

	//删除元素 
	printf("Deleting 'e'.\n");
	deleteElement(tempList, 'e');
	printf("Deleting 'a'.\n");
	deleteElement(tempList, 'a');
	printf("Deleting 'o'.\n");
	deleteElement(tempList, 'o');
	printf("Deleting 'w'.\n");
	deleteElement(tempList, 'w');	
	printList(tempList);
	printf("Deleting '!'.\n");
	deleteElement(tempList, '!');
	printf("Deleting 'l'.\n");
	deleteElement(tempList, 'l');
	printList(tempList)	;
	insertElement(tempList, '0', 1);
	insertElement(tempList, '5', 5);
	insertElement(tempList, '4', 17);
	printList(tempList);
}

//入口 
void main(){
	appendInsertDeleteTest();
}

测试结果：

已分配空间1.
已分配空间2.
已分配空间3.
已分配空间4.
已分配空间5.
已分配空间6.
已分配空间7.
已分配空间8.
已分配空间9.
没有空间.
10的位置超出列表范围！
 Helloworl
Deleting 'e'.
Deleting 'a'.
不能删除a
Deleting 'o'.
Deleting 'w'.
 Hllorl
Deleting '!'.
不能删除!
Deleting 'l'.
 Hlorl
已分配空间2.
已分配空间3.
17的位置超出列表范围！
 H0lor5l
小白123**
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构_静态链表(C语言)
小黯
04-02 3299
目录一、静态链表图文解析二、静态链表代码解析1、基本操作1.1 结构1.2 初始化1.3 插入数据1.4 删除数据1.5 修改数据2、源代码及测试2.1 源代码2.2 测试结果 一、静态链表图文解析 二、静态链表代码解析 1、基本操作 1.1 结构 1.2 初始化 1.3 插入数据 1.4 删除数据 1.5 修改数据 2、源代码及测试 2.1 源代码 2.2 测试结果 ...
使用C语言实现静态链表
Keep_Trying_Go的博客
08-09 1905
使用C语言实现静态链表
C语言-静态链表
qq_64831425的博客
02-20 1139
C语言-静态链表，图解每一个过程
C语言--静态链表
m0_75266675的博客
04-22 478
静态链表
数据结构2.4静态链表
qq_62644791的博客
05-02 916
在C语言中，静态链表的表现形式即为结构体数组，结构体变量包括数据域data和游标CUR。 这种存储结构，仍需要预先分配一个较大的空间，但在作为线性表的插入和删除操作时不需移动元素，仅需修改指针，故仍具有链式存储的主要优点。 接下来进行相关操作展示 定义静态链表 #include <stdio.h> #include <malloc.h> #define DEFAULT_SIZE 5 typedef struct StaticLinkedNode{ char
C语言实现静态链表
qq_46129738的博客
05-30 138
原理: 使用结构数组来存放一组数据, 数组中数据分为游标和数据, 使用游标来模拟指针的作用, 从而实现链表的功能. 第一个和最后一个是不能放数据的, 因为一条作为有数据链条, 一条作为无数据链条.需要初始静态链表数据全部为0, 可以使用memset函数. 需要初始化游标按顺序一个一个全部连起来, 第一个元素指向第二个, 最后一个元素指向第一个, 即为有数据链表为空, 无数据链表为全部.修改游标只用修改3个即可, 即: 插入的位置, 前一个位置, 数组0位置.静态链表的结构: 游标, 数组标号, 数据.
数据结构与算法 c语言 线性表-静态链表
最新发布
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
静态链表C语言代码实现
08-04
关于严蔚敏版数据结构的静态链表的代码实现，C语言实现
c语言实现静态链表
03-17
c语言实现的静态链表
C语言数据结构 静态链表
04-14
我的数据结构作业，静态链表。望大家指点一二
静态链表c语言源码
04-13
静态链表的C语言实现
09-27
静态链表的C语言实现和实例
简单c语言的静态链表测试
07-04
c基础 自己编的代码 这个需要积分大兄弟我也没办法吧随便拿了一个自己弄的练习 见谅哈
C语言实现静态链表的方法
09-05
分享一段代码，一个静态链表的C语言实现，其中包含着一种简单的内存管理策略：固定大小的链式管理。
数据结构——静态链表
weixin_75078464的博客
04-10 1089
静态链表( static linked list ), 就是用数组来表示链表,用数组元素的下标来模拟链表的指针. 由于是利用数组来定义的链表,属于静态储存分配, 因而叫做静态链表. 静态链表的节点也有由两个域组成: 数据域和游标.因此，静态链表中节点的构成用 C 语言实现为： 跟普通链表的区别就是 next 是数组下标是int 类型. 用来记录空间存储空间的位置，以便后期分配给新添加元素使用。 整体代码 运行结果 使用静态链表存储数据，需要预先申请足够
静态链表和动态链表的区别
热门推荐
我的博客
10-10 5万+
静态链表和动态链表的区别： 静态链表和动态链表是线性表链式存储结构的两种不同的表示方式。 1、静态链表是用类似于数组方法实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配地址空间大小。所以静态链表的初始长度一般是固定的，在做插入和删除操作时不需要移动元素，仅需修改指针。 2、动态链表是用内存申请函数（malloc/new）动态申请内存的，所以在链表的长度上没有限制。动态链表
数据结构-第三讲 静态链表 2023.4.6
m0_65396412的博客
04-11 545
2，静态链表是用数组实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配大小。静态链表在插入、删除时也是通过修改指针域来实现的，与动态链表没有什么分别（动态链表还需要删除内存）。1，有些高级语言中没有“指针”数据类型，只能用数组来模拟线性链表的结构，数组元素中的指针“域”存放的不是元素在内存中的真实地址，而是在数组中的位置。3，静态链表：把线性表的元素存放在数组的单元中（不一定按逻辑顺序连续存放），每个单元不仅存放元素本身 ，而且还要存放其后继元素所在的数组单元的下标（游标）。
链式存储结构之静态链表
qq_43411563的博客
04-21 1263
单链表、双向链表以及循环链表等等，都是用来C语言中的指针，使得我们能很快得操作内存中的地址和数据。但是能不能运用数组来描述单链表呢？回答当然是可以的，这就是我们这篇博客所说的静态链表。 一、静态链表的定义 我们让数组的元素都是由两个数据域组成, data 和cur。也就是说，数组的每个下标都对应一个data和一个cur。数据域data,用来存放数据元素，也就是通常我们要处理的数据;而游标cur相当...
C语言数据结构文学研究助手
10-20
C语言数据结构文学研究助手是一个程序，它可以帮助用户实现对文本的各种输入、删除和展示的需求，较大程度上满足了文学文本编辑的要求。该程序采用分行保存文本，每行是动态双向链表，行内字符数组是静态的。字符匹配是对每行文字匹配目标串（目标串不分行），采用KMP算法进行匹配提高匹配效率。此外，该程序还可以帮助用户熟悉串类型的实现方法和文本模式的匹配方法，并初步熟悉文本处理方法和文字统计的方法。用户可以在实际应用中掌握数据结构所学的知识，并提高编程能力。除此之外，该程序还可以帮助用户实现九九乘法表的算法思路，即一个简单的循环的嵌套，外层循环控制行，内层循环控制列，最后输出行和列的乘积，从而加深用户对数据结构和算法的理解和应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小白123**

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

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

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

打赏作者

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

抵扣说明：

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

余额充值