【链表】双向链表的基本操作详解(C语言)

最新推荐文章于 2024-04-20 21:28:50 发布

hong-knight

最新推荐文章于 2024-04-20 21:28:50 发布

阅读量2.3w

点赞数 29

分类专栏：数据结构文章标签： c 链表双向链表数据结构

本文链接：https://blog.csdn.net/ffortunateoy/article/details/91359568

版权

数据结构专栏收录该内容

4 篇文章 6 订阅

订阅专栏

本文是双链表的C语言实现方法，包括双链表的创建、插入、删除、修改、查找等基本操作。

双链表是链表中的一种，他和单链表一样都是通过指针将一个个结点连接起来。他和单链表不同的地方在于：单链表的每个结点的指向只有一个，双向链表每个结点有两个指向。

双向链表结点结构体

双向链表每个结点除了存储数据data外，还有两个指针记录上一个结点和下一个结点的地址，分别是前驱指针prev和后继指针next，所以双向链表结点定义如下：

//双向链表结点结构体
typedef struct Node
{
    int data;           //数据
    struct Node* prev;  //前驱指针
    struct Node* next;  //后继指针
}Node;

双向链表的结构体

在单链表中，由于每个结点只指向下一个节点，所以我们只能通过头结点遍历链表。但是双向链表的每个结点既有指向下一个结点的指针，也有指向上一个结点的指针，所以我们要遍历双向链表可以通过其头结点，也可以通过其尾结点。
当我们要找的结点靠近头结点的时候，我们可以从头结点开始遍历；当我们要找的结点靠近尾结点的时候，我们可以从尾结点开始遍历。从而提高执行效率。
要知道我们要找的结点到底是靠近头结点还是尾结点，那我们也需要知道链表的长度。
所以，双向链表的结构体中需要定义头结点，尾结点以及链表长度。

//双向链表结构体
typedef struct DoubleList
{
    Node* head;     //头结点
    Node* tail;     //尾结点
    size_t size;    //链表长度
}DoubleList;

创建双向链表结点

和创建单链表结点类似。

//创建双向链表结点
Node* create_node(int data)
{
    Node* node = (Node*)malloc(sizeof(Node));//申请内存
    node->data = data;
    node->prev = NULL;
    node->next = NULL;
    return node;
}

初始化双向链表

上面我们定义了双向链表的结构体，但是仅仅是声明了双向链表结构体中的元素，并没有对元素进行初始化，所以我们使用双向链表之前需要对其进行初始化，让头结点和尾结点等于NULL，链表长度等于0。

void init_list(DoubleList* list)
{
    list->head = NULL;
    list->tail = NULL;
    list->size = 0;
}

释放链表

当链表不需要再使用时，我们需要将其内存释放。

void free_list(DoubleList* list)
{
    while(list->size)
    {
        Node* tmp = list->head;
        list->head = list->head->next;
        free(tmp);
        tmp = NULL;
        list->size--;
    }
}

获取头结点

//获取头结点
Node* get_head(DoubleList* list)
{
    return list->head;
}

获取尾结点

//获取尾结点
Node* get_tail(DoubleList* list)
{
    return list->tail;
}

获取链表长度

//获取链表长度
size_t get_size(DoubleList* list)
{
    return list->size;
}

遍历链表

遍历链表打印链表中所有的元素

void show_list(DoubleList* list)
{
    Node* node = list->head;
    for (int i = 0; i < list->size; ++i)
    {
        printf("%d ", node->data);
        node = node->next;
    }
    printf("\n");
}

插入头结点

需要考虑两种情况：

链表为空，那插入的结点既是头结点，也是尾结点；
链表不为空，将新结点和链表通过前驱指针prev和后继指针next连接起来，并将头结点改为新插入的结点；

