C语言实现双向链表的增删查改

最新推荐文章于 2024-03-15 23:17:34 发布
最新推荐文章于 2024-03-15 23:17:34 发布
阅读量3.4k 收藏 23
点赞数 2
分类专栏： c语言 数据结构 双向链表基本操作 线性表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40927789/article/details/79810405
版权

定义一个带头节点的双向链表需要一个数据域两个指针域，其中一个next指针是指向当前节点的下一个节点，另外一个prev指针是指向当前节点的前一个节点。如下图所示：
这里写图片描述
该头结点本质上只是一个傀儡节点并无实际用处，带头节点的好处就是我们在实际操作链表时不用考虑头指针的指向。而双向链表的前后指针域也大大方便了我们对于链表的实际操作。
代码示例：
DBlinklist.h文件

#pragma once

typedef char DLinkType;

typedef struct DLinkNode
{
    DLinkType data;//数据域
    struct DLinkNode *prev;//前指针域
    struct DLinkNode *next;//后指针域
}DLinkNode;

DLinkNode *head;
//初始化函数
void DLinkListInit(DLinkNode **head);
//尾插函数
DLinkNode *DLinkListPushBack(DLinkNode *head,DLinkType value);
//尾删函数
void DLinkListPopBack(DLinkNode *head);
//头插函数
void DLinkListPushFront(DLinkNode *head,DLinkType value);
//头删函数
void DLinkListPopFront(DLinkNode *head);
//给定一个值，查找地址，返回地址
DLinkNode* DLinkListFind(DLinkNode *head,DLinkType to_find);
//在pos位置之前插入指定元素
void DLinkListInsert(DLinkNode *head,DLinkNode *pos,DLinkType value);
//在pos位置之后插入指定元素
void DLinkListInsertAfter(DLinkNode *head,DLinkNode *pos,DLinkType value);
//删除指定位置的元素
void DLinkListErase(DLinkNode *head,DLinkNode *pos);
//删除指定值，若存在多个该元素则只删除第一个
void DLinkListRemove(DLinkNode *head,DLinkType to_remove);
//删除指定值，若存在多个该元素则删除全部
void DLinkListRemoveAll(DLinkNode *head,DLinkType to_remove);
//求链表元素个数，返回元素个数
size_t DLinkListSize(DLinkNode *head);
//判断链表是否为空，非空则返回1否则返回0
int DLinkListEmpty(DLinkNode *head);

DBlinklist.c文件

#include<stdlib.h>
#include<stdio.h>
#include<stddef.h>
#include"DBlinklist.h"

