数据结构-静态链表

这段代码实现了一个静态链表的基本操作，包括初始化、插入元素、删除元素和打印链表内容。静态链表使用数组模拟链表结构，每个节点包含数据域和指向下一个节点索引的next域。以下是代码的主要组成部分和功能：

1.静态链表的初始化

2.链表内容的打印

3.链表中元素的插入

4.链表元素的删除

准备：

#include<iostream>
using namespace std;

const int Max_Size = 5;

typedef struct StaticLinkedNode {
	char data;
	//next域存放的是访问下一个节点的下标（类似于数组下标）
	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) * Max_Size);
	tempPtr->used = (int*)malloc(sizeof(int) * Max_Size);
	//将第一个节点初始化作为头节点，data域为空，next域为-1
	tempPtr->nodes[0].data = NULL;
	tempPtr->nodes[0].next = -1;
	//初始化了头节点，头节点被占用
	tempPtr->used[0] = 1;
	for (int i = 1; i < Max_Size; i++) {
		//其他节点没有被用，所以用0表示
		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");
}

元素的插入（附图在0号位添加H的草图）：

• 遍历链表找到插入位置的前一个节点。

• 在used数组中找到一个未使用的节点，将要插入的数据赋值给该节点，并更新used数组标记为已使用。

• 调整节点的next指针，完成插入操作。

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("The position %d is beyond the scope of the list.\r\n", paraPosition);
			return;
		}
	}
    //找到可以插入的位置
	for (i = 1; i < Max_Size; i++) {
		if (paraListPtr->used[i] == 0) {
			printf("Space at %d allocated.\r\n", i);
			paraListPtr->used[i] = 1;
			q = i;
			break;
		}
	}
	if (i == Max_Size) {
		printf("No space.\r\n");
		return;
	}
	//将值赋给要插入的位置
	paraListPtr->nodes[q].data = paraChar;

	printf("linking\r\n");
	//将插入的位置的next变为q
	paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
	//将p的next域变为下一个的索引
	paraListPtr->nodes[p].next = q;
}

指定元素的删除（附图为删除e元素的过程）：

• 遍历链表找到要删除的元素的前一个节点。

• 调整前一个节点的next指针，跳过要删除的节点，实现删除操作。

• 更新used数组，标记被删除节点为未使用。

void deleteElement(ListPtr paraListPtr, char paraChar) {
	int p, q;
	p = 0;
	//将p进行移动，移动到删除目标的前一个
	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("Cannot delete %c\r\n", paraChar);
		return;
	}

	q = paraListPtr->nodes[p].next;
	//将删除目标前后两个元素连接起来
	paraListPtr->nodes[p].next = paraListPtr->nodes[paraListPtr->nodes[p].next].next;
	//把删除元素位置的used域赋值为0，表示未使用
	paraListPtr->used[q] = 0;
}

对以上功能的测试（附图有测试结果）：

• 初始化链表，依次插入字符'H'、'e'、'l'、'l'、'o'，打印链表内容。

• 删除字符'e'、尝试删除不存在的字符'a'、删除字符'o'，每次删除后打印链表内容。

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);
	printList(tempList);
	
	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);
	
}

以下为运行结果： 总结：

该代码中nodes为一个静态链表的指针，used是一个布尔类型的数组，用来表示静态链表对应位置是否存放了data，next是一个整数，表示下一个元素的相对地址，用来索引下一个元素