//插入头结点
void push_head(DoubleList* list, int data)
{
    Node* new_node = create_node(data);

    //链表为空
    if(list->size == 0)
    {
        //插入的结点既是头结点，也是尾结点
        list->head = new_node;
        list->tail = new_node;
    }
    //链表不为空
    else
    {
        //将新结点和链表通过前驱指针prev和后继指针next连接起来
        new_node->next = list->head;
        list->head->prev = new_node;
        //将头结点改为新插入的结点
        list->head = new_node;
    }
    list->size++;
}

插入尾结点

和插入头结点一样，需要考虑两种情况：

链表为空，那插入的结点既是尾结点，也是头结点；
链表不为空，将新结点和链表通过前驱指针prev和后继指针next连接起来，并将尾结点改为新插入的结点；

//插入尾结点
void push_tail(DoubleList* list, int data)
{
    Node* new_node = create_node(data);

    //链表为空
    if(list->size == 0)
    {
        //插入的结点既是尾结点，也是头结点
        list->tail = new_node;
        list->head = new_node;
    }
    //链表不为空
    else
    {
        //将新结点和链表通过前驱指针prev和后继指针next连接起来
        list->tail->next = new_node;
        new_node->prev = list->tail;
        //将尾结点改为新插入的结点
        list->tail = new_node;
    }
    list->size++;
}

在任意位置插入一个结点

插入前判断插入的位置是否超出链表的范围，排除插入的位置小于0以及大于链表的长度；
插入的位置如果等于0，等同于插入头结点；
插入的位置如果等于链表的长度，等同于插入尾结点；
插入的位置如果小于等于中间位置，那插入的位置更靠近头结点，我们可以从头结点开始往后遍历到插入的前一个位置；
插入的位置如果大于中间位置，那插入的位置更靠近尾结点，我们可以从尾结点开始往前遍历到插入的前一个位置；

//任意位置插入一个结点
//任意位置插入一个结点
bool insert_node(DoubleList* list, int index, int data)
{ 
    //插入的位置超出链表的范围
    if(index <0 || index > list->size)
        return false;
    //插入的位置如果等于0，等同于插入头结点
    if(index == 0)
    {
        push_head(list,data);
        return true;
    }
    //插入的位置如果等于链表的长度，等同于插入尾结点
    else if(index == list->size)
    {
        push_tail(list,data);
        return true;
    }

    Node* tmp = NULL;
    //插入的位置如果小于等于中间位置，那插入的位置更靠近头结点
    //从头结点开始往后遍历到插入的前一个位置
    if(index <= list->size / 2)
    {
        tmp = list->head;
        for(int i=0; i<index-1;i++)
        {
            tmp = tmp->next;
        }
    }
    //插入的位置如果大于中间位置，那插入的位置更靠近尾结点
    //从尾结点开始往前遍历到插入的前一个位置
    else
    {
        tmp = list->tail;
        for (int i = 0; i < list->size - index; ++i)
        {
            tmp = tmp->prev;
        }
    }

    Node* new_node = create_node(data);

    tmp->next->prev = new_node;
    new_node->next = tmp->next;
    tmp->next = new_node;
    new_node->prev = tmp;
    list->size++;
    return true;
}

删除头结点

需要考虑三种情况：

链表为空，不操作，直接返回；
链表只有一个结点，释放该结点的内存，并初始化链表，将链表长度改为0，头结点和尾结点置为NULL；
链表结点大于1，保存头结点，新头结点等于原头结点的下一个结点，然后释放保存的头结点的内存；

//删除头结点
void del_head(DoubleList* list)
{
    if(list->size == 0)
        return;
    if(list->size == 1)
    {
        free(list->head);//释放内存
        init_list(list);
        return;
    }

    Node* tmp = list->head;//保存头结点
    list->head = tmp->next;
    list->head->prev = NULL;
    
    //释放内存
    free(tmp);
    tmp = NULL;
    list->size--;
}

删除尾结点

和删除头结点类似

链表为空，不操作，直接返回；
链表只有一个结点，释放该结点的内存，并初始化链表，将链表长度改为0，头结点和尾结点置为NULL；
链表结点大于1，保存尾结点，新尾结点等于原尾结点的上一个结点，然后释放保存的尾结点的内存；

