双向链表与通用型容器

最新推荐文章于 2025-11-23 20:57:51 发布

原创最新推荐文章于 2025-11-23 20:57:51 发布 · 722 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #数据结构

一、双向链表基本概念

双向链表是一种常见的数据结构，每个节点包含两个指针：一个指向前一个节点（prev），一个指向后一个节点（next）。与单向链表相比，双向链表支持双向遍历，操作更为灵活，尤其适合需要频繁前后遍历的场景。

核心特点：

每个节点包含数据域和两个指针域
支持从头到尾或从尾到头的双向遍历
实际应用中常采用循环结构（首尾相连）

二、双向链表设计与实现

1. 节点设计

typedef struct node
{
    int data;               // 数据域
    struct node* prev_p;    // 前驱指针
    struct node* next_p;    // 后继指针
} node_t, *node_p;

2. 初始化空链表（头节点）

node_p DLINK_LIST_InitHeadNode(void)
{
    node_p p = malloc(sizeof(node_t));
    if (p != NULL) {
        p->prev_p = NULL;
        p->next_p = NULL;
        return p;
    }
    return NULL;
}

关键点：

头节点不存储实际数据
初始时两个指针均指向NULL
头节点用于简化链表操作

3. 初始化数据节点

node_p DLINK_LIST_InitDataNode(int data)
{
    node_p p = malloc(sizeof(node_t));
    if (p != NULL) {
        p->data = data;
        p->prev_p = NULL;
        p->next_p = NULL;
        return p;
    }
    return NULL;
}

4. 判断链表是否为空

bool DLINK_LIST_IfEmpty(node_p head_node)
{
    return (head_node->prev_p == NULL) && (head_node->next_p == NULL);
}

5. 插入操作

头插法：

void DLINK_LIST_HeadInsertDataNode(node_p head_node, node_p new_node)
{
    if (DLINK_LIST_IfEmpty(head_node)) {
        new_node->prev_p = head_node;
        new_node->next_p = NULL;
        head_node->next_p = new_node;
    } else {
        new_node->prev_p = head_node;
        new_node->next_p = head_node->next_p;
        head_node->next_p->prev_p = new_node;
        head_node->next_p = new_node;
    }
}

尾插法：

void DLINK_LIST_TailInsertDataNode(node_p head_node, node_p new_node)
{
    node_p tmp_p = head_node;
    while (tmp_p->next_p != NULL) {
        tmp_p = tmp_p->next_p;
    }
    
    new_node->prev_p = tmp_p;
    new_node->next_p = NULL;
    tmp_p->next_p = new_node;
}

6. 遍历链表

int DLINK_LIST_ShowListData(node_p head_node)
{
    if (DLINK_LIST_IfEmpty(head_node))
        return -1;
    
    node_p tmp_p = head_node->next_p;
    int i = 0;
    
    printf("======================链表数据======================\n");
    while (tmp_p != NULL) {
        printf("节点%d: 数据 = %d\n", i, tmp_p->data);
        tmp_p = tmp_p->next_p;
        i++;
    }
    printf("====================================================\n");
    
    return 0;
}

7. 删除操作

int DLINK_LIST_DelDataNode(node_p head_node, int data)
{
    if (DLINK_LIST_IfEmpty(head_node))
        return -1;
    
    node_p tmp_p = head_node;
    while (tmp_p->next_p != NULL) {
        if (tmp_p->next_p->data == data) {
            node_p del_node = tmp_p->next_p;
            tmp_p->next_p = del_node->next_p;
            
            if (del_node->next_p != NULL)
                del_node->next_p->prev_p = tmp_p;
            
            free(del_node);
            return 0;
        }
        tmp_p = tmp_p->next_p;
    }
    
    return -1;
}

8. 修改操作

int DLINK_LIST_ChangeNodeData(node_p head_node, int data, int change_data)
{
    if (DLINK_LIST_IfEmpty(head_node))
        return -1;
    
    node_p tmp_p = head_node->next_p;
    while (tmp_p != NULL) {
        if (tmp_p->data == data) {
            tmp_p->data = change_data;
            return 0;
        }
        tmp_p = tmp_p->next_p;
    }
    
    return -1;
}

9. 销毁链表

void DLINK_LIST_UnInit(node_p head_node)
{
    if (DLINK_LIST_IfEmpty(head_node)) {
        free(head_node);
        return;
    }
    
    node_p tmp_p = head_node->next_p;
    node_p next_p;
    
    while (tmp_p != NULL) {
        next_p = tmp_p->next_p;
        free(tmp_p);
        tmp_p = next_p;
    }
    
    free(head_node);
}

三、通用型容器设计

1. 基本概念

通用型容器是指不关心存储数据的具体类型，只关注数据间的逻辑关系和相应操作的数据结构。它提供了一套可以处理任何数据类型的通用API。

实现方式：

让用户提供数据类型（C++ STL方式）
将数据从容器中剥离（Linux内核链表方式）

在C语言中，通常采用第二种方式，通过宏定义实现类型切换。

2. 通用型节点设计

// 通过宏定义选择数据类型
#define STU_DATA 1
#define MED_DATA 0

#if STU_DATA
    #define DATATYPE stu_t
#elif MED_DATA
    #define DATATYPE med_t
#endif

typedef DATATYPE datatype;

typedef struct node
{
    datatype data;          // 通用数据域
    struct node* prev_p;    // 前驱指针
    struct node* next_p;    // 后继指针
} node_t, *node_p;