C语言面向对象编程（五）：单链表实现（转）

 这里实现的单链表，可以存储任意数据类型，支持增、删、改、查找、插入等基本操作。（本文提供的是完整代码，可能有些长。）

    下面是头文件：

#ifndef SLIST_H  
#define SLIST_H  
  
#ifdef __cplusplus  
extern "C" {  
#endif  
  
#define NODE_T(ptr, type) ((type*)ptr)  
  
struct slist_node {  
    struct slist_node * next;  
};  
  
typedef void (*list_op_free_node)(struct slist_node *node);  
/* 
 * return 0 on hit key, else return none zero 
 */  
typedef int (*list_op_key_hit_test)(struct slist_node *node, void *key);  
  
struct single_list {  
    /* all the members must not be changed manually by callee */  
    struct slist_node * head;  
    struct slist_node * tail;  
    int size; /* length of the list, do not change it manually*/  
  
    /* free method to delete the node 
     */  
    void (*free_node)(struct slist_node *node);  
    /* 
     * should be set by callee, used to locate node by key(*_by_key() method) 
     * return 0 on hit key, else return none zero 
     */  
    int (*key_hit_test)(struct slist_node *node, void *key);  
  
    struct single_list *(*add)(struct single_list * list, struct slist_node * node);  
    struct single_list *(*insert)(struct single_list * list, int pos, struct slist_node *node);  
    /* NOTE: the original node at the pos will be freed by free_node */  
    struct single_list *(*replace)(struct single_list *list, int pos, struct slist_node *node);  
    struct slist_node *(*find_by_key)(struct single_list *, void * key);  
    struct slist_node *(*first)(struct single_list* list);  
    struct slist_node *(*last)(struct single_list* list);  
    struct slist_node *(*at)(struct single_list * list, int pos);  
    struct slist_node *(*take_at)(struct single_list * list, int pos);  
    struct slist_node *(*take_by_key)(struct single_list * list, void *key);  
    struct single_list *(*remove)(struct single_list * list, struct slist_node * node);  
    struct single_list *(*remove_at)(struct single_list *list, int pos);  
    struct single_list *(*remove_by_key)(struct single_list *list, void *key);  
    int (*length)(struct single_list * list);  
    void (*clear)(struct single_list * list);  
    void (*deletor)(struct single_list *list);  
};  
  
struct single_list * new_single_list(list_op_free_node op_free, list_op_key_hit_test op_cmp);  
  
#ifdef __cplusplus  
}  
#endif  
  
#endif // SLIST_H  

struct single_list 这个类，遵循我们前面介绍的基本原则，不再一一细说。有几点需要提一下：

• 我们定义了 slist_node 作为链表节点的基类，用户自定义的节点，都必须从 slist_node 继承
• 为了支持节点（ node ）的释放，我们引入一个回调函数 list_op_free_node ，这个回调需要在创建链表时传入
• 为了支持查找，引入另外一个回调函数 list_op_key_hit_test 

    好了，下面看实现文件：

#include "slist.h"  
#include <malloc.h>  
  
static struct single_list * _add_node(struct single_list *list, struct slist_node *node)  
{  
  
    if(list->tail)  
    {  
        list->tail->next = node;  
        node->next = 0;  
        list->tail = node;  
        list->size++;  
    }  
    else  
    {  
        list->head = node;  
        list->tail = node;  
        node->next = 0;  
        list->size = 1;  
    }  
  
    return list;  
}  
  
static struct single_list * _insert_node(struct single_list * list, int pos, struct slist_node *node)  
{  
    if(pos < list->size)  
    {  
        int i = 0;  
        struct slist_node * p = list->head;  
        struct slist_node * prev = list->head;  
        for(; i < pos; i++)  
        {  
            prev = p;  
            p = p->next;  
        }  
        if(p == list->head)  
        {  
            /* insert at head */  
            node->next = list->head;  
            list->head = node;  
        }  
        else  
        {  
            prev->next = node;  
            node->next = p;  
        }  
  
        if(node->next == 0) list->tail = node;  
        list->size++;  
    }  
    else  
    {  
        list->add(list, node);  
    }  
  
