C语言实现单链表以及双链表（数据结构基本知识）

最新推荐文章于 2024-02-16 17:42:37 发布
最新推荐文章于 2024-02-16 17:42:37 发布
阅读量99 收藏
点赞数
文章标签： c语言 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CRonaldo_siu/article/details/131654318
版权

一、单链表

1、单链表的存储结构
在操作单链表时加入头结点方便增删查改，本文章使用二级指针操作头结点实现相关功能。
存储结构如下

typedef int NodeDataType;

typedef struct Node
{
    NodeDataType _data; //数据
    struct Node* next; //下一个节点
}Node;

初始化时在定义一个头结点即可

Node* plist = NULL;

后面使用二级指针去操作

2、头文件声明需要实现的函数接口

//销毁以及打印
void NodeDestory(Node** pphead);
void Print(Node **pphead);
//相关增删查改
void NodePushBack(Node **pphead,NodeDataType x);
void NodePopBack(Node **pphead);
void NodePushFront(Node **pphead,NodeDataType x);
void NodePopFront(Node **pphead);
//一些指定功能
Node* NodeFind(Node* phead,NodeDataType x);
void NodeInsertAfter(Node** pphead,int pos,NodeDataType x);
void NodeEraseAfter(Node* phead,int pos);
void NodeDelete(Node* phead,NodeDataType x);

3、Node.c文件逐一实现相关功能
①准备工作
增加新节点时需要开辟空间，定义一个开辟新节点的函数为BuynewNode，代码如下

Node* buyNode(NodeDataType x)
{
    Node* newNode = (Node*) malloc(sizeof(Node));
    if(newNode == NULL)
    {
        printf("申请失败\n");
        exit(-1);
    }
    newNode->_data = x;
    newNode->next = NULL;
    return newNode;
}

在对每个函数测试时需要进行打印操作方便查看

void Print(Node **pphead)
{
    Node* cur = *pphead;
    while(cur)
    {
        printf("%d->",cur->_data);
        cur = cur->next;
    }
    printf("NULL\n");
}

②尾插尾删

//尾插
void NodePushBack(Node **pphead,NodeDataType x)
{
    Node* newNode = buyNode(x);
    //判断链表是否为空，为空则直接改变*phead
    if(*pphead == NULL )
    {
        *pphead = newNode;
    }
    else
    {
        //非空则需要遍历至链表尾端
        Node* tail = *pphead;
        while(tail->next != NULL)
        {
            tail = tail->next;
        }
        tail->next = newNode;
    }
}
//尾删
void NodePopBack(Node **pphead)
{
	//尾删较为复杂，需要判断空，只有一个节点，两个及以上节点三个情况，每个情况操作不同
	//空则直接返回
    if(*pphead == NULL)
    {
         return;
    }
    //一个节点直接释放*pphead
    else if((*pphead)->next == NULL)
    {
        free(*pphead);
        *pphead = NULL;
    }
    else
    {
    	//两个及以上需要遍历至末尾
        Node* prev = NULL;
        Node* tail = *pphead;
        while(tail->next != NULL)
        {
            prev=tail;
            tail=tail->next;
        }
        free(tail);
        prev->next = NULL;
    }

}

③头插 头删

//头插直接插在*pphead前面
void NodePushFront(Node **pphead,NodeDataType x)
{
    Node *newNode = buyNode(x);
    newNode->next = *pphead;
    *pphead = newNode;

}
//头删
//需要判断为空以及其他情况
void NodePopFront(Node **pphead)
{
    if(*pphead == NULL)
    {
        return;
    }
    else
    {
        Node* next = (*pphead)->next;
        free(*pphead);
        *pphead = next;
    }
}

④其他功能

