Leetcode算法入门第五天（双指针（4））

876. 链表的中间结点

题目描述

给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

样例

输入：[1,2,3,4,5]
输出：[3,4,5]
解释：返回的结点值为 3  (测评系统对该结点序列化表述是 [3,4,5])。
我们返回了一个 ListNode 类型的对象 ans，
这样：ans.val = 3, ans.next.val = 4, 
ans.next.next.val = 5, ans.next.next.next = NULL.

思路一

两次遍历，因为链表不能通过下标访问链表中的某个元素，也不知道一共有几个节点。所以我们可以通过第一次遍历，统计链表中节点个数count；第二次遍历：遍历count/2次，就可以找到中间节点并返回。

参考代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode* h=head;
        int count=0;
        //先遍历链表，统计有几个节点
        while(h)
        {
            h=h->next;
            count++;
        }
        //算出到中间节点需要的次数
        count/=2;
        //遍历count次
        while(count)
        {
            head=head->next;
            count--;
        }
        //此时head就是中间节点
        return head;

    }
};

思路二

双指针：在链表里判断是否有环，常用的就是快慢指针，快指针每次走两步，慢指针每次走一步。这里要找的中间节点，也可以用这一方法，当快指针走到链表末尾时，慢指针刚好到达中间节点，直接返回慢指针即可。
PS：好巧妙，一开始真的没想到，原来双指针还可以这么用，豁然开朗。

参考代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        //双指针：链表里一般用快慢指针
        //都是从头指针开始
        ListNode* fast=head;
        ListNode* slow=head;
        //快指针每次走两步，慢指针每次走一步
        //当快指针走到结尾时，慢指针到达中间节点
        while(fast!=NULL&&fast->next!=NULL)
        {
            fast=fast->next->next;
            slow=slow->next;
        }
        return slow;

    }
};

19. 删除链表的倒数第 N 个结点

题目描述

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

样例

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

输入：head = [1], n = 1
输出：[]

思路一

跟前面一道题的思路一基本一致，两次遍历，第一次遍历，统计链表的长度count，第二次遍历到待删除节点的前驱节点，需要遍历count-n次（算上了哑头结点），进行删除操作。
注：对于链表来说，删除一个节点node，一般是通过找到前驱节点pre,将pre的next指针指向node的后继节点，所以如果要删除头结点要特殊处理，常用的方法就是申请一个哑头结点，指针指向原来的头结点，这样原来链表中所有节点都有前驱节点，就可以正常删除了。

参考代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* h=head;
        //第一次遍历：统计原来链表节点数
        int count=0;
        while(h)
        {
            count++;
            h=h->next;
        }
        //第二次遍历：找到待删除节点的前一个元素
        //哑头结点：避免删除头结点需要特殊处理
        ListNode* dummy=new ListNode(0,head);
        h=dummy;
        count=count-n;//因为多了哑头结点，所以需要count-n次才到达
        while(count)
        {
            h=h->next;
            count--;
        }
        //删除操作
        h->next=h->next->next;
        return dummy->next;
    }
};

思路二

双指针：这里还是可以用快慢指针来做。首先还是申请哑头结点，方便删除操作。这里需要的是删除链表中倒数第n个节点，也就是我们要找到待删除节点的前驱节点，才能删除。可以先让快指针从head头结点开始先前进n步，然后再让快慢指针每次同时前进一步。为了快指针到达末尾时，慢指针到达的是待删除节点的前驱节点，**慢指针是从dummy哑头结点出发。**找到其前驱后，就进行正常删除操作，再返回头结点即可

参考代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        //又是双指针：快慢指针
        //快指针先走n步，然后再一起走，直到快指针over，慢指针也就到了答案。
        ListNode* dummy=new ListNode(0,head);
        //初始值：快指针为原来的head，慢指针为哑头结点
        ListNode* fast=head;
        ListNode* slow=dummy;
        //快指针先走n步
        while(n--)
        {
            fast=fast->next;
        }
        //快指针到末尾时，慢指针到达倒数第n个节点的前驱节点
        while(fast)
        {
            fast=fast->next;
            slow=slow->next;
        }
        //删除操作
        slow->next=slow->next->next;
        return dummy->next;
    }
};