    return list;  
}  
  
static struct single_list * _replace(struct single_list * list, int pos, struct slist_node *node)  
{  
    if(pos < list->size)  
    {  
        int i = 0;  
        struct slist_node * p = list->head;  
        struct slist_node * prev = list->head;  
        for(; i < pos; i++)  
        {  
            prev = p;  
            p = p->next;  
        }  
        if(p == list->head)  
        {  
            /* replace at head */  
            node->next = list->head->next;  
            list->head = node;  
        }  
        else  
        {  
            prev->next = node;  
            node->next = p->next;  
        }  
  
        if(node->next == 0) list->tail = node;  
  
        if(list->free_node) list->free_node(p);  
        else free(p);  
    }  
  
    return list;  
}  
  
static struct slist_node * _find_by_key(struct single_list *list, void * key)  
{  
    if(list->key_hit_test)  
    {  
        struct slist_node * p = list->head;  
        while(p)  
        {  
            if(list->key_hit_test(p, key) == 0) return p;  
            p = p->next;  
        }  
    }  
    return 0;  
}  
  
static struct slist_node *_first_of(struct single_list* list)  
{  
    return list->head;  
}  
  
static struct slist_node *_last_of(struct single_list* list)  
{  
    return list->tail;  
}  
  
static struct slist_node *_node_at(struct single_list * list, int pos)  
{  
    if(pos < list->size)  
    {  
        int i = 0;  
        struct slist_node * p = list->head;  
        for(; i < pos; i++)  
        {  
            p = p->next;  
        }  
        return p;  
    }  
  
    return 0;  
}  
  
static struct slist_node * _take_at(struct single_list * list, int pos)  
{  
    if(pos < list->size)  
    {  
        int i = 0;  
        struct slist_node * p = list->head;  
        struct slist_node * prev = p;  
        for(; i < pos ; i++)  
        {  
            prev = p;  
            p = p->next;  
        }  
        if(p == list->head)  
        {  
            list->head = p->next;  
            if(list->head == 0) list->tail = 0;  
        }  
        else if(p == list->tail)  
        {  
            list->tail = prev;  
            prev->next = 0;  
        }  
        else  
        {  
            prev->next = p->next;  
        }  
  
        list->size--;  
  
        p->next = 0;  
        return p;  
    }  
  
    return 0;  
}  
  
static struct slist_node * _take_by_key(struct single_list * list, void *key)  
{  
    if(list->key_hit_test)  
    {  
        struct slist_node * p = list->head;  
        struct slist_node * prev = p;  
        while(p)  
        {  
            if(list->key_hit_test(p, key) == 0) break;  
            prev = p;  
            p = p->next;  
        }  
  
        if(p)  
        {  
            if(p == list->head)  
            {  
                list->head = p->next;  
                if(list->head == 0) list->tail = 0;  
            }  
            else if(p == list->tail)  
            {  
                list->tail = prev;  
                prev->next = 0;  
            }  
            else  
            {  
                prev->next = p->next;  
            }  
  
            list->size--;  
  
            p->next = 0;  
            return p;  
        }  
    }  
    return 0;  
}  
  
static struct single_list *_remove_node(struct single_list * list, struct slist_node * node)  
{  
    struct slist_node * p = list->head;  
    struct slist_node * prev = p;  
    while(p)  
    {  
        if(p == node) break;  
        prev = p;  
        p = p->next;  
    }  
  
    if(p)  
    {  
        if(p == list->head)  
        {  
            list->head = list->head->next;  
            if(list->head == 0) list->tail = 0;  
        }  
        else if(p == list->tail)  
        {  
            prev->next = 0;  
            list->tail = prev;  
        }  
        else  
        {  
            prev->next = p->next;  
        }  
  
        if(list->free_node) list->free_node(p);  
        else free(p);  
  
        list->size--;  
    }  
    return list;  
}  
  
