C++笔试练习笔记【4】：力扣练习题

17.04 消失的数字

思路

因为已知是从0~N的数字，
我们可以将已知数组填入哈希表，之后再次从0开始遍历检查没有在哈希表中的数即为所求数字

解答

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        unordered_set<int> set;
        int n = nums.size();
        for (int i = 0; i < n; i++) {
            set.insert(nums[i]);
        }
        int missing = 0;
        for (int i = 0; i <= n; i++) {
            if (!set.count(i)) {
                missing = i;
                break;
            }
        }
        return missing;
    }
};

876.链表的中间节点

思路

我的思路是用快慢指针，直接能找到中间值

解答

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode* fast=head;
        ListNode* slow=head;

        while(fast!=NULL&&fast->next!=NULL)
        {
            fast=fast->next->next;
            slow=slow->next;
        }

        return slow;
    }
};

206.反转链表

思路

首先，初始化两个指针 prev 为 nullptr ，表示反转后的链表的尾节点（初始时为空）；curr 为原始链表的头节点 head 。
然后，进入 while 循环，只要 curr 不为空，就执行以下操作：

1. 保存当前节点 curr 的下一个节点的指针到 next 中，这是为了在修改当前节点的 next 指针后，还能找到下一个要处理的节点。
2. 将当前节点 curr 的 next 指针指向前一个节点 prev ，实现了当前节点与前一个节点的链接反转。
3. 更新 prev 为当前节点 curr ，以便下一次循环使用。
4. 将 curr 更新为之前保存的下一个节点指针 next ，准备处理下一个节点。

这样，每次循环都将当前节点的指针反转并向前移动，直到遍历完整个链表。最终，prev 就指向了反转后的链表的头节点，所以函数返回 prev 。

解答

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

21.合并两个有序链表

思路

首先，进行边界情况的判断。

• 如果 l1 为空，直接返回 l2 ，因为此时合并后的结果就是 l2 。
• 如果 l2 为空，直接返回 l1 ，此时合并后的结果就是 l1 。
  然后，比较两个链表当前节点的值。
• 如果 l1 节点的值小于 l2 节点的值，那么将 l1 节点的下一个指针指向递归调用 mergeTwoLists 函数- 处理 l1 的下一个节点和 l2 的合并结果，然后返回 l1 。
• 如果 l1 节点的值大于等于 l2 节点的值，那么将 l2 节点的下一个指针指向递归调用 mergeTwoLists 函数处理 l1 和 l2 的下一个节点的合并结果，然后返回 l2 。

通过这样的递归方式，逐步将两个链表合并为一个有序链表。
例如，假设有两个有序链表 l1: 1 -> 3 -> 5 和 l2: 2 -> 4 -> 6 。
在第一次调用时，因为 1 < 2 ，所以 l1->next = mergeTwoLists(l1->next, l2) ，即处理 3 -> 5 和 2 -> 4 -> 6 的合并。
依次类推，不断递归，最终完成整个合并过程。

解答

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

189.轮转数组

思路

这段代码的目的是对给定的整数数组 nums 进行向右旋转 k 个位置的操作。

其思路如下：

首先，获取数组 nums 的长度 n ，并创建一个与 nums 长度相同的新数组 newArr 。

然后，通过一个循环遍历原始数组 nums 。对于每个元素 nums[i] ，计算其在旋转后的位置 (i + k) % n ，并将该元素放置到新数组 newArr 的对应位置上。

这里 (i + k) % n 的计算方式是为了处理当 i + k 超过数组长度 n 的情况，通过取模操作可以得到正确的旋转后的位置索引。

最后，使用 assign 函数将新数组 newArr 的内容赋给原始数组 nums ，从而实现数组的旋转。

例如，如果 nums = [1, 2, 3, 4, 5] ，k = 2 ，那么：

• 对于 nums[0] = 1 ，旋转后的位置是 (0 + 2) % 5 = 2 ，所以 newArr[2] = 1 。
• 对于 nums[1] = 2 ，旋转后的位置是 (1 + 2) % 5 = 3 ，所以 newArr[3] = 2 。
  依次类推，完成整个旋转操作。

解答

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> newArr(n);
        for (int i = 0; i < n; ++i) {
            newArr[(i + k) % n] = nums[i];
        }
        nums.assign(newArr.begin(), newArr.end());
    }
};