//查找指定数字，该函数可以用于其他函数的实现
Node* NodeFind(Node* phead,NodeDataType x)
{
    Node* cur = phead;
    while(cur)
    {
        if(cur->_data == x)
            return cur;
        cur = cur->next;
    }
}
//指定位置后插入
//由于单链表向后指，所以一般实现后插
void NodeInsertAfter(Node** pphead,int pos,NodeDataType x)
{
    Node* cur = *pphead;
    while(--pos)
    {
        cur = cur->next;
    }
    Node* newNode = buyNode(x);
    newNode->next = cur->next;
    cur->next = newNode;
}
//删除指定位置后数据
void NodeEraseAfter(Node* phead,int pos)
{
    Node* cur = phead;
    while(--pos)
    {
        cur = cur->next;
    }
    Node* next = cur->next;
    Node* nextnext = next->next;
    cur->next = nextnext;
    free(next);
    next = NULL;
}
//删除指定数字，该函数考虑的细节比较多
void NodeDelete(Node* phead,NodeDataType x)
{
    Node* prev = NULL;
    Node* cur = phead;
    while(cur->next != NULL)
    {
        if(cur->_data == x)
        {
            if(cur == phead)
            {
                phead = cur->next;
                free(cur);
                cur = phead;
                return;
            }
            else
            {
                prev->next = cur->next;
                free(cur);
                return;
            }
        }
        prev = cur;
        cur = cur->next;
    }
}

二、双向循环链表

1、双向链表的数据存储结构
双向循环链表顾名思义需要头尾相连，因此需要两个指针，一个指向前，一个指向后。
双向链表头结点不进行实际赋值操作

typedef int DNDataType;

typedef struct Double_Node
{
    DNDataType _data;
    struct Double_Node * next;
    struct Double_Node* prev;
}DbNode;

2、头文件声明需要实现的函数

DbNode *DbNodeInit();
DbNode *BuyNode();
void DbNodePrint(DbNode* phead);

void DbNodePushBack(DbNode *phead,DNDataType x);
void DbNodePopBack(DbNode* phead);
void DbNodePushFront(DbNode *phead,DNDataType x);
void DbNodePopFront(DbNode* phead);

DbNode *DbNodeFind(DbNode *phead,DNDataType x);
void DbNodeInsertAfter(DbNode *phead,DNDataType _a,DNDataType x);
void DbNodeEraseAfter(DbNode *phead,DNDataType _a);
void Insert(DbNode* pos,DNDataType x);

void NewPushFront(DbNode* phead,DNDataType x);

void clear(DbNode* phead);
void Destroy(DbNode* phead);

3、Double_Node.c文件逐一实现
①初始化以及销毁

//初始化
DbNode *DbNodeInit()
{
    DbNode *phead = BuyNode();
    phead->next = phead;
    phead->prev = phead; //首尾相连
   
    return phead;
}

//销毁
void Destroy(DbNode* phead)
{
     DbNode *cur = phead->next;
    while(cur != phead)
    {
        DbNode *next = cur->next;
        free(cur);
        cur = next;
    }
    free(phead);
    phead = NULL;
}

②打印以及开辟新节点

//遍历打印
void DbNodePrint(DbNode* phead)
{
    DbNode* cur = phead->next; //注意实际节点从头结点下一个开始
    while(cur != phead) //终止条件
    {
        printf("%d ",cur->data);
        cur = cur->next;
    }
    printf("\n");
}
//开辟新节点
DbNode *BuyNode(DNDataType x)
{
    DbNode* newNode = (DbNode*) malloc(sizeof(DbNode));
    if(newNode == NULL)
    {
        printf("申请失败\n");
        exit(-1);
    }
    newNode->next = NULL;
    newNode->prev = NULL;
    newNode->data = x;
    return newNode;
}

③尾插尾删

//尾插
void DbNodePushBack(DbNode *phead,DNDataType x)
{
    DbNode *tail = phead->prev;
    DbNode* newNode = BuyNode(x);

    tail->next = newNode;
    newNode->prev = tail;

    newNode ->next = phead;
    phead->prev = newNode;

}
//尾删
void DbNodePopBack(DbNode* phead)
{
    DbNode* tail = phead->prev;
    DbNode* tailPrev = tail->prev;

    phead->prev = tailPrev;
    tailPrev->next = phead;

    free(tail);
    tail = NULL;
}

④头插头删

//头插
void DbNodePushFront(DbNode *phead,DNDataType x)
{
    DbNode* next = phead->next;
    DbNode *newNode = BuyNode(x);

    phead->next = newNode;
    newNode->prev = phead;

    newNode->next = next;
    next->prev = newNode;

}
//头删
void DbNodePopFront(DbNode* phead)
{
    DbNode *next = phead->next;
    DbNode* nextnext = next->next;

    phead->next = nextnext;
    next->prev = phead;

    free(next);
    next = NULL;
}

