（C语言版）链表（一）——实现单向链表创建、插入、删除等简单操作（包含个人理解说明及注释，新手跟着写代码）

http://blog.csdn.net/fisherwan/article/details/19701027

我学习了几天数据结构，今天下午自己写了一个单向链表的程序。我也是新手，所以刚开始学习数据结构的菜鸟们（有大牛们能屈尊看一看，也是我的荣幸）可以和我一起共同学习、讨论，当然也很高兴能指出我的错误，因为这是我们一起成长的过程。本代码包含我在写程序时的一些个人理解的说明和一些注释（如果那里说错了，望大家来指正），下面就进入正题了。

首先，这是个单向链表的代码，下面是我找的一张单向链表的示意图。

很明显可以看出它们是像链子一样串在一起，它们是靠什么串在一起的呢？可能有些人已经知道了——是指针，这里的每一个方格我们叫做“节点”，每一个节点包含一个指针指向下一个节点，并且自己被上一个节点的指针指着，然后串在一起。但是这里有一点要注意，就是头节点（就是图中的第一个节点）是不被其他节点指着的，尾节点（就是图中的最后一个节点）不指向其他的节点，程序中我们让它指向NULL，就是不指向任何东西。

SgLInkList.h 头文件

这里定义了节点的结构，包括一个数据成员和一个结构体指针，结构体指针是用来指向下一个节点用的，还包括单向链表的相关操作。

[cpp] view plain copy 
 #ifndef _SINGLY_LINKED_LIST_H_H  
 #define _SINGLY_LINED_LIST_H_H  
   
 //设计节点结构  
 typedef struct Node  
 {  
     int data;  
     struct Node *pNext;  
 }NODE, *pNODE;  
   
 //创建单向链表  
 pNODE CreateSgLinkList(void);  
   
 //打印单向链表  
 void TraverseSgLinkList(pNODE pHead);  
   
 //判断单向链表是否为空  
 int IsEmptySgLinkList(pNODE pHead);  
   
 //计算单向链表的长度  
 int GetLengthSgLinkList(pNODE pHead);  
   
 //向单向链表插入节点  
 int InsertEleSgLinkList(pNODE pHead, int pos, int data);  
   
 //从单向链表删除节点  
 int DeleteEleSgLinkList(pNODE pHead, int pos);  
   
 //删除整个链表，释放内存  
 void FreeMemory(pNODE *ppHead);  
   
 #endif  

SgLinkList.cpp 存放单向链表相关操作函数的定义，包含链表的创建、链表值的打印、判断链表是否为空、计算链表长度、插入节点、删除节点、删除整个链表。

[cpp] view plain copy 
 #include <stdio.h>  
 #include <stdlib.h>  
 #include "SgLinkList.h"  

（1）第一个函数是创建单向链表，这里我首先创建了一个节点作为头节点，但是这个头节点不参与后面相关函数的运行，例如：头结点不参与链表数据的打印；只包含头节点不包含其他节点时，该链表判断为空；计算链表长度时，头结点不参与计数，删除和插入节点函数也都是从头节点后面的节点计数的。当然有一点，最后释放内存的时候，头节点是要跟着一起释放的，因为给头节点分配了内存所以也得释放，要不会造成内存泄露，这一点很容易忽视了。

[cpp] view plain copy 
 //创建单向链表  
 pNODE CreateSgLinkList(void)  
 {  
     int i, length, data;  
     pNODE p_new = NULL, pTail = NULL;  
     //创建头节点，头结点是第0个节点，后面的节点从1开始计数  
     pNODE pHead = (pNODE)malloc(sizeof(NODE));  
   
     if (NULL == pHead)  
     {  
         printf("内存分配失败！\n");  
         exit(EXIT_FAILURE);  
     }  
   
     pHead->data = 0;  
     pHead->pNext = NULL;  
     pTail = pHead;  
   
     printf("请输入要创建链表的长度：");  
     scanf("%d", &length);  
   
     for (i=1; i<length+1; i++)  
     {  
         p_new = (pNODE)malloc(sizeof(NODE));  
         if (NULL == p_new)  
         {  
             printf("内存分配失败！\n");  
             exit(EXIT_FAILURE);  
         }  
   
         printf("请输入第%d个节点的值：", i);  
         scanf("%d", &data);  
   
         p_new->data = data;  
         p_new->pNext = NULL;  
         pTail->pNext = p_new;  
         pTail = p_new;  
     }  
     return pHead;  
 }  

