C和C指针小记(十七)-使用结构和指针-链表

1、链表

链表(linked list)即使是一些包含数据的独立数据结构的(Node)集合.

链表中的每个节点通过链或指针链接在一起.

程序通过指针访问链表中的节点.

节点通常是动态分配的,但也有由节点数组构建的链表(即使这样,程序也是通过指针来遍历链表).

1.1 单链表

单链表中,每个节点包含一个指向链表下一节点的指针.链表最后一个节点的指针字段的值为NULL.提示链表后面不再有其他节点.

根指针,根指针指向链表的第一个节点,根指针只是一个指针,不包含任何数据.

//但链表节点的结构
typedef struct NODE {
    struct Node *link;
    int    value;
} Node;

单链表的一些性质

链表不一定是顺序存储的,它的节点可能分部于内存的各个地方.

单链表可以通过链表从开始遍历链表知道结束位置,但无法从相反方向进行遍历.

1.2 在单链表中插入

我们怎么才能把一个新节点插入到有序单链表中呢?加入要把12插入到单链表.(如果链表中的值为 5, 10, 15)

思路:从链表的起始位置开始,跟随指针直到找到第一个值大于7的节点,然后把这个新值插入到那个节点之前的位置.

有一个问题,当我们找到第一个大于12的节点时,指针可能指向了15,我们无法直到已经遍历过的指针了,我们也无法返回.解决这个问题的方法就是始终保存一个指向链表当前节点之前的那个节点指针.

//插入到一个有序的单链表,函数的参数是一个指向链表第一个节点的指针以及需要插入的值.
#include <stdlib.h>
#include <stdio.h>
#include "ssl_node.h"

#define FALSE 0
#define TRUE 1

int ssl_insert( Node *current, int new_value ) {
    Node *previous;
    Node *new;
    //寻找正确的插入位置,方法是按顺序访问链表,直到到达其值大于或等于新插入的值
    while( current->value < new_value ){
        previour = current;
        current = current->link;
    }
    //为新节点分配内存,并把新值存储到新节点中,如果内存分配失败,函数返回False
    new = (Node *)malloc( sizeof( Node ) );
    if( new == NULL )
        return FALSE;
    new->value = new_value;
    //把新节点插入到链表中,并返回TURE
    new->link = current;
    previous->link = new;
    return TURE;
}
//调用
result = ssl_insert( root, 12 );

以上函数是存在问题的

插入20时,while 会越过链表的尾部.并对一个NULL指针执行间接访问操作. 我们没有对current 指针判空,在while语句中直接对current取value是不对的.对空指针间接引用是非法的.

所以 while( current != NULL & current->value < value ) 时继续循环

插入3时, 为了在链表的起始位置插入一个节点,函数必须修改指针.但是,函数不能反问变量root. 修正这个问题最容易的方法是把 root 声明为全局变量,这样插入函数就能修改它.不幸的是,这是最坏的一种方法.因为这样一来函数只对这个链表起作用了

稍好的解决方法是把一个指向root的指针作为参数传递给函数.然后使用间接访问. 函数不仅可以获得 root (指向链表第一个节点的指针,也就是根指针)的值,也可以向它存储一个新的指针值. 这个参数的类型是什么呢? root 是一个指向 Node 的指针, 所以参数的类型应该是Node **, 也就是一个指向Node 的指针的指针.

#include <stdlib.h>
#include <stdio.h>
#include "ssl_node.h"

#define FALSE 0
#define TRUE 1
//插入到一个有序链表,函数的参数是一个指向链表根指针的指针,以及一个需要插入的新值
int ssl_insert( Node **rootp, int new_value) {
    Node    *current;//当前指针
    Node    *previous;//前一个指针
    Node    *new;//新节点指针

    //得到一个指向第一个节点的指针
    current = *rootp;
    previous = NULL;//初始化previous

    //寻找正确的插入位置,方法是按序访问链表,直到达到一个其值大于或等于新值的节点
    while ( current != NULL && current->value < new_value) {
        previous = current;
        current = current->link;
    }

    //为新节点分配内存,并把新值存储到新的节点,如果内存分配失败.函数返回FALSE
    new = (Node *)malloc( sizeof( Node ));
    if (new == NULL) {
        return FALSE;
    }
    new->value = new_value;

    //把新节点插入到链表中,并返回 TURE
    new->link = current;
    if ( previous == NULL) {//用于检测新值是否应该添加到链表的起始位置
        *rootp = new;
    }else {
        previous->link = new;
    }

    return TRUE;
}

终极优化

把一个节点插入到链表的起始位置必须作为特殊情况进行处理吗?毕竟我们此时插入新节点需要修改的指针是根指针,对于任何其他节点,对指针进行修改时实际修改的是前一个节点的link 字段. 这两个看上去不同的操作实际上是一样的.

消除特殊情况的关键在于:链表中的每个节点都有一个指向它的指针. 对于第一个节点,这个指针是根指针,对于其他节点,这个指针是前一个节点的link字段.重点在于每个节点都有一个指针指向它.至于指针是否位于某个节点之内是无关紧要的.

取得当前节点内部的link字段的地址也是很方便的: &current->link

#include <stdlib.h>
#include <stdio.h>
#include "ssl_node.h"

#define FALSE 0
#define TRUE 1
/**
 把头指针和节点内指针同样对待,就不用对插入第一个节点之前的情况特殊对待了

 @param linkp 指向头指针的指针
 @param new_value 新值
 @return 插入结构 1成功,0失败
 */
int ssl_insert_1( register Node **linkp, int new_value){
    register Node *current;
    register Node *new;

    //寻找正确的插入位置,方法是按序访问链表,直道到达一个其值大于或等于新值的节点
    while ( (current = *linkp) != NULL && current->value < new_value) {
        linkp = &current->link;
    }

    //为新节点分配内存,并把新值存储到新节点中,如果内存分配失败,函数返回FALSE
    new = (Node *)malloc( sizeof( Node) );
    if (new == NULL) {
        return FALSE;
    }
    new->value = new_value;

    //在链表中插入新节点
    new->link = current;
    *linkp = new;
    return TRUE
}