Leecode Hot100 刷题笔记本-数学（C++版）

1. 48. 旋转图像 中等
2. 142. 环形链表 II 中等

48. 旋转图像

解法1: 原地旋转

• 借助temp来存储
• 两层for循环嵌套

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        for (int i = 0; i < n / 2; ++i) {
            for (int j = 0; j < (n + 1) / 2; ++j) {
                int temp = matrix[i][j];
                matrix[i][j] = matrix[n - j - 1][i];
                matrix[n - j - 1][i] = matrix[n - i - 1][n - j - 1];
                matrix[n - i - 1][n - j - 1] = matrix[j][n - i - 1];
                matrix[j][n - i - 1] = temp;
            }
        }
    }
};

• 时间复杂度:O(N2), 其中 N 是 matrix 的边长
• 空间复杂度:O(1)

解法2: 翻转代替旋转

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        // 水平翻转
        for (int i = 0; i < n / 2; ++i) {
            for (int j = 0; j < n; ++j) {
                swap(matrix[i][j], matrix[n - i - 1][j]);
            }
        }
        // 主对角线翻转
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < i; ++j) {
                swap(matrix[i][j], matrix[j][i]);
            }
        }
    }
};

• 时间复杂度:O(N2), 其中 N 是 matrix 的边长
• 空间复杂度:O(1)

142. 环形链表 II

解法1: 哈希表

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_set<ListNode *> visited;
        while (head != nullptr) {
            if (visited.count(head)) {
                return head;
            }
            visited.insert(head);
            head = head->next;
        }
        return nullptr;
    }
};

• 时间复杂度: O(N), 其中 N 为链表中节点的数目。我们恰好需要访问链表中的每一个节点。
• 空间复杂度: O(N), 其中 N 为链表中节点的数目。我们需要将链表中的每个节点都保存在哈希表当中。

方法二：快慢指针

• 使用两个指针，fast 与 slow。它们起始都位于链表的头部
• slow 指针每次向后移动一个位置，而 fast 指针向后移动两个位置。
• 如果链表中存在环，则 fas 指针最终将再次与 slow 指针在环中相遇
• 相遇之后怎么得到环的入口, 借助一个节点从链表头节点开始走, slow也走, 相遇节点就是环的入口

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *slow = head, *fast = head;
        while (fast != nullptr) {
            slow = slow->next;
            if (fast->next == nullptr) {
                return nullptr;
            }
            fast = fast->next->next;
            if (fast == slow) {
                ListNode *ptr = head;
                while (ptr != slow) {
                    ptr = ptr->next;
                    slow = slow->next;
                }
                return ptr;
            }
        }
        return nullptr;
    }
};

• 时间复杂度: O(N), 其中 N 为链表中节点的数目。我们恰好需要访问链表中的每一个节点。
• 空间复杂度: O(1), 我们只使用了 slow,fast,ptr 三个指针