月のLeetCode 每周刷题之 Week1

已于 2022-01-26 19:54:14 修改
阅读量177 收藏
点赞数 1
分类专栏： LeetCode 文章标签： leetcode 算法 c++
于 2022-01-18 18:16:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sukiki09/article/details/122565419
版权

目录

1. 两数​​​​​​之和

2. 两数相加

3. 无重复字符的最​​​​​​长子串

4. 寻找两个正序数组的中位数

15. 三数之和

17. 电话号码的字母组合

19. 删除链表的倒数第 N 个结点

20. 有效的括号

21. 合并两个有序链表

22. 括号生成

23. 合并K个升序链表

1. 两数​​​​​​之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> m;
        for(int i=0;i<nums.size();i++)
        {
            auto ite=m.find(target-nums[i]);    //find()是找key，不是val，所以把值当成key，下标当成val
            if(ite!=m.end())
            {
                return{ite->second,i};
            }
            m[nums[i]]=i;
        }
        return{};
    }
};

  • 使用map查找时间复杂度为O(1)

  • map::find()函数查找的是key，而不是val]

2. 两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]


示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *pre=new ListNode (0);
        ListNode *ls=pre;
        int add=0;
        int t;
​
        while(l1!=NULL||l2!=NULL)
        {
            int x=l1==NULL?0:l1->val;
            int y=l2==NULL?0:l2->val;
            int sum=x+y+add;
            if(sum>=10) 
            {
                add=1;
                sum-=10;
            }
            else add=0;
            ls->next=new ListNode(sum);
            if(l1!=NULL) l1=l1->next;
            if(l2!=NULL) l2=l2->next;
            ls=ls->next;
        }
        if(add==1)
        {
            ls->next=new ListNode (1);
        }
​
        return pre->next;
    }

  • 当l1或l2为空时，无l1->val，则用0占位

  • 巧用前置节点pre和当前节点ls，使ls=pre，操作ls，最后返回pre->next即可。

  • 注意判断最后一个节点的进位问题，如果需要进位则需要再创建一个新节点然后赋值为1

3. 无重复字符的最​​​​​​长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。


示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。


示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。


示例 4:

输入: s = ""
输出: 0

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_set<char> st;
        int n=s.size();
        int maxLen=1;
        if(s=="") return 0;
        
        int left=0;
        for(int i=0;i<n;i++)
        {
            while((st.find(s[i]))!=st.end())
            {
                st.erase(s[left]);
                left++;
            }
            maxLen=max(maxLen,i-left+1);
            st.insert(s[i]);
        }
        return maxLen;
    }
};

  • 滑动窗口，左指针，哈希集合

  • 用哈希集合存已经查找且没有重复的数据

  • 当遍历到哈希集合中存在的数据时，删除集合中左指针指向的数据，直到找不到重复的为止。

4. 寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

示例 3：

输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000

示例 4：

输入：nums1 = [], nums2 = [1]
输出：1.00000

示例 5：

输入：nums1 = [2], nums2 = []
输出：2.00000

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        vector<int> s;
        double ans;
        for(int i=0;i<nums1.size();i++)
        {
            s.push_back(nums1[i]);
        }
        for(int i=0;i<nums2.size();i++)
        {
            s.push_back(nums2[i]);
        }
        sort(s.begin(),s.end(  ));
        int l=0,r=0;
        if(s.size()%2==1)
        {
            while(r!=s.size()-1)
            {
                l++;
                r+=2;
            }
            ans=s[l];
        }
        else
        {
            if(s.size()==2)
            {
                return (s[l]+s[l+1])*1.0/2.0;
            }
            while(r!=s.size()-2)
            {
                
                l++;
                r+=2;
            }
            ans=(s[l]+s[l+1])*1.0/2.0;
        }
        return ans;
    }
};

  • 合并数组+排序

  • 时间复杂度O(m+n)

  • 空间复杂度O(m+n)

15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]

示例 2：

输入：nums = []
输出：[]

示例 3：

