【代码随想录 | Leetcode | 第六天】链表 | 反转链表 | 两两交换链表中的节点

前言

欢迎来到小K的Leetcode|代码随想录|专题化专栏，今天将为大家带来反转链表、两两交换链表中的节点和删除链表的倒数第N个节点的分享✨

206. 反转链表

✨题目链接点这里
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

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

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

示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp;
        ListNode* pre=nullptr;
        ListNode* cur=head;
        while(cur)
        {
            temp=cur->next;
            cur->next=pre;
            pre=cur;
            cur=temp;
        }
        delete temp,cur;
        temp=nullptr,cur=nullptr;
        return pre;
    }
};

class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur) 
    {
        if(cur==nullptr) return pre;
        ListNode* temp=cur->next;
        cur->next=pre;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) 
    {
        return reverse(nullptr,head);
    }
};

24. 两两交换链表中的节点

✨题目链接点这里
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

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

示例 2：

输入：head = []
输出：[]

示例 3：

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

提示：

链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100

class Solution {
public:
    ListNode* swapPairs(ListNode* head) 
    {
        ListNode* virtualHead=new ListNode(0,head);
        ListNode* cur=virtualHead;
        while(cur->next!=nullptr&&cur->next->next!=nullptr)
        {
            ListNode* temp=cur->next;
            ListNode* temp1=cur->next->next->next;

            cur->next=cur->next->next;
            cur->next->next=temp;
            temp->next=temp1;
            
            cur=cur->next->next;
        }
        return virtualHead->next;
    }
};

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

✨题目链接点这里
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

输入：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

思路：使用双指针法，定义一个快指针和一个慢指针，让快指针移动n步，然后让快指针和慢指针一起移动，当快指针指向空时，慢指针的指向就是要删除的节点，这里是让快指针移动了n+1步，这样最后慢指针就指向了要删除节点的前一个，更方便删除

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) 
    {
        ListNode* virtualHead=new ListNode(0,head);
        ListNode* slow,*fast;
        slow=fast=virtualHead;
        n++;
        while(n--&&fast!=nullptr) fast=fast->next;
        while(fast)
        {
            fast=fast->next;
            slow=slow->next;
        }
        slow->next=slow->next->next;
        return virtualHead->next;
    }
};