算法打卡（链表）

链表打卡

链表：物理存储单元上非连续的、非顺序的存储结构。

其逻辑顺序是通过链表的指针地址实现的，由一系列的结点组成，结点可以动态生成

反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

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

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

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

提示：

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

---

思路：

1. 本题很简单，先定义两个指针，一个指向头指针，另一个置空

2. 然后遍历链表

3. 先让原来的头结点置空，然后依次让每个结点的指针指向上一个结点

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

合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

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

输入：l1 = [], l2 = [] 输出：[] 示例 3：

输入：l1 = [], l2 = [0] 输出：[0]

提示：

两个链表的节点数目范围是 [0, 50] -100 <= Node.val <= 100 l1 和 l2 均按 非递减顺序 排列

---

思路：

1. 一开始我想到的是循环，但是一直测试不过

2. 后面看了答案才直到使用递归，一用递归就出来了

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if(list1 == nullptr){
            return list2;
        }else if(list2 == nullptr){
            return list1;
        }else if(list1->val < list2->val){
            list1->next = mergeTwoLists(list1->next,list2);
            return list1;
        }else{
            list2->next = mergeTwoLists(list1,list2->next);
            return list2;
        }
    }
};

旋转链表

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

示例 1：

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

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

提示：

链表中节点的数目在范围 [0, 500] 内 -100 <= Node.val <= 100 0 <= k <= 2 * 109

---

思路：

1. 一开始还是想用循环，后面发现用循环太麻烦了

2. 然后就想着一直先连成环形链表，然后断开不就好了吗

3. 然后就试着使用这个思路做，但是最后，测试没有过完，有的地方老是卡住

4. 最后去看了答案，发现，就是第一次循环完之后，p的指针，是指向链表最后一个结点的

5. 因此，要注意指针的位置

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(k == 0 || head == nullptr || head->next == nullptr){
            return head;
        }
        ListNode* p = head;
        int cnt = 1;
        while(p->next != nullptr){
            p = p -> next;
            cnt++;
        }
        int add = cnt - k % cnt;
        if(k % cnt == 0){
            return head;
        }
        p->next = head;
        while(add--){
            p = p -> next;
        }
        ListNode* q = p -> next;
        p->next = nullptr;
        return q;
    }
};