输入：nums = [0]
输出：[]

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> vec;
        sort(nums.begin(),nums.end());
        int left,right;
        if(nums.size()<3) return vec;
        for(int i=0;i<nums.size();i++)
        {
            if(nums[i]>0) return vec;
            if(i>0&&nums[i]==nums[i-1]) continue;
            left=i+1;
            right=nums.size()-1;
            while(left<right)
            {
                int sum=nums[i]+nums[left]+nums[right];
                if(sum==0)
                {
                    vec.push_back({nums[i],nums[left],nums[right]});
                    while(left<right&&nums[left]==nums[left+1]) left++;
                    while(left<right&&nums[right]==nums[right-1]) right--;
                    left++;
                    right--;
                }
                else if(sum<0) left++;
                else if(sum>0) right--;
            }
        }
        return vec;
    }
};

  • 三循环——>单循环+双指针

  • 排序

  • 从i=0,left=i+1,right=n开始判断

  • 如果nums[i]大于0，因为排序是从小到大，得出nums[i]后面的数也大于0，所以sum肯定大于0，直接返回

  • 如果sum=0且nums[left]==nums[left+1]会产生重复值，则left++，right同理

  • if(i>0&&nums[i]==nums[i-1]) continue; 中的i>0的目的是防止数组越界访问，当i=0时，nums[i-1]会越界

  • 当sum>0时说明right大了，则right--，left同理

17. 电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2：

输入：digits = ""
输出：[]

示例 3：

输入：digits = "2"
输出：["a","b","c"]

class Solution {
public:
    vector<string> letterCombinations(string digits) {
        if(digits.size()==0) return {};
        unordered_map<int,string> m;
        vector<string> vec;
        m.insert({2,"abc"});
        m.insert({3,"def"});
        m.insert({4,"ghi"});
        m.insert({5,"jkl"});
        m.insert({6,"mno"});
        m.insert({7,"pqrs"});
        m.insert({8,"tuv"});
        m.insert({9,"wxyz"});
        queue<string> q;
        int num=digits[0]-'0';
        string temp=m.at(num);
        for(int i=0;i<temp.size();i++) 
        {
            string s=temp.substr(i,1);
            q.push(s);
        }
        for(int i=1;i<digits.size();i++)
        {
            int n=digits[i]-'0';
            string s=m.at(n);  
            while(q.front().size()<=i)
            {           
                for(int j=0;j<s.size();j++)
                {
                    string c=s.substr(j,1);
                    q.push(q.front()+c);
                }
                q.pop();
            }
        }
        while(!q.empty())
        {
            vec.push_back(q.front());
            q.pop();
        }
        return vec;        
    }
};

  • 队列法

  • 先把第一个数字对应的字母入队，从第二个数字开始，队首的字母再分别与第2个数字对应的字母组合，组合完毕后移出队列。

  • 到与第i个数字组合时，队首字符串的长度为i，组合完毕加入队列的字符串长度为i+1。所以当队首字符串长度大于i时，证明与当前数字对应的字母组合完毕

  • 循环下去，当队首字符串的长度<=i时（下标从0开始），循环继续。当队首字符串长度>i时，循环结束。

//以234举例 2->a b c //3->d e f //4->g h i

a b c

a b c ad ae af //与第1个数字3开始组合

b c ad ae af bd be bf ...->

ad ae af bd be bf cd ce cf //因为队首字符串长度=2>1 所以更换下一个数字4，以此类推

ad ae af bd be bf cd ce cf adg adh adi ...->

["adg","adh","adi","aeg","aeh","aei","afg","afh","afi","bdg","bdh","bdi","beg","beh","bei","bfg","bfh","bfi","cdg","cdh","cdi","ceg","ceh","cei","cfg","cfh","cfi"] //最后结果

19. 删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[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:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode*pre=head;
        ListNode*cur=head;
        int len=0;
        if(head->next==NULL) return NULL;
        while(head!=NULL)
        {
            head=head->next;
            len++;  //求链表长度
        }
        int num=len-n-1;
        if(n==1)    //倒数第一个节点为尾删除
        {
            while(num--)
            {
                cur=cur->next;
            }
            cur->next=NULL;
        }
        else if(n==len) //第一个节点为头删除
        {
            return  pre->next;
        }
        else        //其他为中间删除
        {
            while(num--)
            {
                cur=cur->next;
            }
            cur->next=cur->next->next;
        }
        return 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* removeNthFromEnd(ListNode* head, int n) {
        ListNode *pre=new ListNode(0);
        pre->next=head;
        ListNode*l=pre;
        ListNode *r=pre;
        while(n--)
        {
            r=r->next;
        }
        while(r->next!=NULL)
        {
            r=r->next;
            l=l->next;
        }
        l->next=l->next->next;
        return pre->next;;
    }
};

  • 在链表头结点之前new一个空间pre作为链表新头结点

  • 快指针先走n步，然后快慢指针同时走，直到快指针到达链表的最后一个节点(r->null==0)

  • 删除慢指针的下一个节点，即 l->next=l->next->next，返回pre->next即可

