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

http://coolshell.cn/articles/8990.html

Linus举了一个单向链表的例子，但给出的代码太短了，一般的人很难搞明白这两个代码后面的含义。正好，有个编程爱好者阅读了这段话，并给出了一个比较完整的代码。他的话我就不翻译了，下面给出代码说明。

如果我们需要写一个remove_if(link*, rm_cond_func*)的函数，也就是传入一个单向链表，和一个自定义的是否删除的函数，然后返回处理后的链接。

这个代码不难，基本上所有的教科书都会提供下面的代码示例，而这种写法也是大公司的面试题标准模板：

typedef struct node
{
    struct node * next;
    ....
} node;

typedef bool (* remove_fn)(node const * v);

// Remove all nodes from the supplied list for which the
// supplied remove function returns true.
// Returns the new head of the list.
node * remove_if(node * head, remove_fn rm)
{
    for (node * prev = NULL, * curr = head; curr != NULL; )
    {
        node * const next = curr->next;
        if (rm(curr))
        {
            if (prev)
                prev->next = next;
            else
                head = next;
            free (curr);
        }
        else
            prev = curr;
        curr = next;
    }
    return head;
}

这里remove_fn由调用查提供的一个是否删除当前实体结点的函数指针，其会判断删除条件是否成立。这段代码维护了两个节点指针prev和curr，标准的教科书写法——删除当前结点时，需要一个previous的指针，并且还要这里还需要做一个边界条件的判断——curr是否为链表头。于是，要删除一个节点（不是表头），只要将前一个节点的next指向当前节点的next指向的对象，即下一个节点（即：prev->next = curr->next），然后释放当前节点。

但在Linus看来，这是不懂指针的人的做法。那么，什么是core low-level coding呢？那就是有效地利用二级指针，将其作为管理和操作链表的首要选项。代码如下：

void remove_if(node ** head, remove_fn rm)
{
    for (node** curr = head; *curr; )
    {
        node * entry = *curr;
        if (rm(entry))
        {
            *curr = entry->next;
            free (entry);
        }
        else
            curr = &entry->next;
    }
}

同上一段代码有何改进呢？我们看到：不需要prev指针了，也不需要再去判断是否为链表头了，但是，curr变成了一个指向指针的指针。这正是这段程序的精妙之处。（注意，我所highlight的那三行代码）

让我们来人肉跑一下这个代码，对于——

• 删除节点是表头的情况，输入参数中传入head的二级指针，在for循环里将其初始化curr，然后entry就是*head(*curr)，我们马上删除它，那么第8行就等效于*head = (*head)->next，就是删除表头的实现。

• 删除节点不是表头的情况，对于上面的代码，我们可以看到——

1）（第12行）如果不删除当前结点 —— curr保存的是当前结点next指针的地址。

2）（第5行） entry 保存了 *curr —— 这意味着在下一次循环：entry就是prev->next指针所指向的内存。

3）（第8行）删除结点：*curr = entry->next; —— 于是：prev->next 指向了 entry -> next;

是不是很巧妙？我们可以只用一个二级指针来操作链表，对所有节点都一样。

如果你对上面的代码和描述理解上有困难的话，你可以看看下图的示意：

#include <stdio.h>
#include <iostream>

using namespace std;

struct node {
    int a;
    node *next;
};

void print(node* head) {
    for(;head!=NULL;head = head->next) {
        cout << head->a << " ";
    }
    cout << endl;
}

//this method is brief
node* rm(node* head,int val) {
    node *pre = NULL;
    node *curr = head;
    for (;curr != NULL;) {
        node *next = curr->next;
        if(curr->a%2 == val) {
            if (pre == NULL) {
                head = next;
            }
            else {
                pre->next = next;
            }
            free(curr);
        }
        else {
            pre = curr;
        }

        curr = next;
    }
    return head;
}

void remove(node **head, int val) {
    //curr指向的是当前节点的指针的指针
    //对于中间节点而言，当前节点的指针和其前一个节点的next是一样的，所以可以看做是前一个节点的next的指针
    for (node** curr = head; *curr != NULL;) {
        node *entry = *curr;//entry是当前节点的指针//1. curr是头节点，那么*curr = entry->next，就是指head指向了下一个节点//2.如果curr是中间节点，则curr是前一个节点next的指针
        if (entry->a % 2 == val) {
            *curr = entry->next;
            free(entry);
        }
        else {
            curr = &(entry->next);
        }
    }
}

int main() {
    node *head = (node*)malloc(sizeof(node));
    head->a = 1;
    node *a = (node*)malloc(sizeof(node));
    a->a = 2;
    node *b = (node*)malloc(sizeof(node));
    b->a = 3;
    node *c = (node*)malloc(sizeof(node));
    c->a = 4;
    node *d = (node*)malloc(sizeof(node));
    d->a = 5;
    head->next = a;
    a->next = b;
    b->next = c;
    c->next = d;
    d->next = NULL;
    print(head);
    remove(&head,0);
    print(head);
    return 1;
}

换言之，如果一个单向链表，next是 第一个 字段，我们可以用一个二级指针dummy引用一条链表上的所有节点。
struct node **dummy = &head->next;
一次解引用*dummy指向头结点head
二次解引用**dummy指向head下一个节点
三次解引用*(*(*dummy))指向第三个节点
以此类推……
如果我们需要找到从head开始的第N个节点，那么对dummy进行N次解引用即可，当然现实工程中一般不会用到这么tricky的语法糖，但使用一个变量同时引用相邻三个节点是很有用的;-)。

给还不明白的同学论证一下，见如下代码
typedef struct list_s{
struct list_s * next;
int a;
int b;

} list_t;

main()
{
list_t lA, lB, lC, lD;
list_t ** phead = &lA.next;

lA.next = &lB;
lA.a = 11;
lA.b = 12;

lB.next = &lC;
lB.a = 21;
lB.b = 22;

lC.next = &lD;
lC.a = 31;
lC.b = 32;

lD.next = NULL;
lD.a = 41;
lD.b = 42;

printf(“%d\n”, ((list_t *)phead)->a);
printf(“%d\n”, (**(list_t**)phead).a);
printf(“%d\n”, (***(list_t***)phead).a);
printf(“%d\n”, (****(list_t****)phead).a);

printf(“%d\n”, ((list_t *)phead)->b);
printf(“%d\n”, (**(list_t**)phead).b);
printf(“%d\n”, (***(list_t***)phead).b);
printf(“%d\n”, (****(list_t****)phead).b);

}

gcc的结果是
11
21
31
41
12
22
32
42