C语言数据结构2——双向链表的实现

最新推荐文章于 2022-07-07 11:59:35 发布
最新推荐文章于 2022-07-07 11:59:35 发布
阅读量360 收藏
点赞数 1
分类专栏： c语言数据结构 文章标签： c语言 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38114109/article/details/77102863
版权

1.头文件

#ifndef     __LINK_H__
#define     __LINK_H__
typedef struct node {
    int num;
    struct node *p_next;
    struct node *p_prev;
} node;
typedef struct {
    node head, tail;
    node *p_cur;
} link;
//初始化函数
void link_init(link *);
//清理函数
void link_deinit(link *);
//判断链表是否空的函数
int link_empty(const link *);
//判断链表是否满的函数
int link_full(const link *);
//获得有效节点个数的函数
int link_size(const link *);
//把新数字加入到所有数字的前面
void link_add_head(link *, int);
//把新数字加入到原有数字的最后
void link_append(link *, int);
//按顺序加入新数字
void link_insert_in_order(link *, int);
//删除最前面数字的函数
void link_remove_head(link *);
//删除最后有效节点
void link_remove_tail(link *);
//删除某个数字所在的节点
void link_remove(link *, int);
//获得最前面的数字
int link_get_head(const link *, int *);
//获得最后一个数字的函数
int link_get_tail(const link *, int *);
//根据编号找到数字的函数
int link_get(const link *, int, int *);
//开始从前向后依次遍历链表中每个有效节点
void link_begin(link *p_link);
//在从前向后的遍历过程中获得下一个数字
int link_next(link *p_link, int *);
void link_rbegin(link *p_link);
int link_prev(link *p_link, int *);
#endif    //__LINK_H__

2.源文件