#define Test_Header  printf("\n========%s========\n",__FUNCTION__);
//以下是链表打印函数
//因为是双向链表，所以从两个方向遍历打印出来
//结果符合逻辑才说明链表指针指向正确
void DLinkListPrint(DLinkNode *head,const char *msg)
{
    printf("[%s]\n",msg);
    if(head == NULL)
    {
        //非法输入
        printf("非法输入\n");
        return;
    }
    if(head->prev == head)
    {
        //空链表
        printf("空链表\n");
        return;
    }
    DLinkNode *cur = head->next;
    for(;cur != head;cur = cur->next)
    {
        //正向循环遍历打印
        printf("[%c|%p] ",cur->data,cur);
    }
    printf("\n");
    DLinkNode *pre = head->prev;
    for(;pre != head;pre = pre->prev)
    {
        //反向循环遍历打印
        printf("[%c|%p] ",pre->data,pre);
    }
    printf("\n");
}
//以下是创建节点函数
DLinkNode* CreatNode(DLinkType value)
{
    DLinkNode *new_node = (DLinkNode*)malloc(sizeof(DLinkNode));
    new_node->data = value;
    new_node->prev = new_node;
    new_node->next = new_node;
    return new_node;
}
//以下为链表初始化函数
//头结点并无实质意义，因此节点中存放的值可随意设置
void DLinkListInit(DLinkNode **head)
{
    if(head == NULL)
    {
        return;
    }
    *head = CreatNode(0);
}
//以下是尾插函数
DLinkNode* DLinkListPushBack(DLinkNode* head, DLinkType value)
{
    if(head == NULL)
    {
        //非法输入
        return NULL;
    }
    //last_node为链表中最后一个节点
    DLinkNode *last_node = head->prev;
    DLinkNode *new_node = CreatNode(value);
    //last_node 与 new_node两个节点的指针指向的修改
    last_node->next = new_node;
    new_node->prev = last_node;
    //head 与 new_node两个节点的指针的指向的修改
    head->prev = new_node;
    new_node->next = head;

    return new_node;
}
//以下为尾删函数
void DLinkListPopBack(DLinkNode* head)
{
    if(head == NULL)
    {
        //非法输入
        return;
    }
    if(head->prev == head)
    {
        //空链表没有元素可删
        return;
    }
    //最后一个元素为我们需要删除的元素
    DLinkNode *to_delete = head->prev;
    //last_node为倒数第二个元素
    DLinkNode *last_node = to_delete->prev;
    //修改指针指向
    last_node->next = head;
    head->prev = last_node;
    //释放需要删除的节点
    free(to_delete);
    return;
}
//以下为头删函数
void DLinkListPushFront(DLinkNode* head, DLinkType value)
{
    if(head == NULL)
    {
        //非法输入
        return;
    }
    DLinkNode *new_node = CreatNode(value);
    //first_node为第一个元素
    DLinkNode *first_node = head->next;
    //head 与 new_node两个节点的指针的指向的修改
    head->next = new_node;
    new_node->prev = head;
    //new_node 与 first_node两个节点的指针的指向的修改
    new_node->next = first_node;
    first_node->prev = new_node;

    return;
}
//以下为头删函数
void DLinkListPopFront(DLinkNode* head)
{
    if(head == NULL)
    {
        //非法输入
        return;
    }
    if(head->prev == head)
    {
        //空链表没有元素可删
        return;
    }
    //头结点的下一个元素就是我们要删除的元素
    DLinkNode *to_delete = head->next;
    //删除第一个节点以，删除元素的下一个元素就是新的第一个元素
    DLinkNode *next_first_node = to_delete->next;
    //更改指针的指向
    head->next = next_first_node;
    next_first_node->prev = head;
    //释放待删除的元素
    free(to_delete);

    return;
}
//以下为查找元素地址的函数
DLinkNode* DLinkListFind(DLinkNode* head, DLinkType to_find)
{
    if(head == NULL)
    {
        //非法输入
        return NULL;
    }
    //定义一个指针指向第一个元素
    DLinkNode *cur = head->next;
    for(;cur->next != head;cur = cur->next)
    {
        //遍历，并且判断当前节点的值是否与待查找元素的值相等
        if(cur->data == to_find)
        {
            //找到带查找的值则返回该节点
            return cur;
        }
    }
    //遍历完以后没有找到待查找的值
    return NULL;
}
//以下为往指定位置之前插入一个元素的函数 
void DLinkListInsert(DLinkNode *head,DLinkNode* pos, DLinkType value)
{
    if(head == NULL || pos == NULL)
    {
        //非法输入
        return;
    }
    //找到pos位置之前的节点
    DLinkNode *before_pos_node = pos->prev;
    //以value值创建一个新的节点
    DLinkNode *new_node = CreatNode(value);
    //new_node 与 before_pos_node两个节点的指针的指向的修改
    new_node->prev = before_pos_node;
    before_pos_node->next = new_node;
    //new_node 与 pos两个节点的指针的指向的修改
    new_node->next = pos;
    pos->prev = new_node;

    return;
}
//以下为往指定位置之后插入一个元素的函数 
void DLinkListInsertAfter(DLinkNode *head,DLinkNode* pos, DLinkType value)
{
    if(head == NULL || pos == NULL)
    {
        //非法输入
        return;
    }
    //找到pos位置之后的节点
    DLinkNode *next_pos_node = pos->next;
    //以value值创建一个新的节点
    DLinkNode *new_node = CreatNode(value);

    //new_node 与 next_pos_node两个节点的指针的指向的修改
    new_node->next = next_pos_node;
    next_pos_node->prev = new_node;
    //new_node 与 pos两个节点的指针的指向的修改
    pos->next = new_node;
    new_node->prev = pos;

    return;
}
//以下为删除任意位置节点的函数
void DLinkListErase(DLinkNode *head,DLinkNode *pos)
{
    if(head == NULL || pos == NULL || pos == head)
    {
        //非法输入
        //若pos==head则无意义，因为头结点没有实际意义
        return;
    }
    if(head->prev == head)
    {
        //空链表没有可删除的位置
        return;
    }
    //找到pos位置的前一个和后一个节点
    DLinkNode *before_pos_node = pos->prev;
    DLinkNode *next_pos_node = pos->next;
    //before_pos_node 与 next_pos_node两个节点的指针的指向的修改
    before_pos_node->next = next_pos_node;
    next_pos_node->prev = before_pos_node;

    return;
}
//以下为删除指定元素，若存在多个元素则只删除第一个该元素的函数
void DLinkListRemove(DLinkNode *head,DLinkType to_remove)
{
    if(head == NULL)
    {
        //非法输入
        return;
    }
    DLinkNode *cur = head->next;
    //遍历链表，找到待删除元素的位置
    for(;cur->next != head && cur->data != to_remove;cur = cur->next)
        ;
    if(cur->next == head && cur->data != to_remove)
        //该元素不存在
        return;
    //调用之前的删除指定位置的元素的函数
    DLinkListErase(head,cur);
}
//以下为删除指定元素，若存在多个元素则全部删除的函数
void DLinkListRemoveAll(DLinkNode *head,DLinkType to_remove)
{
    if(head == NULL)
    {
        //非法输入
        return;
    }
    DLinkNode *cur = head->next;
    while(1)
    {
        for(cur = head->next;cur->next != head && cur->data != to_remove;cur = cur->next)
            ;
        if(cur->next == head && cur->data != to_remove)
            //该元素不存在
            return;
        DLinkListErase(head,cur);
    }
}
//以下为求链表元素个数的函数，返回元素个数
size_t DLinkListSize(DLinkNode *head)
{
    if(head == NULL)
    {
        //非法输入
        return 0;
    }
    if(head->prev == head)
    {
        //空链表返回0
        return 0;
    }
    //定义一个变量用于计数
    size_t count = 1;
    DLinkNode *cur = head->next;
    //遍历
    for(;cur != NULL && cur->next != head;cur = cur->next)
    {
        count++;
    }
    return count;
}
//以下为判断链表是否为空的函数
//空返回0非空返回1
int DLinkListEmpty(DLinkNode *head)
{
    if(head == NULL)
    {
        return 0;
    }
    if(head->prev != head)
        return 1;
    else
        return 0;
}
//以下为销毁链表函数
void DLinkListDestroy(DLinkNode **head)
{
    if(head == NULL)
    {
        //非法输入
        return;
    }
    DLinkNode *cur = (*head)->next;
    //遍历链表，先释放链表中已经存在的每一个元素
    while(cur != *head)
    {
        DLinkNode *next = cur->next;
        free(cur);
        cur = next;
    }
    //释放头结点
    free(*head);
    //将头结点指向空，避免野指针问题
    *head = NULL;
}
///以下为测试函数//

