Algorithms之单链表

　　链表是一种基础数据结构，亦是一种线性结构。除最后一个节点和第一个节点外，每个节点有且仅有一个前趋且有且仅有一个后继。第一个节点无前趋，最后一个节点无后继。单链表是链表的一种，包括数据域和指向下一个节点的指针域。通常定义在其上的插入，删除只需要调整指针指向，因此只需要O(1)的时间，但搜索需要遍历整个链表，因此需要O(n)的时间。

头文件——定义了List的数据结构及操作接口：

/*************************************************************************
    > File Name: list.h
    > Author: hyolin
    > Created Time: Wed 14 Jan 2015 08:15:49 PM CST
 ************************************************************************/

#ifndef LIST_H
#define LIST_H

#include <stdlib.h>

typedef int (*fun_com)(const void *, const void *) ;
typedef void (*func_des)(void *) ;

/**Define a structure for linked list elements*/
typedef struct ListNode_
{
    void *data ;
    struct ListNode_ *next ;
} ListNode;

/**Define a structure for linked lists*/
typedef struct List_ 
{
    int size ;
    func_com *compare ;
    func_des *destroy ;
    ListNode *head ;
    ListNode *tail ;
} List ;

/**List Interface*/
int list_init (List **list, func_com *compare, func_des *destroy) ;
void list_destroy (List *list) ;
/**Insert success return 0,failure return -1*/
int  list_ins_next (List *list, ListNode *element, const void *data) ;

/**Remove success return 0, failure return -1*/
int  list_rm_next (List *list, ListNode *element, void **data) ;

ListNode* list_search (const List *list, const void *data, ListNode **prev) ;

/**return the size of list*/
#define list_size(list) (list)->size
/**return the head of list*/
#define list_head(list) (list)->head
/**return the tail of list*/
#define list_tail(list) (list)->tail
#define list_is_head(list, element) ((element) == (list)->head ?1 : 0))
#define list_is_tail(element) ((element)->next == NULL ? 1 : 0)
#define list_data(element) ((element)->data)
#define list_next(element) ((element)->next)

#endif

 

//实现

/*************************************************************************
    > File Name: list.c
    > Author: hyolin
    > Created Time: Wed 14 Jan 2015 09:34:33 PM CST
 ************************************************************************/
#include <stdio.h> 
#include <stdlib.h>
#include <string.h>

 #include "list.h"

/*Initialize the list*/
int list_init (List **list, func_com *compare, func_des *destroy)
{
    int ret = 0 ;
    *list = NULL ;
    if ((*list = (List*)malloc(sizeof(List))) == NULL)
    {
        ret = -1 ;
        printf("%s %s %dfailure for malloc error: %d\n",__FILE__, __func__, __LINE__, ret) ;
        return ret ;
    }
    (*list)->size = 0 ;
    (*list)->compare = compare ;
    (*list)->destroy = destroy ;
    (*list)->head = NULL ;
    (*list)->tail = NULL ;
    
    return ret ;
}

/*list_destroy*/
void list_destroy (List *list)
{
    void    *data ;
    while (list_size (list) > 0)
    {
        if (list_rm_next(list, NULL, (void **)&data) == 0 && list->destroy
            != NULL)
        {
            list->destroy(data) ;//call a user-defined function to free dynamically data
        }
    }

    //memset(list, 0, sizeof(list)) ;
    if (list != NULL)
        free(list) ;

    return ;
}

