链表OJ题

前言

本篇博客继续为大家介绍一些链表的OJ题，旨在提高对链表的理解和运用，如果其中有题目足下之前做过，那么请温故而知新；如若没做过，那么我们一起来学习一下，下面进入正文部分。

题目1 返回倒数第k个节点

这道题有很多解法。有的人会选择使用数组解决，但是数组显然不是最好的办法，空间复杂度比较高；这道题我们可以使用快慢指针的方法；

大家来看下面代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

typedef struct ListNode ListNode;
int kthToLast(struct ListNode* head, int k)
{
    ListNode* slow,*fast;
    slow=head;
    fast=head;
    while(k--)//快指针先走k步
    {
        fast=fast->next;
    }
    while(fast)//一起走
    {
        slow=slow->next;
        fast=fast->next;
    }
    return slow->val;
}

大家看到，本题采用了快慢指针的方法，很容易就解决了，这种思想大家可以记住，以后还会用到。

题目2 相交链表

本题有两个要求：

第一我们要判断是否相交，这里我们需要判断尾节点的地址是否相等来判断是否相交，因为只要相交，尾节点肯定是相同的；

第二，我们怎么找交点？

这里我们还是可以使用上一题的思想，我们让长的先走差距步，然后再一起走。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 typedef struct ListNode ListNode;
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
{
    ListNode* curA=headA;
    ListNode* curB=headB;
    int lenA=1;
    int lenB=1;
    while(curA->next)//找尾节点
    {
        curA=curA->next;
        ++lenA;
    }
    while(curB->next)//找尾节点
    {
        curB=curB->next;
        ++lenB;
    }
    if(curA!=curB)//尾节点不相等，不相交
    {
        return NULL;
    }
    //长的先走差距步，再同时走，第一个相等的节点就是交点
    //这里使用假设法
    int gap=abs(lenA-lenB);//计算差距步
    ListNode* longList=headA,*shortList=headB;
    //假设A长B短
    if(lenB>lenA)//假设错了，下面要进行修改
    {
        longList=headB;
        shortList=headA;
    }
    while(gap--)
    {
        longList=longList->next;//长的先走差距步
    }
    while(longList!=shortList)//一起走
    {
        longList=longList->next;
        shortList=shortList->next;
    }
    return longList;
}

题目3 环形链表 

本题乍一看还有点麻烦，但是实际上挺简单的，我们还是可以使用快慢指针来解决。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
typedef struct ListNode ListNode; 
bool hasCycle(struct ListNode *head) 
{
    ListNode* fast=head;
    ListNode* slow=head;
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
    if(fast==slow)
    {
        return true;
    }
    }
    return false;
}

关于本题呢，我们还有两个拓展问题；

第一个问题：快指针一次2步，慢指针一次1步，为什么一定会相遇？有没有可能错过，永远追不上？

解答：

这个问题其实很容易解释，当两个指针都进环的时候，它们之间存在差距，每走一次，快指针就会比慢指针多走一步，差距也就同时减小一步，这样，迟早差距会变为0，即追上。

第二个问题：快指针一次走3步，走4步，...n步行吗？

 

题目4  环形链表II

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
typedef struct ListNode ListNode;
struct ListNode *detectCycle(struct ListNode *head) 
{
    ListNode* slow=head;
    ListNode* fast=head;
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
    if(slow==fast)//相遇
    {
        ListNode* meet=slow;
        while(meet!=head)
        {
            meet=meet->next;
            head=head->next;
        }
        return meet;
    }
    }
    return NULL;
}
    

本道题存在一个有趣的结论：让一个指针从链表起始位置开始遍历链表，同时让一个指针从判环时相遇点的位置开始绕环运行， 两个指针都是每次均走一步，最终肯定会在入口点的位置相遇。

总结

本篇博客为大家重点介绍的链表的带环问题，这是一个很经典的问题，希望大家可以理解并掌握其中的算法思想，最后，希望本篇文章可以对正在学习链表的你带来帮助，感谢阅读！