利用二级指针插入和删除单向链表

单链表是一种我们很常见的数据结构，在每一门介绍数据结构的书本中都会详细介绍单链表的结构和性质，单链表由一系列形如下面结构的Node节点组成

typedef struct Node{

      struct Node *next;

      int         value;

}Node;

链表最后一个节点的指针字段的值为NULL。通常我们使用一个根指针来标记链表的起始位置，通过根指针就可以访问整个链表了，根指针只是一个指针，它不含有任何数据。

上面是一个升序排列的链表。下面让我们考虑一下向链表中插入一个新节点。标准的教科书写法——插入一个结点时，需要一个previous的指针，并且这里还需要做一个边界条件的判断——current是否为链表头。于是我们有下面的代码：

     1    int insert_if(Node *current,int new_value){
     2       Node *previous;
     3       Node *new;
     4       /*find the right position by going through the list*/
     5       while(current != NULL && current->value < new_value){
     6          previous = current;
     7          current = current->next;
     8       }
     9       /*allocate memory for the new node*/
    10       new = (Node *)malloc(sizeof(Node));
    11       if(new == NULL)
    12          return FALSE;
    13       new->value = new_value;
    14    
    15       /*insert the new node into list*/
    16       new->next = current;
    17       previous->next = new;
    18       
    19       return TRUE;
    20    }

当然这段代码是有问题的，因为当在链表头插入节点时，代码将无法正确工作，为了在链表的起始位置插入一个节点，函数必须修改根指针。但是，函数不能访问变量root，因为root的值的拷贝是作为形参传递给current，任何修改都不会真正反映到root上。解决办法就是把一个指向root的指针作为参数传递给函数，这样就有下面的程序：

 1    int insert_if(Node **rootp,int new_value){
     2       Node *previous;
     3       Node *current
     4       Node *new;
     5       /*get the point of the first node*/
     6       current = *rootp;
     7       previous = NULL;
     8    
     9       /*find the right position by going through the list*/
    10       while(current != NULL && current->value < new_value){
    11          previous = current;
    12          current = current->next;
    13       }
    14       /*allocate memory for the new node*/
    15       new = (Node *)malloc(sizeof(Node));
    16       if(new == NULL)
    17          return FALSE;
    18       new->value = new_value;
    19    
    20       /*insert the new node into list*/
    21       new->next = current;
    22       if(previous==NULL)
    23          *rootp = new;
    24       else
    25          previous->next = new;
    26       
    27       return TRUE;
    28    }
         第7行赋值后，就可以用于22行判断新值是否应该被添加到链表的起始位置。上面的代码主要是针对在起始位置插入而做一些特殊处理。因为在起始位置插入新节点需要修改的指针是根指针，而对于其他节点，对指针进行的修改实际修改的是前一个节点的next自段。但事实真的是这样么？其实这两个看上去不同的操作实际上是一样的。
消除特殊情况的关键在于：链表中的每个节点都有一个指向它的指针。对于第一个节点，这个指针是根指针；对于其他节点，这个指针是前一个节点的next字段。重点在于每个指针都有一个指针指向它。至于该指针是不是位于一个节点的内部则无关紧要。

        我们拥有一个指向当前节点的指针，以及一个“指向当今节点的next字段的”指针，我们不需要previous来指示前一个节点。当移动到下一个节点时，我们保存一个“指向下一个节点的next字段的”指针，而不是保存一个指向当前一个节点的指针。如下面两幅图所示：

 

                                                               图一                  

                                                                 图二

这里rootp并不指向节点本身，而是指向节点内部的next字段。代码如下所示：

     1    int insert_if(Node **nextp,int new_value){
     2       Node *current
     3       Node *new;
     4    
     5       /*find the right position by going through the list*/
     6       while((current = *nextp) != NULL && current->value < new_value){
     7          nextp = &current->next;
     8       }
     9       /*allocate memory for the new node*/
    10       new = (Node *)malloc(sizeof(Node));
    11       if(new == NULL)
    12          return FALSE;
    13       new->value = new_value;
    14    
    15       /*insert the new node into list*/
    16       new->next = current;
    17       *nextp = new;
    18       else
    19          previous->next = new;
    20       
    21       return TRUE;
    22    }

这里分析了利用二级指针在单链表中的应用，可见其可以达到优化代码的作用，当然这一思想也可用于对链表的查找和删除，这里有一篇关于coolshell.cn/articles/8990.html 二级指针在链表中删除的应用，其思想是一样的。