/************link.c************/
#include <stdlib.h>
#include "link.h"
//初始化函数
void link_init(link *p_link) {
    p_link->head.p_next = &(p_link->tail);
    p_link->tail.p_next = NULL;
    p_link->tail.p_prev = &(p_link->head);
    p_link->head.p_prev = NULL;
    p_link->p_cur = NULL;
}
//清理函数
void link_deinit(link *p_link) {
    while (p_link->head.p_next != &(p_link->tail)) {
        node *p_first = &(p_link->head);
        node *p_mid = p_first->p_next;
        node *p_last = p_mid->p_next;
        p_first->p_next = p_last;
        p_last->p_prev = p_first;
        free(p_mid);
        p_mid = NULL;
    }
    p_link->p_cur = NULL;
}
//判断链表是否空的函数
int link_empty(const link *p_link) {
    return p_link->head.p_next == &(p_link->tail);
}
//判断链表是否满的函数（此处假设永远不为满）
int link_full(const link *p_link) {
    return 0;
}
//获得有效节点个数的函数
int link_size(const link *p_link) {
    int cnt = 0;
    const node *p_node = NULL;
    for (p_node = &(p_link->head);p_node != &(p_link->tail);p_node = p_node->p_next) {
        const node *p_first = p_node;
        const node *p_mid = p_first->p_next;
        const node *p_last = p_mid->p_next;
        if (p_mid != &(p_link->tail)) {
            cnt++;
        }
    }
    return cnt;
}
//把新数字加入到所有数字的前面
void link_add_head(link *p_link, int num) {
    node *p_first = NULL, *p_mid = NULL, *p_last = NULL;
    node *p_node = (node *)malloc(sizeof(node));
    if (!p_node) {
        return ;
    }
    p_node->num = num;
    p_node->p_next = NULL;
    p_node->p_prev = NULL;
    p_first = &(p_link->head);
    p_mid = p_first->p_next;
    p_last = p_mid->p_next;
    p_first->p_next = p_node;
    p_node->p_prev = p_first;
    p_node->p_next = p_mid;
    p_mid->p_prev = p_node;
    p_link->p_cur = NULL;
}
//把新数字加入到原有数字的最后
void link_append(link *p_link, int num) {
    node *p_first = NULL, *p_mid = NULL, *p_last = NULL;
    node *p_node = (node *)malloc(sizeof(node));
    if (!p_node) {
        return ;
    }
    p_node->num = num;
    p_node->p_next = NULL;
    p_node->p_prev = NULL;
    p_first = p_link->tail.p_prev;
    p_mid = p_first->p_next;
    p_last = p_mid->p_next;
    p_first->p_next = p_node;
    p_node->p_prev = p_first;
    p_node->p_next = p_mid;
    p_mid->p_prev = p_node;
    p_link->p_cur = NULL;
}
//按顺序加入新数字
void link_insert_in_order(link *p_link, int num) {
    node *p_tmp = NULL;
    node *p_node = (node *)malloc(sizeof(node));
    if (!p_node) {
        return ;
    }
    p_node->num = num;
    p_node->p_next = NULL;
    p_link->p_cur = NULL;
    for (p_tmp = &(p_link->head);p_tmp != &(p_link->tail);p_tmp = p_tmp->p_next) {
        node *p_first = p_tmp;
        node *p_mid = p_first->p_next;
        node *p_last = p_mid->p_next;
        if (p_mid == &(p_link->tail) || p_mid->num > num) {
            p_first->p_next = p_node;
            p_node->p_prev = p_first;
            p_node->p_next = p_mid;
            p_mid->p_prev = p_node;
            break;
        }
    }
}
//删除最前面数字的函数
void link_remove_head(link *p_link) {
    node *p_first = &(p_link->head);
    node *p_mid = p_first->p_next;
    node *p_last = p_mid->p_next;
    if (p_link->head.p_next == &(p_link->tail)) {
        return ;
    }
    p_first->p_next = p_last;
    p_last->p_prev = p_first;
    free(p_mid);
    p_mid = NULL;
    p_link->p_cur = NULL;
}
//删除最后有效节点
void link_remove_tail(link *p_link) {
    node *p_first = NULL, *p_mid = NULL, *p_last = NULL;
    if (p_link->head.p_next == &(p_link->tail)) {
        return ;
    }
    p_first = p_link->tail.p_prev->p_prev;
    p_mid = p_first->p_next;
    p_last = p_mid->p_next;
    p_first->p_next = p_last;
    p_last->p_prev = p_first;
    free(p_mid);
    p_mid = NULL;
    p_link->p_cur = NULL;
}
//删除某个数字所在的节点
void link_remove(link *p_link, int num) {
    node *p_node = NULL;
    if (p_link->head.p_next == &(p_link->tail)) {
        return ;
    }
    p_link->p_cur = NULL;
    for (p_node = &(p_link->head);p_node != &(p_link->tail);p_node = p_node->p_next) {
        node *p_first = p_node;
        node *p_mid = p_first->p_next;
        node *p_last = p_mid->p_next;
        if (p_mid != &(p_link->tail) && p_mid->num == num) {
            p_first->p_next = p_last;
            p_last->p_prev = p_first;
            free(p_mid);
            p_mid = NULL;
            break;
        }
    }
}
//获得最前面的数字
int link_get_head(const link *p_link, int *p_num) {
    if (p_link->head.p_next == &(p_link->tail)) {
        return 0;
    }
    *p_num = p_link->head.p_next->num;
    return 1;
}
//获得最后一个数字的函数
int link_get_tail(const link *p_link, int *p_num) {
    const node *p_node = NULL;
    if (p_link->head.p_next == &(p_link->tail)) {
        return 0;
    }
    for (p_node = &(p_link->head);p_node != &(p_link->tail);p_node = p_node->p_next) {
        const node *p_first = p_node;
        const node *p_mid = p_first->p_next;
        const node *p_last = p_mid->p_next;
        if (p_last == &(p_link->tail)) {
            *p_num = p_mid->num;
            return 1;
        }
    }
}
//根据编号找到数字的函数
int link_get(const link *p_link, int sn, int *p_num) {
    int cnt = 0;
    const node *p_node = NULL;
    if (p_link->head.p_next == &(p_link->tail)) {
        return 0;
    }
    for (p_node = &(p_link->head);p_node != &(p_link->tail);p_node = p_node->p_next) {
        const node *p_first = p_node;
        const node *p_mid = p_first->p_next;
        const node *p_last = p_mid->p_next;
        if (p_mid != &(p_link->tail) && cnt == sn) {
            *p_num = p_mid->num;
            return 1;
        }
        cnt++;
    }
    return 0;
}
//准备开始从前向后遍历链表中的每个有效节点
void link_begin(link *p_link) {
    p_link->p_cur = &(p_link->head);
}
//在从前向后的变量过程中获得链表中下一个数字
int link_next(link *p_link, int *p_num) {
    if (!(p_link->p_cur)) {
        return 0;
    }
    p_link->p_cur = p_link->p_cur->p_next;
    if (p_link->p_cur == &(p_link->tail)) {
        p_link->p_cur = NULL;
        return 0;
    }
    else {
        *p_num = p_link->p_cur->num;
        return 1;
    }
}
//准备开始从后向前遍历每个有效节点
void link_rbegin(link *p_link) {
    p_link->p_cur = &(p_link->tail);
}
//在从后向前遍历过程中获得前一个数字
int link_prev(link *p_link, int *p_num) {
    if (!(p_link->p_cur)) {
        return 0;
    }
    p_link->p_cur = p_link->p_cur->p_prev;
    if (p_link->p_cur == &(p_link->head)) {
        p_link->p_cur = NULL;
        return 0;
    }
    else {
        *p_num = p_link->p_cur->num;
        return 1;
    }
}