⑤其他功能

//查找指定数字的节点位置
DbNode *DbNodeFind(DbNode *phead,DNDataType x)
{
    DbNode *cur = phead->next;
    while(cur != phead)
    {
        if(cur->data == x)
        {
            return cur;
        }
        cur = cur->next;
    }
    return NULL;
}
//指定数字后插入新数字
void DbNodeInsertAfter(DbNode *phead,DNDataType _a,DNDataType x)
{
     DbNode* pos = DbNodeFind(phead,_a);
     DbNode *next = pos->next;
     DbNode* newNode = BuyNode(x);

     pos->next = newNode;
     newNode->prev = pos;

     newNode->next = next;
     next->prev = newNode;

}
//删除指定数字后数据
void DbNodeEraseAfter(DbNode *phead,DNDataType _a)
{
    DbNode *pos = DbNodeFind(phead,_a);
    DbNode *next = pos->next;
    DbNode *nextnext = next->next;

    pos->next = nextnext;
    nextnext->prev = pos;

    free(next);
    next = NULL;
}
//指定位置后插入
void Insert(DbNode* pos,DNDataType x)
{
    DbNode* posPrev = pos->prev;
    DbNode* newNode = BuyNode(x);

    posPrev->next = newNode;
    newNode->prev = posPrev;

    newNode->next = pos;
    pos->prev = newNode;
}

三、结语

双向链表相对于单链表更易于操作，功能实现也更为简单。
本文为个人学习记录，写的简单粗糙，如有错误，欢迎指正。