//初始化函数测试
void TestInit()
{
    Test_Header;
    DLinkListInit(&head);
    printf("expected:0 actual:%d\n",(int)head->data);
}
//尾插函数测试
void TestPushBack()
{
    Test_Header;
    DLinkListInit(&head);
    DLinkListPushBack(head,'a');
    DLinkListPushBack(head,'b');
    DLinkListPushBack(head,'c');
    DLinkListPushBack(head,'d');
    DLinkListPrint(head,"尾插四个元素");
}
//尾删函数测试
void TestPopBack()
{
    Test_Header;
    DLinkListPopBack(head);
    DLinkListPopBack(head);
    DLinkListPrint(head,"尾删两个元素");
    DLinkListPopBack(head);
    DLinkListPopBack(head);
    DLinkListPrint(head,"再尾删两个元素");
    DLinkListPopBack(head);
    DLinkListPrint(head,"尝试对空链表删除");
}

测试结果如下图所示：
这里写图片描述

//头插函数测试
void TestPushFront()
{
    Test_Header;
    DLinkListPushFront(head,'a');
    DLinkListPushFront(head,'b');
    DLinkListPushFront(head,'c');
    DLinkListPushFront(head,'d');
    DLinkListPrint(head,"头插四个元素");
}
//头删函数测试
void TestPopFront()
{
    Test_Header;
    DLinkListPopFront(head);
    DLinkListPopFront(head);
    DLinkListPrint(head,"头删两个元素");
    DLinkListPopFront(head);
    DLinkListPopFront(head);
    DLinkListPrint(head,"再头删两个元素");
    DLinkListPopFront(head);
    DLinkListPrint(head,"尝试对空链表删除");
}

