【leetcode】删除链表的倒数第 N 个结点-25-5

最新推荐文章于 2024-09-26 23:50:34 发布

fighting的码农(zg)-GPT

最新推荐文章于 2024-09-26 23:50:34 发布

阅读量262

点赞数 1

分类专栏： LeetCode 文章标签： leetcode 链表算法

本文链接：https://blog.csdn.net/qq_43552933/article/details/141271284

版权

LeetCode 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

在这里插入图片描述
方法：递归

/**
 * 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:
    int delN;
    int curN;
    bool isDelete=false;

    void recurveList(ListNode* a,ListNode* b){
        if(b==nullptr){
            return ;
        }
        recurveList(b,b->next);
        curN+=1;
        if(curN==delN){
            ListNode* c=b;
            a->next=c->next;
            delete b;
            isDelete=true;
        }
        
    }

    ListNode* removeNthFromEnd(ListNode* head, int n) {
        delN=n;
        curN=0;
        if(!head->next){
            delete head;
            return nullptr;
        }
        ListNode* res=head;
        recurveList(head,head->next);
        if(!isDelete){
            ListNode* temp=head;
            res=head->next;
            delete  temp;
        }
        return res;
        
    }
};

在这里插入图片描述
方法：二次遍历

/**
 * 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) {
        int sumLength=0;
        ListNode* temp=head;
        while(temp){
            sumLength+=1;
            temp=temp->next;
        }

        temp=head;
        int leftLength=sumLength-n;
        if(leftLength==0){
            ListNode* deleteNode=head;
            head=head->next;
            delete deleteNode;
            return head;
        }
        int i=1;
        temp=head;
        while(i<leftLength){
            temp=temp->next;
            i+=1;
        }
        ListNode* deleteNode=temp->next;
        temp->next=temp->next->next;
        delete deleteNode;
        return head;

    }
};

在这里插入图片描述
方法：双指针+对称

/**
 * 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* fast=new ListNode(0,head);
        ListNode* slow=fast;

        ListNode* res=fast;

        while(n>0){
            n--;
            fast=fast->next;
        }

        while(fast->next){
            fast=fast->next;
            slow=slow->next;
        }

        ListNode* temp=slow->next;
        slow->next=slow->next->next;
        delete temp;

        temp=res;
        res=res->next;
        delete temp;
        
        return res;

    }
};