20. 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
 

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

示例 4：

输入：s = "([)]"
输出：false

示例 5：

输入：s = "{[]}"
输出：true

class Solution {
public:
    bool isValid(string s) {
        if(s.size()%2!=0) return false;
        unordered_map<char,char> m;
        m['(']=')';
        m['{']='}';
        m['[']=']';
        stack<char> sk;
        for(int i=0;i<s.size();i++)
        {
            char c=s[i];
            auto ite=m.find(c);
            if(ite!=m.end())
            {
                sk.push(m[c]);
            }
            else
            {
                if(sk.empty()||sk.top()!=c) return false;
                else
                    sk.pop();
            }
        }
        if(sk.empty()) return true;
        return false;
    }
};

  • 辅助栈法

  • 遍历字符串，在map中查找

    • 当找到当前字符时，把当前字符对应的字符即m[c]入栈

    • 没找到时在栈顶找

      • 当栈顶为空时说明字符不匹配，返回FALSE

      • 当栈顶元素和当前查找字符不相等时，返回false

      • 当栈顶元素和当前查找字符相等时，说明当前字符匹配，，移出栈顶元素，继续匹配下一个字符

  • 当遍历完毕后，栈为空，则证明匹配完毕所有字符，返回true，否则返回FALSE

21. 合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

示例 1：


输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：

输入：l1 = [], l2 = []
输出：[]

示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