（2）这个是打印单向链表函数，可以看到是从头结点的后面一个节点开始打印的，p=pHead->pNext。一直打印到最后一个

[cpp] view plain copy 
 //打印单向链表，不打印头结点的值。  
 void TraverseSgLinkList(pNODE pHead)  
 {  
     pNODE pt = pHead->pNext;  
   
     printf("打印链表：");  
     while (pt != NULL)  
     {  
         printf("%d ", pt->data);  
         pt = pt->pNext;  
     }  
     putchar('\n');  
 }  

（3）这个是判断链表是否为空的函数，通过检查头节点的后面一个节点来判断，所以这里头节点也不参与运算。

[cpp] view plain copy 
 //判断链表是否为空  
 int IsEmptySgLinkList(pNODE pHead)  
 {  
     if (pHead->pNext == NULL)  
         return 1;  
     else  
         return 0;  
 }  

（4）这个是计算链表长度的函数，也是从头节点后面的节点开始，找到节点就让length加1，直到找到最后一个节点为止。

[cpp] view plain copy 
 //计算单向链表长度  
 int GetLengthSgLinkList(pNODE pHead)  
 {  
     int length = 0;  
     pNODE pt = pHead->pNext;  
   
     while (pt != NULL)  
     {  
         length++;  
         pt = pt->pNext;  
     }  
     return length;  
 }  

（5）这个是向单向链表插入节点的函数，这里我定义位置值是从1开始，到链表长度加1结束（当然也可以自己定义从什么数值开始），这里位置要比删除节点函数多一个，为什么呢？例如：一个链表包含三个节点（头节点除外），它们的元素值分别为1、2、3，那么我们可以插入节点的地方就有4个位置了，4个位置夹住了三个节点。但是如果是删除节点函数的话呢，操作的是实际的节点，所以位置值就只能是这三个节点了。说到这里大家应该明白了吧。这里附一张插入节点的示意图：

[cpp] view plain copy 
 //向单向链表插入一个节点,位置从1开始，到链表长度加1结束。  
 int InsertEleSgLinkList(pNODE pHead, int pos, int data)  
 {  
     pNODE pt = NULL, p_new = NULL;  
   
     if (pos > 0 && pos < GetLengthSgLinkList(pHead) + 2)  
     {  
         p_new = (pNODE)malloc(sizeof(NODE));  
         if (NULL == p_new)  
         {  
             printf("内存分配失败！\n");  
             exit(EXIT_FAILURE);  
         }  
         p_new->data = data;  
   
         while (1)  
         {  
             pos--;        
             if (0 == pos)  
                 break;  
             pHead  = pHead->pNext;  
         }  
   
         pt = pHead->pNext;  
         pHead->pNext = p_new;  
         p_new->pNext = pt;  
   
         return 1;  
     }  
     else  
         return 0;  
 }  

（6）这个是删除单向链表节点的函数，至于位置值为什么是从1到链表的长度上面已经介绍过了，这里就不再介绍了。这里就说说在删除节点时要注意的地方，首先你要找到要删除的那个节点，然后把要删除节点的下一个节点的地址保存好（这里保存到pt），然后释放该节点的内存，让改指针指向NULL指针（这里因为马上要用到这个指针就没有让它指向NULL指针），接着让被删除节点的上一个的指针指向上面保存好的节点地址（也就是pt），这样节点被删除了，内存也释放了，链表也连接起来了。这就是我个人的简单理解，下面附一张示意图：

