一.矩阵
1.旋转图像
旋转图像
观察规律可得:
matrix[i][j] 最终会被交换到 matrix [j][n−i−1]位置,最初思路是直接上三角交换,但是会存在问题,有几个元素是无法交换到的
错误示范
void rotate(vector<vector<int>>& matrix) { int n = matrix.size(); for (int i = 0 ; i < n; i++) { for (int j = 0; j < i; j++) { swap(matrix[i][j], matrix[j][n - i - 1]); } } } }; ``` 解答错误 执行用时: 0 ms Case 1 输入 matrix = [[1,2,3],[4,5,6],[7,8,9]] 输出 [[7,4,3],[8,5,6],[1,2,9]] 预期结果 [[7,4,1],[8,5,2],[9,6,3]]
看了解题思路,需要水平翻转 + 主对角线翻转
水平翻转:
主对角线翻转:
对于水平轴翻转而言,我们只需要枚举矩阵上半部分的元素,和下半部分的元素进行交换,即
matrix[i][j] ==> matrix[n - i - 1][j]
对于主对角线翻转而言,我们只需要枚举对角线左侧的元素,和右侧的元素进行交换,即
matrix[i][j] ==> matrix[j][i]
联立可得:
matrix[i][j] ==> matrix[j][n - i - 1]
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]);
}
}
}
};
二.链表
1. 相交链表
相交链表
当链表 headA和 headB 都不为空时,创建两个指针 pA 和 pB,初始时分别指向两个链表的头节点 headA 和 headB,然后将两个指针依次遍历两个链表的每个节点。具体做法如下:
- 每步操作需要同时更新指针 pA 和 pB。
- 如果指针 pA 不为空,则将指针 pA 移到下一个节点;如果指针 pB 不为空,则将指针 pB 移到下一个节点。
- 如果指针 pA 为空,则将指针 pA 移到链表 headB 的头节点;如果指针 pB 为空,则将指针 pB 移到链表 headA 的头节点。
- 当指针 pA 和 pB 指向同一个节点或者都为空时,返回它们指向的节点或者 null。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
if (headA == nullptr || headB == nullptr) {
return nullptr;
}
ListNode *pa = headA, *pb = headB;
while (pa != pb) {
pa = pa == nullptr ? headB : pa->next;
pb = pb == nullptr ? headA : pb->next;
}
return pa;
}
};
2.反转链表
反转链表
假设链表为 1→2→3→∅1,我们想要把它改成 ∅←1←2←3。
在遍历链表时,将当前节点的 next 指针改为指向前一个节点。由于节点没有引用其前一个节点,因此必须事先存储其前一个节点。在更改引用之前,还需要存储后一个节点。最后返回新的头引用。
1.保存后继节点 tmp = cur->next
2.让当前节点指向pre节点 cur->next = pre
3.暂存当前节点,这是后继节点需要指向的pre, pre = cur
4.访问下一个节点 cur = tmp
pre最终保存的是头节点
/**
* 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* pre = nullptr;
ListNode* cur = head;
while(cur != nullptr) {
ListNode* nextnode = cur->next;
cur->next = pre;
pre = cur;
cur = nextnode;
}
return pre;
}
};
3.回文链表
回文链表
存数组中进行比较,但是空间复杂度为o(n),还可以再优化
/**
* 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) {
vector<int> ans;
while(head != nullptr) {
ans.push_back(head->val);
head = head->next;
}
int n = ans.size();
for (int i = 0, j = n - 1; i < j; i++, j--) {
if (ans[i] != ans[j]) return false;
}
return true;
}
};
4.环形链表
环形链表
龟兔赛跑,乌龟走一步,兔子走两步,如果有环总能相遇
需要注意的是:while的条件是fast & fast->next不为空
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
bool hasCycle(ListNode *head) {
if (head == nullptr || head->next == nullptr) return false;
ListNode *fast = head, *slow = head;
while (fast != nullptr && fast->next != nullptr) {
slow = slow->next;
fast = fast->next->next;
if (slow == fast) return true;
}
return false;
}
};
5.环形链表 II
环形链表 II
基于上一题环形链表,如果slow和fast相遇,让其中一个指针重新指向head,并且两个指针都每次只走一步,再次相遇就是环的入口
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
if (head == nullptr || head->next == nullptr) return nullptr;
ListNode *slow = head, *fast = head;
while (fast != nullptr && fast->next != nullptr) {
slow = slow->next;
fast = fast->next->next;
if (slow == fast) {
fast = head;
while (fast != slow) {
slow = slow->next;
fast = fast->next;
}
return fast;
}
}
return nullptr;
}
};