/**
 * 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) {
        multiset<int> s;
        while(list1!=NULL)
        {
            s.insert(list1->val);
            list1=list1->next;
        }
        while(list2!=NULL)
        {
            s.insert(list2->val);
            list2=list2->next;
        }
        auto ite=s.begin();
        ListNode *cur=new ListNode(0);
        ListNode *pre=cur;
        while(ite!=s.end())
        {
            ListNode *cur1=new ListNode(*ite);
            cur->next=cur1;
            cur=cur->next;
            ite++;
        }
        return pre->next;
        
    }
};

  • 合并到multiset中，再遍历生成链表

法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:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if(list1==NULL)
        {
            return list2;
        }
        else if(list2==NULL)
        {
            return list1;
        }
        else if(list1->val<list2->val)
        {
            list1->next=mergeTwoLists(list1->next, list2);
            return list1;
        }
        else
        {
            list2->next=mergeTwoLists(list1, list2->next);
            return list2;
        }
        return {};
    }
};

  • 递归法

22. 括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例 1：

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

示例 2：

输入：n = 1
输出：["()"]

class Solution {
public:
    vector<string> vec;
    vector<string> generateParenthesis(int n) {
        if(n<=0) return {};
        f("",n,n);
        return vec;
    }
​
    void f(string s,int l,int r)
    {
        if(r==0&&l==0)
        {
            vec.push_back(s);
            return ;
        }
        if(l==r)
        {
            f(s+"(",l-1,r);
        }
        else if(l<r)
        {
            if(l>0)
                f(s+"(",l-1,r);
            f(s+")",l,r-1);
        }
    }
};
​

  • 如果剩余左括号和右括号数量都为0，返回

  • 如果剩余左括号数量与右括号数量相等，下一个一定是左括号

  • 如果剩余左括号和右括号不相等，下一个都可以

23. 合并K个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

小根堆法

/**
 * 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* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<int, vector<int>, greater<int>> q;
        for(int i=0;i<lists.size();i++)
        {
            while(lists[i]!=NULL)
            {
                q.push(lists[i]->val);
                lists[i]=lists[i]->next;
            }
        }
​
        ListNode *pre= new ListNode (0);
        ListNode *head= new ListNode (0);
        pre=head;
        while(!q.empty())
        {
            head->next=new ListNode(q.top());
            head=head->next;
            q.pop();
        }
        return pre->next;
    }
};

  • priority_queue<int, vector<int>, greater<int>> q; //小根堆

  • priority_queue<int, vector<int>, less<int>> q; //大根堆

mutiset

/**
 * 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* mergeKLists(vector<ListNode*>& lists) {
        multiset<int> s;
        for(int i=0;i<lists.size();i++)
        {
            while(lists[i]!=NULL)
            {
                s.insert(lists[i]->val);
                lists[i]=lists[i]->next;
            }
        }
​
        ListNode *pre= new ListNode (0);
        ListNode *head= new ListNode (0);
        pre=head;
        for(auto ite=s.begin();ite!=s.end();ite++)
        {
            head->next=new ListNode(*ite);
            head=head->next;
        }
        return pre->next;
    }
};

月Sukii
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode:leetcode的刷题之旅
07-01
本篇文章将深入探讨在 LeetCode 上进行刷题之旅的相关知识点，特别是与 Java 语言相关的部分。 1. **算法基础**： - **排序算法**：如冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序等，它们在解决...
C语言 LeetCode算法刷题30天全面提升教程百度网盘链接
06-19
C语言 C语言 LeetCode算法刷题30天全面提升教程算法刷题30天全面提升教程
月のLeetCode 每周刷题之 Week4
sukiki09的博客
02-14 7783
目录 42. 接雨水 124. 二叉树中的最大路径和 剑指 Offer 03. 数组中重复的数字 剑指 Offer 04. 二维数组中的查找 剑指 Offer 05. 替换空格 剑指 Offer 06. 从尾到头打印链表 剑指 Offer 07. 重建二叉树 06. 从中序与后序遍历序列构造二叉树 剑指 Offer 09. 用两个栈实现队列 剑指 Offer 10- I. 斐波那契数列 剑指 Offer 11. 旋转数组的最小数字 剑指 Offer 13. 机器人的运动范围 剑指
月のLeetCode 每周刷题之 Week8
sukiki09的博客
03-21 167
目录 88. 合并两个有序数组 25. K 个一组翻转链表 415. 字符串相加 199. 二叉树的右视图 56. 合并区间 82. 删除排序链表中的重复元素 II 143. 重排链表 88. 合并两个有序数组 给你两个按 非递减顺序 排列的整数数组nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。 请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。 注意：最终，合并后数组不应由函数返回，.
月のLeetCode 每周刷题之 Week7
sukiki09的博客
03-06 295
目录 958. 二叉树的完全性检验 41. 缺失的第一个正数 918. 环形子数组的最大和 1114. 按序打印 1115. 交替打印 FooBar 329. 矩阵中的最长递增路径 7. 整数反转 24. 两两交换链表中的节点 1143. 最长公共子序列 最长公共子串 5. 最长回文子串 179. 最大数 129. 求根节点到叶节点数字之和 206. 反转链表 102. 二叉树的层序遍历 给定一个二叉树的root，确定它是否是一个完全二叉树。 在一个完...
月のLeetCode 每周刷题之 Week6
sukiki09的博客
02-27 306
剑指 Offer 59 - I. 滑动窗口的最大值 目录 剑指 Offer 59 - I. 滑动窗口的最大值 剑指 Offer 59 - II. 队列的最大值 剑指 Offer 61. 扑克牌中的顺子 剑指 Offer 62. 圆圈中最后剩下的数字 剑指 Offer 63. 股票的最大利润 剑指 Offer 64. 求1+2+…+n 剑指 Offer 66. 构建乘积数组 剑指 Offer 68 - I. 二叉搜索树的最近公共祖先 剑指 Offer 68 - II. 二叉树的最近公共祖先
月のLeetCode 每周刷题之 Week5
sukiki09的博客
02-20 202
目录 剑指 Offer 30. 包含min函数的栈 剑指 Offer 31. 栈的压入、弹出序列 面试题32 - I. 从上到下打印二叉树 剑指 Offer 32 - III. 从上到下打印二叉树 III 剑指 Offer 33. 二叉搜索树的后序遍历序列 剑指 Offer 34. 二叉树中和为某一值的路径 剑指 Offer 35. 复杂链表的复制 剑指 Offer 36. 二叉搜索树与双向链表 剑指 Offer 37. 序列化二叉树 剑指 Offer 38. 字符串的排列 剑指
月のLeetCode 每周刷题之 Week3
sukiki09的博客
02-04 677
142. 环形链表 II 给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回null。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 不允许修改 链表。 class Solution { public: ListNode *...
月のLeetCode 每周刷题之 Week2
sukiki09的博客
01-26 629
月のLeetCode 每周刷题之 Week2
leetcode刷题：Week1
wnznw的博客
03-06 143
0 废话 这周集中刷了点题，准备每周总结一下，先占个坑。周末主要任务是 写完上周作业 搞明白没懂的知识 周六晚参加一下双周赛 周日上午参加这周的周赛 概率论感觉没有复习的那么透，做点题？ 总结这周题型和知识点 那么周日晚上见啦 ！ ...
Leetcode刷题--Week 1
Zhenxue_Xu的博客
03-23 180
滚动阅读全文 前言 眼瞅今年暑假就要开始找工作了，正好借助Leetcode刷题复习一下相关算法，随便为找工作做些准备。接下来每周至少回顾一个算法同时刷一道题，每周打卡。 本周刷题 树 题目： Given a binary tree, find its minimum depth.The minimum depth is the number of nodes along the shortes...
LeetCode_java_leetcode_刷题_
09-30
本资料包聚焦于Java语言，整理了150多道LeetCode上的热门问题，是Java开发者进行刷题训练的理想资源。 LeetCode中的题目涵盖了数据结构、算法、设计模式等多个方面，每道题目都分为Easy、Medium、Hard三个难度级别...
leetcode寻找最近的-LeetCode:LeetCode漫漫刷题之路
07-01
LeetCode漫漫刷题之路 鹅厂面试题之数组与字符串 1、两数之和 2、寻找两个有序数组的中位数 3、最长回文子串 4、字符串转换整数 (atoi) 5、最长公共前缀 6、三数之和 7、最接近的三数之和 8、有效的括号 9、删除排序...
在LeetCode上刷题的记录，目前实现的代码都是C#与t-sql
03-07
在LeetCode上刷题的记录，目前实现的代码都是C#与t-sql 在LeetCode上刷题的记录，目前实现的代码都是C#与t-sql 在LeetCode上刷题的记录，目前实现的代码都是C#与t-sql 在LeetCode上刷题的记录，目前实现的代码都是...
leetcode--恢复二叉搜索树
liulanba的博客
07-09 462
给你二叉搜索树的根节点 root ，该树中的 恰好 两个节点的值被错误地交换。请在不改变其结构的情况下，恢复这棵树。示例 1：输入：root = [1,3,null,null,2]输出：[3,1,null,null,2]解释：3 不能是 1 的左孩子，因为 3 > 1。交换 1 和 3 使二叉搜索树有效。示例 2：输入：root = [3,1,4,null,null,2]输出：[2,1,4,null,null,3]解释：2 不能在 3 的右子树中，因为 2 < 3。
leetcode--从中序与后序遍历序列构造二叉树
liulanba的博客
07-09 628
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树。
力扣-bfs
最新发布
weixin_63551790的博客
07-12 331
何为广度优先搜索？广度优先搜索，即bfs。不同于dfs（走到底然后再换另外一条路），bfs更像是一层一层的走。常常用来处理最短路径问题。
力扣双指针算法题目：快乐数
m0_73426459的博客
07-07 347
由图可知，这是一个有环链表，说起链表问题，在判断一个链表是否有环的时候，我们常用的思想就是快慢指针思想，通常来讲就是有两个指针slow和fast，slow初始化在第一个位置，fast初始化在第二个位置，slow一次走一格，fast一次走两格，如果slow指针可以和fast指针相遇，那么就说明这个链表是有环的。如何让快指针dfast每次推进两个格子，我们只要将fast目前所代表的数字调用一下bitsum得到它后面的一个数字，再让它后面的一格数字再次调用一下bitsum就可以了，这便是如下的代码。
leetcodejava刷题
09-24
Leetcode Java刷题是指在Leetcode上使用Java语言来解决各种算法和数据结构题目的过程。刷题的过程中，可以采用一些高效的方法来提高效率。例如，可以采用"刷题三板斧"方法，该方法包括：1.理清题目思路；2.编写重点步骤的代码；3.整体实现。另外，还可以借鉴其他人的思路，通过阅读他人的解题思路和代码来提高自己的解题能力。 在开始刷题之前，可以先画图来理清题目的思路，然后根据图的旁边写下重点步骤的代码。最后，根据这些重点代码来实现整个解题过程。通过不断地实践，才能真正掌握编程的技巧和知识。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值