链表常见操作【整理自剑指offer及csdn】

最新推荐文章于 2020-11-28 11:42:22 发布
最新推荐文章于 2020-11-28 11:42:22 发布
阅读量505 收藏
点赞数
分类专栏： LeetCode and Algorithm 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u013777351/article/details/48639091
版权

1：单链表的节点定义：

struct ListNode
{
    int m_nValue;
    ListNode *m_pNext;
};

2：向链表末尾中添加一个节点：

void AddToTail(ListNode** pHead, int value)
{
    ListNode *pNew = new ListNode();
    pNew->m_nValue = value;
    pNew->m_pNext = NULL;

    if(*pHead == NULL)
    {
        *pHead = pNew;  
    }
    else
    {
        ListNode *pNode = *pHead;
        while(pNode->m_pNext != NULL)
            pNode = pNode->m_pNext;
        pNode->m_pNext = pNew;
    }
}

3：在链表中找到第一个含有某值的节点并删除该节点：

void RemoveNode()
{
    if(pHead == NULL || *pHead == NULL)
        return;
    ListNode* pToBeDeleted = NULL;
    if((*pHead)->m_nValue == value)
    {
        pToBeDeleted = *pHead;
        *pHead = (*pHead)->m_pNext;
    }
    else
    {
        ListNode* pNode = *pNode;
        while(pNode->m_pNext != NULL &&
             pNode->m_pNext->m_nValue != value)
             pNode = pNode->m_pNext;
        if(pNode->m_pNext != NULL && 
            pNode->m_pNext->m_nValue == value)
        {
            pToBeDeleted = pNode->m_pNext;
            pNode->m_pNext = pNode->m_pNext->m_pNext;
        }
    }
    if(pToBeDeleted != NULL)
    {
        delete pToBeDeleted;
        pToBeDeleted = NULL;
    }
}

4：从尾到头打印链表

// 链表的定义
struct ListNode
{
    int m_nKey;
    ListNode* m_pNext;
};

// 方法1 非递归方法
void PrintListReversingly(ListNode* pHead)
{
    stack<ListNode*> nodes;
    ListNode* pNode = pHead;
    while(pNode != NULL)
    {
        nodes.push(pNode);
        pNode = pNode->m_pNext;
    }
    while(!nodes.empty())
    {
        pNode = nodes.top();
        printf("%d\t", pNode->m_nValue);
        nodes.pop();
    }
}

// 方法三 递归版
void PrintListReversingly(ListNode* pHead)
{
    if(pHead != NULL)
    {
        if(pHead->m_pNext != NULL)
        {
            PrintListReversingly(pHead->m_pNext);
        }
        printf("%d\t", pHead->m_nValue);
    }
}

/*
 递归的弊端： 当链表非常长的时候，就会导致函数调用层次很深，
从而有可能导致函数调用栈溢出;
*/

5：在O(1)时间删除链表节点

struct ListNode
{
    int m_nValue;
    ListNode* m_pNext;
};

void DeleteNode(ListNode** pListHead, ListNode* pToBeDeleted)
{
    if(!pListHead || !pToBeDeleted)
        return;

    // 要删除的结点不是尾结点
    if(pToBeDeleted->m_pNext != NULL)
    {
        ListNode* pNext = pToBeDeleted->m_pNext;
        pToBeDeleted->m_nValue = pNext->m_nValue;
        pToBeDeleted->m_pNext = pNext->m_pNext;

        delete pNext;
        pNext = NULL;
    }
    // 链表只有一个结点，删除头结点（也是尾结点）
    else if(*pListHead == pToBeDeleted)
    {
        delete pToBeDeleted;
        pToBeDeleted = NULL;
        *pListHead = NULL;
    }
    // 链表中有多个结点，删除尾结点
    else
    {
        ListNode* pNode = *pListHead;
        while(pNode->m_pNext != pToBeDeleted)
        {
            pNode = pNode->m_pNext;            
        }

        pNode->m_pNext = NULL;
        delete pToBeDeleted;
        pToBeDeleted = NULL;
    }
}

