SGL_LGS的博客

前缀和，注意c++取模被除数为负数情况，要进行调整：class Solution {public: int subarraysDivByK(vector<int>& A, int K) { int out = 0; unordered_map<int ,int> data; data[0]=1; int sum = 0; for(size_t i=0;i<A.size();i+.

用栈进行替换：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* swapPairs(ListNode* head) { if (head == nullptr |.

这道题算法方面倒不是难点，主要在于类和数据结构额设计，如何高效合理。struct DListNode{ int key, value; DListNode* pre; DListNode* next; DListNode():key(0),value(0),pre(nullptr),next(nullptr){} DListNode(int _key, int _value):key(_key),value(_value),pre(nullptr),next(nu.

递归加移位思想，困住我的竟然是边界溢出值，要哭了：class Solution {private: int function(long num, long divisor) { if (num<divisor) return 0; long long time = 1; long long temp = divisor; while (num >= temp) { temp = temp << 1; time = time << .

递归调用：1、function函数中的string参数需要定义成const引用；class Solution {private: vector<string> out; void function(const string &solution, int left, int right, int n){ if(right == n && left == n){ out.push_back(solution);.

class Solution {public: string intToRoman(int num) { string Roman[13] = {"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"}; int data[13] = {1000,900,500,400,100,90,50,40,10,9,5,4,1}; string out; int start = 0;.

滑动窗口加HASH表：class Solution {private: map<char, int> data; bool check(map<char, int> &data) { map<char, int>::iterator it; for (it = data.begin(); it != data.end(); it++) { if (it->second > 0) return false; } r.

两种情况考虑，反向思维：class Solution {public: string longestPalindrome(string s) { if (s.size() <= 1) return s; int mid = 0; int max_length = 1; for (int i = 0; i<s.size() - 1; i++) { int temp1 = funt(s, i, i); int temp2 = funt(s, i, i + 1.

前缀和和状态码：class Solution {public: int findTheLongestSubstring(string s) { int ans = 0, status = 0, n = s.size(); vector<int> pos(32, -1); pos[0] = 0; for (int i = 0; i < n; i ++) { if (s[i] == 'a') .

简单题：双指针class Solution {private: bool funt(string s,int &begin, int &end) { while(begin<=end&&s[begin]==s[end]){ begin++; end--; } if(begin>end) return true; .

方法一：递归法（超出时间限制）class Solution {private: int recursive(int n){ if(n==0||n==1) return 1; return recursive(n-1)+recursive(n-2); }public: int climbStairs(int n) { return recursive(n); }};方法二：记忆化搜索.

方法一：遍历链表，用两个队列分别存储小于x和大于等于x的值，最后再合并：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* partition(ListNode* .

解法一：引入栈和队列的性质，缺点就是引入大量的额外空间；/** * 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, ListNo.

快指针每次走两步，慢的每次走一步，当快指针为nullptr或者下一个节点为nullptr时，就返回慢的：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* midd.

三种解法实现，第三种有点巧妙，值得考虑：暴力遍历：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode *getIntersectionNode(ListNode *.

直接空缺补0，不然讨论起来很麻烦：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* addTwoNumbers(ListNode* l1, ListNode* l.

此题是链表中比较基础的题目，需要彻底掌握，这里提供四种方法：递归法：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* reverseList(ListNode*.

先上一个暴力求解吧，复杂度有O(n2)，编译超时:class Solution {public: int subarraySum(vector<int>& nums, int k) { int count = 0; for (int start = 0; start < nums.size(); ++start) { int sum = 0; for (int end = start; e.

回溯加剪枝优化class Solution {public: vector<vector<int>> outs; vector<int> out; void funt(int n, int k, int start, vector<int> &out) { if(out.size()==k){ outs.push_back(out); return;.

通过这一题，总算是对回溯算法有了相对清晰的认识。什么时候递归该回溯，什么时候不该，想明白了其实也没有这么复杂。这里推荐一个视频讲解的特别清晰特别好：点这里。class Solution {public: vector<vector<int>> outs; vector<bool> used; void funt(vector<int>& nums, int index, vector<int> out, ve.

这个题就是典型的会者不难。考查异或的三条性质：1、任何数与0异或结果是其本身；2、两个相同的数异或，结果为0；3、异或满足交换律与结合律；class Solution {public: int singleNumber(vector<int>& nums) { for(int i=1;i<nums.size();i++) nums[0]=nums[0]^nums[i]; return nums[0]; .

利用前序的第一个数字确定根节点值，中序中该根节点左边是左子树元素，右侧是右子树元素。以此，递归出整棵树。主要是要有子树的思想。/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * };.

DFS解法：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public: int dfs(TreeNode* T, in.

递归解法：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public: bool fun(TreeNode* T1, .

可以用广度优先（BFS）或者深度优先（DFS）算法遍历：广度优先（BFS）/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {pub.

关键词：分治法，递归思想/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* mergetwo(ListNode* l1, ListNode *l2){ .

实际上刚拿到这个题目时，无从下手，不知道他到底想干啥，好像是需要自己手动设计栈。但是看到官解，瞬间自闭了。比较简单没啥要记录的。class MinStack {public: /** initialize your data structure here. */ stack<int> data; stack<int> min_data; MinStack() { min_data.push(INT_MAX); } .

这个题可以用暴力法循环实现。我尝试的是会报错超出时间限制。参看官方的过程是快速幂加递归实现。感觉递归还是自己的难点，需要专项练习。class Solution {public: double Mul(double x, long long n) { if(n==0) return 1.0; double y = Mul(x,n/2); return n % 2 == 0 ? y * y : y * y * x; .

这个题目就简单多了，好像没有碰到什么问题，一次通过。解题代码：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* mergeTwoLists(ListNode*.

这个题的思路其实非常简单，就用快慢指针，在一次遍历中，使快指针与慢指针之间的距离为n。但是实现过程确实充满波折，怀疑人生，还需要多加练习。思考及遇到的几个问题：1、慢指针最终指向待删除元素还是其上一个元素？如果我们将慢指针指向删除元素，那么如何将其上一个节点的指针域指向其下一个节点，达到将其删除的目的。所以，我们应该将慢指针最终指向待删除元素的上一个元素。2、特例情况？在n小于链表长度时，上述过程其实是非常容易实现的。但是在第一个例子就出Bug了（[1], 1）链表只有一个元素，那么如何指向其上面一.

思考及遇到的几个问题：1、关于头结点，一般会给返回的链表变量，设置一个头节点。再将相加的节点值链接上去。因此返回时代码如下，可以省略掉头结点。return out->next;2、关于链表插入，这里使用的是尾插法，因此引入另外一个变量如下。让该变量始终指向返回链表的最后一个节点，并在初始化时令其等于返回变量，方便循环插入。ListNode *out=new ListNode(0), *L;L = out;3、关于解题思路，将短链表的空位补0，再与另一个同位相加，并设置进位标志。当最后.