测试结果如下图所示：
这里写图片描述

//查找指定元素的地址函数测试
void TestFind()
{
    Test_Header;
    DLinkListPushBack(head,'a');
    DLinkListPushBack(head,'b');
    DLinkListPushBack(head,'c');
    DLinkListPushBack(head,'d');
    DLinkListPrint(head,"先尾插四个元素");
    DLinkNode *ret1 = DLinkListFind(head,'b');
    printf("元素b的地址为：%p\n",ret1);
    DLinkNode *ret2 = DLinkListFind(head,'e');
    printf("元素e的地址为：%p\n",ret2);
    DLinkListPopFront(head);
    DLinkListPopFront(head);
    DLinkListPopFront(head);
    DLinkListPopFront(head);
    DLinkListPrint(head,"头删四个元素形成空链表");
    DLinkNode *ret3 = DLinkListFind(head,'b');
    printf("元素b的地址为：%p\n",ret3);
}
//删除指定元素的函数测试
void TestErase()
{
    Test_Header;
    DLinkListPushBack(head,'a');
    DLinkListPushBack(head,'b');
    DLinkListPushBack(head,'c');
    DLinkListPushBack(head,'d');
    DLinkListPrint(head,"先尾插四个元素");
    DLinkNode *pos = DLinkListFind(head,'b');
    DLinkListErase(head,pos);
    DLinkListPrint(head,"尝试删除b位置的元素");
    DLinkListErase(head,NULL);
    DLinkListErase(head,head);
    DLinkListPrint(head,"pos为空或者为head时删除之后的链表元素");
}

测试结果如下图所示：
这里写图片描述

//在pos位置之前插入指定元素的函数测试
void TestInsert()
{
    Test_Header;
    DLinkNode *pos = DLinkListFind(head,'c');
    DLinkListInsert(head,pos,'b');
    DLinkListPrint(head,"c之前插入b之后的链表元素");
    DLinkListInsert(head,head->next,'A');
    DLinkListPrint(head,"a之前插入A之后的链表元素");
}
//在pos位置之后插入指定元素的函数测试
void TestInsertAfter()
{
    Test_Header;

    DLinkNode *pos = DLinkListFind(head,'a');
    DLinkListInsertAfter(head,pos,'B');
    DLinkListPrint(head,"a后面插入B之后的链表元素");
    DLinkListInsertAfter(head,head->prev,'e');
    DLinkListPrint(head,"d后面插入e之后的链表元素");
}

测试结果如下图所示：
这里写图片描述

