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

最新推荐文章于 2018-10-22 17:22:23 发布
最新推荐文章于 2018-10-22 17:22:23 发布
阅读量472 收藏
点赞数
分类专栏： LeetCode and Algorithm 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/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.csdn.net/luckyxiaoqiang/article/details/7393134

life_爱水的鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指offer--判断链表是否带环？若带环求环的长度？若带环求环的入口点？
he_shuai20的博客
07-15 862
1、判断链表是否带环？ 链表是否带环，可以采用快慢指针法，用两个指针指向链表的头结点，一个指针一次向后走一个位置，另一个指针向后走两个位置，这样如果两个指针如果相遇，这样就能说该链表带环，如果当快指针或者快指针的next为NULL时，还没有相遇。哪么就说明该链表不带环。 我实现时，用一个pair模板去实现，这样为了方便后面两个问题的解决。 代码实现： #include struct Lis
剑指offer：单链表的基本操作
Jeff Li
04-12 1193
时间久了，怕忘了，就写下来，算是一个回忆吧，这是常见的数据结构： #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】面试题6-从头到尾打印链表-完整的可执行代码（Java）
01-22
题目描述： 输入一个链表，按链表从尾到头的顺序返回一个ArrayList。 解题思路参考：https://blog.csdn.net/flower_48237/article/details/104034942
剑指 Offer 35. 复杂链表的复制python（csdn）————程序.pdf
12-04
《复杂链表的复制》是编程面试中常见的一道题目，主要考察对链表操作的深入理解和技巧。这里我们讨论如何使用Python实现复杂链表的复制，包括理解问题描述、设计解决方案以及具体代码实现。 首先，我们需要理解题目...
剑指offer计划2（链表）---java（csdn）————程序.pdf
12-04
在本文中，我们将深入探讨与链表相关的三个Java编程题目，这些都是出自《剑指Offer》这本书的挑战。我们将依次分析每个题目，理解其要求，并详细解释解决方案。 **第一题：从尾到头打印链表** 这道题目的目标是从...
剑指offer源代码
05-17
《剑指Offer》是一本非常知名的编程面试指南，它涵盖了大量经典的编程面试题目，旨在帮助求职者提升在面试中的竞争力。这里的"剑指offer源代码"指的是书中各题目的C语言实现版本，这些代码经过了严格的测试，确保了...
C语言中的数据结构关于链表
02-21
链表在C语言中也是很重要的，数据结构在C的编程中是必不可少的。
C语言 数据结构链表的实例（十九种操作）
08-29
主要介绍了C语言 数据结构链表的实例（十九种操作）的相关资料,需要的朋友可以参考下
单链表的基本操作C语言实现
sofia_m的博客
10-18 1424
          单链表主要有以下基本操作：头插，尾插，头删，尾删，返回结点在链表中的位置，任意位置插入值为data的结点， 删除pos位置上的结点 ，求链表中节点的个数，销毁单链表 。         代码如下所示： List.h #ifndef __LINKED_LIST__ #define __LINKED_LIST__ typedef int DataType; typede...
单向链表的C语言实现与基本操作
热门推荐
TECH_PRO的博客
04-17 5万+
本文的主要内容目录： 一、单向链表的C语言实现 二、单向链表的基本操作 一、单向链表的C语言实现 链表作为一种基本的数据结构在程序开发过程当中经常会使用到。对C语言来说链表的实现主要依靠结构体和指针，所以本文相关内容和程序需要有C语言当中指针和结构体的基础。 链表是一种线性存储数据的结构，存储内容在逻辑上连续的，在物理上却不一定连续。单向链表的组成包括一个链表头（head）和若干
剑指offer面试题-判断链表是否带环并求环的入口点和环的长度
Hyacinth_Dy
07-17 2237
题目：输入一个链表的头节点，判断链表是否带环，若带环，求环的入口点，和环的长度。 判断链表是否带环
SDUT_单链表去重
Guojing_Huang的博客
03-12 721
数据结构实验之链表七：单链表中重复元素的删除Time Limit: 1000 ms Memory Limit: 65536 KiBSubmit StatisticProblem Description按照数据输入的相反顺序（逆位序）建立一个单链表，并将单链表中重复的元素删除（值相同的元素只保留最后输入的一个）。Input第一行输入元素个数 n (1 &lt;= n &lt;= 15)；第二行输入 ...
数据结构之链表1（单项链表）
Norman的专栏
03-03 581
链表的定义 链表的时间复杂度（证明过程稍后补充） 插入 - O(1),随机插入时复杂度为O(n) 删除 - O(n) 搜索 - O(n) 示例实现
L2-002. 链表去重
chenyang890的博客
03-20 447
L2-002. 链表去重时间限制 300 ms 内存限制 65536 kB 代码长度限制 8000 B 判题程序 Standard 作者 陈越 给定一个带整数键值的单链表L，本题要求你编写程序，删除那些键值的绝对值有重复的结点。即对任意键值K，只有键值或其绝对值等于K的第一个结点可以被保留。同时，所有被删除的结点必须被保存在另外一个链表中。例如：另L为21→-15→-15→-7→
C语言单链表的入门学习
weixin_43484734的博客
10-22 1821
新手C语言单链表 单链表 建立一个链表存放输入的整数，
剑指offer Java题解：二维查找、替换空格与链表反转
牛客网剑指offer——Java题解是一本针对Java程序员设计的面试题集，旨在帮助求职者提升算法技能，解决实际工作中的编程问题。本书包含一系列精心挑选的面试题目，涵盖数据结构、算法和基本编程技巧，有助于考生在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值