数据结构2.4静态链表

在C语言中，静态链表的表现形式即为结构体数组，结构体变量包括数据域data和游标CUR。

这种存储结构，仍需要预先分配一个较大的空间，但在作为线性表的插入和删除操作时不需移动元素，仅需修改指针，故仍具有链式存储的主要优点。

接下来进行相关操作展示

定义静态链表

#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;

初始化

/**
 * 初始化头节点。
 * @return 返回头节点的指针。
 */
ListPtr initLinkedList(){
    // 指向整个链表空间的指针
    ListPtr tempPtr = (ListPtr)malloc(sizeof(struct StaticLinkedList));
 
    // 分配总空间
    tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * DEFAULT_SIZE);
	tempPtr->used = (int*)malloc(sizeof(int) * DEFAULT_SIZE);
 
    // 第一个节点是头结点
    tempPtr->nodes[0].data = '\0';
    tempPtr->nodes[0].next = -1;
    
    // 初始化时只有头结点使用
    tempPtr->used[0] = 1;
	for (int i = 1; i < DEFAULT_SIZE; i ++){
		tempPtr->used[i] = 0;
	}
 
	return tempPtr;
}

打印

/**
 * 打印链表。
 * @param paraHeader 是链表的头结点。
 */
void printList(ListPtr paraListPtr){
	int p = 0;
	while (p != -1) {
		printf("%c", paraListPtr->nodes[p].data);
		p = paraListPtr->nodes[p].next;
	}
	printf("\r\n");
}

插入元素

/**
 * 在给定的位置加入元素。
 * @param paraHeader 是链表的头结点。
 * @param paraChar 给定的char元素。
 * @param paraPosition 给定的位置。
 */
void insertElement(ListPtr paraListPtr, char paraChar, int paraPosition){
	int p, q, i;
 
	// Step 1. 搜索位置
	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;
		}
	} 
 
	// Step 2. 创建一个新的节点
	for ( i; i < DEFAULT_SIZE; i ++){
		if (paraListPtr->used[i] == 0){
			printf("Space at %d allocated.\r\n", i);
			paraListPtr->used[i] = 1;
			q = i;
			break;
		}
	}
	if (i >= DEFAULT_SIZE){
		printf("No space.\r\n");
		return;
	}
 
	paraListPtr->nodes[q].data = paraChar;
 
	// Step 3. 链接节点
	printf("linking\r\n");
	paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = q;
}

删除元素

/**
 * 删除链表中的元素。
 * @param paraHeader 是链表的头结点。
 * @param paraChar 给定的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;
	}
 
	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;
	
	// 此语句和free(q)功能相同
	paraListPtr->used[q] = 0;
}

功能测试

/**
 * 功能测试。
 */
void appendInsertDeleteTest(){
	// Step 1. 初始化一个空链表
	ListPtr tempList = initLinkedList();
	printList(tempList);
 
	// Step 2. 加入一些元素
	insertElement(tempList, 'H', 0);
	insertElement(tempList, 'e', 1);
	insertElement(tempList, 'l', 2);
    insertElement(tempList, 'l', 1);
	insertElement(tempList, 'l', 3);
	insertElement(tempList, 'o', 4);
	printList(tempList);
 
	// Step 3. 删除一些元素(首次出现的该元素)
	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);
}

运行结果

Space at 1 allocated.
linking
Space at 2 allocated.
linking
Space at 3 allocated.
linking
Space at 4 allocated.
linking
No space.
No space.
Hlel
Deleting 'e'.
Deleting 'a'.
Cannot delete a
Deleting 'o'.
Cannot delete o
Hll
Space at 2 allocated.
linking
Hxll

顺序链表和单链表的区别主要是：

1.存储方式不同

2.空间上的区别，顺序表需要一次性申请一大片连续空间

3.操作时间复杂度不同