6：链表中倒数第K个结点

struct ListNode
{
    int m_nValue;
    ListNode* m_pNext;
};

ListNode* FindKthToTail(ListNode* pListHead, unsigned int k)
{
    if(pListHead == NULL || k == 0)
        return NULL;

    ListNode *pAhead = pListHead;
    ListNode *pBehind = NULL;

    for(unsigned int i = 0; i < k - 1; ++ i)
    {
        if(pAhead->m_pNext != NULL)
            pAhead = pAhead->m_pNext;
        else
        {
            return NULL;
        }
    }

    pBehind = pListHead;
    while(pAhead->m_pNext != NULL)
    {
        pAhead = pAhead->m_pNext;
        pBehind = pBehind->m_pNext;
    }

    return pBehind;
}

7：反转链表

struct ListNode
{
    int m_nValue;
    ListNode* m_pNext;
};

ListNode* ReverseList(ListNode* pHead)
{
    ListNode* pReversedHead = NULL;
    ListNode* pNode = pHead;
    ListNode* pPrev = NULL;
    while(pNode != NULL)
    {
        ListNode* pNext = pNode->m_pNext;

        if(pNext == NULL)
            pReversedHead = pNode;

        pNode->m_pNext = pPrev;

        pPrev = pNode;
        pNode = pNext;
    }

    return pReversedHead;
}

8：合并两个排序的链表

struct ListNode
{
    int m_nValue;
    ListNode* m_pNext;
};

ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
{
    if(pHead1 == NULL)
        return pHead2;
    else if(pHead2 == NULL)
        return pHead1;

    ListNode* pMergedHead = NULL;

    if(pHead1->m_nValue < pHead2->m_nValue)
    {
        pMergedHead = pHead1;
        pMergedHead->m_pNext = Merge(pHead1->m_pNext, pHead2);
    }
    else
    {
        pMergedHead = pHead2;
        pMergedHead->m_pNext = Merge(pHead1, pHead2->m_pNext);
    }

    return pMergedHead;
}

9：求单链表中结点的个数

// 求单链表中结点的个数  
unsigned int GetListLength(ListNode * pHead)  
{  
    if(pHead == NULL)  
        return 0;  

    unsigned int nLength = 0;  
    ListNode * pCurrent = pHead;  
    while(pCurrent != NULL)  
    {  
        nLength++;  
        pCurrent = pCurrent->m_pNext;  
    }  
    return nLength;  
}

10：查找单链表的中间结点

也是设置两个指针，只不过这里是，两个指针同时向前走，前面的指针每次走两步，后面的指针每次走一步，前面的指针走到最后一个结点时，后面的指针所指结点就是中间结点，即第（n/2+1）个结点。注意链表为空，链表结点个数为1和2的情况。时间复杂度O（n）。

// 获取单链表中间结点，若链表长度为n(n>0)，则返回第n/2+1个结点  
ListNode * GetMiddleNode(ListNode * pHead)  
{  
    // 链表为空或只有一个结点，返回头指针  
    if(pHead == NULL || pHead->m_pNext == NULL) 
        return pHead;  

    ListNode * pAhead = pHead;  
    ListNode * pBehind = pHead;

    // 前面指针每次走两步，直到指向最后一个结点，后面指针每次走一步
    while(pAhead->m_pNext != NULL)   
    {  
        pAhead = pAhead->m_pNext;  
        pBehind = pBehind->m_pNext;  
        if(pAhead->m_pNext != NULL)  
            pAhead = pAhead->m_pNext;  
    }  
    return pBehind; // 后面的指针所指结点即为中间结点  
}

11：判断一个单链表是否有环

