数据结构：单向链表

已于 2024-08-29 19:45:05 修改
阅读量349 收藏 6
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 链表 单向链表
于 2024-08-28 19:22:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64378221/article/details/141647447
版权

目录

结构体

创建链表

插入链表

头插法

尾插法

遍历打印

更新链表指定节点

查找链表指定节点

删除链表指定节点

销毁链表

找到元素中间位置

 找到链表倒数第k个节点

链表元素倒置

链表元素排序

冒泡排序

选择排序

结构体

typedef int DataType;
typedef struct node
{
    DataType data;
    struct node *pnext;
}LinkNode;

创建链表

LinkNode *CreateLinklist()
{
    LinkNode *pHead=NULL;
    pHead=malloc(sizeof(LinkNode));
    if(pHead==NULL)
    {
        return NULL;
    }
    pHead->pnext=NULL;
    return pHead;
}

插入链表

头插法

int HeadInsertLink(LinkNode *pHead,DataType data)
{
    LinkNode *pTmpnode=NULL;
//申请一个新的节点空间
    pTmpnode=malloc(sizeof(LinkNode));
    if(pTmpnode==NULL)
    {
        return -1;
    }
//为节点data赋值
    pTmpnode->data=data;
//新节点的pnext指向头结点的pnext
    pTmpnode->pnext=pHead->pnext;
//头结点的pnext指向新节点
    pHead->pnext=pTmpnode;
    return 0;
}

尾插法

int TailInsertLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *ptmpnode=NULL;
    LinkNode *Newnode=NULL;
    ptmpnode=pHead;
//找到最后一个节点(最后一个节点的特点是pnext为空)
    while (ptmpnode->pnext!=NULL)
    {
        ptmpnode=ptmpnode->pnext;
    }
//申请一个新的节点空间
    Newnode=malloc(sizeof(LinkNode));
    if(Newnode==NULL)
    {
        return -1;
    }
//为节点数据空间赋值
    Newnode->data=TmpData;
//新节点的pnext指向NULL
    Newnode->pnext=NULL;
//最后一个节点next指向当前节点,当前节点变为最后一个节点
    ptmpnode->pnext=Newnode;
    return 0;
}

遍历打印

int Showlist(void *Element,void *arg)
{
    int *data = Element;
    printf("%d  ",*data);
    return 0;
}
int ShowLinkList(LinkNode *pHead,int (*pFun)(void *Element,void *arg),void *arg)
{
    LinkNode *pTmpnode=NULL;
    pTmpnode=pHead->pnext;
    int ret=0;
    while(pTmpnode!=NULL)
    {
        ret=pFun(&pTmpnode->data,arg);
        if(ret!=0)
        {
            break;
        }
        pTmpnode=pTmpnode->pnext;
    }
    return 0;
}

更新链表指定节点

int UpdateLinkList(LinkNode *pHead, DataType OldData, DataType NewData)
{
    LinkNode *pTmpnode=NULL;
    pTmpnode=pHead->pnext;
    while(pTmpnode!=NULL)
    {   
        if(pTmpnode->data==OldData)
        {
             pTmpnode->data=NewData;
        }
        pTmpnode=pTmpnode->pnext;
   
    }
    
    return 0;
}

查找链表指定节点

LinkNode *FindLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pTmpnode=NULL;
    pTmpnode=pHead;
    while(pTmpnode->data!=TmpData)
    {
        pTmpnode=pTmpnode->pnext;
    }
    return pTmpnode;
}

删除链表指定节点

int DeleteLinklist(LinkNode *pHead,DataType data)
{
    LinkNode *pTmpnode=NULL;
    LinkNode *pPreNode=NULL;
    pTmpnode=pHead;
    pPreNode=pHead;
    while(pTmpnode!=NULL)
    {
       if((pTmpnode->data!=data)) //如果不是要被删除的节点
       {
            pPreNode=pTmpnode;//保存此节点
            pTmpnode=pTmpnode->pnext;//指向下一个节点
       }
        else
        {   //前一个节点的pnext指向要被删除节点的后一个节点
            pPreNode->pnext=pTmpnode->pnext;
            free(pTmpnode);//释放要被删除的节点
            pTmpnode=pPreNode->pnext;//循环遍历下一个节点
        }
    }
  
    return 0;

}

销毁链表

int DestoryLinklist(LinkNode **pHead)
{
    LinkNode *pTmpnode=NULL;
    LinkNode *pTmpnext=NULL;
    pTmpnode=*pHead;

    while(pTmpnode!=NULL)
    {  //保存下一个节点
        pTmpnext=pTmpnode->pnext;
        free(pTmpnode);//释放当前节点
        pTmpnode=pTmpnext; //指向下一个节点
    }
    *pHead=NULL;//头结点指向空
    return 0;
}

