2.4 静态链表

1.静态链表的定义

  我们前面学习了单链表的实现及操作，但这是我们使用动态的空间所实现的链表，我们需要链接某个数据的时候我们就申请一片空间，但这种链表如果要访问最后一个元素时，需要遍历整个链表，那如果我们想做一个快速访问的链表，就可以融合顺序表的优点。那么我们现在要用静态的空间去实现一个链表，该如何操作呢？

2.链表实现的操作

  首先，我们要分配一片连续的空间给它，同时还要申请一片一样的空间用于标记上一片空间的某个位置是否被占用（我们把这片新空间叫做备用链表），假定表的长度为5，代码如下：

我们先声明要用到的变量

节点的结构体

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

 头指针

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

建立这片空间，形成静态链表

   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;
   for (int i = 1; i < DEFAULT_SIZE; i ++){
      tempPtr->used[i] = 0;//标记空间的使用情况
   }// Of for i

   return tempPtr;
}// Of initLinkedList

接下来就是实现链表中的各项操作（通过指针移动或者叫做浮标）

插入元素

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

 删除元素

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

 

 3.测试程序及结果（中使用了打印函数查看内容）

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

 4.收获及感悟

  通过学习静态链表，我了解了如何在自己创造的空间实现一个链表，模仿计算机在系统中的操作，同时明了链表的逻辑结构，对链表这种数据结构的理解更加地深入。