链表的常见实现

链表结点声明如下：

[cpp] view plain copy

1. struct LinkList {  
2.     int value;  
3.     LinkList *next;  
4. };  

以下是不带头结点的单链表的操作。

1. 根据输入建立单链表

将输入的节点插入到链表头部。

[cpp] view plain copy

1. //根据输入建立单链表：链表头部插入  
2. LinkList *BuildList() {  
3.     LinkList *head = NULL;  
4.     int data;  
5.     int i = 0;  
6.     while (scanf("%d", &data) != EOF) {  
7.         //scanf("%d", &data);++i;  
8.         LinkList *new_node = (LinkList *)malloc(sizeof(LinkList));  
9.         if (NULL == new_node) {  
10.             fprintf(stderr, "malloc failed");  
11.             return head;  
12.         }  
13.         new_node->value = data;  
14.         if (head == NULL) {  
15.             new_node->next = NULL;  
16.             head = new_node;  
17.         }  
18.         else {  
19.             new_node->next = head;  
20.             head = new_node;  
21.         }  
22.     }  
23.     return head;  
24. }  

2. 链表插入操作

链表插入时注意当链表为空的情况。

（1）在链表头插入

[cpp] view plain copy

1. //在链表头部插入节点  
2. LinkList *InsertToHead(int value, LinkList *head) {  
3.     LinkList *new_node = (LinkList *)malloc(sizeof(LinkList));  
4.     if (new_node == NULL) {  
5.         fprintf(stderr, "malloc failed");  
6.         return head;  
7.     }  
8.     new_node->value = value;  
9.     new_node->next = NULL;  
10.     if (head == NULL) {  
11.         head = new_node;  
12.     }  
13.     else {  
14.         new_node->next = head;  
15.         head = new_node;  
16.     }  
17.     return head;  
18. }  

（2）在链表尾部插入

[cpp] view plain copy

1. //链表尾部插入节点  
2. LinkList *InsertToTail(int value, LinkList *head) {  
3.     LinkList *new_node = (LinkList *)malloc(sizeof(LinkList));  
4.     if (new_node == NULL) {  
5.         fprintf(stderr, "malloc failed");  
6.         return head;  
7.     }  
8.     new_node->value = value;  
9.     new_node->next = NULL;  
10.   
11.     if (head == NULL)  
12.         head = new_node;  
13.     else {  
14.         LinkList *pnode = head;  
15.         while (pnode->next != NULL)  
16.             pnode = pnode->next;  
17.         pnode->next = new_node;  
18.     }  
19.     return head;  
20. }  

3. 链表的删除操作

注意当链表仅有一个节点时的删除。

[cpp] view plain copy

1. //删除某节点  
2. LinkList *DeletebyValue(int value, LinkList* head) {  
3.     if (head == NULL)  
4.         return head;  
5.     LinkList *pToDelete = NULL;  
6.     if (head->value == value) {  
7.         pToDelete = head;  
8.         head = head->next;  
9.     }  
10.     else {  
11.         LinkList *p = head;  
12.         while (p->next != NULL && p->next->value != value)  
13.             p = p->next;  
14.         if (p->next != NULL) {  
15.             pToDelete = p->next;  
16.             p->next = pToDelete->next;  
17.         }  
18.     }  
19.     if (pToDelete != NULL) {  
20.         free(pToDelete);  
21.         pToDelete = NULL;  
22.     }  
23.     return head;  
24. }  

4. 求单链表中结点的个数

注意检查链表是否为空。时间复杂度为O（n）。该操作不用特意检查链表是否为空，如下代码，链表为空会返回0。

[cpp] view plain copy

1. unsigned int Length(LinkList *head) {  
2.     unsigned int length = 0;  
3.     LinkList *p = head;  
4.     while (p) {  
5.         ++length;  
6.         p = p->next;  
7.     }  
8.     return length;  
9. }  

5. 打印链表元素

（1）正向打印链表

[cpp] view plain copy

1. //打印单链表  
2. void PrintList(LinkList *head) {  
3.     LinkList *p = head;  
4.     while (p) {  
5.         printf("%d ", p->value);  
6.         p = p->next;  <li class="alt" style="border-t