首页 > 其他分享 >数据结构——单向链表

数据结构——单向链表

时间:2024-08-28 21:23:58浏览次数:10  
标签:pTmpNode NULL 单向 链表 pHead 数据结构 LinkNode pNext pFast

链表

1.空间可以不连续(理论上长度是无限的)

2.访问元素不方便

3.链表需要更大的空间存放数据和节点地址

4.链表的插入和删除效率很高O(1)

单向链表

无头单向链表,节点插入在头的话,每次头结点都会变,所以有了有头链表,头结点的pNext总是指向链表的第一个节点

1.创建空链表
//创建空链表
LinkNode *CreateLinkList(void)
{   
    LinkNode *pTmpNode = NULL;

    pTmpNode = malloc(sizeof(LinkNode));
    if (NULL == pTmpNode)
    {
        return NULL;
    }

    pTmpNode->Data = 0;
    pTmpNode->pNext = NULL;

    return pTmpNode;
}
2.头插法
int HeadInsertLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pTmpNode = NULL;

    //1.申请空间
    pTmpNode = malloc(sizeof(LinkNode));
    if (NULL == pTmpNode)
    {
        return -1;
    }

    //2.将Data成员初始化
    pTmpNode->Data = TmpData;

    //3.将pNext成员初始化(和后面连起来)
    pTmpNode->pNext = pHead->pNext;

    //4.将头结点的pNext指向新申请节点(和前面连起来)
    pHead->pNext = pTmpNode;

    return 0;
}
3.遍历
int ShowLinkList(LinkNode *pHead)
{
    LinkNode *pTmpNode = NULL;

    pTmpNode = pHead->pNext;
    while (pTmpNode != NULL)
    {
        printf("%d ", pTmpNode->Data);
        pTmpNode = pTmpNode->pNext;
    }
    printf("\n");

    return 0;
}
4.修改
int UpdateLinkList(LinkNode *pHead, DataType OldData, DataType NewData)
{
    LinkNode *pTmpNode = NULL;
    int cnt = 0;

    pTmpNode = pHead->pNext;
    while (pTmpNode != NULL)
    {
        if (pTmpNode->Data == OldData)
        {
            pTmpNode->Data = NewData;
            cnt++;
        }
        pTmpNode = pTmpNode->pNext;
    }

    return cnt;
}
5.查找
LinkNode *FindLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pTmpNode = NULL;

    pTmpNode = pHead->pNext;
    while (pTmpNode != NULL)
    {
        if (pTmpNode->Data == TmpData)
        {
            return pTmpNode;
        }
        pTmpNode = pTmpNode->pNext;
    }

    return NULL;
}
6.尾插
int TailInsertLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pNewNode = NULL;
    LinkNode *pTmpNode = NULL;

    pNewNode = malloc(sizeof(LinkNode));
    if (NULL == pNewNode)
    {
        return -1;
    }

    pNewNode->Data = TmpData;
    pNewNode->pNext = NULL;

    pTmpNode = pHead;
    while (pTmpNode->pNext != NULL)
    {
        pTmpNode = pTmpNode->pNext;
    }

    pTmpNode->pNext = pNewNode;

    return 0;
}
7.删除链表节点

删除链表节点,必须要知道要删节点的前一个结点,所以要定义两个指针来操作

int DeleteLinkList(LinkNode *pHead, DataType TmpData)
{
    LinkNode *pPreNode = NULL;
    LinkNode *pTmpNode = NULL;
    int cnt = 0;

    pPreNode = pHead;
    pTmpNode = pHead->pNext;
    while (pTmpNode != NULL)
    {
        if (pTmpNode->Data == TmpData)
        {
            //删除
            pPreNode->pNext = pTmpNode->pNext;
            free(pTmpNode);
            pTmpNode = pPreNode->pNext;
            cnt++;
        }
        else 
        {
            pTmpNode = pTmpNode->pNext;
            pPreNode = pPreNode->pNext;
        }
    }

    return cnt;
}

注意:free掉pTmpNode后,它变成了野指针,要为它重新赋值

8.销毁
int DestroyLinkList(LinkNode **ppHead)
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pFreeNode = NULL;

    pTmpNode = pFreeNode = *ppHead;
    while (pTmpNode != NULL)
    {
        pTmpNode = pTmpNode->pNext;
        free(pFreeNode);
        pFreeNode = pTmpNode;
    }
    *ppHead = NULL;

    return 0;
}
复杂操作
 1.查找链表中间节点

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

LinkNode *FindMidLinkNode(LinkNode *pHead)
{
    LinkNode *pFast = NULL;
    LinkNode *pSlow = NULL;

    pFast = pSlow = pHead->pNext;
    while (pFast != NULL)
    {
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            break;
        }
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            break;
        }

        pSlow = pSlow->pNext;
    }

    return pSlow;
}

 2.查找链表倒数第k个节点

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

