精华内容
下载资源
问答
  • 1.两数之和 题目描述:给定一个整数数组 nums和一个目标值 target,请你在该数组中找出和为目标值的那两整数,并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是,数组中同一个元素不能使用两遍。...

    1.两数之和

    题目描述:给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那两整数,并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是,数组中同一个元素不能使用两遍。

    示例:给定 nums = [2, 7, 11, 15], target = 9。因为 nums[0] + nums[1] = 2 + 7 = 9,所以返回 [0, 1]。

    这道题的总体上思路是num[i]一定位于数组中,所以只要找出target-num[i]在数组中的位置即可。

    第一种方法是遍历数组,但每一次循环都会利用切片将i之前的元素转化成一个新的数组,这样做是为了应对数组中出现类似于[2,3,3,5]相邻数字相等的状况。如果找到了符合的值就赋给j,由于j总是位于i之前,所以返回[j,i]。

    def twoSum(nums, target):
        j = -1
        for i in range(1,len(nums)):
            new_nums = nums[:i]
            if target-nums[i] in new_nums:
                j = new_nums.index(target-nums[i])
                break
        if j>=0:
            return [j,i]

    第二种方法是利用哈希表,首先初始化一个空字典,遍历数组,如果target-num[i]在字典中,就返回该值的索引和i;如果未出现在字典中,就将该值作为key,该索引作为value传入字典中,等下次循环再判断。

    def twoSum(nums, target):
        dict_ = {}
        for i in range(len(nums)):
            if target-nums[i] in dict_:
                return [dict_[target-nums[i]],i]
            else:
                dict_[nums[i]] = i
    • 方法一用时548ms,内存消耗14.8MB
    • 方法二用时68ms,内存消耗14.9MB

    7.整数反转

    题目描述:题目描述给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。

    示例:输入: 123输出: 32、输入: -123输出: -321、输入: 120输出: 21

    注意:假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231,  231 − 1]。请根据这个假设,如果反转后整数溢出那么就返回 0。

    第一种方法是利用字符串,首先对字符串反转,这一步可以利用切片或者内置函数reverse。如果输入数字$x\geq0$,直接将反转后的字符串转为整型赋值给num;如果$x<0$,需要先在字符串前加上"-"再转为整型赋值给num。若num处于范围之内直接返回,否则返回0。

    def reverse(x):
        str1 = str(abs(x))
        str2 = str1[::-1]
        if x>=0:
            num = int(str2)
        else:
            str3 = '-'+str2
            num = int(str3)
        if num < (-2) ** 31 or num > 2 ** 31 - 1:
            return 0
        else:
            return num

    第二种方法是利用数学方法,利用整数除以10取余可以得到该整数的最后一位、整数地板除可以去除该整数的最后一位两个性质相结合就可以得到反转后的数字,之后的判断与上述方法同理。

    def reverse(x):
        temp = abs(x)
        i = len(str(temp))
        num = 0
        while i>0:
            num = num * 10 + temp % 10
            temp = temp // 10
            i -= 1
        if x<0:
            num = -num
        if num<(-2)**31 or num>2**31-1:
            return 0
        else:
            return num
    • 方法一用时52ms,内存消耗13.7MB
    • 方法二用时52ms,内存消耗13.4MB

    13. 罗马数字转整数

    LeetCode小白入门——简单题目八题合集,每题两解

    示例:输入: "III"输出: 3、输入: "IV"输出: 4、输入: "MCMXCIV"输出: 1994(解释: M = 1000, CM = 900, XC = 90, IV = 4)。

    第一种方法是利用字典(哈希表)暴力破解,将所有可能出现的组合按照罗马数字作为key、阿拉伯数字作为value的格式存入字典中,对于输入的字符串,如果一个字符对应值小于其右边的值,那么这个组合必定是IV、IX、XL、XC、CD、CM其中一个。

    那么就可以利用切片在字符串中截取两位,在字典中查询这个组合的对应值,并且下标也需后移两位;否则只需在字典中查询该字符对应值,下标后移一位即可。

    def romanToInt(self, s: str) -> int:
        dict_ = {"I": 1, "IV":4,"V": 5,"IX":9, "X": 10, "XL":40,"L": 50,
                 "XC":90,"C": 100,"CD":400,"D": 500, "CM":900,"M": 1000}
        sum = 0
        i = 0
        while i< len(s) - 1:
            if dict_[s[i]] < dict_[s[i + 1]]:
                sum += dict_[s[i:i + 2]]
                i += 2
            else:
                sum += dict_[s[i]]
                i += 1
        if i >= len(s):
            return sum
        else:
            return sum + dict_[s[-1]]

    最后为什么又会增加一个判断呢?是因为i的范围是(0,len(s)-1),所以最后需要查询的可能是一个组合,也可能是单个字符,需要区分这两种可能性。

    第二种方法也是利用哈希表,这种方法也是遍历整个字符串,如果一个字符小于它右边的字符,那么在和的基础上减去这个字符对应值,比如IV不就是-1+5=4嘛;否则就直接在和的基础上加上该字符对应值即可,由于每次只判断一个字符,所以也无需对结果进行上面的区分。

    def romanToInt(self, s: str) -> int:
        dict_ = {"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000}
        sum = 0
        for i in range(len(s)-1):
            if dict_[s[i]]<dict_[s[i+1]]:
                sum -= dict_[s[i]]
            else:
                sum += dict_[s[i]]
        return sum + dict_[s[-1]]
    • 方法一用时76ms,内存消耗13.6MB
    • 方法二用时64ms,内存消耗13.7MB

    14. 最长公共前缀

    题目描述:编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀,返回空字符串 ""。

    示例:输入: ["flower","flow","flight"]输出: "fl"、输入: ["dog","racecar","car"]输出: ""。

    前缀是指字符串最后一个字符之前所有字符

    第一种方法是利用两层循环嵌套,因为公共前缀的长度一定是小于等于数组中最短字符长度的,所以第一层循环用来切分字符串,利用第一个字符串str0与其余字符串做比较,如果str0更长,则其切分后的长度需要与其相比较的字符串相等。

    第二层循环是在str0长度范围内,依次比较str0和其他字符串每个对应位置上的字符是否相等,如果不相等则更新str0并利用break退出该层循环,再比较下一个字符串。

    def longestCommonPrefix(strs):
        if len(strs) == 0:
            return ""
        str0 = strs[0]
        for i in strs:
            if len(str0) > len(i):
                str0 = str0[:len(i)]
            for j in range(len(str0)):
                if str0[j] != i[j]:
                    str0 = str0[:j]
                    break
        return str0

    第二种方法利用了zip和set两个方法相结合,下面结合程序一些断点运行截图进行讲解。

    def longestCommonPrefix(strs):
        words = list(zip(*strs))
        str_ = ''
        for i in words:
            word = list(set(i))
            if len(word) == 1:
                str_ += word[0]
            else:
                break
        return str_

    LeetCode小白入门——简单题目八题合集,每题两解
    可以看到zip(*strs)会将每个字符串相应位置上的字符存入一个元组中,元祖的个数就是输入中字符串最小长度。然后遍历words这个列表,对每个元祖利用set方法去重,如果去重后得到新列表的长度为1,那么证明这个字符是三者共有的,就可以将其加入到定义的空字符串str中;否则就跳出循环返回字符串str

    • 方法一用时48ms,内存消耗13.6MB
    • 方法二用时36ms,内存消耗13.7MB

    20.有效的括号

    题目描述:给定一个只包括 '(',')','{','}','[',']' 的字符串,判断字符串是否有效。有效字符串需满足:左括号必须用相同类型的右括号闭合;左括号必须以正确的顺序闭合。注意空字符串可被认为是有效字符串。

    示例:输入: "()[]{}"输出: true、输入: "(]"输出: false、输入: "([)]"输出: false、输入: "{[]}"输出: true。

    第一种方法利用了内置方法replace,根据示例可以看到每组括号都需要左右括号对应才能消除,只要字符串中含有可以消除的括号,就可以将其替换成空字符串,利用循环无脑替换,最后字符串如果为空就返回True,反之则返回False。

    def isValid(s):
        if len(s)%2 != 0:
            return False
        while '()' in s or '[]' in s or '{}'in s:
            s = s.replace('()','').replace('[]','').replace('{}','')
        return s==''

    第二种方法利用栈的思想,首先按照右括号为key,左括号为value的格式传入字典中,然后遍历整个字符串,如果是左括号就存入栈中,然后如果是右括号则比较其对应的左括号是否与栈顶位置的左括号相同,相同的话从栈中移除,不同的话就将其存入栈中,循环过后的栈如果和最初的栈相同返回True,反之则返回False。

    这里需要注意的是在新定义栈时,需要向其中加入一个元素,防止在比较的时候列表下标溢出的现象发生。

    def isValid(s):
        if s == '':
            return True
        dict = {')':'(',']':'[','}':'{'}
        stack = [0]
        for i in s:
            if i in ['(','[','{']:
                stack.append(i)
            elif dict[i] == stack[-1]:
                stack.pop()
            else:
                stack.append(i)
        return stack == [0]
    • 方法一用时56ms,内存消耗13.7MB
    • 方法二用时44ms,内存消耗13.7MB

      26. 删除排序数组中的重复项

    题目描述:给定一个排序数组,你需要在 原地 删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度。不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

    示例:给定 nums = [0,0,1,1,1,2,2,3,3,4],函数应该返回新的长度5,并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4,不需要考虑数组中超出新长度后面的元素。

    在编写程序的时候一定要注意题目中两个关键的要求,一个是不要使用额外的空间,所以这里不能定义新的数组;另一个是不需要考虑数组中超出新长度后面的元素,在需要满足示例中的要求的基础上可以选择删除、覆盖、交换多种方式。

    第一种方法利用双指针,分别初始化为0和1,遍历输入数组,如果两个指针对应元素值相等,则移除后面指针对应元素;否则就将两个指针分别加一,继续排查数组中剩下的元素。

    def removeDuplicates(nums):
        market1,market2 = 0, 1
        while market2<len(nums):
            if nums[market1]==nums[market2]:
                nums.pop(market2)
            else:
                market1 += 1
                market2 += 1
        return len(nums)

    第二种方法是将数组自后向前遍历,如果从前向后遍历的话,每当删除一个元素时,它后面所有元素的下标都会变,而且也容易有下溢出的情况。而自后向前很好的解决了这个问题,因为输入数组总是有序数组嘛,所以值相等的永远相邻,只需要比较两个相邻元素是否相等,若相等则删去后面的元素。

    def removeDuplicates(nums):
        for i in range(len(nums)-1,0,-1):
            if nums[i] == nums[i-1]:
                nums.pop(i)
        return len(nums)

    这里在介绍一下第三种方法(官方解法),这种方法也是利用双指针,但它体现的是覆盖而不是是删除,首先定义第一个指针i=0,然后利用第二个指针j遍历数组,如果j与i对应元素值不相等,则将j的值赋给i+1,随之指针i也后移一位,这样i+1就是新数组的长度,并且每个元素都不重复。

    def removeDuplicates(nums) int:
        i = 0
        for j in range(len(nums)):
            if nums[j]!=nums[i]:
                nums[i+1] = nums[j]
                i += 1
        return i+1
    • 方法一用时72ms,内存消耗14.8MB
    • 方法二用时56ms,内存消耗14.7MB
    • 方法三用时44ms,内存消耗14.7MB

      28. 实现 strStr()

      题目描述:给定一个 haystack 字符串和一个 needle 字符串,在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在,则返回-1。

    示例:输入: haystack = "hello", needle = "ll"输出: 2、输入: haystack = "aaaaa", needle = "bba"输出: -1。

    第一种方法就是暴力破解,问题是在haystack中找到needle出现的第一个位置,这个位置一定是在0到len(haystack)-len(needle)+1之间,因为剩下的字符串也要匹配嘛。在haystack中利用切片方法搜寻与needle相同的字符串,找到返回第一个位置对应下标,反之返回-1。

    def strStr(haystack,needle):
        m,n = len(haystack),len(needle)
        for i in range(0,m-n+1):
            if needle == haystack[i:i+n]:
                return i
        return -1

    第二种方法是利用双指针方法,利用两个指针遍历两个数组,比较对应位置字符是否相同,相同的话两个指针分别加一。不相同的话,如果needle数组中的指针移动过了,则需要将其重置,haystack数组指针则回到二者匹配开始的下一位重新匹配;如果needle数组中的指针未移动,只需将haystack数组指针后移一位即可。

    例如haystack="ababd",needle="abd",二个数组下标为3时,即a和d不匹配,那么haystack数组的指针要指向第一个b的位置,而needle数组的指针则指向a。

    def strStr(haystack,needle):
        m,n = len(haystack),len(needle)
        mar1,mar2=0,0
        while mar1<m and mar2<n:
            if haystack[mar1] == needle[mar2]:
                mar1 += 1
                mar2 += 1
            else:
                if mar2>0:
                    mar1 = mar1-mar2+1 #回到匹配的下一位
                    mar2 = 0
                else:
                    mar1 += 1
        return mar1-n if mar2==n else -1
    • 方法一用时28ms,内存消耗14.8MB
    • 方法二用时60ms,内存消耗14.7MB

      35. 搜索插入位置

      题目描述:给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。如果目标值不存在于数组中,返回它将会被按顺序插入的位置。你可以假设数组中无重复元素。

    示例:输入: [1,3,5,6], 5输出: 2、输入: [1,3,5,6], 2、输出: 1、输入: [1,3,5,6], 7输出: 4。

    第一种方法利用单层循环查找,因为输入数组是排序数组,所以只需要找到数组中第一个大于等于target元素的下标即可,如果等于那么该位置就是target在数组中的位置,如果是大于那么该位置正好是target需要插入的位置;若没有符合条件的元素,则证明target最大,需要插入至列表最后。

    def searchInsert(nums,target):
        mar = 0
        while mar<len(nums):
            if nums[mar] >= target:
                return mar
            mar += 1
        return len(nums)

    第二种方法是二分查找法,首先初始化一个左指针left和右指针right,并在二者之间找到处于中间位置的下标mid。如果该位置元素小于target,下次查找位于mid+1与right之间的元素;如果该位置元素大于target,则下次查找位于left与mid-1之间的元素;如果两者相等(target在数组中),则直接返回mid,反之返回左指针left。

    def searchInsert(nums,target):
        left = 0
        right = len(nums) - 1
        while (left <= right):
            mid = (right + left) // 2
            if nums[mid] < target:
                left = mid + 1
            elif nums[mid] > target:
                right = mid - 1
            else:
                return mid
        return left
    • 方法一用时44ms,内存消耗14.1MB
    • 方法二用时36ms,内存消耗14.4MB
    展开全文
  • leetcode下载 java-rookie 项目简介 bootdemo: SpringBoot为主体的网络应用,用于新项目。配置了Swagger struts2.demo Struts2的学习,用于老项目的维护 2.5.26 为了和新的文档兼容,采用了blank-archtype来快速上手...
  • c++刷leetcode入门

    2019-08-13 19:27:48
    #include <vector> // 这个必须加上,要不然报错 #include <iostream> // 这个必须加上,要不然报错 ...#include "leetcode279_24Game.h" using namespace std; // 这个必须加上,要不然报错 class S...
    #include <vector>
    // 这个必须加上,要不然报错
    #include <iostream>
    // 这个必须加上,要不然报错
    #include <cmath>
    // 这个必须加上,要不然报错
    
    #include "leetcode279_24Game.h"
    
    using namespace std;
    // 这个必须加上,要不然报错
    
    class Solution {
    public:
        bool judgePoint24(vector<int> nums){
            cout << "这是个引用吗?:"  <<endl;
            for(int i=0 ;i<nums.size();i++){
                nums[i] = 9;
                cout<< nums[i] <<" ";}
    
    //        cout<<endl;
    
            return judge24({nums.begin(), nums.end()}); }
    
        static bool judge24(vector<double> nums) {
            auto n = nums.size();
            if(n == 1) return abs(nums[0] - 24) < 1e-10;
    
            sort(nums.begin(), nums.end());
            // For each permutation,
            do {
                // merge the last two numbers.
                vector<double> temp(nums.begin(), nums.end()-1);
                auto a = nums[n-1], b = nums[n-2];
                for(auto num: {a+b, a-b, a*b, a?b/a:0}){
                    // For each merged number, combine with the rest and test it
                    temp.back() = num;
                    if(judge24(temp)) return true;
                }
            } while(next_permutation(nums.begin(), nums.end()));
    
            return false;
        }
    };
    
    int main(){
        bool a;
        vector<int> nums = {7, 1, 5, 3, 6, 4};
    
        for(int i=0 ;i<nums.size();i++)
            cout<<nums[i]<<" ";
        cout<<endl;
        Solution s;
        a = s.judgePoint24(nums);
        cout << "Box2 的体积:" << a <<endl;
        for(int j=0 ;j<nums.size();j++){
            cout << "修改后:" << nums[j] <<" ";}
        cout<<endl;
    
        return 0;
    }
    

    缺少了就会报错呀

    展开全文
  • 力扣刷题的开始(3) 如有不对的地方欢迎指正(๑•̀ㅂ•́)و✧ 1 -题目 ...已给定部分代码(注意这代表已给定部分数据,不可删除,可以理解为让我们完成一个函数) ...2.字符串和字符数组存在差别,对 字符串,...

    力扣刷题的开始(3)

    如有不对的地方欢迎指正(๑•̀ㅂ•́)و✧

    • 1
      -题目
      在这里插入图片描述

    • 2

    已给定部分代码(注意这代表已给定部分数据,不可删除,可以理解为让我们完成一个函数)

    在这里插入图片描述

    • 3

    笔记

    1.提取字符串的中单个字符,也可以用(a[n])的形式提取。
    2.字符串和字符数组存在差别,对 字符串,编译时会自动在末尾增加一个 null 字符(也就是’\0’),而对于 字符数组,则不会自动增加任何东西。也会导致长度差异(strlen中字符串为真实长度,sizeof中字符数组为真实长度)。 详细分析请看大佬文章
    3判断字符串中数字一定( a[n] ==‘1’)
    4,字符数字(‘1’)如何进行数字运算? ’2’-‘0’=2 同理可得( a[i]-‘0’ )转化为数字。
    5题目已定义int变量 sum 等,无需自己定义。

    • 4
      代码实现
      在这里插入图片描述
      思路如下:
      在这里插入图片描述
    char* addBinary(char* a, char* b) {
    	int p = 0;//length为字符串c的长度,p来判断是否进位
    	int length = (strlen(a) > strlen(b) ? strlen(a) + 2 : strlen(b) + 2);//+2是因为还要放'/0
    	char* c = (char*)malloc(sizeof(char) * length);
    	c[length - 1] = '\0'; 
    	for (int i = strlen(a) - 1, j = strlen(b) - 1, k = length - 2; (i >= 0) || (j >= 0); i--, j--, k--)
    	{
    		int sum = p;
    		sum += (i >= 0 ? a[i] - '0' : 0);//用?语句来解决小数高位不存在问题
    		sum += (j >= 0 ? b[j] - '0' : 0);
    
    		p = sum / 2;
    		c[k] = '0' + sum % 2;
    	}
    	c[0] = p + '0';
    	if (p == 0)//首位为零,所有数向前移一位
         {
    		for (int i = 0; i < length - 1; i++)
    			c[i] = c[i + 1];
    	}
    	return c;
    }
    
    
    

    如有侵权,请联系

    展开全文
  • 力扣刷题的开始(5) 如有不对的地方欢迎指正(๑•̀ㅂ•́)و✧ 1 题目 ...已给定部分代码(注意这代表已给定部分数据,不可删除,可以理解为让我们完成一个函数) ...1.当要定义数组a[N]是,无法编译时可以用(*a+...

    力扣刷题的开始(5)

    如有不对的地方欢迎指正(๑•̀ㅂ•́)و✧

    • 1
      题目
      在这里插入图片描述

    • 2

    已给定部分代码(注意这代表已给定部分数据,不可删除,可以理解为让我们完成一个函数)
    在这里插入图片描述

    • 3

    笔记

    1.当要定义数组a[N]是,无法编译时可以用(*a+malloc)语句来实现。
    2.当要取一组数时,一般有两种思路。1(y→x)在所有数中选出符合条件的。2(x→y)把所有x带入得到y。
    3动态规划,就是正向迭代来简化过程。

    • 4
      代码实现
      在这里插入图片描述
    #define min(a,b) ((a>b) ? b : a)
    
    int numSquares(int n) {
        int* a = malloc(sizeof(int) * (n + 1));
        a[0] = 0;
        for (int i = 1; i <= n; i++) {
            a[i] = i;
            for (int j = 1; i - j * j >= 0; j++)
                a[i] = min(a[i], a[i - j * j] + 1);
        }
        return a[n];
    }
    
    

    如有侵权,请联系

    展开全文
  • 力扣刷题的开始 如有不对的地方欢迎指正(๑•̀ㅂ•́)و✧ 1 -题目 ...已给定部分代码(注意这代表已给定部分数据,不可删除,可以理解为让我们完成一个函数) 最后返回一个数组,returnSize为返回数组的长度 ...
  • 初刷leetCode--入门

    千次阅读 2019-03-04 21:01:30
    本系列文章主要是给第一次接触LeetCode的同学提供一些参考意见,有不合理的地方麻烦指点出来。 从何入手 刷题网址:https://leetcode.com/problemset/all/ 对于第一次进入leetCode的同学,可能面对1000多道的题...
  • 力扣刷题的开始(2) 如有不对的地方欢迎指正(๑•̀ㅂ•́)و✧ -题目 ...已给定部分代码(注意这代表已给定部分数据,不可删除,可以理解为让我们完成一个函数) ...1 执行时出错(最后输入2000105819)则说明要...
  • [刷题] Leetcode: 从入门到放弃

    千次阅读 2019-03-19 19:57:46
    Leetcode打卡以及心得记录
  • 第一次在LeetCode上做算法题,重拾了很久没接触过的代码,采用了暴力解法 思路:暴力求解,直接遍历vector中的值进行相加求和 注意:暴力求解可能会遇到两个坑 1、对 j 的取值范围不清,j = i导致可能会在...
  • leetcode 答案 Leetcode-C++ 1. 简介 本仓库的代码为 ...有的工程代码量过于庞大,不利于新手入门学习,可以先练习 Leetcode 算法题目开始,锻炼速度。为之后的计算机能力提供坚实保障。 3. LICENSE GPL v3.0
  • 个人刷题记录,帮助入门者开始LeetCode。尽量争取一题多解,将每种解法解释清晰。 如何使用? 使用搜索功能(浏览器上快捷键一般是Ctrl+F)搜索题号,即可查看解法思路介绍的文章。 需要注意: 为了绝大多数国内用户...
  • 新手入门指南 Mac OS 更新系统 Mac OS X 10.11.1 安装 Xcode Xcode Xcode commandline tools 常用系统工具安装 带*号的是必须安装,其他推荐 [*] 安装 brew 工具,参考 编辑器,推荐 Vim/Emacs/Sublime Text 3 ...
  • ACM新手入门

    2019-01-05 18:21:25
    比赛很多,校内赛,cf,vj,Leetcode,牛客等等,打不完的比赛,一定要反思, 找到自己擅长的,了解自己不擅长的,自己给自己制定训练计划,并严格执行。 时常整理自己的模板,并不是说平常用,而是想看的时候,...
  • 本题来自Leetcode48:旋转图像 我们熟悉图像的旋转问题,而这个问题要求在原地旋转,即不能用额外的矩阵(空间复杂度o(1))。输入输出都是二维列表。 所以,收起将列表转化为numpy的想法。 如果您之前没接触这个问题,...
  • 不少小白选手难免会东一榔头西一棒槌,最终看了很多文章,却仍没跨过新手那道门槛。 结合自身的学习经验以及与很多自学者的沟通了解,我们整理出一条可操作性较强的自学路线,同时收集了多种形式的 Python 优质学习...
  • Python 新手入门引导

    2021-02-23 08:34:34
    不少小白选手难免会东一榔头西一棒槌,最终看了很多文章,却仍没跨过新手那道门槛。 结合自身的学习经验以及与很多自学者的沟通了解,我们整理出一条可操作性较强的自学路线,同时收集了多种形式的 Python 优质学习...
  • LeetCode总结

    2017-03-30 23:38:00
    LeetCode总结 所有代码见我的github。不过一般leetcode上答案也一大堆,最好还是自己动动手,收获比较大。 100 知识点:递归,二叉树 难度Easy,主要是注意对当p和q均为null时也要做判断。 104 知识点:二叉树,DFS ...
  • 文章目录题目暴力实现--一步一步的移动(超时警告)反转实现 题目 旋转数组 暴力实现–一步一步的移动(超时警告) void rotate(vector<int>& nums, int k) { int len = nums.size(); k = k % len;...
  • 三、初始条件和边界情况 dp数组的初值和结束边界很重要,很多新手容易在初值设置环节犯错,即赋错值。 四、确定计算顺序 即确定循环计算的方式。 下面我们以LeetCode上的简单动态规划题的顺序开始进行学习 LeetCode...
  • leetcode 001 two sum

    2018-02-14 19:59:32
    解法一Python的字典dictionary数据结构,{key:value},key和value是一对,in dict一般是key在循环里嵌套if语句,一边存入前面i的target-nums[i]的值作为key,i作为value,一边判断nums[i]是否已经存在dict里面,存在...
  • Leetcode刷题就如同打怪一样,随着不断地刷题,你的知识库会更加牢靠,你会更加顺手的去用手里的武器,这里指的是各种数据结构,类型,以及系统提供的库,快速帮助你完成目标。 基础的算法刷完,后面你遇见一些实际...
  • 我自己在新学erlang,在LeetCode OJ上找了题目练习,题目很适合新手熟悉语言,但是LeetCode OJ里面只有几门主流语言的答案,下面是已完成的erlang源代码,后续有空再做其他问题续传,题目包含:(源码开头都有题目...
  • 因为这个网站在学习编程入门的过程中用得最多,写着很熟悉,整体布局比较简单,适合新手。 各位无聊的话不妨来玩一玩,当然因为网站可能还是会有安全问题,注册账号时就不要用自己常用的账户名和密码啦。 , 技术栈 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,170
精华内容 468
关键字:

leetcode新手入门