//删除尾结点
void del_tail(DoubleList* list)
{
    if(list->size == 0)
        return;
    if(list->size == 1)
    {
        free(list->tail);//释放内存
        init_list(list);
        return;
    }

    Node* tmp = list->tail;//保存尾结点
    list->tail = tmp->prev;
    list->tail->next = NULL;

    free(tmp);//释放内存
    tmp = NULL;
    list->size--;
}

删除任意位置结点

与在任意位置插入结点类似，

删除前判断插入的位置是否超出链表的范围，排除删除的位置小于0以及大于链表的长度；
删除的位置如果等于0，等同于删除头结点；
删除的位置如果等于链表的长度，等同于删除尾结点；
删除的位置如果小于中间位置，那删除的位置更靠近头结点，我们可以从头结点开始往后遍历到删除的结点；
删除的位置如果大于等于中间位置，那删除的位置更靠近尾结点，我们可以从尾结点开始往前遍历到删除的结点；

//删除任意位置结点
bool del_node(DoubleList* list, int index)
{
    //判断插入的位置是否超出链表的范围
    if(index < 0 || index > list->size)
        return false;
    //删除的位置如果等于0，等同于删除头结点
    if(index == 0)
    {
        del_head(list);
        return true;
    }
    //删除的位置如果等于链表的长度，等同于删除尾结点
    if(index == list->size)
    {
        del_tail(list);
        return true;
    }

    Node* tmp = NULL;

    //删除的位置如果小于中间位置
    if(index < list->size/2)
    {
        //从头结点开始往后遍历到删除的的结点
        tmp = list->head;
        for (int i = 0; i < index; ++i)
        {
            tmp = tmp->next;
        }
    }
    //删除的位置如果大于等于中间位置
    else
    {
        //从尾结点开始往前遍历到删除的结点
        tmp = list->tail;
        for (int i = 0; i < list->size - index - 1; ++i)
        {
            tmp = tmp->prev;
        }
    }

    tmp->prev->next = tmp->next;
    tmp->next->prev = tmp->prev;
    free(tmp);//释放内存
    tmp = NULL;
    list->size--;
    return true;
}

获取任意节点位置

遍历前判断插入的位置是否超出链表的范围，排除删除的位置小于0以及大于链表的长度；
目标结点的位置如果小于中间位置，那目标结点的位置更靠近头结点，我们可以从头结点开始往后遍历到目标结点；
目标结点的位置如果大于等于中间位置，那目标结点的位置更靠近尾结点，我们可以从尾结点开始往前遍历到目标结点；

//获取任意位置结点
Node* get_node(DoubleList* list, int index)
{
    //判断插入的位置是否超出链表的范围
    if(index < 0 || index > list->size)
        return NULL;
    Node* node = NULL;
    //目标结点的位置如果小于中间位置
    if(index < list->size / 2)
    {
        //从头结点开始往后遍历到目标结点
        node = list->head;
        for(int i =0; i < index ; i++)
        {
            node = node->next;
        }
    }
    //目标结点的位置如果大于等于中间位置
    else
    {
        //从尾结点开始往前遍历到目标结点
        node = list->tail;
        for (int i = 0; i < list->size - index - 1; ++i)
        {
            node = node->prev;
        }
    }
    return node; 
}

获取链表中指定数据所在的第一个结点

Node* find_data(DoubleList* list, int data)
{
    if(list->size == 0)
        return NULL;
    Node* node = list->head;
    while(node)
    {
        if(node->data == data)
            return node;
        node = node->next;
    }
    return NULL;
}

修改链表中指定结点的值

先获取到目标位置的结点，再修改目标结点的值

bool modify_node(DoubleList* list, int index, int data)
{
    Node* node = get_node(list, index);
    if(node)
    {
        node->data = data;
        return true;
    }
    return false;
}

修改链表中指定的第一个数据

先获取目标数据所在的第一个结点，再修改改结点的值

