初识单链表

代码 

• #include <stdio.h>
  #include<malloc.h>
   
  /**
  *Linked list of characters.The key is data.
  */
  typedef struct LinkNode{
  	char data;
  	struct LinkNode *next;
  }LNode,*LinkList,*NodePtr;
   
  /**
  *Initialize the list with a header.
  *@return The pointer to the header.
  */
  LinkList initLinkList(){
  	NodePtr tempHeader = (NodePtr)malloc(sizeof(LNode));
  	tempHeader->data = '\0';
  	tempHeader->next = NULL;
  	return tempHeader;
  } //Of initLinkList
   
  /**
  *Add an element to the tail.
  *@param paraHeader The header of the list.
  */
  void printList(NodePtr paraHeader){
  	NodePtr p = paraHeader->next;
  	while (p != NULL){
  		printf("%c",p->data);
  	    p = p->next;
      }//Of while
  printf("\r\n");
  }//Of printList
   
  /**
  *Add an element to the tail.
  *@param paraHeader The header of list.
  *@param paraChar The given char.
  */
  void appendElement(NodePtr paraHeader,char paraChar){
  	NodePtr p, q;
  	
  	//Step 1.Construct a new node.
  	q = (NodePtr)malloc(sizeof(LNode));
  	q->data = paraChar;
  	q->next = NULL;
  	
  	//Step 2. Seach to the tail.
  	p = paraHeader;
  	while (p->next !=NULL){
  		p = p->next;
  		}//Of while
  		
  		//Step 3. Now add/link.
  		p->next = q;
  } //Of appendElement
   
  /**
  *Insert an element to the given position.
  *@param paraHeader The header of the list
  *@param paraChar The given char.
  *@param paraPosition The given position.
  */
  void insertElement(NodePtr paraHeader,char paraChar,int paraPosition){
  	NodePtr p,q;
  	
  	//Step 1. Seach to the position.
  	p = paraHeader;
  	for (int i = 0; i< paraPosition;i++){
  		p = p->next;
  		if(p == NULL){
  			printf("The position %d is beyond the scope of the list.",paraPosition);
  			return ;
  		}//OF if
  	}//Of for i
  	
  	//Step 2. Construct a new node.
  	q = (NodePtr)malloc(sizeof(LNode));
  	q->data = paraChar;
  	
  	//Step 3.Now link.
  	printf("linking\r\n");
  	q->next = p->next;
  	p->next = q;
  }//Of insertElement
   
  /**
  *Delete anelement from the list.
  *@param paraHeader The header of the list.
  *@param paraChar The given char.
  */
  void deleteElement(NodePtr paraHeader,char paraChar){
  	NodePtr p,q;
  	p = paraHeader;
  	while((p->next !=NULL)&&(p->next->data != paraChar)){
  		p = p->next;
  	}//Of while
  	
  	if (p->next == NULL){
  		printf("Cannot delete %c\r\n",paraChar);
  		return ;
  	}//Of if
  	
  	q = p->next;
  	p->next = p->next->next;
  	free(q);
  }//of deleteElement
   
  /**
  *Unit test.
  */
  void appendInsertDeleteTest(){
  	//Step 1. Initialize an empty List.
  	LinkList tempList = initLinkList();
  	printList(tempList);
  	
  	//Step 2. And some characters.
  	appendElement(tempList,'H');
  	appendElement(tempList,'e');
  	appendElement(tempList,'l');
  	appendElement(tempList,'l');
  	appendElement(tempList,'o');
  	appendElement(tempList,'!');
  	printList(tempList);
  	
  	//Step 3. Delete some characters(the first occurrence).
  	deleteElement(tempList,'e');
  	deleteElement(tempList,'a');
  	deleteElement(tempList,'o');
  	printList(tempList);
  	
  	//Step 4. Insert to a given position.
  	insertElement(tempList,'o',1);
  	printList(tempList); 
  }//Of appendInsertDeleteTest
   
  /**
  *Address test: beyond the book.
  */
  void basicAddressTest(){
  	LNode tempNode1, tempNode2;
  	
  	tempNode1.data = 4;
  	tempNode1.next = NULL;
  	
  	tempNode2.data = 6;
  	tempNode2.next = NULL;
  	
  	printf("The first node: %d, %d, %d\r\n",
  	&tempNode1,&tempNode1.data,&tempNode1.next);
  	printf("The second node: %d, %d, %d\r\n",
  	&tempNode2,&tempNode2.data,&tempNode2.next);
  	
  	tempNode1.next = &tempNode2;
  }//Of basicAddressTest
   
  /**
  *The entrance.
  */
  int main(){
  	appendInsertDeleteTest();
  } //Of main

运行结果

上课的收获：

线性表链式存储结构的特点是：用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因此，为了表示公式每个数据元素ai与其直接后续元素ai+1之间的逻辑关系，对数据元素ai来说，除了存储本身的信息之外，还需要存储一个指示其直接后继的信息（直接后继的存储位置）。这两部分信息组成元素ai的存储映像，称为节点（node）。

根据链表节点所含指针个数，指针指向和指针连接方式，可将链表分为单链表，循环链表，双向链表，二叉链表，十字链表，邻接表，邻接多重表等。其中单链表，循环链表和双向链表多用于实现线性表的链式存储结构，其他形式多用于实现树和图等非线性结构。

通过这次抄代码对于链表的理解更深

速度更快