【牛客刷题系列】链表常见笔试题总结

反转链表

输入一个链表，反转链表后，输出新链表的表头

示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

牛客链接

实现思路

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        ListNode* newhead=nullptr;
        ListNode* tmp=nullptr;
        while(pHead)
        {
            tmp=pHead;
            pHead=pHead->next;
            
            tmp->next=newhead;
            newhead=tmp;
        }
        return newhead;
    }
};

这里假设新的头为空，tmp一开始也指向原头，第一次循环把原来的头移到下一个节点，然后按照头插法，把每一个节点头插到新的头前面，也就是tmp->next=newhead; 再把新的头赋值为tmp。如此循环，直到原来的头走到空的位置。
边界情况：pHead为空代码也不会有问题，不进入循环，直接return null。

链表中的节点每k个一组翻转

题目描述
将给出的链表中的节点每 k 个一组翻转，返回翻转后的链表
如果链表中的节点数不是k 的倍数，将最后剩下的节点保持原样
你不能更改节点中的值，只能更改节点本身。
要求空间复杂度 O(1)
例如：
给定的链表是1→2→3→4→5
对于 k=2, 你应该返回 2→1→4→3→5
对于 k=3, 你应该返回 3→2→1→4→5

牛客链接

实现思路

递归的思想,剩余数量小于k的话，则不需要反转

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        // write code here
        if(head==NULL||head->next==NULL)
            return head;
        ListNode* tail = head;
        
        for (int i = 0; i < k; i++) {
        //剩余数量小于k的话，则不需要反转。
            if (tail == NULL) {
                return head;
                }
            tail = tail->next;
          }
        // 反转前 k 个元素
        ListNode* newHead = reverse(head, tail);
        //下一轮的开始的地方就是tail
        head->next = reverseKGroup(tail, k);
        return newHead;
    }
    
    ListNode* reverse(ListNode* head,ListNode* tail)
    {
        ListNode* newhead=nullptr;
        ListNode* tmp=nullptr;
        while(head!=tail)
        {
            tmp=head;
            head=head->next;
                
            tmp->next=newhead;
            newhead=tmp;
        }
        return newhead;
    }
};

判断链表是否有环

1，快慢指针解决
判断链表是否有环应该是老生常谈的一个话题了，最简单的一种方式就是快慢指针，慢指针针每次走一步，快指针每次走两步，如果相遇就说明有环，如果有一个为空说明没有环。代码比较简单

class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(!head)return false;
        ListNode* slow=head,*fast=head;
        while(fast!=NULL&&fast->next!=NULL)
        {
            slow=slow->next;
            fast=fast->next->next;
            if(slow==fast)
                return true;
        }
        return false;
    }
};

到这里问题好像并没有结束，为什么快慢指针就一定能判断是否有环。我们可以这样来思考一下，假如有环，那么快慢指针最终都会走到环上，假如环的长度是m，快慢指针最近的间距是n，如下图中所示。

快指针每次走两步，慢指针每次走一步，所以每走一次快慢指针的间距就要缩小一步，在图一中当走n次的时候就会相遇，在图二中当走m-n次的时候就会相遇。

2，逐个删除
一个链表从头节点开始一个个删除，所谓删除就是让他的next指针指向他自己。如果没有环，从头结点一个个删除，最后肯定会删完，如下图所示

如果是环形的，那么有两种情况，一种是o型的，一种是6型的。原理都是一样，我们就看一下o型的

如上图所示，如果删到最后，肯定会出现head=head.next；因为有环，肯定会走回来，回来发现head=head.next，那就是有环。代码如下

class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(!head||!head->next)
            return false;
        if(head->next==head)
            return true;
        ListNode* nextnode=head->next;
        head->next=head;
        return hasCycle(nextnode);
    }
};

合并有序链表

将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的，且合并后新链表依然有序。

牛客链接

实现

方法一：递归

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1 == NULL) {
            return l2;
        }
        if (l2 == NULL) {
            return l1;
        }
        ListNode* mergenode=nullptr;
        if(l1->val<=l2->val)
        {
            mergenode=l1;
            mergenode->next=mergeTwoLists(l1->next,l2);
        }
        else{
            mergenode=l2;
            mergenode->next=mergeTwoLists(l1,l2->next);
        }
        return mergenode;
    }
};

方法二: 循环

class Solution {
public:
	    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
		if (l1 == NULL) {
            return l2;
        }
        if (l2 == NULL) {
            return l1;
        }
        ListNode *head = NULL, *last = NULL;
        if (l1->val < l2->val) {
            head = l1;
            last = head;
            l1 = l1->next;
        } else {
            head = l2;
            last = head;
            l2 = l2->next;
        }
        while (l1 && l2) {
            if (l1->val < l2->val) {
                last->next = l1;
                l1 = l1->next;
            } else {
                last->next = l2;
                l2 = l2->next;
            }
            last = last->next;
        }
        last->next = l1 ? l1 : l2;
        return head;
  	}
  };

链表中倒数第k个结点

题目

 ListNode* FindKthToTail(ListNode* pHead, int k) {
    // write code here
    if(!pHead)return nullptr;
    ListNode* fast=pHead;
    ListNode* last=pHead;
    for(int i=0;i<k;i++)
    {
        if(fast->next)
            fast=fast->next;
        else //走到空的位置，分两种
        {
            if(i==k-1) //一个是链表长度等于n
                return pHead;
            //另一个是链表长度大于n，返回空
            return nullptr;
        }
    }
        //走到下面就是要找的节点在中间，返回last指针
    while(fast)
    {
        fast=fast->next;
        last=last->next;
    }
    return last;
}
};