bool HasCircle(ListNode * pHead)  
{  
    ListNode * pFast = pHead; // 快指针每次前进两步  
    ListNode * pSlow = pHead; // 慢指针每次前进一步  
    while(pFast != NULL && pFast->m_pNext != NULL)  
    {  
        pFast = pFast->m_pNext->m_pNext;  
        pSlow = pSlow->m_pNext;  
        if(pSlow == pFast) // 相遇，存在环  
            return true;  
    }  
    return false;  
}

12： 判断两个单链表是否相交

方法：如果两个链表相交于某一节点，那么在这个相交节点之后的所有节点都是两个链表所共有的。也就是说，如果两个链表相交，那么最后一个节点肯定是共有的。先遍历第一个链表，记住最后一个节点，然后遍历第二个链表，到最后一个节点时和第一个链表的最后一个节点做比较，如果相同，则相交，否则不相交。时间复杂度为O(len1+len2)，因为只需要一个额外指针保存最后一个节点地址，空间复杂度为O(1)。

bool IsIntersected(ListNode * pHead1, ListNode * pHead2)  
{  
    if(pHead1 == NULL || pHead2 == NULL)  
                return false;  
    ListNode * pTail1 = pHead1;  
    while(pTail1->m_pNext != NULL)  
        pTail1 = pTail1->m_pNext;  

    ListNode * pTail2 = pHead2;  
    while(pTail2->m_pNext != NULL)  
        pTail2 = pTail2->m_pNext;  
    return pTail1 == pTail2;  
}

13：求两个单链表相交的第一个节点

对第一个链表遍历，计算长度len1，同时保存最后一个节点的地址。
对第二个链表遍历，计算长度len2，同时检查最后一个节点是否和第一个链表的最后一个节点相同，若不相同，不相交，结束。
两个链表均从头节点开始，假设len1大于len2，那么将第一个链表先遍历len1-len2个节点，此时两个链表当前节点到第一个相交节点的距离就相等了，然后一起向后遍历，知道两个节点的地址相同。
时间复杂度，O(len1+len2)。参考代码如下：

ListNode* GetFirstCommonNode(ListNode * pHead1, ListNode * pHead2)  
{  
    if(pHead1 == NULL || pHead2 == NULL)  
        return NULL;  

    int len1 = 1;  
    ListNode * pTail1 = pHead1;  
    while(pTail1->m_pNext != NULL)  
    {  
        pTail1 = pTail1->m_pNext;  
        len1++;  
    }  

    int len2 = 1;  
    ListNode * pTail2 = pHead2;  
    while(pTail2->m_pNext != NULL)  
    {  
        pTail2 = pTail2->m_pNext;  
        len2++;  
    }  

    if(pTail1 != pTail2) // 不相交直接返回NULL  
        return NULL;  

    ListNode * pNode1 = pHead1;  
    ListNode * pNode2 = pHead2;  
    // 先对齐两个链表的当前结点，使之到尾节点的距离相等  
    if(len1 > len2)  
    {  
        int k = len1 - len2;  
        while(k--)  
            pNode1 = pNode1->m_pNext;  
    }  
    else  
    {  
        int k = len2 - len1;  
        while(k--)  
            pNode2 = pNode2->m_pNext;  
    }  
    while(pNode1 != pNode2)  
    {  
        pNode1 = pNode1->m_pNext;  
        pNode2 = pNode2->m_pNext;  
    }  
        return pNode1;  
}

14：已知一个单链表中存在环，求进入环中的第一个节点

首先判断是否存在环，若不存在结束。在环中的一个节点处断开（当然函数结束时不能破坏原链表），这样就形成了两个相交的单链表，求进入环中的第一个节点也就转换成了求两个单链表相交的第一个节点。参考代码如下：

