- 博客(35)
- 收藏
- 关注
RSS订阅原创 Leetcode 300. 最长上升子序列
思路动态规划：转移方程是 f[i] = max( f[j]) +1 ( j<i 且 nums[i] < nums[j] )，f[i] 取决于它前面的值代码int lengthOfLIS(vector<int>& nums) { int n=nums.size(); if(n==0) return 0; int f[n]; f[0]=1; //初始值 int maxn=1;
2020-11-09 07:43:42
79
原创 Leetcode 64. 最小路径和
思路动态规划。代码int minPathSum(vector<vector<int>>& grid) { int m=grid.size(); int n=grid[0].size(); if(m==0||n==0) return 0; int f[m][n]; f[0][0]=grid[0][0]; //初始化 //the first row（边界条件）
2020-11-08 21:16:53
84
原创 Leetcode 62. 不同路径
思路（计数型）动态规划，用加法。代码int uniquePaths(int m, int n) { if(m==1 || n==1) return 1; //特殊情况 int f[m][n]; for(int i=0;i<m;i++){ for(int j=0;j<n;j++){ if(i==0||j==0) f[i][j]=1; //边界条件
2020-11-08 20:49:08
80
原创 Leetcode 897. 递增顺序查找树
Leetcode 897. 递增顺序查找树思路先将中序遍历的结果放到一个数组里，然后新建一棵只有右子树的二叉树。代码TreeNode* increasingBST(TreeNode* root) { vector<int> nums; inOrder(root,nums); TreeNode* pre=new TreeNode(-1); TreeNode* res=pre; for(int i: nums){
2020-09-08 17:22:05
97
原创 Leetcode 剑指 Offer 55 - I. 二叉树的深度
Leetcode 剑指 Offer 55 - I. 二叉树的深度思路递归：树的高度就是左子树和右子树的高度最大者加一，非常简单。代码int maxDepth(TreeNode* root) { if(root==NULL) return 0; else{ int l=maxDepth(root->left); int r=maxDepth(root->right); return ma
2020-09-08 16:53:33
66
原创 Leetcode 面试题 04.02. 最小高度树
Leetcode 面试题 04.02. 最小高度树思路递归：取数组的中间元素为根节点，前半部分为左子树，后半部分为右子树，然后递归下去，直到遇到没有元素。代码TreeNode* sortedArrayToBST(vector<int>& nums) { return dfs(nums, 0, nums.size()-1); } TreeNode* dfs(vector<int>& nums, int low, int high
2020-09-08 16:37:49
140
原创 Leetcode 543. 二叉树的直径
Leetcode 543. 二叉树的直径思路代码public: int maxd; int depth(TreeNode* root){ if(root==NULL) return 0; int l=depth(root->left); int r=depth(root->right); maxd=max(l+r, maxd); return max(l,r)+1; } int diameterO
2020-08-29 11:35:00
97
原创 Leetcode 101. 对称二叉树
Leetcode 101. 对称二叉树思路递归：确定终止条件如果两个子树都为空，返回true如果只有一个子树为空，返回false如果都不为空，且不相等，返回false单层递归的逻辑比较左子树的左子树与右子树的右子树比较左子树的右子树与右子树的左子树若不等返回false，若相等返回true代码 bool check(TreeNode* l, TreeNode* r){ if(!l && !r) return true; else if
2020-08-28 17:41:36
70
原创 Leetcode 844. 比较含退格的字符串
Leetcode 844. 比较含退格的字符串思路用两个栈：将字符串入栈，若是#则将栈里的字符出栈，之后再比较栈内元素是否相等。代码 bool backspaceCompare(string S, string T) { stack<char> st1, st2; //将两个字符串入栈 for(int i=0;i<S.length();i++){ if(S[i]!='#') st1.push(S[i]
2020-08-28 08:23:00
127
1
原创 Leetcode 155. 最小栈
Leetcode 155. 最小栈思路用一个辅助栈和一个保存当前最小值的栈代码class MinStack {public: /** initialize your data structure here. */ stack<int> sup, mins; //sup为辅助栈，mins为保存当前最小值的栈 MinStack() { mins.push(INT_MAX); //初始化将最大整数入栈 } void push
2020-08-28 07:50:44
63
原创 Leetcode 933. 最近的请求次数
Leetcode 933. 最近的请求次数思路读不懂题，所以还是看了解题，原来还是比较简单的：用一个队列保存到当前为止所有的ping的时间，将所有距当前时间3000ms之前的ping弹出队列，然后剩下的ping即为所求。代码public: RecentCounter() {} queue<int> que; //用于保存所有ping记录 int ping(int t) { que.push(t); while(que.f
2020-08-25 19:18:12
99
原创 Leetcode 滑动窗口的最大值
Leetcode 滑动窗口的最大值思路比较暴力的方法：遍历数组，如果当前窗口最大值在窗口内，则比较窗口最大值与刚添加进来的元素的大小；如果当前窗口最大值不在窗口内，则比较全部窗口内的元素，取最大值。代码 vector<int> maxSlidingWindow(vector<int>& nums, int k) { int n = nums.size() - k + 1; //窗口数 vector<int> res;
2020-08-25 17:11:44
182
原创 Leetcode 234. 回文链表
Leetcode 234. 回文链表思路将链表所有元素按序放进数组里，再判断是否为回文串。代码bool isPalindrome(ListNode* head) { vector<int> num; while(head){ //将元素放进数组 num.push_back(head->val); head=head->next; } bool
2020-08-24 17:32:02
77
原创 Leetcode 141. 环形链表
Leetcode 141. 环形链表思路设置两个工作指针，一个每次走一步，另一个每次走两步，起始时，都从链表头节点开始走，这样的话，如果链表有环，那么走的慢的肯定能追上走的快的，否则，直到最后也无法追上。代码bool hasCycle(ListNode *head) { ListNode* p1=head; ListNode* p2=head; if(!head || !head->next) return NULL; //要注意检测是否为空链
2020-08-24 13:56:25
69
转载 Leetcode 160. 相交链表
Leetcode 160. 相交链表思路暴力解法：对每一个A链表的节点，对比所有B链表节点判断是否相等，如果不相等则继续下一个节点，直到遍历完所有节点。代码ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { ListNode* hA=headA; while(hA){ ListNode* hB=headB; while(hB){
2020-08-24 13:35:55
65
原创 Leetcode 21. 合并两个有序链表
Leetcode 21. 合并两个有序链表思路遍历两个链表，当两个链表都不为空时，判断哪个链表的当前节点较小，将该节点添加到合并链表里。当某一链表为空，则将另外一个链表剩下的节点都加进合并链表里。代码ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode* lhead=new ListNode(0); //合并链表 ListNode* l=lhead; //合并链表的工作指针
2020-08-23 18:22:29
64
原创 Leetcode 206. 反转链表
Leetcode 206. 反转链表思路设置三个指针：当前节点、上一节点、下一节点，遍历数组，每次将当前节点的next改为指向上一节点，然后将当前节点赋值为下一节点，直到节点为空。代码ListNode* reverseList(ListNode* head) { ListNode* pre=NULL; //上一个节点 ListNode* cur=head; //当前节点 while(cur){ ListNode* nextNo
2020-08-23 17:13:11
61
原创 Leetcode 104. 二叉树的最大深度
Leetcode 104. 二叉树的最大深度思路递归：树的高度=max（左子树高度，右子树高度）+1代码 int maxDepth(TreeNode* root) { int height=0; if(root==NULL) height=0; else{ int l=maxDepth(root->left);//左子树的高度 int r=maxDepth(root->right);//右子树
2020-08-22 09:11:16
66
原创 Leetcode 226. 翻转二叉树
Leetcode 226. 翻转二叉树思路递归交换左右子树，遇到空节点返回。代码TreeNode* invertTree(TreeNode* root) { if (root == NULL) return root; //交换左右子树 TreeNode* temp = root->left; root->left = root->right; root->right = temp; //对左右子树进行递归 invertTree(root->left);
2020-08-21 20:14:13
72
原创 Leetcode 617. 合并二叉树
Leetcode 617. 合并二叉树思路递归法（修改了输入的树t1）：先将根节点相加，再递归生成左子树和右子树。代码//树的定义struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode (int x): val(x),left(NULL), right(NULL){} //初始化支持 TreeNode（int x）这种方式，即把x赋给val，left和right赋值NULL};TreeNode* me
2020-08-21 19:45:24
69
原创 Leetcode14. 最长公共前缀
Leetcode14. 最长公共前缀思路从前往后找两两字符串的公共前缀，等到遍历完数组，结果就是所有字符串的公共前缀了。代码string prefixOf2(string s1, string s2) { //找出两个字符串的公共前缀 int len = min(s1.length(), s2.length()); int i = 0; while (i < len && s1[i] == s2[i]) { i++; //公共前缀的位数 } string pre
2020-08-21 12:32:03
72
原创 Leetcode 28. 实现 strStr()
Leetcode 28. 实现 strStr()思路暴力解法：遍历字符串，让其与needle逐个元素对比，若相同则指针都加1，若不同则回退到主字符串的下一个元素与needle从头开始比较。代码int strStr(string haystack, string needle) { int j = 0; int i = 0; int res = 0; while(i<haystack.length()&& j<needle.length()){ if (hays
2020-08-21 11:30:14
146
原创 2020-08-20
Leetcode 20.有效的括号思路本题的思路比较简单，利用栈来解决：遇到左括号就进栈，遇到右括号就看看栈顶元素与其是否匹配，不匹配就返回false。但要注意很多种情况，不要漏了。代码bool isValid(string s) { stack<char> mystack; bool res = true; for (char ch : s) { if (ch == '(' || ch == '{' || ch == '[') mystack.push(ch); //如果是
2020-08-20 10:27:53
70
原创 Leetcode 125. 验证回文串
Leetcode 125. 验证回文串思路首先想到的就是用两个指针i，j分别从前后出发，利用多个if-else判断，但这样情况比较多，很容易漏了某种情况，导致一直调试不好。后来看到一些小伙伴的思路比较简单：先处理一下字符串，将数字和字母保留，而且字母都转换为小写字母，再进行判断。代码bool isPalindrome(string s) { string ss; bool res = true; for (char n : s) { //将所有字母或数
2020-08-20 09:34:30
92
原创 Leetcode 387. 字符串中的第一个唯一字符
Leetcode 387. 字符串中的第一个唯一字符思路首先想到的是暴力解法：顺序遍历数组，对于每个字符，看看它后面有没有相同字符，如果有则跳过本次循环，如果没有则返回该字符的下标。后来感觉这个方法时间复杂度比较高，就想到了利用hash表：将所有字符放进hash表，并统计每个字符出现的次数，然后再遍历数组，利用hash表找出出现次数为1的首个字符。代码int firstUniqChar(string s) { unordered_map<char, int> mp; //字符-出
2020-08-19 20:59:34
91
原创 Leetcode 38.外观数列
Leetcode 38.外观数列思路因为每一行都是根据其上面的一行而生成的，所以会用到递归：for循环遍历上面一行，如果当前字符与后一字符不同，则将该字符的数量和字符放入字符串中（此时要注意重置计数器），如果当前字符与后一字符相同，那么计数器加一。代码string countAndSay(int n) { string res; if (n == 1) { res = "1"; } else { string s = countAndSay(n - 1); int count =
2020-08-19 17:28:43
142
原创 Leetcode 344. 反转字符串
Leetcode 344. 反转字符串思路这题比较简单，设置两个小标i和j，分别同时从前和后开始遍历数组，每遇到一对元素就直接将它们交换，直到i和j相遇。代码void reverseString(vector<char>& s) { int i=0; int j=s.size()-1; char tmp; while(i<=j){ tmp=s[i]; s[i]=s[j]; s[j]=tm
2020-08-19 09:20:30
65
原创 Leetcode 13. 罗马数字转整数
Leetcode 13. 罗马数字转整数思路先找规律，发现两个字符的罗马数字有两种情况：若前一个字符比后一字符大，则数值为这两个字符各自代表的数值相加（如VI=6）；若后一字符比前一字符大，则相减（如IX=9）。遍历字符数组，比较当前字符与其后面字符所代表数值的大小，若大，则加上当前字符的数指，若小，则减去。另外，参考了其他小伙伴的思路，用unordered_map存储对应关系，其实这个哈希表就是key-value的对应，在此题用比较方便。代码int romanToInt(string s) {
2020-08-19 09:12:43
49
原创 Leetcode 581. 最短无序连续子数组
Leetcode 581. 最短无序连续子数组思路先将数组排序，然后分别从前、后依次与排好序的数组对比，一旦找到不相等的元素，就返回下标（min与max），它们之间的子序列即为所求。代码int findUnsortedSubarray(vector<int>& nums) { vector<int> compare(nums); sort(compare.begin(),compare.end()); int min = 0; int max = 0; in
2020-08-18 11:24:45
67
原创 Leetcode 1. 两数之和
Leetcode 1. 两数之和思路暴力解法：遍历数组，将每个元素与其后所有元素都两两相加一遍，比较和与target是否相等，若不等则继续遍历，若相等则跳出循环。代码vector<int> twoSum(vector<int>& nums, int target) { int sum = 0; vector<int> res; for (int i = 0; i < nums.size() - 1; i++) { for (int j =
2020-08-18 10:12:23
75
原创 Leetcode 53. 最大子序和
Leetcode 53. 最大子序和思路暴力解法：遍历数组，穷举所有子区间并求和，将结果与max比较，比max大则成为新的max。代码int maxSubArray(vector<int>& nums) { int max = INT_MIN; //将max的初始值设为最小整数，因为结果有可能是负的 for (int i = 0; i < nums.size(); i++) { int sum = 0; for (int j = i; j < nums.
2020-08-17 16:33:30
62
原创 Leetcode 448. 找到所有数组中消失的数字
Leetcode 448. 找到所有数组中消失的数字思路1利用hash表，遍历数组把元素放进相应的桶，然后遍历hash表，把值为零（在数组中不存在）的元素提取出来，即为答案。但这个方法开销比较大（这是官方给的思路，感觉不符合题中所说的“不使用额外空间”）。代码vector<int> findDisappearedNumbers(vector<int>& nums) { unordered_map<int, int> mp; for
2020-08-16 17:14:37
102
原创 Leetcode 283. 移动零
Leetcode 283. 移动零思路遍历数组，设置一个计数器（用来统计当前零的个数），若是遇到零，则计数器加一并跳过；若是非零元素，则向前移动计数器个位置，最后将剩下的空位都补上零。代码void moveZeroes(vector<int>& nums) { int count = 0; //记录当前零的个数 for (int i = 0; i < nums.size(); i++) { if (nums[i] == 0) count++; else n
2020-08-16 10:43:36
83
原创 Leetcode 169. 多数元素
Leetcode 169. 多数元素思路其实参考了力扣上面小伙伴的解题思路，选取了哈希表的思路：遍历整个数组，把每个元素放进哈希表里（凡是相同的元素都放进同一个“桶”里），选出数量比n/2大的就是多数元素了。代码int majorityElement(vector<int>& nums) { unordered_map<int, int> myMap; for (int n : nums) { //相当于foreach myMap[n]++; /
2020-08-14 22:00:07
82
原创 Leetcode 1051 高度检查器
Leetcode 1051 高度检查器思路其实就是要找出与排序后数组不同的元素的数量：先将heights数组排序，再跟原来的比较，凡是有一位不同的元素，计数器就加一。代码int heightChecker(vector<int>& heights) { int count = 0; int n = heights.size(); vector<int> b; b.assign(heights.begin(), heights.end()); //copy
2020-08-13 17:00:54
268
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人