【算法日记】力扣206、24、19

力扣206.反转链表

题目描述：

给你单链表的头节点 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

进阶： 链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

思路：

双指针法，两个指针分别保留前后节点，调转->next的值即可

源码：

/**
 * 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* reverseList(ListNode* head) {
        // 双指针法
        ListNode* curr = head;
        ListNode* pre = nullptr;
        while (curr) {
            ListNode* tmp = curr->next;
            curr->next = pre;
            pre = curr;
            curr = tmp;
        }
        return pre;
    }
};

简单构思进阶递归法，循环可以通过递归实现。此代码片段可见主要使用了while循环，稍作修改即可实现进阶。

class Solution {
public:
    ListNode* reverseList(ListNode *head) {
        return reverse(NULL, head);
    }

    ListNode* reverse(ListNode *pre, ListNode *cur) {
        if (cur) {
            ListNode *tmp = cur->next;
            cur->next = pre;
            return reverse(cur, tmp);
        } else return pre;
    }
};

在每个栈帧中反转，函数返回值为末尾节点的地址。

力扣24.两两交换链表的节点

题目描述：

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

思路：

模拟过程，注意交换实现的细节需要一个前置节点

源码：

/**
 * 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* swapPairs(ListNode* head) {
        if (head == NULL) return head;
        ListNode *pre, *before, *after;
        ListNode* v_head = new ListNode(0, head);
        pre = v_head;
        int Lenght = 0;
        while (pre->next) {
            pre = pre->next;
            Lenght++;
        }
        pre = v_head;
        if (Lenght == 0 || Lenght == 1) return head;
        int times = Lenght / 2;
        while (times--) {
            before = pre->next;
            after = before->next;

            pre->next = after;
            before->next = after->next;
            after->next = before;
            pre = before;
        }
        return v_head->next;
    }
};

力扣19.删除链表的倒数第N个节点

题目描述：

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

提示：

• 链表中结点的数目为 sz
• 1 <= sz <= 30
• 0 <= Node.val <= 100
• 1 <= n <= sz

**进阶：**你能尝试使用一趟扫描实现吗？

思路：

一开始打算用双指针来标记和操作但发现这样容易混淆代码->next一多就容易出问题，于是用了三个指针。我们的目的是删除slow这个位置，pre_slow是为了方便实现删除操作的

源码：

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 *dummyHead = new ListNode(0, head);
        ListNode *pre_slow = dummyHead;
        ListNode *slow = head;
        ListNode *fast = head;
        for (int i = 1; i < n; i++) {
            fast = fast->next;
        }
        while (fast->next) {
            pre_slow = pre_slow->next;
            slow = slow->next;
            fast = fast->next;
        }
        // 删除slow
        pre_slow->next = slow->next;
        delete slow;
        return dummyHead->next;
    }
};