数据结构之静态链表

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

#define DEFAULT_SIZE 6

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;
	for(int i = 0; i<DEFAULT_SIZE; i++){
		tempPtr->used[i] = 0;
	}//off for i
	
	return tempPtr;
}

/*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;
	}//off while
	printf("\r\n");
}//off paraListPtr

/*Insert an element to the given position
 *param paraListPtr the pointer 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 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;
		}//off if
	}//off for i
	
	//step 2.construct a new node
	for(i = 1; i < DEFAULT_SIZE; i++){
		if(paraListPtr->used[i] == 0){
			//This identical to malloc.
			printf("Space at %d allocated.\r\n",i);
			paraListPtr->used[i] = 1;
			q = i;
			break;
		}//off if
	}//off for i
	if(i == DEFAULT_SIZE){
		printf("No space.\r\n");
		return;
	}
	
	paraListPtr->nodes[q].data = paraChar;
	
	//step 3.link
	printf("Linking\r\n");
	paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = q;
}//off 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; 
	}//off while
	
	if (paraListPtr->nodes[p].next == -1){
		printf("cannot delete %c\r\n", paraChar);
		return;
	}//off if
	
	q = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = paraListPtr->nodes[paraListPtr->nodes[p].next].next;
	
	//this statement is to free q;
	
	paraListPtr->used[q] = 0;
}//off deleteElement

//test
void appendInsertDeleteTest(){
	//1.Initialize an empty list.
	ListPtr tempList = initLinkedList();
	printList(tempList);
	
	//2.add some characters.
	insertElement(tempList, 'w',0);
	insertElement(tempList, 'o',1);
	insertElement(tempList, 'l',2);
	insertElement(tempList, 'r',3);
	insertElement(tempList, 'd',4);
	insertElement(tempList, '!',5);
	printList(tempList);
	
	//3.delete some characters
	printf("deleting 'l'...\r\n");
	deleteElement(tempList,'l');
	printList(tempList);
	printf("\n");
	printf("deleting 'd'...\r\n");
	deleteElement(tempList,'d');
	printList(tempList);
	printf("\n");
	printf("deleting '!'...\r\n");
	deleteElement(tempList,'!');
	printList(tempList);
	printf("\n");
	
	insertElement(tempList,'f',3);
	printList(tempList);
	printf("Test over");
}//off the test.

//the entrance
int main(){
	appendInsertDeleteTest();
}//off main.

运行结果:
运行结果:的优点：在插入和删除操作的时候，不需要移动元素。
静态链表的缺点：失去了顺序储存结构随机存取的特征，没有解决连续储存分配带来的表长难以确定的问题

 

学习静态链表的过程中，我对数据结构的理解进一步加深，也对链表这种数据结构的特点和实现方式有了更深刻的认识。