C罗差个世界杯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言数据结构各种程序源代码
06-13
String，队列，二叉树，赫夫曼数，链队列，十字链表， 顺序表，稀疏矩阵等程序源码。
数据结构源码笔记（C语言）：线性表的单链表示
半个冯博士
08-07 915
/* LinkList.c*/ /*线性表的单链表示：函数实现*/ #include <stdio.h> #include <stdlib.h> //#include "LinkList.h" /*LinkList.h*/ /* 线性表的单链表示：类型和界面定义*/ /* 定义顺序表的元素类型。应根据需要修改 */ typedef int DataType; struct Node; /* 单链表结点类型 */ typedef struct Node * PNo
c语言实现数据结构中的链表源代码
热门推荐
u014574317的博客
03-23 1万+
#include #include typedef struct LNode *List; struct LNode { int data; List next; }; struct LNode L; List InitList(List PtrL) { PtrL = (List) malloc(sizeof(L)); PtrL->next = NULL; return PtrL
仿照单链表的合并功能，在双向链表类中定义双向链表合并函数并实现此功能。
Maoriland的博客
10-15 210
仿照单链表的合并功能，在双向链表类中定义双向链表合并函数并实现此功能。
C语言数据结构之循环链表的简单实例
12-26
C语言数据结构之循环链表的简单实例 实例代码： # include # include typedef struct node //定义链表中结点的结构 { int code; struct node *next; }NODE,*LinkList; /*错误信息输出函数*/ void Error(char *message) { fprintf(stderr,"Error:%s/n",message); exit(1); } //创建循环链表 LinkList createList(int n) { LinkList head; //头结
C语言实现数据结构和双向链表操作
08-31
本文主要介绍了C语言实现数据结构双向链表操作的相关知识点。双向链表是一种常用的数据结构，它可以从两个方向搜索某个结点，且可以从头结点和尾结点进行遍历。 1. 双向链表的类型描述 在C语言中，双向链表结点的...
C语言数据结构 双向链表的建立与基本操作
01-01
C语言数据结构 双向链表的建立与基本操作 双向链表比单链表有更好的灵活性，其大部分操作与线性表相同。下面总结双向链表与单链表之间的不同之处及我在实现过程中所遇到的问题。 1.双向链表的建立 双向链表在初始...
数据结构--数组、单链表和双链表介绍以及双向链表 数组和链表.pdf
04-18
数据结构--数组、单链表和双链表介绍以及双向链表 数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。数组、链表是两种常见的数据结构，下面将对它们进行介绍。 一、数组 数组是数据结构中的一...
C语言顺序表_单链表_双链表代码.zip
03-30
本压缩包"**C语言顺序表_单链表_双链表代码.zip**"提供了C语言实现的三种基本数据结构——顺序表、单链表和双链表的源代码，这些代码适用于初学者学习和实践。以下将详细介绍这三种数据结构及其应用。 **1. 顺序表*...
C语言 数据结构 单链表的操作代码
haungxinhui的博客
01-16 377
/假设没有重复的该数据。
数据结构之单链表（C语言代码及注释）
qq_43965022的博客
09-17 1720
一、单链表的特点 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 优点：元素的存储单元是任意的，可连续也可不连续；不需要限定长度。 缺点：其查找时间复杂度为O(n)；存放元素时需要另外开辟一个指针域的空间。 二、代码实现 头文件：SList.h #ifndef SLIST_H_INCLUDED #define S
C语言实现链表(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-14 1718
#include "stdio.h" #include "stdlib.h" #include "malloc.h" //5 个常量定义 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW -1 //类型定义 typedef int Status; typedef int ElemType; //测试程序长度定义 #define LONGTH 5 //链表的类型 typedef struct LNode {
C语言链表代码，注释详细
cooping
11-09 2628
C语言链表代码，注释详细，配套视频讲解如下 看动画学编程 | C语言链表概念详解 /* * C语言版本C99，如果编译器版本过低会无法编译 * 在CodeBlocks和VS2019上测试过 * 看代码遇到问题可以+Q: 1497161158 */ #include <stdio.h> #include <stdlib.h> // 导入库用于调用malloc函数动态分配内存 // 定义链表节点 typedef struct Node { int value; .
数据结构——C语言实现 顺序表和链表代码
ZhangJiawen的博客
10-25 2739
今天敲了一下数据结构中顺序表的代码，发现C语言好久不用真的忘得差不多了。代码都是可以直接运行的（我的运行环境是Dev）。如果有写错的地方，欢迎大家留言一起讨论。 对这一部分概念的介绍可以参考这篇博客：数据结构中的顺序表 下来就直接看代码吧 #include<stdio.h> #define MAXSIZE 100 typedef struct{ int elem[MAXSIZE]; int length; }SeqList; //初始化 void Init_SeqList(SeqLis
数据结构（C语言）--链表
研究生在读，记录学习历程
12-30 598
线性表的链式实现
c语言数据结构---链表
邓富民的博客
12-08 938
1.对链表的理解2.链表每个节点的创建3.输出链表链表的基本结构 首先，一条铁链，有多个节点，每两个节点之间会连接起来。 那么这些节点是如何创建的呢？ —结构体— 创建一个结构体类型，该结构体有两个成员，一个是数据data，一个是结构体指针。 为什么要这样创建呢？ 一条铁链，要有第一个节，第二个节，第三个节… 第一个节和第二个节之间，是不是互相扣在一起呢？下面： 结构体成员设置完后
数据结构——链表 原理及C语言代码实现（可直接运行版）
最新发布
m0_63596031的博客
02-16 523
存储都在数据段上，而在函数内部临时开辟的则存储在栈区（记忆技巧：栈区后来先出，生命周期短，适合存储临时使用的变量，在函数执行结束时会自动被释放），堆区存放的则是在函数运行过程中开辟出来的空间，需要程序员进行手动分区以及释放，也可能程序结束时由OS回收，所以也可能会发生内存泄漏问题。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
C语言实现数据结构——链队列
qq_52491380的博客
05-22 262
源码 /** * 创建时间 : 2022/5/21 20:16 * 作 者 : Marson * 内 容 : 队列的链式存储结构(带头结点) */ #include <stdlib.h> #include <stdio.h> #include <stdbool.h> typedef int ElemType; //队列结点 typedef struct QNode { ElemType data; struct QNode
单链表数据结构代码（C语言）
m0_51512094的博客
04-25 2400
利用单链表数据结构实现一组数据的存储，通过简单的交互实现单链表的增删改查。 //ADT 线性表（List） 链式存储结构 LinkList #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType; typedef int Status; //定义单链表 typedef struct Node {
C语言实现栈的三种方式：数组、单链表、双链表
"这篇文档详细解析了C语言中栈的概念和实现方式，涵盖了数组、单向链表和双向链表三种不同的数据结构实现。" 在计算机科学中，栈是一种非常重要的数据结构，它遵循“后进先出”（LIFO）的原则。这意味着最后进入栈...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值