/**list_ins_next*/
int list_ins_next (List *list, ListNode *element, const void *data)
{
    int ret = 0 ;

    if (list == NULL || data == NULL)
    {
        ret = -1 ;
        printf("%s %s %d list == NULL || data == NULL %d\n",__FILE__, __func__, __LINE__, ret) ;
        return ret ;
    }
    ListNode    *newNode ;

    /* Allocate storage for the element */
    if ((newNode = (ListNode *)malloc(sizeof(newNode))) == NULL)
    {
        ret = -2 ;
        printf("%s %s %d malloc error : %d\n", __FILE__, __func__, __LINE__, ret) ;
        return ret ;
    }

    /* Insert the element into the list */
    newNode->data = (void *)data ;
    if (element == NULL)
    {
        /* Handle the head of the list */
        if (list_size(list) == 0)
            list->tail = newNode ;

        newNode->next = list->head ;
        list->head = newNode ;
    }
    else {
        if (element->next == NULL)
            list->tail = newNode ;

        newNode->next = element->next ;
        element->next = newNode ;
    }
    /*Adjust the size of the list */
    list->size++ ;

    return ret ;
}
   
/* list_rm_next */
int list_rm_next (List *list, ListNode *element, void **data)
{
    int ret = 0 ;
    ListNode    *oldNode ;
    /* Don't allow remove from an empty list */
    if (list == NULL || list_size(list) == 0)
    {
        ret = -1 ;
        printf("%s %s %d failure  %d",__FILE__, __func__, __LINE__, ret) ;
        return ret ;
    }

    if (element == NULL)
    {
        *data = list->head->data ;
        oldNode = list->head ;
        list->head = list->head->next ;

        if (list_size(list) == 1)
            list->tail = NULL ;
    }
    else {
        if (element->next == NULL)
        {

            ret = -2 ;
            printf("%s %s %d failure: element next is empty %d",__FILE__, __func__, __LINE__, ret) ;
            return ret ;
        }

        oldNode = element->next ;
        *data = oldNode->data ;
        element->next = element->next->next ;
        
        if (element->next ==NULL)
            list->tail = element ;    
    }

    free(oldNode) ;
    list->size-- ;

    return ret ;
}

/* list_search */
ListNode* list_search (const List *list, const void *data, ListNode **prev/*,
                        int (*compare)(const void *key1, const void *key2)*/)
{
    int ret = 0 ;
    if (list == NULL || data == NULL)
    {
        ret = -1 ;
        printf("%s %s %d failure: list ==  NULL or data == NULL %d",__FILE__, __func__, __LINE__, ret) ;
        return ret ;
    }
    /** Return the data of the list node */
    ListNode *element = list_head(list) ;
    *prev = NULL ;

    while (element)
    {
        if (list->compare(element->data, data) == 0)
            break ;
        prev = element ;
        element = element->next ;
    }
    /* 
     for (; element != NULL; element = list_next(element))
     {
        if (compare(list_data(element) == 0))
            break ;
        prev = element ;
     }
     */
    return element ;
}

 //测试函数

/*************************************************************************
    > File Name: list_test.c
    > Author: hyolin 
    > Created Time: Thu 15 Jan 2015 01:56:48 PM CST
 ************************************************************************/

#include <stdio.h>

#include "list.h"


typedef struct st_ {
    int age ;
} st ;

void destroy(void *data)
{
    if (data != NULL)
        free(data);
    data = NULL ;
}
void print_list (List *list)
{
    ListNode * p = NULL ;
    if (list == NULL)
        return ;
    p = list->head ;
    while (p)
    {
        printf("listNode:%d\n", *(int *)p->data) ;
        p = p->next ;
    }
}

/* List testing function */
int list_test ()
{
    st *data = NULL ;
    List *list = NULL ;

    list_init(&list, NULL, destroy) ;

    int i ;
    st *d[10] ;
    for (i = 0; i <10; i++)
    {
        d[i] = NULL ;
        if ((d[i] = (st*)malloc(sizeof(st))) == NULL)
            return -1 ;
        d[i]->age = i ;
        list_ins_next(list, NULL, (void*)d[i]) ;
        printf("list:%p size:%d\n",list->head->data,list->size) ;
    }

    print_list(list) ;

    list_rm_next(list, NULL, (void**)&data) ;
    destroy((void*)data) ;
    
    print_list(list) ;
    
    list_destroy(list) ;
    
    return 0 ;
}

int main ()
{
    list_test() ;
    return 0 ;
}

测试结果：