记录刷题中遇到的知识点方便复习（十二）（链表3）

生病了几天，要抓紧补回来了TuT

二十九、LeetCode第二十九题（19）

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

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

这道题的思路就是创建一个新链表，然后找到要删除的结点的前一个位置，然后将next指针指向下下一个结点，然后采取delete操作将需要删除的结点删掉。

代码如下：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *p = new ListNode(0, head);
        ListNode *q = p;
        int m = 0;
        //链表长度
        while(head){
            m++;
            head = head->next;
        }

        for(int i = 0; i<m-n; i++) q = q->next;
        q->next = q->next->next;
        ListNode *ans = p->next;
        delete p;
        return ans;

    }
};

ListNode *p = new ListNode(0, head);这行的意思是初始化一个空结点，初始赋值为0，并且p的下一个next指针指向head。

三十、LeetCode第三十题（24）

两两交换链表中的节点

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

这道题需要三个指针，其中两个指针分别指向要交换的两个节点，还需要一个指针是指向两个交换节点的前面一个节点。然后根据各自的next指针进行交换。需要注意的是交换指针指向不能为空。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode *ans = new ListNode(0, head);
        
        ListNode *tmp = ans;
       
        while(tmp->next != nullptr && tmp->next->next != nullptr){
            ListNode *p = tmp->next, *q = tmp->next->next;
            tmp->next = q;
            p->next = q->next; 
            q->next = p;            
            tmp = p;
            
        }
        return ans->next;
    }
};

 这是用的迭代的方法。

也可以用递归的方法：

思路是head为原链表的头节点，newHead为head->next，作为新链表的头节点，head连接剩下的交换好的链表，newHead连接head完成交换。

代码：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        //递归
        
        if(head == nullptr || head->next == nullptr){
            return head;
        }
        ListNode *newHead = head->next;       
        head->next = swapPairs(newHead->next);
        newHead->next = head;
        return newHead;
    }
};

最后都跑了一下是迭代更快一些。

讲真虽然递归的代码看起来简单些，但是不好想明白。会用啥用啥吧。

三十一、LeetCode第三十一题（25）

K个一组翻转链表

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

这道题常规思路就是，按k个一组给链表分组，不够k个的保持不变，k长度的子链表进行翻转操作，链表翻转之前写过了，可以单独拎一个函数出来，但是我直接写一起了。但是这种方法就是细节比较多，我写了一堆但是编译没通过，而且找不出来哪有问题，考虑的不够详细吧。

官方题解讲第一种方法很详细，而且评论区有很清晰的代码：. - 力扣（LeetCode）

我用递归的方法写出来了。

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        //递归
        ListNode *p = head;
        ListNode *cur = head;
        ListNode *pre = new ListNode;
        pre->next = head;

        int count = 0;
        while(p){
            count ++;
            p = p->next;
        }
        if(count < k) return head;
        int n = k;
        while(k){
            ListNode *tmp = nullptr;
            tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
            k--;
        }
        head->next = reverseKGroup(cur, n);
        return pre;

    }
};

递归还是很好想的。