找到元素中间位置

算法：

       快指针pFast每次走2步
       慢指针pSlow每次走1步
       快指针到达末尾时，慢指针所在的位置即为中间位置

LinkNode *FindMidLinkNode(LinkNode *pHead)
{
    LinkNode *pFast=pHead->pnext;
    LinkNode *pSlow=pHead->pnext;
    while(pFast!=NULL)
    {
//快节点先走两步，若是只有一个节点或两个节点，就跳出循环，此时慢节点指向第一个节点
        pFast=pFast->pnext;
        if(pFast==NULL)
        {
            break;
        }
        pFast=pFast->pnext;
        if(pFast==NULL)
        {
            break;
        }
//快节点走完两步，慢节点走一步
        pSlow=pSlow->pnext;
    }
    return pSlow;
}

 找到链表倒数第k个节点

算法：

         快指针先走k步
         慢指针和快指针每次走1步(快指针总是领先慢指针k步)
          当快指针走到末尾时,慢指针即指向链表倒数第k个节点

LinkNode *FindKthLinkNode(LinkNode *pHead,int k)
{
    int i=0;
    LinkNode *pFast=pHead->pnext;
    LinkNode *pSlow=pHead->pnext;
//快节点先走k步
    for(i=0;i<k;i++)
    {
        pFast=pFast->pnext;
        if(pFast->pnext==NULL)
        {
            return NULL;
        }
    }
//快慢节点每次都走1步，当快节点到达末尾时，慢节点的位置就是第k个节点
    while(pFast!=NULL)
    {
        pFast=pFast->pnext;
        pSlow=pSlow->pnext;
    }
    return pSlow;
}

链表元素倒置

算法

        使用头插法将链表元素开始到结尾重新插入链表中，即第一个插入后第二个插入，第一个就在末尾，以此类推实现倒置

int ReverseLinkList(LinkNode *pHead)
{
    LinkNode *pInsertNode=pHead->pnext;
    LinkNode *pTmpNode=pHead->pnext;
    pHead->pnext=NULL;
    while(pTmpNode!=NULL)
    {
        //保留革命火种
        pTmpNode=pTmpNode->pnext;
        //将剩余链表的第一个插入头结点pnext
        pInsertNode->pnext=pHead->pnext;
        pHead->pnext=pInsertNode;
        //插入节点向后移动
        pInsertNode=pTmpNode;
    }
    return 0;
}

链表元素排序

冒泡排序

int BubbleLinkList(LinkNode *pHead)
{
    LinkNode *ptmpNode1=NULL;
    LinkNode *ptmpNode2=NULL;
    LinkNode *pEnd=NULL;
    DataType pTmpData;
//没有元素或只有一个元素直接返回
    if(pHead->pnext==NULL ||pHead->pnext->pnext==NULL)
    {
        return -1;
    }
    while(1)
    {
        ptmpNode1=pHead->pnext;
        ptmpNode2=pHead->pnext->pnext;
//最后一次只有两个元素，此时链表已经排好序，pEnd和pTmpNode
相等，直接结束外层循环        
        if(ptmpNode2==pEnd)
        {
            break;
        }


//第一次排序结束时标志为pTmpNode=NULL,但是pEnd此时还是NULL,所以这里直接写成pEnd
        while(ptmpNode2!=pEnd)
        {
//相邻节点作比较，将大数往后挪
            if(ptmpNode1->data > ptmpNode2->data)
            {
                pTmpData=ptmpNode1->data;
                ptmpNode1->data=ptmpNode2->data;
                ptmpNode2->data=pTmpData;
            }
//一直向后遍历
            ptmpNode1=ptmpNode1->pnext;
            ptmpNode2=ptmpNode2->pnext;
        }   
//当ptmpNode2走到NULL或者end时，ptmpNode1就是此时保存的数据最大节点，下一次就不用遍历此节点 
        pEnd=ptmpNode1;
    }
    return 0;
}

选择排序

pTmpNode负责遍历后面的节点，当找到比pMinNode节点更小的值时，更新pMinNode,然后比较pSwapNode与pMinNode值的大小，将小的值存放在pSwapNode节点的数据中，pSwap再指向像一个节点，进行下一轮比较