static struct single_list *_remove_at(struct single_list *list, int pos)  
{  
    if(pos < list->size)  
    {  
        int i = 0;  
        struct slist_node * p = list->head;  
        struct slist_node * prev = p;  
        for(; i < pos ; i++)  
        {  
            prev = p;  
            p = p->next;  
        }  
        if(p == list->head)  
        {  
            list->head = p->next;  
            if(list->head == 0) list->tail = 0;  
        }  
        else if(p == list->tail)  
        {  
            list->tail = prev;  
            prev->next = 0;  
        }  
        else  
        {  
            prev->next = p->next;  
        }  
  
        if(list->free_node) list->free_node(p);  
        else free(p);  
  
        list->size--;  
    }  
  
    return list;  
}  
  
static struct single_list *_remove_by_key(struct single_list *list, void *key)  
{  
    if(list->key_hit_test)  
    {  
        struct slist_node * p = list->head;  
        struct slist_node * prev = p;  
        while(p)  
        {  
            if(list->key_hit_test(p, key) == 0) break;  
            prev = p;  
            p = p->next;  
        }  
  
        if(p)  
        {  
            if(p == list->head)  
            {  
                list->head = list->head->next;  
                if(list->head == 0) list->tail = 0;  
            }  
            else if(p == list->tail)  
            {  
                prev->next = 0;  
                list->tail = prev;  
            }  
            else  
            {  
                prev->next = p->next;  
            }  
  
            if(list->free_node) list->free_node(p);  
            else free(p);  
  
            list->size--;  
        }  
    }  
  
    return list;  
}  
  
static int _length_of(struct single_list * list)  
{  
    return list->size;  
}  
  
static void _clear_list(struct single_list * list)  
{  
    struct slist_node * p = list->head;  
    struct slist_node * p2;  
    while(p)  
    {  
        p2 = p;  
        p = p->next;  
  
        if(list->free_node) list->free_node(p2);  
        else free(p2);  
    }  
  
    list->head = 0;  
    list->tail = 0;  
    list->size = 0;  
}  
  
static void _delete_single_list(struct single_list *list)  
{  
    list->clear(list);  
    free(list);  
}  
  
struct single_list * new_single_list(list_op_free_node op_free, list_op_key_hit_test op_cmp)  
{  
    struct single_list *list = (struct single_list *)malloc(sizeof(struct single_list));  
    list->head = 0;  
    list->tail = 0;  
    list->size = 0;  
    list->free_node = op_free;  
    list->key_hit_test = op_cmp;  
  
    list->add = _add_node;  
    list->insert = _insert_node;  
    list->replace = _replace;  
    list->find_by_key = _find_by_key;  
    list->first = _first_of;  
    list->last = _last_of;  
    list->at = _node_at;  
    list->take_at = _take_at;  
    list->take_by_key = _take_by_key;  
    list->remove = _remove_node;  
    list->remove_at = _remove_at;  
    list->remove_by_key = _remove_by_key;  
    list->length = _length_of;  
    list->clear = _clear_list;  
    list->deletor = _delete_single_list;  
  
    return list;  
}  

上面的代码就不一一细说了，下面是测试代码：

/* call 1 or N arguments function of struct */  
#define ST_CALL(THIS,func,args...) ((THIS)->func(THIS,args))  
  
/* call none-arguments function of struct */  
#define ST_CALL_0(THIS,func) ((THIS)->func(THIS))  
  
struct int_node {  
    struct slist_node node;  
    int id;  
};  
  