bool modify_data(DoubleList* list, int data, int val)
{
    Node* node = find_data(list, data);
    if(node)
    {
        node->data = val;
        return true;    
    }
    return false;
}

完整代码

双向链表测试代码请前往：https://github.com/HongKnight/linked-list/tree/master/double_list

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <stdbool.h>

//创建双向链表结点
Node* create_node(int data)
{
    Node* node = (Node*)malloc(sizeof(Node));//申请内存
    node->data = data;
    node->prev = NULL;
    node->next = NULL;
    return node;
}

//初始化链表
void init_list(DoubleList* list)
{
    list->head = NULL;
    list->tail = NULL;
    list->size = 0;
}

//释放链表
void free_list(DoubleList* list)
{
    while(list->size)
    {
        Node* tmp = list->head;
        list->head = list->head->next;
        free(tmp);
        tmp = NULL;
        list->size--;
    }
}

//获取链表长度
size_t get_size(DoubleList* list)
{
    return list->size;
}

//获取头结点
Node* get_head(DoubleList* list)
{
    return list->head;
}

//获取尾结点
Node* get_tail(DoubleList* list)
{
    return list->tail;
}

//遍历链表
void show_list(DoubleList* list)
{
    Node* node = list->head;
    for (int i = 0; i < list->size; ++i)
    {
        printf("%d ", node->data);
        node = node->next;
    }
    printf("\n");
}

//插入一个头结点
void push_head(DoubleList* list, int data)
{
    Node* new_node = create_node(data);

    //链表为空
    if(list->size == 0)
    {
        //插入的结点既是头结点，也是尾结点
        list->head = new_node;
        list->tail = new_node;
    }
    //链表不为空
    else
    {
        //将新结点和链表通过前驱指针prev和后继指针next连接起来
        new_node->next = list->head;
        list->head->prev = new_node;
        //将头结点改为新插入的结点
        list->head = new_node;
    }
    list->size++;
}

//插入一个尾结点
void push_tail(DoubleList* list, int data)
{
    Node* new_node = create_node(data);

    //链表为空
    if(list->size == 0)
    {
        //插入的结点既是尾结点，也是头结点
        list->tail = new_node;
        list->head = new_node;
    }
    //链表不为空
    else
    {
        //将新结点和链表通过前驱指针prev和后继指针next连接起来
        list->tail->next = new_node;
        new_node->prev = list->tail;
        //将尾结点改为新插入的结点
        list->tail = new_node;
    }
    list->size++;
    
}

//任意位置插入结点
bool insert_node(DoubleList* list, int index, int data)
{ 
    //插入的位置超出链表的范围
    if(index <0 || index > list->size)
        return false;
    //插入的位置如果等于0，等同于插入头结点
    if(index == 0)
    {
        push_head(list,data);
        return true;
    }
    //插入的位置如果等于链表的长度，等同于插入尾结点
    else if(index == list->size)
    {
        push_tail(list,data);
        return true;
    }

    Node* tmp = NULL;
    //插入的位置如果小于等于中间位置，那插入的位置更靠近头结点
    if(index <= list->size / 2)
    {
        //从头结点开始往后遍历到插入的前一个位置
        tmp = list->head;
        for(int i=0; i<index-1;i++)
        {
            tmp = tmp->next;
        }
    }
    //插入的位置如果大于中间位置，那插入的位置更靠近尾结点
    else
    {
        //从尾结点开始往前遍历到插入的前一个位置
        tmp = list->tail;
        for (int i = 0; i < list->size - index; ++i)
        {
            tmp = tmp->prev;
        }
    }

    Node* new_node = create_node(data);

    tmp->next->prev = new_node;
    new_node->next = tmp->next;
    tmp->next = new_node;
    new_node->prev = tmp;
    list->size++;
    return true;
}

