结构体队列实现

在网上找的队列，发现有问题，已修改
衔接：http://tieba.baidu.com/p/1109535412

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 链表结点结构，贮存链表中的一个结点
typedef struct list_node_type_struct
{
    void* m_data; // 抽象的数据域，void*的类形使得我们的链表可以贮存任何类型的数据
    struct list_node_type_struct* m_prev;
    struct list_node_type_struct* m_next;
} list_node_type;

// 链表结构，贮存整个链表
typedef struct list_type_struct
{
    size_t m_item_size; // 结点中数据域的大小
    size_t m_list_size; // 链表元素个数
    list_node_type m_head;  // 不存放数据的头结点
} list_type;

list_type* list_create(size_t item_size)
{
    list_type* new_list = malloc(sizeof(list_type)); // 为了简单就不做异常检测了

    // 建立一个空的链表
    new_list->m_list_size = 0;
    new_list->m_item_size = item_size;

    new_list->m_head.m_next = &new_list->m_head; // 空的链表
    new_list->m_head.m_prev = &new_list->m_head;
    return new_list;
}

list_node_type* list_insert(list_type* list, list_node_type* node, void* data)
{
    // 在node结点之前插入新节点，如果node为null的话就默认在链表尾部插入
    if(!node)
        return list_insert(list, &list->m_head, data); // 尾部插入
    list_node_type* new_node = malloc(sizeof(list_node_type));    

    new_node->m_data = malloc(list->m_item_size);
    memcpy(new_node->m_data, data, list->m_item_size); // 给data赋值给新节点

    new_node->m_next = node; // node节点之前插入
    new_node->m_prev = node->m_prev;
    new_node->m_next->m_prev = new_node;
    new_node->m_prev->m_next = new_node;

    list->m_list_size += 1;
    return new_node;
}

void list_remove(list_type* list, list_node_type* node)
{
    // 删除结点
    node->m_next->m_prev = node->m_prev;
    node->m_prev->m_next = node->m_next;
    free(node->m_data);
    free(node);
    list->m_list_size -= 1;
    return;
}

// 一组链表的遍历函数
list_node_type* list_head(list_type* list) { return list->m_list_size > 0 ? list->m_head.m_next : NULL; }
list_node_type* list_tail(list_type* list) { return list->m_list_size > 0 ? list->m_head.m_prev : NULL; }
list_node_type* list_next(list_type* list, list_node_type* node) { return node != list->m_head.m_prev ? node->m_next : NULL; }
list_node_type* list_prev(list_type* list, list_node_type* node) { return node != list->m_head.m_next ? node->m_prev : NULL; }

void list_destroy(list_type* list)
{
    // 销毁整个链表
    while(list->m_list_size > 0)
        list_remove(list, list->m_head.m_next);
    free(list);
    return;
}


// 以下是示范程序
int main()
{
#if 0

// 示范一：读入5个数存入链表，再打印出来
    {
        list_type* list;
        list_node_type* node;
        int i;
        int data;

        list = list_create(sizeof(int)); // 创建链表
        for(i = 0; i < 5; i++)
        {
            // 输入数据
            printf("input the %d th number\n", i + 1);
            scanf("%d", &data);
            list_insert(list, NULL, &data);
        }
        for(node = list_head(list); node != NULL; node = list_next(list, node))
        {
            // 输出数据
            printf("%d\n", *(int*)node->m_data);
        }
        list_destroy(list); // 炸毁整个链表
    }

#else

// 示范二：读入5个学生姓名和成绩，删除第4个，再打印出来
    typedef struct student_info_type_struct
    {
        char m_name[16];
        int m_score;
    } student_info_type;

    student_info_type data;
    list_type* list;
    list_node_type* node;
    int i;

    list = list_create(sizeof(student_info_type)); // 创建链表
    for(i = 0; i < 5; i++)
    {
        // 输入数据
        printf("input name and score of %d th student\n", i + 1);
        scanf("%s%d", data.m_name, &data.m_score);
        list_insert(list, NULL, &data);
    }

    for(node = list_head(list), i = 0; i < 3; i++) // 删除第4个结点
        node = list_next(list, node);
    list_remove(list, node);

    for(node = list_head(list); node != NULL; node = list_next(list, node))
    {
        // 输出数据
        data = *(student_info_type*)node->m_data;
        printf("name %s, score %d\n", data.m_name, data.m_score);
    }
    list_destroy(list); // 炸毁整个链表

#endif
    return 0;
}