3.测试函数

#include <stdio.h>
#include "link.h"
int main() {
    int num = 0, num1 = 0;
    link lnk = {0};
    link_init(&lnk);
    link_append(&lnk, 50);
    link_append(&lnk, 60);
    link_append(&lnk, 70);
    link_append(&lnk, 80);
    link_append(&lnk, 90);
    link_add_head(&lnk, 40);
    link_add_head(&lnk, 30);
    link_add_head(&lnk, 20);
    link_add_head(&lnk, 10);
    link_insert_in_order(&lnk, 45);
    link_insert_in_order(&lnk, 65);
    link_insert_in_order(&lnk, 25);
    link_insert_in_order(&lnk, 55);
    link_remove_head(&lnk);
    link_remove_tail(&lnk);
    link_remove(&lnk, 50);
    printf("数字个数是%d\n", link_size(&lnk));
    link_get_head(&lnk, &num);
    printf("最前面的数字是%d\n", num);
    link_get_tail(&lnk, &num);
    printf("最后面的数字是%d\n", num);
    for (num1 = 0;;num1++) {
        if (!link_get(&lnk, num1, &num)) {
            break;
        }
        printf("%d ", num);
    }
    printf("\n");
    link_begin(&lnk);
    while (1) {
        if (!link_next(&lnk, &num)) {
            break;
        }
        printf("%d ", num);
    }
    printf("\n");
    link_rbegin(&lnk);
    while (1) {
        if (!link_prev(&lnk, &num)) {
            break;
        }
        printf("%d ", num);
    }
    printf("\n");
    link_deinit(&lnk);
    return 0;
}
阿德5473
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之---c语言实现双向链表操作
杨鑫newlife的专栏
05-16 2138
数据结构之---c语言实现双向链表操作
C语言数据结构----双向链表
CoderChe
08-23 1824
概括：主要说明循环链表的基本概念和具体操作以及源代码。 一、基本概念 1.有了单链表以后我们可以把内存中小块的空间联系在一起，并且把每一个小块都存储上我们想要存储的数值。但是单链表只有一个next，我们每一次都要从头开始遍历整个链表，这样的话如果我们对单链表进行逆序访问那么将是一项很耗时的操作。 2.双向链表解决了上面的问题，我们不单对每一个数据节点都设置一个next，同时还有一个pre指针
C 语言 数据结构之双向链表
huayutiancheng的专栏
09-01 498
#include #include struct Node {   char data;   struct Node *left;   struct Node *right; }; typedef struct Node DListNode; typedef struct Node *DLinkList; int InitDList(DLinkLis
数据结构双向链表（c语言）
七喜是雪碧
03-28 438
数据结构双向链表（c语言） 通过c语言实现双向链表的建立、初始化、头插法插入结点、尾插法插入结点、在指定位置添加结点、删除指定位置的结点、查找结点的内容、获取结点的长度、打印输出结点的内容。 #include <stdio.h> #include <stdlib.h> typedef struct List { //双向链表的结点 struct List *head;...
针对在校大学生的C语言入门学习——链表源码
01-26
【标题】"针对在校大学生的C语言入门学习——链表源码"，旨在为初学者提供C语言中链表数据结构的基本概念和实现方法。链表是计算机科学中一种重要的抽象数据类型，它与数组不同，不连续存储元素，而是通过指针链接...
C语言链表课程设计——仓库管理系统.rar
04-20
总的来说，"C语言链表课程设计——仓库管理系统"是一个结合了C语言基础知识、链表数据结构和实际问题解决的综合性项目。通过实现这个系统，学生不仅可以巩固C语言编程技能，还能深入理解链表的工作原理，并学习如何...
数据结构C语言list实现
最新发布
05-12
本话题将深入探讨如何使用C语言来实现一种基础且重要的数据结构——单链表。 单链表是一种线性数据结构，每个元素（节点）包含两部分：数据域和指针域。数据域用于存储实际的数据，而指针域则指向链表中的下一个...
C语言程序设计——职工管理系统（链表）.zip
07-13
在本项目"C语言程序设计——职工管理系统（链表）"中，主要涉及的是使用C语言进行程序设计，尤其是利用链表数据结构实现一个职工管理系统的具体应用。链表是一种非常重要的数据结构，它与数组不同，不连续存储数据，...
数据结构---线性表之双链表（C语言）
03-29
数据结构---线性表之双链表，创建、插入、删除，完整的C代码
[C语言]数据结构之双向链表
Code_beeps的博客
12-09 338
简介 本文将实现双向链表的基础接口功能 1.初始化/销毁 2.增删改查 头文件DList.h #pragma once //数据类型 typedef int DLDataType; //结点类型 typedef struct DListNode{ DLDataType val; struct DListNode *next; struct DListNode *prev; } DL...
C语言数据结构双向链表
huxyc的博客
06-16 173
双向链表不仅可以从头向尾查找也可以从尾向头查找。 #include<stdio.h> #include<stdlib.h> #include<memory.h> #ifdef _DEBUG #include<vld.h> #endif /*_DEBUG*/ typedef struct _dlist { int data; struct _dlist *p_head; struct _dlist *p_tail; }DList,Node; in
c语言数据结构（双向链表）
weixin_39270987的博客
09-14 475
一、双向链表概述 双向链表和单向链表的区别之处在于，双向链表的不仅可以从头部向尾部遍历，也可以从尾部向头部遍历，它的基本结构如下： 双向链表的每一个元素都包含两个指针，其中一个指针指向链表的上一个节点，另外一个指针指向链表的下一个节点； 二、双向链表的基本操作 2.1、从链表尾部的插入节点 第一步：Node-C的指向下一个节点的指针指向Node-D； 第二步：Node-D的指向上一个节点的指针指向Node-C; 第三步：Node-D指向下一个节点的指针指向NULL，这点很重要，因为NULL
数据结构 --- c语言实现双向链表
weixin_60569662的博客
07-07 2646
双向链表主要分为三部分前项指针后项指针数据域一般情况下，创建单一个体，前项指针和后项指针都赋值为空一般采用记录头节点和记录尾节点，再封装的方式写双向链表 再定义一个结构体(链表) 通过记录头节点和尾节点的方式去描述链表 创建节点 把用户的数据变成一个结构体变量 创建链表 描述链表最初的状态 头插法 ①新节点的后项指针指向原来链表的头节点②原来链表的头节点的前项指针指向新节点③把原来的头节点移到新节点的位置 打印链表 可以通过前项指针去做打印，也可以通过后项
数据结构之双向链表（C语言实现）
qq_57312085的博客
08-04 632
双向链表的几种插入，删除，指定位置输出 双向链表的长相 双向链表由前驱指针和后项指针还有数据域组成，把节点之间的前后指针相连接形成链表 双向链表节点的封装 双向链表与单链表相比，仅多了一个前驱指针 typedef struct Node { int data;//内容 struct Node* frontNode;//前驱指针 struct Node* nextNode;//后项指针 }*LPNODE; 双向链表的特点在于可以从左到右，也可以从右到左输出链表，因此.
C语言数据结构-双链表
三哥的博客
10-10 1129
双链表与单链表不同的是，双链表节点具有两个指针，一个指向后面数据，一个指向其前面的数据。其结构如下图所示：当首尾相连时，链表叫做双循环链表； 其和单链表类似，通过一个头指针来表示；下面为双循环链表的创建及相关的插入删除函数实现：#include <stdio.h> #include <stdlib.h>//定义链表节点结构 typedef struct node{ int data;
数据结构--双链表(C语言)
一只菜鸟程序猿
10-04 434
双链表： 双链表与单链表不同的是，其结构体中存在两个指针，“Next”指向直接后继，“Prior”指向直接前驱，链表的访问不再是单链表的单向访问(只能访问后继结点)，可以利用next和prior指针方便的进行双向访问(既可以访问后继结点也可以访问前驱结点)。 实现： //结构体 typedef struct node{ int data; struct node
数据结构（双向链表）（C语言）
x18261294286的博客
08-10 1257
利用C语言实现双向链表的基本功能： 头文件： //LinkList.c #ifndef _LINKLIST_H #define _LINKLIST_H #define SUCCESS 10000 #define FAILURE 10001 #define TRUE 10002 #define FALSE 10003 typedef int Elemtype; typedef s...
C语言描述的双向链表基础操作与数据结构应用
《21世纪高职高专新概念教材——数据结构（C语言描述）》这本书遵循了实用性与应用性原则，适合初学者系统学习和深入理解数据结构概念，包括但不限于数组、链表（包括单链表和双向链表）、栈、队列、树、图等基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值