struct string_node {  
    struct slist_node node;  
    char name[16];  
};  
  
  
static int int_free_flag = 0;  
static void _int_child_free(struct slist_node *node)  
{  
    free(node);  
    if(!int_free_flag)  
    {  
        int_free_flag = 1;  
        printf("int node free
");  
    }  
}  
  
static int _int_slist_hittest(struct slist_node * node, void *key)  
{  
    struct int_node * inode = NODE_T(node, struct int_node);  
    int ikey = (int)key;  
    return (inode->id == ikey ? 0 : 1);  
}  
  
static int string_free_flag = 0;  
static void _string_child_free(struct slist_node *node)  
{  
    free(node);  
    if(!string_free_flag)  
    {  
        string_free_flag = 1;  
        printf("string node free
");  
    }  
}  
  
static int _string_slist_hittest(struct slist_node * node, void *key)  
{  
    struct string_node * sn = (struct string_node*)node;  
    return strcmp(sn->name, (char*)key);  
}  
  
void int_slist_test()  
{  
    struct single_list * list = new_single_list(_int_child_free, _int_slist_hittest);  
    struct int_node * node = 0;  
    struct slist_node * bn = 0;  
    int i = 0;  
  
    printf("create list && nodes:
");  
    for(; i < 100; i++)  
    {  
        node = (struct int_node*)malloc(sizeof(struct int_node));  
        node->id = i;  
        if(i%10)  
        {  
            list->add(list, node);  
        }  
        else  
        {  
            list->insert(list, 1, node);  
        }  
    }  
    printf("create 100 nodes end
----
");  
    printf("first is : %d, last is: %d
----
",  
           NODE_T( ST_CALL_0(list, first), struct int_node )->id,  
           NODE_T( ST_CALL_0(list, last ), struct int_node )->id);  
  
    assert(list->size == 100);  
  
    printf("list traverse:
");  
    for(i = 0; i < 100; i++)  
    {  
        if(i%10 == 0) printf("
");  
        bn = list->at(list, i);  
        node = NODE_T(bn, struct int_node);  
        printf(" %d", node->id);  
    }  
    printf("
-----
");  
  
    printf("find by key test, key=42:
");  
    bn = list->find_by_key(list, (void*)42);  
    assert(bn != 0);  
    node = NODE_T(bn, struct int_node);  
    printf("find node(key=42), %d
------
", node->id);  
  
    printf("remove node test, remove the 10th node:
");  
    bn = list->at(list, 10);  
    node = NODE_T(bn, struct int_node);  
    printf("  node 10 is: %d
", node->id);  
    printf("  now remove node 10
");  
    list->remove_at(list, 10);  
    printf(" node 10 was removed, check node 10 again:
");  
    bn = list->at(list, 10);  
    node = NODE_T(bn, struct int_node);  
    printf("  now node 10 is: %d
------
", node->id);  
  
    printf("replace test, replace node 12 with id 1200:
");  
    bn = list->at(list, 12);  
    node = NODE_T(bn, struct int_node);  
    printf("  now node 12 is : %d
", node->id);  
    node = (struct int_node*)malloc(sizeof(struct int_node));  
    node->id = 1200;  
    list->replace(list, 12, node);  
    bn = list->at(list, 12);  
    node = NODE_T(bn, struct int_node);  
    printf("  replaced, now node 12 is : %d
----
", node->id);  
  
    printf("test remove:
");  
    ST_CALL(list, remove, bn);  
    bn = ST_CALL(list, find_by_key, (void*)1200);  
    assert(bn == 0);  
    printf("test remove ok
----
");  
    printf("test remove_by_key(90):
");  
    ST_CALL(list, remove_by_key, (void*)90);  
    bn = ST_CALL(list, find_by_key, (void*)90);  
    assert(bn == 0);  
    printf("test remove_by_key(90) end
----
");  
    printf("test take_at(80):
");  
    bn = ST_CALL(list, take_at, 80);  
    printf("  node 80 is: %d
", NODE_T(bn, struct int_node)->id);  
    free(bn);  
    printf("test take_at(80) end
");  
  
    int_free_flag = 0;  
    printf("delete list && nodes:
");  
    list->deletor(list);  
    printf("delete list && nodes end
");  
    printf("
 test add/insert/remove/delete/find_by_key/replace...
");  
}  
  
void string_slist_test()  
{  
    struct single_list * list = new_single_list(_string_child_free, _string_slist_hittest);  
}  
  
void slist_test()  
{  
    int_slist_test();  
    string_slist_test();  
}  

测试代码里主要演示了：

• 自定义链表节点类型
• 定义释放回调
• 定义用于查找的 hit test 回调
• 如何创建链表
• 如何使用（ add 、remove 、 take 、find 、 insert 等）

    相信到这里，单链表的使用已经不成问题了。

    以单链表为基础，可以进一步实现很多数据结构，比如树（兄弟孩子表示法），比如 key-value 链表等等。接下来根据例子的需要，会择机进行展示。

转自：http://blog.csdn.net/foruok/article/details/18594177