//选择排序
int SelectSortLinkList(LinkNode *pHead)
{
    LinkNode *pSwapNode=pHead->pnext;
    LinkNode *pMinNode=pHead->pnext;
    LinkNode *pTmpNode=NULL;
    DataType TmpData;
    if(pHead->pnext==NULL)
    {
        return 0;
    }
    while(pSwapNode->pnext!=NULL)
    {
//每次先将pMinNode保存为待交换的节点
        pMinNode=pSwapNode;
//从待交换节点的下一个节点开始遍历
        pTmpNode=pSwapNode->pnext;
//找到后面最小的数据的节点，将每一个遍历的节点都与最小节点比较，让pMinNode总是指向更小的节点
        while(pTmpNode!=NULL)
        {
            if(pMinNode->data >pTmpNode->data )
            {
                pMinNode=pTmpNode;
            }
            pTmpNode=pTmpNode->pnext;
        }
//如果最小的数据比带交换数据还小，就交换两个节点的数据，保证此轮最小的数据在最前面
        if(pMinNode->data < pSwapNode->data)
        {
            TmpData=pMinNode->data;
            pMinNode->data=pSwapNode->data;
            pSwapNode->data=TmpData;
        }
//待交换数据向后依次遍历
        pSwapNode=pSwapNode->pnext;
    }
    return 0;
}

如何判断一个链表是否有环？环长？环的入口位置？

是否有环：

        快指针每次走2步,慢指针每次走1步,快慢指针相遇则说明有环
如何计算环长：

        标记相遇的位置，让指针继续向后走，没走一步计算器自加,走回到标记位置，则计算器值即为环长
如何计算环入口位置：

        将一个指针从第一个节点向后走，将一个指针从相遇点向后走，两个指针相遇的位置即为环入口的位置

LinkNode *IsHasCircle(LinkNode *pHead,int *len)
{
    int ret=0;
    *len=1;
    LinkNode *pFast=NULL;
    LinkNode *pSlow=NULL;
    LinkNode *pTmpNode=NULL;
    LinkNode *pNode1=NULL;
    LinkNode *pNode2=NULL;
    pFast=pSlow=pHead->pnext;
//判断是否有环
    while(1)
    {
        pFast=pFast->pnext;
        if(pFast==NULL)
        {
            ret=0;
            break;
        }
        pFast=pFast->pnext;
        if(pFast==NULL)
        {
            ret=0;
            break;
        }
        pSlow=pSlow->pnext;
        if(pFast==pSlow)
        {
            ret=1;
            break;
        }
    }
    if(ret==1)
    {
        //获得环长
//从相遇节点的下一个节点触发，再次走到相遇节点刚好走路一圈
        pTmpNode=pSlow->pnext;
        while(pTmpNode!=pSlow)
        {
            (*len)++;
            pTmpNode=pTmpNode->pnext;
        }
        获得环入口节点
//pNode1从第一个节点开始向后走
        pNode1=pHead->pnext;
//pNode2从快慢相遇位置开始走（在环内走）
        pNode2=pSlow;
//pNode1和pNode2节点相遇的位置即为环入口节点
        while(pNode1!=pNode2)
        {
            pNode1=pNode1->pnext;
            pNode2=pNode2->pnext;
        }
        return pNode1;
        
    }
    return NULL;
}