ListNode* GetFirstNodeInCircle(ListNode * pHead)  
{  
    if(pHead == NULL || pHead->m_pNext == NULL)  
        return NULL;  

    ListNode * pFast = pHead;  
    ListNode * pSlow = pHead;  
    while(pFast != NULL && pFast->m_pNext != NULL)  
    {  
        pSlow = pSlow->m_pNext;  
        pFast = pFast->m_pNext->m_pNext;  
        if(pSlow == pFast)  
            break;  
    }  
    if(pFast == NULL || pFast->m_pNext == NULL)  
        return NULL;  

    // 将环中的此节点作为假设的尾节点，将它变成两个单链表相交问题  
    ListNode * pAssumedTail = pSlow;   
    ListNode * pHead1 = pHead;  
    ListNode * pHead2 = pAssumedTail->m_pNext;  

    ListNode * pNode1, * pNode2;  
    int len1 = 1;  
    ListNode * pNode1 = pHead1;  
    while(pNode1 != pAssumedTail)  
    {  
        pNode1 = pNode1->m_pNext;  
        len1++;  
    }  

    int len2 = 1;  
    ListNode * pNode2 = pHead2;  
    while(pNode2 != pAssumedTail)  
    {  
        pNode2 = pNode2->m_pNext;  
        len2++;  
    }  

    pNode1 = pHead1;  
    pNode2 = pHead2;  
    // 先对齐两个链表的当前结点，使之到尾节点的距离相等  
    if(len1 > len2)  
    {  
        int k = len1 - len2;  
        while(k--)  
            pNode1 = pNode1->m_pNext;  
    }  
    else  
    {  
        int k = len2 - len1;  
        while(k--)  
            pNode2 = pNode2->m_pNext;  
    }  
    while(pNode1 != pNode2)  
    {  
        pNode1 = pNode1->m_pNext;  
        pNode2 = pNode2->m_pNext;  
    }  
    return pNode1;  
}

参考资料：
剑指offer
http://blog.youkuaiyun.com/luckyxiaoqiang/article/details/7393134

