C语言实现单链表算法

#include 
#include 
#include 


typedef struct slist_node_s
{
    struct slist_node_s* next;
}slist_node_t;


struct slist_s
{
    slist_node_t* head;
    slist_node_t* tail;
    int count;
};
typedef struct slist_s slist_t;


slist_t*
slist_new()
{
    slist_t* node = NULL;
    node = (slist_t*)malloc(sizeof(slist_t));
    if (node)
    {
        memset(node, 0, sizeof(slist_t));
    }
    return node;
}

void
slist_free(slist_t* node)
{
    if (node)
    {
        free(node);
    }
    return;
}

void*
slist_add_head(slist_t* slist, slist_node_t* node)
{
    if (!slist || !node)
    {
        return NULL;
    }
    if (slist->head == NULL)
    {
        slist->tail = node;
    }
    else
    {
        node->next = slist->head;
    }
    slist->head = node;
    slist->count++;
    return node;
}

void*
slist_add_tail(slist_t* slist, slist_node_t* node)
{
    if (!slist || !node)
    {
        return NULL;
    }
    if (slist->head == NULL)
    {
        slist->head = node;
    }
    else
    {
        slist->tail->next = node;
    }
    slist->tail = node;
    slist->tail->next = NULL;
    slist->count++;

    return node;
}

void
slist_del_node(slist_t* slist, slist_node_t* del_node)
{
    slist_node_t* node;
    slist_node_t* node_prev;
    slist_node_t* node_next;

    if (!slist || !del_node)
    {
        return;
    }

    for(node = slist->head; node; node_prev = node, node = node_next)
    {
        node_next = node->next;
        if (node == del_node)
        {
            if (del_node == slist->head)
            {
                slist->head = node_next;
                if (!node_next)
                {
                    slist->tail = NULL;
                }
            }
            else
            {
                node_prev->next = node_next;
                if (!node_next)
                {
                    slist->tail = node_prev;
                }
            }
            slist->count--;
            break;
        }
    }
    return;
}

struct my_data_s
{
    slist_node_t head;
    int num;
};

typedef struct my_data_s my_data_t;

#define ENTRY_NUM 100

int 
main()
{
    int ii = 0;
    my_data_t* my_data = NULL;
    slist_t* slist = NULL;
    slist_node_t* node;
    my_data_t* temp = NULL;

    slist = slist_new();
    if (!slist)
    {
        return -1;
    }
    my_data = (my_data_t*)malloc(ENTRY_NUM * sizeof(my_data_t));
    if (!my_data)
    {
        return -1;
    }
    memset(my_data, 0 ,sizeof(my_data_t));
    for (ii = 0; ii < ENTRY_NUM; ii++)
    {
        my_data[ii].num = ii;
        slist_add_tail(slist, &(my_data[ii].head));
    }

    slist_del_node(slist, &(my_data[50].head));

    ii = 1;
    for (node = slist->head; node; node = node->next)
    {
        temp = (my_data_t*)node;
        printf("%.2d ", temp->num);
        if (ii%4 == 0)
        {
            printf("\n");
        }
        ii++;
    }

    for (node = slist->head; node; node = node->next)
    {
        slist_del_node(slist, node);
    }
    slist_free(slist);
    free(my_data);

    return 0;
}