⊙^⊙
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之单向链表
yjhqukq的博客
10-28 1866
单向链表中的每个结点都有一个数据域、一个指针域。数据域用来存储结点的数据，指针域用来存储下一个结点所在的内存空间地址。这里完成了单向链表的五个基本功能，初始化、头插法、尾插法、删除结点、遍历链表。
数据结构：单向链表源码
07-02
单向链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。在计算机科学和编程领域，理解并能够实现单向链表的源码是至关重要的，因为它是构建更复杂数据结构（如双向链表、循环...
数据结构：单向链表的反转
又蠢又笨的懒羊羊程序猿的博客
08-03 1166
文章目录单链表的反转1.头插法1.1思路1.2代码实现2.就地逆置法2.1思路2.2代码实现 单链表的反转 本文主要介绍头插法逆置和就地逆置法实现链表的反转 1.头插法 1.1思路 迭代方式的链表反转操作核心是从链表头到链表尾 首先让创建一个temp指针使其指向头节点的下一个节点，并将其取出 取出之后让新创建的reverseNode节点指向刚取出的节点，反复进行上述操作。需要注意的是每次取出节点之前，需要用另外一个指针暂存temp指向的节点的下一个节点，防止temp指针变化后找不到新的节点。 最后让初
数据结构：单向链表及其基本操作
JimmyC18的博客
08-28 900
1. 单向链表介绍 链表的定义：是一种物理存储结构上非连续、非顺序的存储结构，数据元素（结点）的逻辑顺序是通过链表中的指针链接次序实现的。 注：结点包含两个域：数据域和指针域； 链表的特点： 存储单元可以是可连续的，也可以是不连续的； 作插入和删除操作时，不需要移动元素，仅需修改指针； 不可随机存取； 单向链表：链表的每一个结点中只包含一个指针域，如下图所示： 其中，单向链表的第一个结点之前附设的结点，称为头结点head;链表的结点位置从0开始，例如第一个结点再链表中所对应的位置pos=0. 2
数据结构：单向链表反转（C/C++）
kaixian2003的博客
03-25 1729
单向链表在数据结构中比较常见，要求实现单向链表的反转，如下图所示： 反转前： 反转后： 代码如下： #include <stdio.h> #include <stdlib.h> struct list{ int var; struct list *next; }; //反转单向链表 void reversal(struct list* &head) { struct list *p1,*pre,*after; p1=head; pre=head; head=h
链表，认识数据结构：单向链表，双向链表，反转链表
weixin_46838716的博客
04-28 692
单向链表和双向链表的结构特点记住，还有：反转链表的代码，别整错了，一定按照逻辑，先后操作谁，错了不行的。
数据结构3：单向链表实现及图解
m0_53607711的博客
10-03 1558
头删的逻辑也不算困难，理解了二级指针之后就非常容易了。
数据结构：单向链表、单向循环链表、双向链表
Jags的博客
05-13 1534
一、概述 链式存储结构是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。又称链表。 链表特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。这就意味着，这些数据元素可以存在内存未被占用的任意位置(如图所示)。 以前在顺序结构中,每个数据元素只需要存数据元素信息就可以了。现在链式结构中，除了要存数据元素信息外，还要存储它的后继元素的存储地址。 把存储数据元素信息的域称为数据域，把存储直接后继位置的域称
数据结构笔记：单向链表
BBJG_001的博客
02-29 1963
原文地址 分类目录——数据结构笔记 离散存储，手拉手，每一块有指向下一块的指针（形象描述，python中没有指针），就好像形成了一条链 一个元素包括两部分：value 和 next 链表与顺序表都是线性表 知识点补充 b = 20 a = 'achar' a = b # 在python中，所有的变量保存的都是值的地址（就相当于c语言中的指针） # 等号右边表示执行，=b中的b就是执...
【数据结构】单向链表
m0_73648729的博客
05-05 1157
哈喽，大家好，今天我们学习的是数据结构里的链表，这里主要讲的是不带哨兵卫头节点的单向链表，下篇将会继续带大家学习双向链表。
数据结构：单向循环链表源码
07-04
单向循环链表是计算机科学中一种基本的数据结构，它在数据存储和处理中起着重要作用。本资源提供了单向循环链表的源码实现，旨在帮助读者更好地理解和掌握这一概念。下面，我们将深入探讨单向循环链表的定义、特性、...
Python-MNE-源定位和逆问题01：源估计（SourceEstimate）数据结构
weixin_58312922的博客
08-25 668
stc是MNE-Python的一个类，表示从源估计中获得的转换的时间序列。对于两个半球，数据分别存储在和中，储存形式为的形式为一个m*n的矩阵，m是这个半球的空间位置的数量，n是时间点的个数。和对应和。这些是表面表征的位置索引。表面的坐标存储在和中，分别表示左半球和右半球。
集合及数据结构第十节（下）————常用接口介绍、堆的应用和java对象的比较
2301_79418684的博客
08-25 806
常用接口介绍和堆的应用 1. PriorityQueue的特性 2. .PriorityQueue常用接口介绍 3. top-k问题 4. 堆排序 5. PriorityQueue中插入对象 6. 元素的比较 7. .对象的比较 8. .集合框架中PriorityQueue的比较方式
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 556
数组，双链表实现队列，附完整代码
数据结构之链表
WSH2012ffff的博客
08-27 623
本文从链表的定义、创建、遍历、插入、删除等多个方面进行了详细讲解，希望能够帮助大家更好地理解和掌握c/c++语言中的链表操作。链表是一种动态数据结构，由节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表是计算机科学中常见的一种数据结构，c/c++语言中也有着丰富的链表操作函数库。在c/c++中，可以使用结构体来定义一个节点，并用指针来表示节点之间的关系，从而实现链表。链表遍历是指按照一定的顺序依次访问链表中的每一个节点。链表删除是指在链表中删除一个节点。
Linux 数据结构 链表
最新发布
mxyzhy的博客
08-28 227
单向链表操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值