//删除指定元素，若存在多个该元素则只删除第一个的函数测试
void TestRemove()
{
    Test_Header;
    DLinkListPushBack(head,'c');
    DLinkListPushBack(head,'d');
    DLinkListPrint(head,"先尾插两个元素");
    DLinkListRemove(head,'a');
    DLinkListPrint(head,"先删除一个出现一次的元素a");
    DLinkListRemove(head,'d');
    DLinkListPrint(head,"再删除一个出现两次的元素d");
    DLinkListRemove(head,'d');
    DLinkListPrint(head,"再删除一个出现一次的元素d");
}
//删除指定元素，若存在多个该元素则全部删除的函数测试
void TestRemoveAll()
{
    Test_Header;
    DLinkListRemoveAll(head,'e');
    DLinkListPrint(head,"先删除一个出现一次的元素e");
    DLinkListRemoveAll(head,'c');
    DLinkListPrint(head,"再删除一个出现两次的元素c");
}

测试结果如下图所示：
这里写图片描述

//求链表元素个数的函数测试
void TestSize()
{
    Test_Header;
    size_t ret = DLinkListSize(head);
    DLinkListPrint(head,"链表中的元素为");
    printf("链表中共有：%lu 个元素\n",ret);
}
//判断链表是否为空的函数测试
void TestEmpty()
{
    Test_Header;
    DLinkListPrint(head,"链表中的元素为");
    int ret = DLinkListEmpty(head);
    printf("判空返回值为：%d\n",ret);
    DLinkListPopFront(head);
    DLinkListPopFront(head);
    DLinkListPopFront(head);
    DLinkListPrint(head,"删除三个元素后链表中的元素为");
    ret = DLinkListEmpty(head);
    printf("判空返回值为：%d\n",ret);
}
void TestDestroy()
{
    Test_Header;
    DLinkListDestroy(&head);
    DLinkListPrint(head,"尝试对一个已经被销毁的链表进行打印");
}

测试结果如下图所示：
这里写图片描述

