2021-09-30每日刷题打卡

2021-09-30每日刷题打卡

力扣——链表

25. K 个一组翻转链表

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

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

进阶：

你可以设计一个只使用常数额外空间的算法来解决此问题吗？
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：

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

这题前几天看过然后放弃了，实在是有点难，然后昨天在写另一题1721. 交换链表中的节点时想到了方法。先准备两个结点，一个start一直指着变化后的链表头，一个指向变化后的链表尾，拿一个vector容器来存放结点，当容器的内存等于k时，把容器里的元素逆置，再串起来（新链表），end始终指着最后一个结点。然后把容器清空继续装结点，循环往复。因为有可能结点没存满就退出了循环，导致剩下的结点没有接入我们的新链表里，所以while结束后对vector进行判断，如果不为0，按照题目规定也不用逆置，直接把剩下的结点连在end就行，最后返回start。

/**
 * 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* reverseKGroup(ListNode* head, int k) {
    if (head == NULL || head->next == NULL)
    {
        return head;
    }
    vector<ListNode*>v;
    ListNode* p, * end, * start;
    start = (ListNode*)malloc(sizeof(ListNode));
    end = (ListNode*)malloc(sizeof(ListNode));
    start->next = end;
    int b = 1;
    while (head != NULL)
    {
        if (v.size() != k)
        {
            v.push_back(head);
            head = head->next;
        }
        else
        {
            int left = 0, right = v.size() - 1;
            while (left < right)
            {
                p = v[left];
                v[left] = v[right];
                v[right] = p;
                left++;
                right--;
            }
            if (b)
            {
                start->next = v[0];
                end = v[0];
                for (int i = 1; i < v.size(); i++)
                {
                    end->next = v[i];
                    end = v[i];
                }
                b = 0;
            }
            else
            {
                for (int i = 0; i < v.size(); i++)
                {
                    end->next = v[i];
                    end = v[i];
                }
            }
            v.clear();
        }
    }
    if (v.size() < k)
    {
        for (int i = 0; i < v.size(); i++)
        {
            end->next = v[i];
            end = v[i];
        }
    }
    else
    {
        int left = 0, right = v.size() - 1;
        while (left < right)
        {
            p = v[left];
            v[left] = v[right];
            v[right] = p;
            left++;
            right--;
        }
        for (int i = 0; i < v.size(); i++)
        {
            end->next = v[i];
            end = v[i];
        }
    }
    end->next = NULL;
    if (start->next->val < 0)
    {
        start = start->next;
    }
    head = start->next;
    return head;
}
};

回文链表类：

234. 回文链表

面试题 02.06. 回文链表

234. 回文链表

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

示例 1：

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

存进vector里，对撞指针检测完事

/**
 * 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:
    bool isPalindrome(ListNode* head) {
        if (head == NULL)
    {
        return true;
    }
    vector<int>v;
    int num;
    ListNode* p;
    p = (ListNode*)malloc(sizeof(ListNode));
    p->next = head;
    while (p->next != NULL)
    {
        p = p->next;
        num = p->val;
        v.push_back(num);
    }
    int left = 0, right = v.size() - 1;
    while (left < right)
    {
        if (v[left] != v[right])
        {
            return false;
        }
        left++;
        right--;
    }
    return true;
    }
};