2.4静态链表

一、收获感受

知识查询：

静态链表的定义

静态链表( static linked list ), 就是用数组来表示链表,用数组元素的下标来模拟链表的指针。
由于是利用数组来定义的链表,属于静态储存分配, 因而叫做静态链表。

其实很好理解,如果把内存看作一个巨大的数组, 那么递归定义的链表和静态链表就相差无几了。

最常用的静态链表是静态单链表( 有一个next指针 ), 后面静态链表特指静态单链表。

 

 

心得体会：

在每次上新课之前先手敲一遍代码练习，虽然抄的过程中大部分都看不懂，但是怀揣着心中的疑问再去听课就会发现学有所指，随着老师上课过程中心中的疑惑一点点解开，听课学习效率也提高很多。

二、摘抄代码

摘抄的代码如下：

#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;
	for (int i = 1; i < DEFAULT_SIZE; i++){
		tempPtr->used[i] = 0;
	} // of for i
	
	return tempPtr;
 }// of initLinkedList
 
 /**
  * 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;
	  }//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 (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
  
  /**
   * The entrance
   */
   int main(){
   	appendInsertDeleteTest();
   }// of main

三、运行结果

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