双链表C语言实现

已于 2022-02-16 17:47:36 修改
阅读量512 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： c语言 链表 开发语言
于 2022-02-10 02:20:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Helpsen/article/details/122852955
版权

双链表C语言实现

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

/*声明描述节点信息的结构体*/
typedef struct node {
    int data; //数据
    struct node *next; //指向下一个节点
    struct node *prev; //指向上一个节点
}node_t;

/*声明描述整个链表的结构体*/
typedef struct list {
    struct node head; //头节点
    struct node tail; //尾节点
}list_t;

/*定义初始化链表函数*/
/*空链表：head和tail连起来*/
void list_init(list_t *list)
{
    list->head.next = &list->tail; //头指向尾
    list->tail.prev = &list->head; //尾指向头
    list->head.prev = NULL;
    list->tail.next = NULL;
}

/*判断链表是否为空*/
int list_empty(list_t *list)
{
    return list->head.next == &list->tail; //空返回1,非空返回0
}

/*获取链表节点个数*/
int list_size(list_t *list)
{
    int count = 0; //计数
    for(node_t *pnode = &list->head; 
            pnode != &list->tail;
            	pnode = pnode->next) {
        node_t *pfirst = pnode;
        node_t *pmid = pfirst->next;
        node_t *plast = pmid->next;
        if(pmid != &list->tail)
            count++; //只要没有到tail,加一个
    }
    return count;
}

//定义创建节点函数
static node_t *create_node(int data)
{
    //给节点分配内存
    node_t *p = (node_t *)malloc(sizeof(node_t));
    //初始化节点
    p->next = NULL;
    p->prev = NULL;
    p->data = data;
    return p;
}

//定义将新节点插入pfirst和pmid之间
static void insert_data(node_t *pfirst, node_t *pmid, node_t *pnode)
{
    //将新节点插入pfirst和pmid之间
    pfirst->next = pnode;
    pnode->prev = pfirst;
    pnode->next = pmid;
    pmid->prev = pnode;
}

/*后插*/
void list_add_tail(list_t *list, int data)
{
    //创建新节点
    node_t *pnode = create_node(data); 
    //定义游标：随意定游标,这个代码仅仅参考
    node_t *pfirst = list->tail.prev; //pfirst指向最后一个节点
    node_t *pmid = pfirst->next; //pmid指向tail
    node_t *plast = pmid->next; //plast指向NULL
    //插入
    insert_data(pfirst, pmid, pnode);
}

/*前插*/
void list_add_head(list_t *list, int data)
{
    //创建新节点
    node_t *pnode = create_node(data); 
    //定义游标 
    node_t *pfirst = &list->head; //pfirst指向head
    node_t *pmid = pfirst->next; //pmid指向第一个节点
    node_t *plast = pmid->next; //plast指向第二个节点
    //插入
    insert_data(pfirst, pmid, pnode);
}

/*由小到大插*/
void list_add(list_t *list, int data)
{
    //1.创建新节点
    node_t *pnode = create_node(data);
    //2.遍历
    for(node_t *ptmp = &list->head; 
            ptmp != &list->tail;
            	ptmp = ptmp->next) {
        //3.游标
        node_t *pfirst = ptmp;
        node_t *pmid = pfirst->next;
        node_t *plast = pmid->next;
        //4.将新节点同样插入到pfirst和pmid之间
        if(pmid->data > pnode->data || pmid == &list->tail) {
            insert_data(pfirst, pmid, pnode); //插入
            break;
        }
    }
}

//删除节点
static void del_data(node_t *pfirst, node_t *pmid, node_t *plast)
{
    //1.连接pfirst和plast,干掉pmid
    pfirst->next = plast;
    plast->prev = pfirst;

    //2.释放pmid的内存
    free(pmid);
    pmid = NULL;
}

/*删除最后一个节点*/
void list_del_tail(list_t *list)
{
    //1.判断是否空链表
    if(list->head.next == &list->tail) {
        printf("list is empty.\n");
        return;
    }

    //2.定义游标
    node_t *plast = &list->tail; //plast指向tail
    node_t *pmid = plast->prev; //pmid指向最后一个节点
    node_t *pfirst = pmid->prev; //pfirst指向倒数第二个节点

    //3.删除数据
    del_data(pfirst, pmid, plast);
}

