2.3静态链表

静态链表代码

#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 paraListPre 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 (ten 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 etrance.
  */
  void main() {
  	appendInsertDeleteTest();
  }//Of main

运行结果

以上是闵帆老师的代码以及运行结果

心得体会

通过对静态链表的学习，对链表是如何连接、插入和删除元素有了更加清晰的认知，这非常有利于后续的分析。它首先需要由数据域和游标构成的节点，然后再创建一个数组用于存储“1”和“0”，表示该处的数据是否被使用。游标相当于地址，“-1”表示NULL，由游标连接各个数据。nodes[0]相当于头节点，因此在insertElement创建新节点(添加新元素)的时候从nodes[1]开始，在一共5个空间里面，最后输出为"Hell"，没有"o"。只需要跟着思路推导，将思路转化为代码，就可以实现各个功能。在抄写闵帆老师的代码时，也要思考代码运行的过程，自己再去敲一遍，才知道自己有没有掌握。

我的代码

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

#define DEFAULT_SIZE 6

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

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

//函数声明 
ListPtr Initailize();
void InsertList(ListPtr, char, int);
void printList(ListPtr);
void deleteElement(ListPtr, char);

int main() {
	ListPtr tempList = Initailize();
//	插入元素 
	printf("Now insert.\r\n"); 
	InsertList(tempList, 'H', 0);
	InsertList(tempList, 'e', 1);
	InsertList(tempList, 'l', 2);
	InsertList(tempList, 'l', 3);
	InsertList(tempList, 'o', 4);
	printList(tempList);
//	检验 
	InsertList(tempList, 'k', 10);
//	printList(tempList);
//	删除元素	
	printf("Now delete.\r\n");
	deleteElement(tempList, 'e');
	printList(tempList);
//	检验 
	deleteElement(tempList, 'k');
//	printList(tempList); 
	return 0;
}

ListPtr Initailize() {
	int i;
	ListPtr tempList = (ListPtr)malloc(sizeof(struct StaticLinkList));
	
	tempList->nodes = (NodePtr)malloc(sizeof(struct StaticLinkNode)*DEFAULT_SIZE);
	tempList->used = (int*)malloc(sizeof(int)*DEFAULT_SIZE);
	
	tempList->nodes[0].data = '\0';
	tempList->nodes[0].next = -1;
	
	tempList->used[0] = 1;
	for(i = 1; i < DEFAULT_SIZE; i++) {
		tempList->used[i] = 0;
	} 
	
	return tempList;
}

void InsertList(ListPtr paraList, char paraChar, int paraPosition) {
	int p, q, i;
	
	p = 0;
//	找到要添加的地方 ,p需要记住的是添加元素的上一个位置，所以传H时为0，以此内推 
	for(i = 0; i < paraPosition; i++) {
		p = paraList->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 < DEFAULT_SIZE; i++) {
		if(paraList->used[i] == 0) {
			paraList->used[i] = 1;
			q = i;//给新节点占有位置 
			break; //一定要有 
		} 
	} 
	
	paraList->nodes[q].data = paraChar;
	
	paraList->nodes[q].next = paraList->nodes[p].next;
	paraList->nodes[p].next = q;
}

void deleteElement(ListPtr paraList, char paraChar) {
	int p, q, i;
	
	p = 0;
	while(paraList->nodes[paraList->nodes[p].next].data != paraChar) {
		p = paraList->nodes[p].next;
		if(p == -1) {
			printf("Cannot delete %c！\r\n", paraChar);
			return;
		}
	}
	
	q = paraList->nodes[p].next;
	paraList->nodes[p].next = paraList->nodes[q].next;
	
//	free(q) 
	paraList->used[q] = 0; 
}

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

运行结果

自己敲代码过后才发现原来并没有掌握这个知识，一定要自己去敲，才会发现自己隐藏的问题，还有很多不足，多多改进。