LinkNode *FindLastKthLinkNode(LinkNode *pHead, int k)
{
    LinkNode *pFast = pHead->pNext;
    LinkNode *pSlow = pHead->pNext;
    int i = 0;

    for (i = 0; i < k; i++)
    {
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            break;
        }
    }

    if (NULL == pFast)
    {
        return NULL;
    }

    while (pFast != NULL)
    {
        pSlow = pSlow->pNext;
        pFast = pFast->pNext;
    }

    return pSlow;
}
 3.链表的倒置(反转)

算法:例如:将第头节点与第一个节点断开连接,在断开前都要保存一下头节点的下一个节点,然后向头插法一样将第一个节点插入到链表中,依次类推

int ReversalLinkList(LinkNode *pHead)
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pInsertNode = NULL;

    pTmpNode = pHead->pNext;
    pHead->pNext = NULL;
    pInsertNode = pTmpNode;

    while (pTmpNode != NULL)
    {
        pTmpNode = pTmpNode->pNext;
        pInsertNode->pNext = pHead->pNext;
        pHead->pNext = pInsertNode;
        pInsertNode = pTmpNode;
    }

    return 0;
}

4.链表的排序(冒泡排序、选择排序)

冒泡排序

每轮比较之后pTmpNode1,都是下一轮的pEnd,直到pEnd = pHead->pNext->pNext;

//链表排序(冒泡排序法)
int BubbleSortLinkList(LinkNode *pHead)
{   
    LinkNode *pTmpNode1 = NULL;
    LinkNode *pTmpNode2 = NULL;
    LinkNode *pEnd = NULL;
    DataType TmpData;

    //如果链表没有节点或者只有1个节点返回0 
    if (NULL == pHead->pNext || NULL == pHead->pNext->pNext)
    {
        return 0;
    }

    while (1)
    {
        pTmpNode1 = pHead->pNext;
        pTmpNode2 = pHead->pNext->pNext;
        if (pTmpNode2 == pEnd)
        {
            break;
        }

        while (pTmpNode2 != pEnd)
        {
            if (pTmpNode1->Data > pTmpNode2->Data)
            {
                TmpData = pTmpNode1->Data;
                pTmpNode1->Data = pTmpNode2->Data;
                pTmpNode2->Data = TmpData;
            }
            pTmpNode1 = pTmpNode1->pNext;
            pTmpNode2 = pTmpNode2->pNext;
        }
        pEnd = pTmpNode1;
    }
    
    return 0;
}

选择排序:

每次选出最小的,第二小的...最大的,


//选择排序
int SelectSortLinkList(LinkNode *pHead)
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pMinNode = NULL;
    LinkNode *pSwapNode = NULL;
    DataType TmpData;

    if (NULL == pHead->pNext)
    {
        return 0;
    }

    pSwapNode = pHead->pNext;

    while (pSwapNode->pNext != NULL)
    {
        pMinNode = pSwapNode;
        pTmpNode = pSwapNode->pNext;
        while (pTmpNode != NULL)
        {
            if (pTmpNode->Data < pMinNode->Data)
            {
                pMinNode = pTmpNode;
            }
            pTmpNode = pTmpNode->pNext;
        }
        if (pMinNode != pSwapNode)
        {
            TmpData = pMinNode->Data;
            pMinNode->Data = pSwapNode->Data;
            pSwapNode->Data = TmpData;
        }
        pSwapNode = pSwapNode->pNext;
    } 

    return 0;
}

 5.已知链表中间某个节点地址,不知道头结点地址,如何删除该节点
算法:可以上中间这个的值变成下一个节点的值,并把它的pNext指向它的pNext->pNext,然后free掉空间
 6.如何判断一个链表是否有环?环长?环的入口位置?
        

是否有环:快指针每次走2步,慢指针每次走1步,快慢指针相遇则说明有环

因为快指针第一次比慢指针多1,第二次快指针比慢指针快2,依次类推,环长一定是一个自然数,所以一定能相遇

 如何计算环长:标记相遇的位置,让指针继续向后走,每走一步计算器自加,走回到标记位置,则计算器值即为环长
 如何计算环入口位置:将一个指针从第一个节点向后走,将一个指针从相遇点向后走,两个指针相遇的位置即为环入口的位置

//判断链表是否有环
//实现方式:
//     快指针每次走2步,慢指针每次走1步
//     两者能够相遇即为有环
LinkNode *IsHasCircle(LinkNode *pHead, int *pcnt)
{
    LinkNode *pFast = NULL;
    LinkNode *pSlow = NULL;
    LinkNode *pTmpNode = NULL;
    LinkNode *pNode1 = NULL;
    LinkNode *pNode2 = NULL;
    int ret = 0;
    int cnt = 1;

    pSlow = pFast = pHead->pNext;
    while (1)
    {
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            ret = 0;
            break;
        }
        pFast = pFast->pNext;
        if (NULL == pFast)
        {
            ret = 0;
            break;
        }

        pSlow = pSlow->pNext;
        if (pSlow == pFast)
        {
            ret = 1;
            break;
        }
    }

    if (1 == ret)
    {
        //获得环长
        pTmpNode = pSlow->pNext;
        while (pTmpNode != pSlow)
        {
            cnt++;
            pTmpNode = pTmpNode->pNext;
        }
        *pcnt = cnt;

        //获得环入口位置
        pNode1 = pSlow;
        pNode2 = pHead->pNext;
        while (1)
        {
            pNode1 = pNode1->pNext;
            pNode2 = pNode2->pNext;
            if (pNode1 == pNode2)
            {
                return pNode1;
            }
        }
    }

    return NULL;
}