/*删除第一个节点*/
void list_del_head(list_t *list)
{
    /*1.判断链表是否为空*/
    if(list_empty(list)) {
        printf("list is empty.\n");
        return;
    }

    //2.定义游标
    node_t *pfirst = &list->head; //pfirst指向头节点
    node_t *pmid = pfirst->next; //pmid指向第一个节点
    node_t *plast = pmid->next; //plast指向第二个节点

    //3.删除数据
    del_data(pfirst, pmid, plast);
}

/*删除某个数字所在的节点*/
void list_del(list_t *list, int data)
{
    //通过data遍历遍历找到要删除的节点pmid
    for(node_t *pnode = &list->head; 
            pnode != &list->tail;
            	pnode=pnode->next) {
        node_t *pfirst = pnode;
        node_t *pmid = pfirst->next;
        node_t *plast = pmid->next;
        if(pmid->data == data && pmid != &list->tail) {
            //删除数据
            del_data(pfirst, pmid, plast);
            return;
        }
    }
    printf("the data isn't exist\n");
}

/*获取最后一个节点的数据并返回*/
int list_get_tail(list_t *list)
{
    //判断链表是否为空
    if(list_empty(list))
        return -1;

    //定义游标
    node_t *plast = &list->tail; //plast指向tail
    node_t *pmid = plast->prev; //pmid指向最后一个节点
    node_t *pfirst = pmid->prev; //pfirst指向倒数第二个节点

    //返回pmid指向的最后一个节点中的数据
    return pmid->data;
}

/*获取第一个节点的数据并返回*/
int list_get_head(list_t *list)
{
    //判断链表是否为空
    if(list_empty(list))
        return -1;

    //定义游标
    node_t *pfirst = &list->head; //pfirst指向head
    node_t *pmid = pfirst->next; //pmid指向第一个节点
    node_t *plast = pmid->next; //pfirst指向第二个节点

    //返回pmid指向的第一个节点中的数据
    return pmid->data;
     
}

/*根据节点编号获取对应的数据*/
int list_get(list_t *list, int index)
{
    //1.计数
    int count = 0;

    //2.找节点
    for(node_t *pnode = &list->head;
            pnode != &list->tail;
            	pnode=pnode->next) {
        //3.定义游标
        node_t *pfirst = pnode;
        node_t *pmid = pfirst->next;
        node_t *plast = pmid->next;
        //4.判断count和index
        if(count == index && pmid != &list->tail) {
            return pmid->data;
        }
        count++;
    }
    return -1; //没有找到
}
/*打印链表所以数据*/
void list_show(list_t *list)
{
	if(list_empty(list)){
		printf("list is empty\n");
		return;
	}
	for(node_t *pnode = &list->head;
			pnode != &list->tail;
				pnode = pnode->next){
		node_t *pfirst = pnode;
		node_t *pmid = pfirst->next;
		node_t *plast = pmid->next;
		if(pmid != &list->tail)
			printf("%d ",pmid->data);
	}
	putchar('\n');
}
/*清理链表*/
void list_deinit(list_t *list)
{
    while(list->head.next != &list->tail) {
        //定义游标
        node_t *pfirst = &list->head;
        node_t *pmid = pfirst->next;
        node_t *plast = pmid->next;
        
        //先连接pfirst和plast
        pfirst->next = plast;
        plast->prev = pfirst;

        //干掉pmid节点的内存
        free(pmid);
        pmid = NULL;
    }
}

