文章目录
矩阵相关
1. 旋转矩阵
题目描述： 给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
题解思路： 先将矩阵上下翻转，然后对矩阵进行对角线翻转。
题解代码：
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]);
}
}
}
};
关键结论：对于矩阵中的元素
matrix
[
row
]
[
col
]
\textit{matrix}[\textit{row}][\textit{col}]
matrix[row][col]，在旋转后，它的新位置为
matrix
new
[
col
]
[
n
−
row
−
1
]
\textit{matrix}_\textit{new}[\textit{col}][n - \textit{row} - 1]
matrixnew[col][n−row−1] 。
2. 搜索二维矩阵
题目描述： 编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：
- 每行的元素从左到右升序排列。
- 每列的元素从上到下升序排列。
题解思路： 由于每一行都是单调递增的，因此可以逐行使用二分查找，这样就可以将时间复杂度控制在 O ( n l o g m ) O(nlogm) O(nlogm)之内。
题解代码：
class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
for(const auto& row : matrix){
auto it = lower_bound(row.begin(),row.end(),target);
if( it != row.end() && *it == target){
return true;
}
}
return false;
}
};
注意，需要先判断it != row.end()，再判断*it == target，否则，判断*it == target会不合法，导致未定义行为（Undefined Behavior, UB）
关于
lower_bound(StartIterator, EndIterator, Value)方法的使用：
StartIterator：范围开始的迭代器。
EndIterator：范围结束的迭代器。
Value：需要查找的值。
链表相关
1. 相交链表
题目描述： 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
题解思路： 首先通过Hash表（这里用的unordered_set）存储链表A中的每个节点，然后再遍历链表B中的节点，如果存在节点在Hash表中，就返回这个节点（这个就是相交节点），否则继续遍历。
题解代码：
/**
* 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) {
ListNode * temp = headA;
unordered_set<ListNode*> mp;
while(temp!=nullptr){
mp.insert(temp);
temp = temp->next;
}
temp = headB;
while(temp!=nullptr){
if(mp.count(temp)){
return temp;
}
temp = temp->next;
}
return nullptr;
}
};
2. 反转链表
题目描述： 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例：假设链表为1→2→3→∅，我们想要把它改成 ∅←1←2←3。
题解思路： 遍历链表中的每个节点，修改next指针为前一个节点，因此需要一个辅助节点prev存储上一个节点的指针。另一个cur指针，指向当前节点，nex指针暂存当前节点的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* prev = nullptr;
ListNode* cur = head;
while(cur){
ListNode* nex = cur->next;
cur->next = prev;
prev = cur;
cur = nex;
}
return prev;
}
};
3. 回文链表
题目描述： 给你一个单链表的头节点 head ，请你判断该链表是否为回文链表如果是，返回 true ；否则，返回 false 。
题解思路：
- 思路1：将单链表转换成数组后再通过双指针来判断是否为回文串。但是这样的空间复杂度为 O ( n ) O(n) O(n)。
- 思路2：使用快慢指针，找到链表的前半部分和后半部分的分割点。（这一步通过快指针
fast，慢指针slow，二者的速度差异来实现定位。）找到链表的前半部分和后半部分的分割点之后，可以将链表后半部分翻转，然后再遍历两段链表是否相同。最后还需要恢复链表。
题解代码：
思路1：
/**
* 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> temp ;
while(head)
{
temp.push_back(head->val);
head = head->next;
}
for(int i = 0 ,j = temp.size()-1;i<j;i++,j--){
if(temp[i]!=temp[j])
return false;
}
return true;
}
};
思路2：
/**
* 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 == nullptr) {
return true;
}
ListNode* p1 = head;
ListNode* halfOfEnd = findHalf(head); // 找到分界点
ListNode* halfOfStart = reverseList(halfOfEnd->next);// 将后半部分翻转
ListNode* p2 = halfOfStart;
bool result = true;
while(result && p2!=nullptr)
{
if(p1->val!=p2->val){
result = false;
}
p1 = p1->next;
p2 = p2->next;
}
halfOfEnd->next = reverseList(halfOfStart);
return result;
}
ListNode* findHalf(ListNode* head) {
ListNode* fast = head;
ListNode* slow = head;
while ( fast->next != nullptr && fast->next->next != nullptr) {
fast = fast->next->next;
slow = slow->next;
}
return slow;
}
ListNode* reverseList(ListNode* head) {
ListNode* prev = nullptr;
ListNode* cur = head;
while (cur!=nullptr) {
ListNode* nx = cur->next;
cur->next = prev;
prev = cur;
cur = nx;
}
return prev;
}
};
4. 环形链表Ⅰ
题目描述:
给你一个链表的头节点 head ，判断链表中是否有环。如果链表中有某个节点，可以通过连续跟踪next指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。
注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。如果链表中存在环 ，则返回true 。 否则，返回 false 。
题解思路：
- 思路1：使用哈希表，
unordered_set或者unordered_map，将遍历到的指针存进去，然后每次查表看是否重复出现过，思路简单，但是空间复杂度为 O ( n ) O(n) O(n)。 - 思路2：使用快慢指针，如果存在环路，那么快指针和慢指针必然会相遇。空间复杂度为 O ( 1 ) O(1) O(1)。
题解代码：
- 思路1：
/**
* 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) {
unordered_map<ListNode* ,int> mp;
while(head)
{
mp[head]++;
if(mp[head] > 1)
{
return true;
}
head = head->next;
}
return false;
}
};
- 思路2：
/**
* 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->next;
ListNode* slow = head;
while(fast != slow){
if(fast == nullptr || fast->next == nullptr){
return false;
}
fast = fast->next->next;
slow = slow->next;
}
return true;
}
};
5. 环形链表Ⅱ
题目描述： 给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回null。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。不允许修改链表。
题解思路： 为了简单解决，这里使用的是最简单的哈希表，通过哈希表来存储遍历到的节点，检查遍历到的节点是否在哈希表中出现过，如果出现，那么就是存在环，那么这个点就是需要输出的环的起点。
题解代码：
/**
* 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) {
unordered_set<ListNode*> mp;
while (head) {
if (mp.count(head)) {
return head;
}
mp.insert(head);
head = head->next;
}
return nullptr;
}
};
6. 合并两个有序链表
题目描述： 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
题解思路： 使用迭代的思想，ptr指针是一个哨兵指针，prev指针用于将list1和list2中较小节点加入到链表中，最后检查那个链表还有节点，再进行一次合并即可。
题解代码：
/**
* 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* mergeTwoLists(ListNode* list1, ListNode* list2) {
ListNode* ptr = new ListNode(-1);
ListNode* prev = ptr;
while (list1 != nullptr && list2 != nullptr) {
if (list1->val < list2->val) {
prev->next = list1;
list1 = list1->next;
} else {
prev->next = list2;
list2 = list2->next;
}
prev = prev->next;
}
if (list2 == nullptr)
prev->next = list1;
else
prev->next = list2;
return ptr->next;
}
};
7. 亮亮交换链表中的节点
题目描述： 给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
题解思路：
题解代码：
8. 随机链表的复制
题目描述：
给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。
返回复制链表的头节点。用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：
val：一个表示 Node.val 的整数。
random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。
你的代码 只 接受原链表的头节点 head 作为传入参数。
9. 两数相加
题目描述： 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
题解思路：
题解代码：
10. 删除链表倒数第N个节点
题目描述： 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
题解思路：
题解代码：
276
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