标签:pTmpNode,NULL,单向,链表,pHead,数据结构,LinkNode,pNext,pFast
From: https://blog.csdn.net/m0_61965705/article/details/141629314

相关文章

  • 【数据结构与算法第二章(理论知识)】绪论:数据结构的定义、算法的基本概念和算法效率分析
     目录【数据结构与算法第二章(理论知识)】绪论1.1数据结构的定义1.2算法的基本概念1.3算法效率分析1.3.1时间复杂度1.3.2空间复杂度【数据结构与算法第二章(理论知识)】绪论1.1数据结构的定义    数据结构没有一个统一的官方定义,以下是一些经典书籍对数据......
  • 信息学奥赛初赛天天练-77-NOIP2015普及组-基础题2-二进制、连通图、最小生成树、链表
    NOIP2015普及组基础题24在计算机内部用来传送、存贮、加工处理的数据或指令都是以()形式进行的A二进制码B八进制码C十进制码D智能拼音码5下列说法正确的是()ACPU的主要任务是执行数据运算和程序控制B存储器具有记忆能力,其中信息任何时候都不会......
  • 算法与数据结构——哈希算法
    哈希算法前面介绍了哈希表的工作原理和哈希冲突的处理方法。然而无论是开放寻址还是链式地址,它们只能保证可以在发生冲突时正常工作,而无法减少哈希冲突的发生。如果哈希冲突过于频繁,哈希表的性能则会急剧劣化。如下图所示,对于链式哈希表,理想情况下键值对均匀分布在各个桶中,达到......
  • Python基本数据结构
    本篇是Python系列教程第8篇,更多内容敬请访问我的Python合集Python提供了几种内置的数据结构,这些数据结构可以帮助我们有效地组织和管理数据。下面是一些基本的数据结构及其介绍和示例:1列表(list)列表是一种有序的、可变的数据结构,可以包含任何类型的项。特点:有......
  • 3217. 从链表中移除在数组中存在的节点
    从链表中移除在数组中存在的节点给你一个整数数组nums和一个链表的头节点head。从链表中移除所有存在于nums中的节点后,返回修改后的链表的头节点。示例1:输入:nums=[1,2,3],head=[1,2,3,4,5]输出:[4,5]解释:移除数值为1,2和3的节点。示例2:输入:nums=[......
  • Redis几种常用数据类型的数据结构
    以下是redis-7版本以下适用stringint编码:当字符串长度小于等于12字节并且字符串可以表示为整数时,Redis会使用int编码。这样可以节省内存,并且在执行一些命令时可以直接进行数值计算。embstr编码:当字符串长度小于等于39字节时,Redis会使用embstr编码。这种编码方式会将......
  • 82. 删除排序链表中的重复元素 II
    传送锚点:力扣给你一个链表的头节点head和一个整数val,请你删除链表中所有满足Node.val==val的节点,并返回新的头节点。示例1:输入:head=[1,2,6,3,4,5,6],val=6输出:[1,2,3,4,5]示例2:输入:head=[],val=1输出:[]示例3:输入:head=[7,7,7,7],val=7输......
  • 数据结构之链表
    C++中常见的数据结构-CSDN博客目录一、链表的定义二、链表的创建三、链表的遍历四、链表的插入五、链表的删除六、总结 链表是计算机科学中常见的一种数据结构,c/c++语言中也有着丰富的链表操作函数库。本文将从链表的定义、创建、遍历、插入、删除等多个方面进行详细......
  • 给自己复盘的随想录笔记-链表练习题(在整理ing)
    删除链表的倒数第N个节点双指针的经典应用,如果要删除倒数第n个节点,让fast移动n步,然后让fast和slow同时移动,直到fast指向链表末尾。删掉slow所指向的节点就可以了。思路是这样的,但要注意一些细节。分为如下几步:推荐大家使用虚拟头结点,这样方便处理删除实际头结点的逻辑,定......
  • 数据结构学习第一周
    本文需要掌握的知识1.认识数据结构2.了解数据结构(逻辑结构)的分类3.内存储器模型以及分配方式(物理结构)4.认识Node类5.简单了解泛型1.数据结构(D-S/DataStructure)1.1简介1.1.1数据分为原子数据和复合数据1.1.2结构分为逻辑结构和物理结构数据结构是由数据和数据......