//删除头结点
void del_head(DoubleList* list)
{
    if(list->size == 0)
        return;
    if(list->size == 1)
    {
        free(list->head);//释放内存
        init_list(list);
        return;
    }

    Node* tmp = list->head;//保存头结点
    list->head = tmp->next;
    list->head->prev = NULL;

    free(tmp);//释放内存
    tmp = NULL;
    list->size--;
}

//删除尾结点
void del_tail(DoubleList* list)
{
    if(list->size == 0)
        return;
    if(list->size == 1)
    {
        free(list->tail);//释放内存
        init_list(list);
        return;
    }

    Node* tmp = list->tail;//保存尾结点
    list->tail = tmp->prev;
    list->tail->next = NULL;

    free(tmp);//释放内存
    tmp = NULL;
    list->size--;
}

//删除任意位置结点
bool del_node(DoubleList* list, int index)
{
    //判断插入的位置是否超出链表的范围
    if(index < 0 || index > list->size)
        return false;
    //删除的位置如果等于0，等同于删除头结点
    if(index == 0)
    {
        del_head(list);
        return true;
    }
    //删除的位置如果等于链表的长度，等同于删除尾结点
    if(index == list->size)
    {
        del_tail(list);
        return true;
    }

    Node* tmp = NULL;

    //删除的位置如果小于中间位置
    if(index < list->size/2)
    {
        //从头结点开始往后遍历到删除的的结点
        tmp = list->head;
        for (int i = 0; i < index; ++i)
        {
            tmp = tmp->next;
        }
    }
    //删除的位置如果大于等于中间位置
    else
    {
        //从尾结点开始往前遍历到删除的结点
        tmp = list->tail;
        for (int i = 0; i < list->size - index - 1; ++i)
        {
            tmp = tmp->prev;
        }
    }

    tmp->prev->next = tmp->next;
    tmp->next->prev = tmp->prev;
    free(tmp);//释放内存
    tmp = NULL;
    list->size--;
    return true;
}

//获取任意位置结点
Node* get_node(DoubleList* list, int index)
{
    //判断插入的位置是否超出链表的范围
    if(index < 0 || index > list->size)
        return NULL;
    Node* node = NULL;
    //目标结点的位置如果小于中间位置
    if(index < list->size / 2)
    {
        //从头结点开始往后遍历到目标结点
        node = list->head;
        for(int i =0; i < index ; i++)
        {
            node = node->next;
        }
    }
    //目标结点的位置如果大于等于中间位置
    else
    {
        //从尾结点开始往前遍历到目标结点
        node = list->tail;
        for (int i = 0; i < list->size - index - 1; ++i)
        {
            node = node->prev;
        }
    }
    return node; 
}

//获取链表中指定数据所在的第一个结点
Node* find_data(DoubleList* list, int data)
{
    if(list->size == 0)
        return NULL;
    Node* node = list->head;
    while(node)
    {
        if(node->data == data)
            return node;
        node = node->next;
    }
    return NULL;
}

//修改链表中指定结点的值
bool modify_node(DoubleList* list, int index, int data)
{
    Node* node = get_node(list,index);
    if(node)
    {
        node->data = data;
        return true;
    }
    return false;
}

//修改链表中指定的第一个数据
bool modify_data(DoubleList* list, int data, int val)
{
    Node* node = find_data(list,data);
    if(node)
    {
        node->data = val;
        return true;    
    }
    return false;
}

更多链表相关代码请前往：https://github.com/HongKnight/linked-list

hong-knight

关注

29
点赞
踩
177

收藏

觉得还不错? 一键收藏
4
评论
【链表】双向链表的基本操作详解(C语言)

本文是单链表的C语言实现方法，包括单链表的创建、插入、删除、修改、查找等基本操作。双链表是链表中的一种，他和单链表一样都是通过指针将一个个结点连接起来。他和单链表不同的地方在于：单链表的每个结点的指向只有一个，双向链表每个结点有两个指向。双向链表结点结构体双向链表每个结点除了存储数据data外，还有两个指针记录上一个结点和下一个结点的地址，分别是前驱指针prev和后继指针next，所以双向链...
复制链接

扫一扫