[cpp] view plain copy 
 //从单向链表中删除一个节点，位置从1开始，到链表长度结束。  
 int DeleteEleSgLinkList(pNODE pHead, int pos)  
 {  
     pNODE pt = NULL;  
   
     if (pos > 0 && pos < GetLengthSgLinkList(pHead) + 1)  
     {  
         while (1)  
         {  
             pos--;  
             if (0 == pos)  
                 break;  
             pHead = pHead->pNext;  
         }  
   
         pt = pHead->pNext->pNext;  
         free(pHead->pNext);  
         pHead->pNext = pt;  
   
         return 1;  
     }  
     else  
         return 0;  
 }  

（7）这个是删除整个单向链表的函数，当然也起到了释放内存的作用。这里有两个地方要注意的就是，第一，头节点的内存也要参与释放，因为它也分配了内存；第二，这里为什么要用到指向结构体指针的指针，因为内存的分配和释放的原因，那么有人可能就要问了，为什么上面创建链表的时候没有用到这个，那是因为上面用到了返回值来获得分配的内存，这也是一种方法。

这里我就补充个知识点（可能有很多人已经知道了）：指针做函数的形参时，编译器总是要为函数的每个参数制作临时副本，指针参数p的副本是ptemp，编译器使ptemp=p。如果函数体的程序修改了ptemp的内容，就相应的就该了参数p的内容，这就是指针可以用作输出参数的原因。但是在申请内存时情况就不一样了，因为只是把ptemp所指向的内存地址改变了，但是p丝毫未变。所以，如果非要用指针参数去申请内存，那么应该用“指向指针的指针”。

[cpp] view plain copy 
 //删除整个单向链表，释放内存。  
 void FreeMemory(pNODE *ppHead)  
 {  
     pNODE pt = NULL;  
     while (*ppHead != NULL)  
     {  
         pt = (*ppHead)->pNext;  
         free(*ppHead);  
         *ppHead = pt;  
     }  
 }  

main.cpp 这是测试程序，判断函数是否得到了正确的结果。

[cpp] view plain copy 
 #include <stdio.h>  
 #include <stdlib.h>  
 #include "SgLinkList.h"  
   
 int main(void)  
 {  
     int flag = 0, length = 0;  
     int position = 0, value = 0;  
     pNODE head = NULL;  
   
     head = CreateSgLinkList();  
       
     flag = IsEmptySgLinkList(head);  
     if (flag)  
         printf("单向链表为空！\n");  
     else  
     {  
         length = GetLengthSgLinkList(head);  
         printf("单向链表的长度为：%d\n", length);  
         TraverseSgLinkList(head);  
     }  
       
     printf("请输入要插入节点的位置和元素值(两个数用空格隔开)：");  
     scanf("%d %d", &position, &value);  
     flag = InsertEleSgLinkList(head, position, value);  
     if (flag)  
     {  
         printf("插入节点成功！\n");  
         TraverseSgLinkList(head);  
     }     
     else  
         printf("插入节点失败！\n");  
       
     flag = IsEmptySgLinkList(head);  
     if (flag)  
         printf("单向链表为空，不能进行删除操作！\n");  
     else  
     {  
         printf("请输入要删除节点的位置：");  
         scanf("%d", &position);  
         flag = DeleteEleSgLinkList(head, position);  
         if (flag)  
         {  
             printf("删除节点成功！\n");  
             TraverseSgLinkList(head);  
         }     
         else  
             printf("删除节点失败！\n");  
     }  
           
     FreeMemory(&head);  
     if (NULL == head)  
         printf("已成功删除单向链表，释放内存完成！\n");  
     else  
         printf("删除单向链表失败，释放内存未完成！\n");  
   
     return 0;  
 }  