//测试代码
void main(int argc,char *argv[])
{
	//1.定义链表变量l
	list_t list;

	//2.链表初始化
	list_init(&list);

	//3.头插法添加链表结点
	list_add_head(&list,30);
	list_add_head(&list,20);
	list_add_head(&list,10);

	//4.尾插法添加链表结点
	list_add_tail(&list,40);
	list_add_tail(&list,50);
	list_add_tail(&list,60);
	//打印链表所有结点数据
	list_show(&list);	

	//5.判断链表是否为空
	if(list_empty(&list)){
		printf("list is empty\n");
	}

	//6.获取链表结点个数
	printf("the size of list is %d\n",list_size(&list));

	//7.从小到大插入到链表中
	list_add(&list,45);
	//打印链表所有结点数据
	list_show(&list);	

	//8.删除第一个结点
	list_del_head(&list);
	//打印链表所有结点数据
	list_show(&list);	

	//9.删除最后一个结点
	list_del_tail(&list);
	//打印链表所有结点数据
	list_show(&list);

	//10.删除某个数据所在结点
	list_del(&list,45);
	//打印链表所有结点数据
	list_show(&list);

	//11.获取第一个结点的数据
	printf("the data in first is %d\n",list_get_head(&list));

	//12.获取最后一个结点的数据
	printf("the data in end is %d\n",list_get_tail(&list));

	//13.通过结点编号获取结点数据(-1时表示给定结点编号错误)
	printf("the appointed node number data is %d\n",list_get(&list,0));

	//14.清理链表
	list_deinit(&list);
	//打印链表所有结点数据
	list_show(&list);
	return;
}
Helpsen
关注
专栏目录
数据结构-双向链表的基本操作 （c语言实现）
weixin_59799963的博客
10-19 3645
1.创造一个节点,函数实现 DListNode* BuyListNode(Datetype x) { DListNode*node = (DListNode*)malloc(sizeof(DListNode)); node->date = x; node->next = NULL; node->prev = NULL; return node; } 2. 初始化 DListNode* DListInit() { DListNode*plist = BuyListNod
C语言双向链表的实现
m0_63666616的博客
05-03 4821
双向链表简介 我们知道，单链表（singly linked list）只有一个指向直接后继的指针来表示结点间的逻辑关系，可以方便地查找下一个结点，但是找前驱结点就非常困难。这时，我们就需要用上双向链表(doubly linked list)来解决这个问题。 结构体构建 第一个动作和单链表类似，我们使用结构体来定义出这种数据类型。代码： typedef struct DLinkNode{ int data; struct DLinkNode *prev; struct DLinkNode *next;
双向链表C实现
02-04
产品级代码，安全可靠，包含如下功能： 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素 9.将游标重置指向链表中的第一个数据元素 10.将游标移动指向到链表中的下一个数据元素 11.将游标移动指向到链表中的上一个数据元素 12.直接指定删除链表中的某个数据元素
【C语言】C语言实现双链表
熠熠L的博客
04-18 813
头文件 #pragma once #ifndef _L_LIST_H #define _L_LIST_H /* 需要用到的C库文件 */ #include <stdlib.h> #include <stdio.h> /* 双向链表节点结构体声明 */ typedef struct node { struct node* nextNode, * prevNode; //指向上一个节点和下一个节点的地址 void* nodeData; //指向节点的数据地址 }no
C/C++ 双链表的实现
qq_39839033的博客
10-07 168
带头结点的双链表的实现：在单链表的基础上再加上了一个指向前驱节点的指针 #include<iostream> #include <cstdio> #include<stdlib.h> using namespace std; //双链表 typedef struct DLNode{ int data; struct DLNode *prior; ...
实现双链表的基本操作（c语言）
qq_63152286的博客
02-27 4118
介绍双链表 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 一、实现双链表的具体操作 定义双链表元素 创建链表 ①头插法 ②尾插法 插入结点 删除结点 查找结点 销毁双链表 打印双链表
双向链表C语言实现
12-13
以上代码展示了如何使用C语言实现一个双向链表，包括基本的操作函数。这些函数可以作为模块化代码，方便在实际项目中复用。在实际应用中，可能还需要添加其他功能，例如打印链表、逆序遍历等。通过理解并实践这些...
058 双链表 C语言 058 双链表 C语言
06-01
在C语言中，实现双链表通常涉及到定义一个结构体来表示链表节点，该结构体包含数据域和两个指针域，分别用于存储数据和指向前后节点的指针。例如： ```c typedef struct Node { int data; // 数据域，这里假设存储...
二元查找树转变为双向链表C语言实现
05-13
在C语言中，实现这个转换需要定义相应的数据结构，如`struct TreeNode`表示二元查找树节点，`struct DoublyListNode`表示双向链表节点。同时，需要编写二元查找树的中序遍历函数和转换函数。在转换函数中，使用递归...
C语言实现的双链表功能完整示例
08-27
主要介绍了C语言实现的双链表功能,结合完整实例形式分析了基于C语言实现的双链表定义、添加、删除、排序等相关操作实现技巧,需要的朋友可以参考下
数据结构与算法@双向链表
qq_34740116的博客
09-19 295
双向链表双向链表的数据结构双向链表的建立双向链表的插入节点双向链表的删除节点双向链表的遍历双向链表的长度双向链表查找节点双向链表替换节点主函数 http://c.biancheng.net/view/3343.html 双向链表的数据结构 typedef struct line{ struct line * prior; //指向直接前趋 int data; struct line * next; //指向直接后继 }line; 双向链表的建立 line* initLine(lin
双链表的简单实现（C语言）
文溪山人的博客
03-19 1294
数据结构双链表的简单实现（C语言）
C语言 双链表的基本操作与实现
qq_41740162的博客
03-30 445
C语言 双链表的基本操作与实现 背景 单链表结点中只有一个指向其后继的指针，使得单链表只能从头结点依次顺序地向后遍历。要访问某个结点的前驱结点(插入、删除操作时)，只能从头开始遍历，访问后继结点的时间复杂度为0(1),访问前驱结点的时间复杂度为O(n)。 为了克服单链表的上述缺点，引入了双链表，双链表结点中有两个指针front和tail,分别指向其前驱结点和后继结点 结构体 typedef s...
C语言数据结构 双向链表以及基本功能实现
chaidao7207的博客
07-22 125
项目头文件： #ifndef _LIST_H_ #define _LIST_H_ #include <stdio.h> #include<stdlib.h> typedef int LTDataType; typedef struct ListNode { LTDataType _data; struct ListNode* _next; stru...
C语言实现双链表及其基本操作
海马有力量的博客
11-04 296
双链表比普通的链表多了指向前方数据的指针，方便对链表的查找。不过在实现方面却复杂了不少，增加或者删除数据的时候要考虑到前后数据指针，其中的操作顺序一定不能错。 #include<stdio.h> #include<stdlib.h> #define N 100 typedef int ElemType; typedef struct Dnode{ ElemType data; struct Dnode *prior,*next; }Dnode,*DLinkList; DLink
双向链表的实现（c语言数据结构）
芊樱烛渊的博客
05-12 1030
目录 需要实现的功能 具体功能的实现 1.创建新的结点 2.双向链表的初始化 3.双向链表的尾插 4.双向链表的打印 5.双向链表的头删 6.双向链表的摧毁 7.双向链表的结点查找 8.双向链表在pos位置之前插入 9.删除目标位置的结点 10.头删 11.尾删 汇总 以下是测试文件 需要实现的功能 以下是定义在我们的List.h的文件中，来声明我们双向链表需要实现的功能。 双向链表携带了该结点的前置结点和后置结点，可以比单链表更加方便地访问结点的前置元素。 同
C语言实现双链表
Aiden_yan的博客
10-01 1073
C语言实现双链表 文章目录C语言实现双链表说明实现的功能结构体定义初始化插入结点删除结点输出所有元素全部代码测试 说明 图片自己画的，有点丑，不要介意。 本文来自专栏：数据结构 后续还会继续coding。如果有需要可以关注点赞一波。 实现的功能 插入结点 删除结点 从头到尾遍历输出所有元素 获取某个结点的前驱和其后继结点 获取前驱和后继主要是为了测试双链表是否编写正确，因为双链表可以访问前驱，这是与单链表不同的地方。 结构体定义 typedef struct BiLinkNode { Elem
将二叉搜索树转化排序的双向链表c语言实现
最新发布
06-12
以下是将二叉搜索树转化为排序的双向链表的C语言实现： ```c #include #include typedef struct Node { int data; struct Node* left; struct Node* right; } Node; Node* createNode(int data) { Node* ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值