LeetCode 19. Remove Nth Node From End of List【快慢指针模板题】⭐

题目描述

知识点

双指针（快慢指针）

结果

实现

码前思考

1. 快慢指针模板题

代码实现

//使用快慢指针进行解题！

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* fast = head;
        ListNode* slow = head;
        bool flag = false;

        //首先将快指针快速移动n位
        for(int i=0;i<n+1;i++){
            //特殊处理
            if(fast == NULL){
                flag = true;
                break;
            }
            fast = fast->next;
        }

        //直到fast指针到达了NULL
        while(fast != NULL){
            fast = fast->next;
            slow = slow->next;
        }

        if(slow == head && flag == true){   //特判删除头的情况
            head = head->next;
        }else{
            ListNode* node = slow->next->next;
            slow->next = node;
        }

        return head;
    }
};

码后反思

1. 第一次提交的时候，忽略了一些情况，导致答案错误，没有理清楚到达链表末尾之后的操作，混淆了两种情况。
   错误代码如下：

   //使用快慢指针进行解题！
   
   /**
    * Definition for singly-linked list.
    * struct ListNode {
    *     int val;
    *     ListNode *next;
    *     ListNode(int x) : val(x), next(NULL) {}
    * };
    */
   
   class Solution {
   public:
       ListNode* removeNthFromEnd(ListNode* head, int n) {
           ListNode* fast = head;
           ListNode* slow = head;
           
           //首先将快指针快速移动n位
           for(int i=0;i<n+1;i++){
               //特殊处理
               if(fast ==NULL){
                   break;
               }
               fast = fast->next;
           }
   
           //直到fast指针到达了NULL
           while(fast != NULL){
               fast = fast->next;
               slow = slow->next;
           }
   
           if(slow == head){   //特判删除头的情况
               head = head->next;
           }else{
               ListNode* node = slow->next->next;
               slow->next = node;
           }
   
           return head;
       }
   };
   

   输入：
   [1,2]
   1
   输出：
   [2]
   预期：
   [1]

2. 为了避免上面的错误我们最好还是使用一个虚拟结点dummyNode比较好：

//使用快慢指针进行解题！

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        //设置一个虚拟结点
        ListNode* dummyNode = new ListNode(0);
        dummyNode->next = head;

        ListNode* fast = dummyNode;
        ListNode* slow = dummyNode;

        //首先将快指针快速移动n位
        for(int i=0;i<n+1;i++){
            fast = fast->next;
        }

        //直到fast指针到达了NULL
        while(fast != NULL){
            fast = fast->next;
            slow = slow->next;
        }

        ListNode* node = slow->next->next;
        slow->next = node;


        return dummyNode->next;
    }
};

二刷代码

使用快慢指针解题，链表的题目中dummyNode的设置非常重要。

//使用快慢指针算法
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head==NULL){
            return NULL;
        }
        //链表传统艺能，dummyNode
        ListNode* dummyNode = new ListNode(0);
        dummyNode->next = head;
        ListNode* pre = dummyNode;
        ListNode* slow = head;
        ListNode* fast = head;
        //先让fast走
        for(int i=0;i<n;i++){
            fast = fast->next;
        }
        //然后一起动
        while(fast!=NULL){
            fast = fast->next;
            pre=slow;
            slow = slow->next;
        }

        //移除slow结点
        pre->next = slow->next;
        return dummyNode->next;
    }
};