SDUT_单链表去重
Guojing_Huang的博客
03-12 773
数据结构实验之链表七：单链表中重复元素的删除Time Limit: 1000 ms Memory Limit: 65536 KiBSubmit StatisticProblem Description按照数据输入的相反顺序（逆位序）建立一个单链表，并将单链表中重复的元素删除（值相同的元素只保留最后输入的一个）。Input第一行输入元素个数 n (1 &lt;= n &lt;= 15)；第二行输入 ...
线性表之单链表基本操作（C语言实现，详细注释版）
u010067603的博客
03-23 1340
有不懂的可以问我，把自己练习编写的代码在这里和大家分享下。如有错误欢迎指正。 #include <stdio.h> #include <stdlib.h> #define N 5 //链表节点单元 typedef struct Link{ int value;//数据域 struct Link *next;//指针域 }link; /*************...
剑指offer--判断链表是否带环？若带环求环的长度？若带环求环的入口点？
he_shuai20的博客
07-15 920
1、判断链表是否带环？ 链表是否带环，可以采用快慢指针法，用两个指针指向链表的头结点，一个指针一次向后走一个位置，另一个指针向后走两个位置，这样如果两个指针如果相遇，这样就能说该链表带环，如果当快指针或者快指针的next为NULL时，还没有相遇。哪么就说明该链表不带环。 我实现时，用一个pair模板去实现，这样为了方便后面两个问题的解决。 代码实现： #include struct Lis
剑指offer：单链表的基本操作
Jeff Li
04-12 1277
时间久了，怕忘了，就写下来，算是一个回忆吧，这是常见的数据结构： #include typedef struct ListNode { int key; struct ListNode *next; }ListNode; ListNode *insertList(ListNode *head,int value); //创建一个单链表和向一个链表中插入元素，这里默认的是头插入
建立单向动态链表的方法
07-20
最简单的建立单向动态链表的方法，用c语言实现，希望对各位有帮助
C语言 数据结构之链表实现代码
09-01
主要介绍了C语言 数据结构之链表实现代码的相关资料,需要的朋友可以参考下
剑指offer–链表–删除链表中重复的结点(python实现)
01-20
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点， 重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5处理后为 1->2->5 代码： class ListNode: def __init__(self, x): self....
剑指offer刷题笔记
11-08
### 剑指Offer刷题笔记知识点解析 #### 一、二维数组查找 **题目描述：** 给定一个二维数组，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。编写一个函数来判断一个给定的数是否存在...
java版剑指Offer
07-30
《剑指Offer》是一本非常流行的求职面试书籍，尤其在准备中国IT行业相关职位的候选人中。这本书籍主要采用Java语言编写，覆盖了众多面试中常见的算法题目和数据结构问题，是帮助求职者提高编程能力和应对面试技巧的...
剑指offer计划2（链表）---java（csdn）————程序.pdf
12-04
在本文中，我们将深入探讨与链表相关的三个Java编程题目，这些都是出自《剑指Offer》这本书的挑战。我们将依次分析每个题目，理解其要求，并详细解释解决方案。 **第一题：从尾到头打印链表** 这道题目的目标是从...
剑指 Offer 35. 复杂链表的复制python（csdn）————程序.pdf
12-04
《复杂链表的复制》是编程面试中常见的一道题目，主要考察对链表操作的深入理解和技巧。这里我们讨论如何使用Python实现复杂链表的复制，包括理解问题描述、设计解决方案以及具体代码实现。 首先，我们需要理解题目...
C语言中的数据结构关于链表
02-21
链表在C语言中也是很重要的，数据结构在C的编程中是必不可少的。
C语言 数据结构链表的实例（十九种操作）
08-29
主要介绍了C语言 数据结构链表的实例（十九种操作）的相关资料,需要的朋友可以参考下
剑指offer面试题-判断链表是否带环并求环的入口点和环的长度
Hyacinth_Dy
07-17 2291
题目：输入一个链表的头节点，判断链表是否带环，若带环，求环的入口点，和环的长度。 判断链表是否带环
L2-002. 链表去重
chenyang890的博客
03-20 549
L2-002. 链表去重时间限制 300 ms 内存限制 65536 kB 代码长度限制 8000 B 判题程序 Standard 作者 陈越 给定一个带整数键值的单链表L，本题要求你编写程序，删除那些键值的绝对值有重复的结点。即对任意键值K，只有键值或其绝对值等于K的第一个结点可以被保留。同时，所有被删除的结点必须被保存在另外一个链表中。例如：另L为21→-15→-15→-7→
C语言单链表的入门学习
weixin_43484734的博客
10-22 1909
新手C语言单链表 单链表 建立一个链表存放输入的整数，
链表关于链表合并和反转的两类题型
dongdong7_77的博客
11-28 195
第一类 将链表的头部指向尾部，再指向头部的第二个，再由头部的第二个指向尾部的第二个 例子 输入：1，3，5，7，8，9，0 输出：1，0，3，8，5，8，7 这里我的思路是先将将一条表分为两段从中间截断，这时候我们将第二条链表反转，最后将他们有序的合并就可以达成目的 link1* fanzhuan (link1 *p) { link1 *p1,*p2,*tem; p1 =p; p2 =p->next; p1 ->next =NULL; tem =p2 ->next; whi
C++学习（三十六）（C语言部分）之 链表2
weixin_30496431的博客
04-01 82
测试代码笔记如下： #include<stdio.h> #include<stdlib.h> typedef struct node { int data;//数据 struct node*pre;//前驱 struct node*next;//后继 }NODE,*PNODE; //申请一个结点 PNODE c...
剑指OFFER题解与代码复刻教程(C++)
2. 算法和数据结构：通过剑指OFFER的题解，用户可以深入理解并掌握各种常见算法和数据结构，包括数组，链表，二叉树，堆栈，队列，排序算法，搜索算法等。 3. 编程思维和解题技巧：资源中除了提供完整的源码和工程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值