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

Elvin域文

已于 2022-10-29 15:58:53 修改

阅读量567

点赞数 2

分类专栏：算法文章标签： leetcode 算法链表数据结构 c++

于 2022-10-28 15:28:40 首次发布

本文链接：https://blog.csdn.net/m0_51787573/article/details/127572116

版权

算法专栏收录该内容

31 篇文章 0 订阅

订阅专栏

第一站 LeetCode 新手村

前言

最近玩OJ赛，发现对算法的理解还需要更加扎实，code能力还可以进一步提升，所以做这样一个算法的系列文章，用于记录学习心得，交流经验，更好地进步和成长。也欢迎小伙伴们来给笔者留言，提问

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

题目描述

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

示例1

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

示例 2

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

示例 3

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

提示

链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

解题思路

预知

LeetCode是核心代码模式，所以只需要考虑核心算法，输入由系统自动完成，最后的输出以return返回；

思路

利用栈存储链表结点，寻找到倒数第n个元素的前一个，然后指向该元素next的next，刚好跳过倒数第n个元素，具体的实现思路请参考代码和注释；

空说无意，还是代码来的生动呐！

不熟悉栈特性的小伙伴可以看leetcode官方讲解，更加详细，入口放在下方；也欢迎给笔者留言，有问必答；

力扣

双指针

这里还有一种双指针的写法，感兴趣的朋友，可以查看代码注释，能力强就是方法多嘛

代码

C++

/**
 * 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* dummy = new ListNode(0, head); //哑结点，下一结点指向head
        stack<ListNode*> stk;  //定义栈  压入栈中的是链表结点
        ListNode* cur = dummy;
        while(cur){
            stk.push(cur); //元素入栈
            cur = cur->next;
        }

        for(int i=0;i<n;i++){
            stk.pop();  //元素出栈   弹出该元素并没有消失，只是不存在栈中了，原来占用的存储空间仍然存在
        }               //这里调用栈的目的，就是找到倒数第n个元素
        ListNode* prev = stk.top();  //等于它栈顶的元素
        prev->next = prev->next->next;  //这里解释下为什么可以直接指向，因为压入栈中的是链表结点
                                        //所以栈中的各元素仍然会是以一个单链表的形式存在，只不过head被存到了栈的最底部
        //下面这三步的目的其实就是释放哑结点
        ListNode* ans = dummy->next;    
        delete dummy;  //释放哑结点
        return ans;
        // return dummy->next;  //不释放哑结点，直接指向它的下一个结点输出也是可以的
    }
};

//笔者认为，调栈的方法有些臃肿，时间复杂其实并没有降低，还占用了空间

双指针

/**
 * 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) {
        //双指针， first是second前的第n+1个元素，当，first位于尾部（为空）时，second刚好位于第n个结点的前一位
        ListNode* dummy = new ListNode(0, head);   //声明哑结点为0，并且该结点的下一位指向头结点
        ListNode* first = head;
        ListNode* second = dummy; //我们来解释下为什么要有一个哑结点，或者说second的起始位置为什么是一个哑结点而不是head
       
        while(n--){
            // 让first是second的前n+1个结点
            first = first->next;
        }

        while(first!=nullptr){   //因为当second直接指向head的话，在这一步当first为5时，second为3
            first = first->next; //first不为空，继续进入first为空，second为4, 不是我们要找的倒数第n个结点的上一个，
                                 // 所以为了避免这种情况，我们通常会选择将second的起始点，
                                 //放在哑结点上使最终停止的位置在倒数第n个结点的上一个
            second = second->next;
        }
        second->next = second->next->next; //跳过要被删除的结点，指向倒数第n个结点的下一个
        return dummy->next; //哑结点是0,这里返回哑结点的下一位，也就是头节点
    }
};