【LeetCode】Remove Nth Node From End of List

给定一个链表，删除从链表尾数起第n个节点，并返回头节点。

e.g. 

给定链表：1 -> 2 -> 3 -> 4 -> 5，n = 2

删除倒数第二个节点后的链表： 1 -> 2 -> 3 -> 5

 

我的笨方法：

原理是判断要删除的节点为从头数起第 count 个节点，然后判断是否为头节点，进行删除。

    int length(ListNode* head) {
        int n = 0;
        ListNode *p = head;
        while (p) {
            p = p -> next;
            n++;
        }
        return n;
    }
    
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int count = length(head) - n + 1;
        if (count == 1) {
            ListNode *p = head;
            head = head -> next;
            delete p;
        } else if (count-- > 1) {
            ListNode *p = head, *q;
            while (count) {
                q = p;
                p = p -> next;
                count--;
            }
            q -> next = p -> next;
            delete p;
        }
        return head;
    }

 

看答案看到一个使用二级指针的方法，惊为天人。

ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode** t1 = &head, *t2 = head;
    // t2向后移n个节点
    while (n--) t2 = t2->next;  
    // 使t2移到最后一个节点的next，即NULL
    // t1指向那个指向待删除节点的指针，即指向待删除节点的上一个节点的next
    while (t2 != NULL) {
        t2 = t2->next;
        t1 = &((*t1)->next);
    }   
    t2 = *t1;   // t2指向待删除节点
    (*t1) = t2->next;
    delete t2;
    return head;
}

原理：

    该方法 4 - 11 行直接正序找到倒数第 n 个节点。

    如本例 n = 2 时，t2 先向后移动 2 个节点到 3 ，然后 t1 和 t2 一起向后移动，当 t2 移动到最后的 NULL 时，t1 指向那个【指向待删除节点 4 的指针】，即指向待删除节点 4 的上一个节点 3 的next。最后 t2 = *t1; 则让 t2 指向待删除节点 4 。

 

二级指针在链表中的使用

参考 http://coolshell.cn/articles/8990.html

    一般人以及多数教材在实现删除链表节点的函数的时候，维护了一个 prev 指针，然后删除当前指针 cur 。

while (cur)  
{  
    if (cur->data == tdata) {  /* 删除data == tdata的链表节点 */
        /* 如果待删除的节点是链表头 */  
        if (cur == head) {
            head = cur->next;  
        } else {   /* 如果待删除的节点不是链表头 */
            prev->next = cur->next;  
        }  
        delete cur;    
    }  
    prev = cur;  
    /* 遍历所有节点 */  
    cur = cur->next;  
}  

这种一般方法是通过 head 指向的结构体实例以及所有 next 指针指向的结构体实例来遍历链表的。

    而如果使用二级指针，可以把头结点和其他节点等效对待，为什么呢？因为链表中每个节点都由前面一个节点的 next 指针来指向，而头结点是由 head 指针指向的，所以 head 指针和其他节点的 next 指针扮演着完全相同的角色。因此二级指针 **cur 使用 head 和所有 next 指针来遍历链表。

while (*cur) {  
    entry = *cur;  
    if (entry->data == tdata) {  
        /* 删除 entry 节点 */  
        *cur = entry->next;  
       delete entry;  
    }  
    /* 遍历所有节点的指针 */  
    cur = &(entry->next);  
} 

在C++中，变量名的意义是拷贝一个值。之前的常见做法，cur = head->next，仅仅是把指针 head->next 的值copy给了指针 cur，使得 cur 可以访问链表的下一个节点；而声明为二级指针的 cur，*cur 不是 head->next 的copy值，它“就是” head->next 这个变量名的别名，它获得的是 head->next 这个变量的读写权。

 

不过个人认为这两种方法没有孰优孰劣，都声明了 2 个指针。。。

最有用的还是用两个指针正序遍历链表找到倒数第 n 个节点，因此可以写出最简洁的一般算法。

C++实现：

ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode *t1 = head, *t2 = head;
    while (n--) t2 = t2->next;
    if (!t2)    return head->next;  // 要删除的是头节点  
    t2 = t2->next;    // t2再后移一个节点，保证t1、t2之间间隔n个节点，这样t2变为NULL时，t1为待删除节点的前驱
    while (t2) {
        t1 = t1->next;
        t2 = t2->next;
    }
    t2 = t1->next;    // t2为待删除节点
    t1->next = t2->next;
    delete t2;
    return head;
}

PS：

C++对应的Java代码

ListNode *t1 = head;          ListNode t1=head;
head->next                    head.next

{    
    t2 = t1->next;
    t1->next = t2->next;   ===>   Java可直接写成 t1.next = t1.next.next; 不会有内存泄漏
    delete t2;
}