文章目录
刷题链接
两数之和
哈希
#include <unordered_map>
class Solution {
public:
/**
*
* @param numbers int整型vector
* @param target int整型
* @return int整型vector
*/
vector<int> twoSum(vector<int>& numbers, int target) {
// write code here
unordered_map<int,int> hash; // <值，下标>
for(int i = 0;i < numbers.size(); i++)
{
if(hash.count(target - numbers[i])){
return {
hash[target - numbers[i]] + 1, i + 1};
}
hash[numbers[i]] = i;
}
return {
};
}
};
子数组的最大累加和
动态规划，空间复杂度 O ( 1 ) O(1) O(1)
class Solution {
public:
/**
* max sum of the subarray
* @param arr int整型vector the array
* @return int整型
*/
int maxsumofSubarray(vector<int>& arr) {
// write code here
int res = 0, cur = 0;
for(auto c : arr)
{
cur += c;
if(cur < 0) cur = 0;
res = max(res,cur);
}
return res;
}
};
合并有序链表
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
class Solution {
public:
/**
*
* @param l1 ListNode类
* @param l2 ListNode类
* @return ListNode类
*/
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
// write code here
ListNode* head = new ListNode(-1); // 新建头结点
ListNode* cur = head;
while(l1 && l2)
{
if(l1->val <= l2->val) {
cur->next = l1;
l1 = l1->next;
}else{
cur->next = l2;
l2 = l2->next;
}
cur = cur->next;
}
cur->next = l1 == NULL? l2 : l1;
return head->next;
}
};
用两个栈实现队列
模拟
class Solution
{
public:
void copy(stack<int> &source,stack<int> ©to)
{
while(source.size()){
copyto.push(source.top());
source.pop();
}
}
void push(int node) {
stack1.push(node);
}
int pop() {
int res = 0;
copy(stack1,stack2);
if(!stack2.empty()) {
res = stack2.top();
stack2.pop();
}
copy(stack2,stack1);
return res;
}
private:
stack<int> stack1;
stack<int> stack2;
};
找到字符串最长无重复子串
哈希，双指针，滑动窗口
class Solution {
public:
/**
*
* @param arr int整型vector the array
* @return int整型
*/
int maxLength(vector<int>& arr) {
// write code here
int n = arr.size();
int res = 0;
map<int,int> hash;
for(int i = 0, j = 0;i < n;i ++ )
{
hash[arr[i]] ++;
while(hash[arr[i]] > 1){
hash[arr[j]] -- ;
j ++ ;
}
res = max(res,i - j + 1);
}
return res;
}
};
合并两个有序数组
双指针算法，从后往前遍历，就不用担心覆盖了，归并排序的思想
class Solution {
public:
void merge(int A[], int m, int B[], int n) {
int k = m + n - 1;
int i = m - 1,j = n - 1;
while(i >= 0 && j >= 0)
{
if(A[i] >= B[j]) A[k -- ] = A[i -- ];
else A[k -- ] = B[j -- ];
}
while(i >= 0) A[k -- ] = A[i -- ];
while(j >= 0) A[k -- ] = B[j -- ];
}
};
链表中的节点k个一组翻转
前置知识：翻转链表。可以画图理解
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
class Solution {
public:
/**
*
* @param head ListNode类
* @param k int整型
* @return ListNode类
*/
ListNode* reverseKGroup(ListNode* head, int k) {
// write code here
ListNode *dummy = new ListNode(-1);
dummy->next = head;
ListNode *cur = dummy;
while(cur)
{
// 1.确定是否有k个数
ListNode *first = cur->next;
ListNode *end = cur;
for(int i =0;i < k && end != NULL;i ++ )
end = end->next;
if(end == NULL) break;
// 2.k个反转
ListNode *p1 = cur->next, *p2 = p1->next;
while(p1 != end)
{
auto next = p2->next;
p2->next = p1;
p1 = p2,p2 = next;
}
// 3.重新连接,画图理解
first->next = p2;
cur->next = end;
cur = first;
}
return dummy->next;
}
};
链表中环的入口节点
/**
* 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) {
/*
思路：快慢指针
fast走两步，slow走一步，相遇的时候slow返回起点，然后各自走一步，再相遇就是环的入口
证明：
slow * 2 =fast -> (x + y) * 2 = x + y + n(y + z);
化简得：x = (n - 1) * (y + z) + z, n为任意
*/
auto fast = head,slow = head;
while(fast)
{
fast = fast->next;
if(fast) fast=fast->next;
else break;
slow = slow->next;
if(fast == slow)
{
slow = head;
while(fast != slow)
{
fast =fast->next;
slow = slow->next;
}
return slow;
}
}
return NULL;
}
};
括号序列
栈
#include <unordered_map>
class Solution {
public:
/**
*
* @param s string字符串
* @return bool布尔型
*/
bool isValid(string s) {
// write code here
unordered_map<char,char> hash = {
{
'(',')'},
{
'[',']'},
{
'{','}'}
};
stack<char> stk;
for(auto c : s)
{
if(hash.count(c)) stk.push(c);
else
{
if(stk.empty() || hash[stk.top()] != c) return false; // 这里是栈顶元素与c比较
stk.pop();
}
}
if(stk.size()) return false;
return true;
}
};
删除链表倒数第n个节点
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
class Solution {
public:
/**
*
* @param head ListNode类
* @param n int整型
* @return ListNode类
*/
ListNode* removeNthFromEnd(ListNode* head, int n) {
// write code here
ListNode *dummy = new ListNode(-1);
dummy->next = head;
auto fast = dummy, slow = dummy;
while(n -- ) fast =fast->next;
while(fast->next)
{
fast = fast->next;
slow = slow->next;
}
slow->next = slow->next->next; // 这里出错
return dummy->next;
}
};