小心眼儿猫
关注
  • 2
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C语言如何建立链表并实现增删查改详解
01-01
前言 以下是本人完成的一个C语言建立链表并进行增删查改操作的程序，为方便学习，本人将整个程序分为头文件和主函数两部分： 1.头文件(函数部分) (1)初始化函数 #include <stdio> #include <stdlib> typedef struct { int *head; int length; int capacity; } Toslist; //Toslist类型 //初始化顺序表 Toslist initSeqlist() { Toslist list; list.length = 0; list.capacity = 5; list.head =
用c语言实现双向链表的倒序,C语言实现双向链表，增删改查，排序
weixin_39719077的博客
05-23 318
#includetypedef struct Node* NodePtr;typedef struct Node{int data;NodePtr prev;NodePtr next;} Node;void putPrev(int data, NodePtr head) {NodePtr node = (NodePtr)malloc(sizeof(Node));if (node==NULL){pr...
用C语言实现链表（增删改查）
最新发布
2201_75849076的博客
03-15 266
记录用C语言实现链表的创建和增删改查
C语言---双向链表（详解）---数据结构
weixin_57535054的博客
02-07 6419
双向链表所需要头文件 首先重定义类型名 意义我前几篇讲过几次了，这里就不在赘述了，（顺序表，单链表的开头都有说明） 然后我们需要一个结构体 结构体包含 ： 存储数据的 a 指向一个节点的指针 next 指向上一个节点的指针 prve 双向链表实现的函数功能有 ：1.申请动态内存空间 2.初始化 3.双向链表的头，尾的插入与删除，在合法的任意位置进行插入和删除 4.释放链表，5.打印链表 1.申请动态内存空间 因为进行插入和初始化需要用到此函数 所以我们要先实现此功能 1.先申.
C语言数据结构-----双向链表增删查改的代码实现
qq_57425280的博客
11-12 175
完整代码见gitee： 链接: 双向链表增删查改的代码实现 2.创建链表节点 3.打印链表 4.尾插 8.2 在pos之前插入(改造尾插) 9.1 删除pos位置(改造头删) 10.查找 11.毁灭
基于C语言-双链表-增删查改等功能实现
m0_51480797的博客
12-14 118
基于C语言的双链表简单增删查改
C语言实现双向链表
Jeson_的博客
01-13 258
创建空链表 dlist_t create_emptydlist() { //申请空间 dlist_t head = (dlist_t)malloc(sizeof(dnode_t)); if(head) { //head->data = -1; //空链表头节点的前置和后置指针都指向自己 head->pr...
c语言简单实现双向链表
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
08-18 2561
c语言最简单实现双向链表
双链表（C语言实现）超级简洁版
weixin_45983489的博客
03-14 343
数据结构设计 //定义迭代器迭代方向 #define LIST_START_HEAD 0 #define LIST_START_TAIL 1 //链表节点 typedef struct list_node { struct list_node* prev; struct list_node* next; void* value; }list_node; //链表 typedef struct list { unsigned int length; list_node* head; list_
数据结构初阶 --- 双向链表的C语言实现
m0_71722065的博客
09-12 2373
带头双向循环链表
C语言详解双向链表的基本操作
qq_61386381的博客
05-17 3059
双链表的定义与接口函数 定义双链表 接口函数 详解接口函数的实现 创建新节点（BuyLTNode） 初始化双链表（ListInit） 双向链表打印（ListPrint） 双链表查找（ListFind） 双链表销毁（ListDestory） 1、双链表pos位置之前插入（ListInsert） 2、双链表删除pos位置（ListEarse） 3、双向链表尾插（ListPushBack） 4、双向链表头插（ListPushFront） 5、双链表头删（ListPopF.......
用c语言实现链表增删改查
11-07
自己写的，能够使用，对c语言的指针用的淋漓精致，有需要的小伙伴可以下载看下
双向链表创建插入删除销毁等
11-29
双向链表，创建，插入，删除，销毁等，写的一个代码（包括详细的注释，初学者都看得懂），已经成功测试。及拿即用。
单链表c语言实现增删改查操作
09-21
VS2008运行环境 c语言实现单链表增删改查操作 并输出到控制台上
C语言实例-双向链表增删改查
09-11
双向链表（Doubly Linked List）是一种常见的数据结构，在单链表的基础上增加了向前遍历的功能。与单向链表不同，双向链表的每个节点除了包含指向下一个节点的指针外，还包含指向前一个节点的指针。
哈希表的基本操作（一）：线性探测法解决哈希冲突
热门推荐
小心眼儿猫的博客
05-20 3万+
哈希概念 在之前学习过的顺序搜索和二叉树搜索中，元素存储位置和元素各关键码之间没有对应关系，因此在查找一个元素时，必须要经过关键码的多次比较。搜索的效率取决于搜索过程中元素的比较次数。 我们希望可以不经过任何比较，一次直接从表中得到想要的元素，这样一来，搜索效率就有了质的提高。如果构造一种存储结构，通过某种函数是元素的存储位置与他的关键码之间能够建立一一映射的关系，那么在查找的时候通...
C语言实现单链表的增删查改
小心眼儿猫的博客
03-25 1万+
链表：一种链式存储的线性表，用一组地址任意的存储单元存放线性表的数据元素，称存储单元为一个节点。 链表分类： 单链表 双链表 双向循环链表 代码实现单链表的增删查改： linklist.h文件 #pragma once #include&lt;stddef.h&gt; typedef char LType; typedef struct LinkNode { //数据...
通过两个队列实现一个栈（C语言）
小心眼儿猫的博客
04-16 9528
stackBy2Queue.h文件 #pragma once #define max_size 1000 typedef char DataType; typedef struct Queue { DataType data[max_size]; int head; int tail; //队列中有效元素个数 int size; }Queue; ...
数据结构链表增删查改
07-28
对于链表的增删查改操作，可以按照以下方式进行： 1. 增加节点：在链表中插入新的节点。要插入一个新节点，需要修改上一个节点的指针，使其指向新节点，并将新节点的指针指向原先下一个节点。 2. 删除节点：从链表...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值