两两交换链表节点+删除链表的倒数第n个节点

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

示例 1：

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

输入：head = []
输出：[]
示例 3：

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/swap-nodes-in-pairs
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 （代码有一点问题，有时间会修改）

#include<iostream>
using namespace std;
struct LNode {
    int data;
    struct LNode* next;
};
typedef struct LNode LNode;
typedef struct LNode* LinkList;
void CreateLinkList(LinkList& L, int n)
{
    L = new LNode;
    L->next = NULL;
    LinkList r;
    r = L;
    for (int i = 0; i < n; i++)
    {
        LinkList p;
        p = new LNode;
        std::cin >> p->data;
        p->next = NULL;
        r->next = p;
        r = p;
    }
}
void ExchangeLinkList(LinkList& L) {//有问题，头结点不能被打印出来
    LNode* dummyHead = new LNode;
    dummyHead->next = L;
    LNode* cur = dummyHead;
    while (cur->next != NULL && cur->next->next != NULL) {
        LNode* temp = cur->next;
        LNode* temp1 = cur->next->next->next;
        cur->next = cur->next->next;
        cur->next->next = temp;
        cur->next->next->next = temp1;
        cur = cur->next->next;
    }
    LNode* p = L->next;
    while (p)
    {
        std::cout << p->data;
        p = p->next;
    }
}
int main() {
    LinkList L;
    CreateLinkList(L, 4);
    ExchangeLinkList(L);
}

给你一个链表，删除链表的倒数第 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]

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n-- && fast != NULL) {
            fast = fast->next;
        }
        fast = fast->next; // fast再提前走一步，因为需要让slow指向删除节点的上一个节点
        while (fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next; 
        
        // ListNode *tmp = slow->next;  C++释放内存的逻辑
        // slow->next = tmp->next;
        // delete nth;
        
        return dummyHead->next;
    }
};