精华内容
下载资源
问答
  • 1.数据结构和算法 数据结构分为逻辑结构和物理结构 四大逻辑结构:集合结构、线性结构、树形结构、图形结构 数据元素的存储结构形式有两种:顺序存储和链式存储 算法效率、函数的渐近 2.算法题 组合题 输入 k = 2 ...

    1.数据结构和算法

    • 数据结构分为逻辑结构和物理结构
    • 四大逻辑结构:集合结构、线性结构、树形结构、图形结构
    • 数据元素的存储结构形式有两种:顺序存储和链式存储
    • 算法效率、函数的渐近

    2.算法题

    组合题

    输入 k = 2 ,n = 4
    输出 12 13 14 23 24 34 组合

    # n = input("请输入n值:") n = 4
    # k = input("请输入K值: ") k = 2
    n = 20
    k = 16
    nums = [i for i in range(1, n + 1)]
    res = []
    
    
    # print(nums)
    def backtrace(nums_b, curr_res, index):
        if len(curr_res) == k:
            res.append(curr_res[:])
            #print(res)
            return
    
        for i in range(index, n):
            curr_res.append(nums[i])
            backtrace(nums_b[index:], curr_res, i + 1)
            curr_res.pop()
    
        if n == 0 or k == 0:
            return res
    
    backtrace(nums,[],0)
    print(res[:])
    
    

    (1)回溯法
    (2)python的深拷贝与浅拷贝
    具体如下:
    Python中列表和数组的赋值,浅拷贝和深拷贝

    列表赋值:

    >>> a = [1, 2, 3]
    >>> b = a
    >>> print b
    [1, 2, 3]
    >>> a[0] = 0
    >>> print b
    [0, 2, 3]
    

    解释:[1, 2, 3]被视作一个对象,a,b均为这个对象的引用,因此,改变a[0],b也随之改变

    如果希望b不改变,可以用到切片

    >>> b = a[:]
    >>> a[0] = 0
    >>> print b
    [1, 2, 3]
    

    解释,切片a[:]会产生一个新的对象,占用一块新的内存,b指向这个新的内存区域,因此改变a所指向的对象的值,不会影响b

    列表深拷贝和浅拷贝

    浅拷贝

    >>> import copy
    >>> a = [1, 2, 3, [5, 6]]
    >>> b = copy.copy(a)
    >>> print b
    [1, 2, 3, [5, 6]]
    >>> a[3].append('c')
    >>> print b
    [1, 2, 3, [5, 6, 'c']]
    

    深拷贝

    >>> a = [1, 2, 3, [5, 6]]
    >>> b = copy.deepcopy(a)
    >>> a[3].append('c')
    >>> print b
    [1, 2, 3, [5, 6]]
    

    拷贝即是开辟一块新的内存空间,把被拷贝对象中的值复制过去。而浅拷贝并没有为子对象[5,6]开辟一块新的内存空间,而仅仅是实现对a中[5,6]的引用。所以改变a中[5,6]的值,b中的值也会发生变化。

    深拷贝则是为子对象也开辟了一块新空间。所以改变a中[5, 6]的值,并不影响b

    数组赋值不能用切片来达到相同的目的

    >>> import numpy as np
    >>> a = np.array([1, 2 ,3])
    >>> b = a[:]
    >>> a[0] = 5
    >>> print a, b
    [5 2 3] [5 2 3]
    

    如上,虽然用切片,但不能达到修改a而不影响b的目的。说明a,b仍然指向同一块内存。

    此时,只能用拷贝

    >>> b = a.copy()
    >>> a[0] = 5
    >>> print a, b
    [5 2 3] [1 2 3]
    

    此时修改a不会影响到b。其中的原因以后进一步深究。

    注意,列表的拷贝是copy.copy(obj)或copy.deepcopy(obj),数组的拷贝是obj.copy()
    深拷贝和浅拷贝转自:https://blog.csdn.net/lc_lc2000/article/details/53135839

    展开全文
  • LeetCode刷题 1. Category Difficulty Likes Dislikes algorithms Easy (49.47%) 9609 - Tags Companies 给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那 两个 整数,并返回他们的...
  • 算法刷题笔记

    2021-07-14 20:17:17
    排序算法2.迭代与递归2.分治思想2.搜素算法2.贪心算法2.动态规划一、OJ1.字符串OJ 7 Words2.线性表2.链表3.哈希表2.树2.图2.排序算法2.迭代与递归2.分治思想2.搜素算法2.贪心算法2.动态规划 一、LeetCode 1.字符串...


    一、LeetCode

    1.字符串

    LeetCode 704

    /**
     * LC704二分查找
     * 当left<=right,比较中间元素nums[pivot]和目标值
     * 如果target = nums[pivot],返回pivot
     * 如果target < nums[pivot],向左侧继续搜索 right=pivot-1
     * 如果target > nums[pivot],向右侧继续搜索 left=pivot+1
     * 当跳出while循环没有找到,则返回-1
     */
    public class Main {
    	public static void main(String[] args) {
    		//int[] nums = {-1,0,3,5,9,12};
    		int[] nums = {-1,0,3,5,9,12};
    		int target = 2;
    		int r = search(nums, target);
    		System.out.println(r);
    	}
    	
    	public static int search(int[] nums, int target) {
    		int pivot, left = 0, right = nums.length - 1;
    	    while (left <= right) {
    	      pivot = left + (right - left) / 2;
    	      if (nums[pivot] == target) return pivot;
    	      if (target < nums[pivot]) right = pivot - 1;
    	      else left = pivot + 1;
    	    }
    	    return -1;
    	}
    }
    
    

    LeetCode 28

    /**
     * LC28 实现strStr()
     * 1.得到needle的length
     * 1.for i loop haystack
     * 2.用substring得到 str = haystack.substring(i,i+length)
     * 3.如果str等于needle就返回i
     * 4.最后如果没有相等的就返回-1
     */
    public class Main {
        public int strStr(String haystack, String needle) {
            int length = needle.length();
            if (haystack.equals("") && needle.equals("")) {
                return 0;
            }
            for (int i = 0; i < haystack.length(); i++) {
                if (i + length <= haystack.length()) {
                    String str = haystack.substring(i, i + length);
                    if (str.equals(needle)) {
                        return i;
                    }
                }
            }
            return -1;
        }
    
        public static void main(String[] args) {
            Main2 main2 = new Main2();
            int result = main2.strStr("aaaaa", "aab");
            System.out.println(result);
        }
    }
    

    2.线性表

    2.链表

    3.哈希表

    2.树

    2.图

    2.排序算法

    2.迭代与递归

    2.分治思想

    2.搜素算法

    2.贪心算法

    LeetCode 455 分发饼干

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /**
     * LC455. 分发饼干
     * 1.把g和s排序,s转成sList
     * 2.嵌套for loop比较选取满足条件sList.get(j)>=g[i]
     * 3.满足条件num++,sList.remove(j),break跳出循环
     */
    class Main2 {
        public int findContentChildren(int[] g, int[] s) {
            Arrays.sort(g);
            Arrays.sort(s);
            List<Integer> sList = new ArrayList<>();
            for (int i : s) {
                sList.add(i);
            }
            int num = 0;
            for (int i = 0; i < g.length; i++) {
                for (int j = 0; j < sList.size(); j++) {
                    if (sList.get(j) >= g[i]) {
                        num++;
                        sList.remove(j);
                        break;
                    }
                }
            }
            return num;
        }
    
        public static void main(String[] args) {
            Main2 main2 = new Main2();
            int[] g = {1, 2, 3};
            int[] s = {1, 1};
            main2.findContentChildren(g, s);
        }
    }
    
    

    LeetCode 53 最大子序和

    /**
     * LC53 最大子序和
     * 局部最优:当前连续和为负数时,变为0,从下一个元素崇信计算连续和
     * 全局最优:选取最大连续和
     * 
     */
    class Main2 {
        public int maxSubArray(int[] nums) {
            if (nums.length == 1) {
                return nums[0];
            }
            int count = 0;
            int sum = Integer.MIN_VALUE;
            for (int i = 0; i < nums.length; i++) {
                if (count < 0) {
                    count = 0;
                }
                count += nums[i];
                sum = Math.max(count,sum);
            }
            return sum;
        }
    
        public static void main(String[] args) {
            Main2 main2 = new Main2();
            int[] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
            System.out.println(main2.maxSubArray(nums));
        }
    }
    

    2.动态规划

    一、OJ

    1.字符串

    OJ 7 Words

    package main;
    import java.util.Scanner;
    /**
     * OJ 7.Words
     * 1.读取String,以空格分割
     * 2.计算每个字符串长度,再除以总数
     * 3.返回结果
     */
    public class Main {
    	public static void main(String[] args) {
    		Scanner scan = new Scanner(System.in);
    		String arr[] = scan.nextLine().split(" ");
    		int sum = 0;
    		for (int i = 0; i < arr.length; i++) {
    			sum += arr[i].length();
    		}
    		double result = (double)sum / (double)arr.length; 
    		System.out.println(String.format("%.2f", result));
    	}
    }
    
    

    2.线性表

    2.链表

    import java.util.Arrays;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Scanner;
    /**
     * OJ 134 LinkedList
     * 1.读取String,split分解成array
     * 2.创建链表根据第二行
     * 3.通过判断 1 或 2 来插入或删除
     */
    public class Main {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            String str1 = scanner.nextLine(); // 读取第一行
            String str2 = scanner.nextLine(); // 读取第二行
            String[] arr1 = str1.split(" "); // 转换成array
            String[] arr2 = str2.split(" ");
            // 把第一行转化成int
            int[] a1 = new int[arr1.length];
            for (int i = 0; i < arr1.length; i++) {
                a1[i] = Integer.parseInt(arr1[i]);
            }
            int length = a1[1];
            // 创建list
            List<String> list = new LinkedList<>(Arrays.asList(arr2));
            // 添加
            for (int i = 0 ;i < length; i++) {
                String str = scanner.nextLine();
                String[] arr = str.split(" ");
                // 插入
                if (arr[0].equals("1")) {
                    list.add(Integer.parseInt(arr[1]), arr[2]);
                }
                // 删除
                if (arr[0].equals("2")) {
                    if (!list.isEmpty()) {
                        list.remove(Integer.parseInt(arr[1]) - 1);
                    }
                }
            }
            for (String str : list) {
                System.out.print(str + " ");
            }
            System.out.println();
        }
    }
    

    3.哈希表

    2.树

    2.图

    2.排序算法

    2.迭代与递归

    2.分治思想

    2.搜素算法

    2.贪心算法

    2.动态规划

    展开全文
  • 算法刷题的一点感受和建议

    千次阅读 2020-06-26 10:00:00
    现在的公司在面试招聘的时候(尤其是校招),还是非常在意候选人的算法思维和代码能力的,所以面试过程中的算法题现场写代码这一环节基本是跑不掉了。但是手撕代码这一块的确是最难准备的环节,对于绝...

    现在的公司在面试招聘的时候(尤其是校招),还是非常在意候选人的算法思维和代码能力的,所以面试过程中的算法题现场写代码这一环节基本是跑不掉了。

    但是手撕代码这一块的确是最难准备的环节,对于绝大部分没有算法竞赛经历的同学来说,得依靠剑指offerleetcode来快速培养算法能力。

    剑指offer66题好说,但是leetcode上千道题,从头开始刷不仅效率低下,并且无法形成系统的算法思维,实际上也并推荐。

    那么到底应该如何准备手撕代码环节呢,该如何有效而系统的进行刷题训练呢?

    01

    面试考察的算法类型

    1、原题

    我自己感觉原题的概率还是挺大的,特别是剑指offer的66题更是如此。千万别小看这66题,这几十道题里面基本所有的算法类型都有包括在内,常用的数据结构,操作方式,常用算法思路都有不少的题。

    如果真的能够充分理解这几十道题的最优解,我感觉其实已经形成基本的算法思维了。

    另外,leetcode的原题也很常见,因为LC本身题量大,在里面出原题不是为了考倒你,而是检验你的刷题质量。

    毕竟那些大公司面试官也不是傻子,知道你在面试前肯定会大规模刷题的。所以把刷过的题完全搞懂才是最重要的。

    2、改编题

    改编题就很显而易见了。改编题大多需要从基本的算法原理中找到处理的思维,然后结合实际题干进行性能优化,就能够搞定。

    这里要记得一点的是,正常的算法考察不会故意刁难你(正常情况),也不会给过多的时间让你思考和敲代码。

    所以遇到改编题不要想得太复杂,尽量要找到它的算法思维是什么。怎么说呢,透过现象看本质。我总结的改编题有以下几种思路:

    1)新的数据结构,换汤不换药。比如最常见的排序算法的改编,原来是对数字进行排序,现在对链表排序等等。比较难一点的可能会遇到自定义的数据结构。但是算法本质不会变。

    2)算法类型改编

    这里要说的就是一个比较大的范围,比如动态规划、贪心算法、递归、回溯和分治等等。这种是从算法大的类型上进行改编,很难用相同的套路去解题。

    遇到这类题的关键就是要先弄明白算法核心。比如动态规划的状态方程,贪心算法的局部最优情况,递归回溯的边界判断,分治的子问题划分等等。这种类型的确比较难把握,怎么硕呢,每种类型的都来搞几道感觉感觉吧。

    3)添加应用题背景。

    这种题目看起来不难,但是难就难在对应用题背景的理解,需要去理解题意,然后考虑合适的数据结构和处理算法。这里面有数学建模的思维在里面,需要把一堆无用的信息剔除,筛选出有效的信息,然后才能选择正确的算法。

     

    3、创新题

    这类题考察的是你的扩展思维,如果说上面的题考查的是你的思维深度,这种题就是考察算法的广度。可能一看题目,完全没见过这种类型。但是算法本身其实不就是让计算机代替人脑进行高重复性的计算嘛。

    首先你需要想到你应该去怎么算这个题,然后再换到计算机上,会发生什么问题(空间时间问题,运行效率,代码冗余等等),之后再想通过经典的算法原理来解决这些问题。

    无论怎样,面试官总不可能让你在短时间内造一个新算法出来,解题思路肯定是有所依托的。

     

    02

    短时间如何系统刷题

    说了那么多,还是得自己去刷题才行。那在时间不够的情况下,应该怎么去刷题,怎样才能形成系统的算法思维呢?

    1、题型分类

    按照个人的习惯,喜欢按照一种类型狂刷,然后再刷另外一种类型。一般常见的算法类型可分为:

    • 数组、链表

    包含基本排序算法、二分查找、链表的一系列操作。

    • 栈、队列、堆

    利用栈、队列互相实现,堆的使用

    • 二叉树与图

    主要是遍历算法和节点的计算:

    二叉树四种遍历方式、广度优先遍历(BFS)和广度优先遍历(DFS),节点到节点距离等等。

    • 哈希表

    使用标准库自带的模板或者函数就很简单了,一般会与其它数据结构相结合来提升时间复杂度。

    • 字符串操作

    字符串的操作也很多,本质上可以看作是数组的操作。另外字符串的一些匹配和寻求字串的算法还是非常具有思考价值的。KMP,马拉车等等。

    • 递归

    重点掌握边界判断条件。

    • 回溯

    重点掌握边界判断条件。

    • 分治

    重点掌握如何划分子问题。

    • 动态规划

    题太多了,可从一阶dp到二阶dp理解不同的状态方程。

    • 贪心及其它

    这个就很容易理解了,遇到贪心题应该要偷笑了。

    2、高频热点多刷

    这不多说了吧,Leetcode热题HOT 100。你值得拥有。

    在不知道怎么刷的情况下,不如先刷起来。刷个题没那么多捷径,只有坚持刷起来了,才会形成自己的思维方式和学习习惯。

    我建议是先按照类型刷,每个类型刷十几二十道。然后打混按照算法热度排序重新查漏补缺。

    3、思路回顾

    许多同学在一股脑刷了很多题之后,再看做过的题会发现忘了不少。可能大家都是这样的吧。我觉得是因为在刷题的时候过于心急,理解了大概就过了,或者类型做的太杂,没有留下印象。

    我比较喜欢的方式是偶尔会重新看看曾经做过的题,就看题目然后想思路,再画一画步骤演进,没时间就不细敲了。这样可以增强一下思维记忆,之前理解过的东西,再回忆起来还是非常快的。

     

    03

    Leetcode题号

    每个类型的题号我就懒得再单独列出来,Leetcode上的筛选已经做得非常好了。点进来,选择你想刷的类型,进去可以先挑战简单的题,然后再到中等,再到困难。题号在300之前的我都建议刷一下,后面的就看心情和精力了。

     

    04

    如何在面试中应对手撕代码

    上面说了那么多,其实都是在面试前的准备工作。但是就算准备工作做得好,也不代表一定能够发挥得好。

    毕竟面试存在太多的影响因素,你心理状态、身体状态以及和面试官的交流气氛都会影响你在算法题上的解题效果。因此在面试过程遇到手撕代码,我有以下几点建议:

    1、保持冷静

    情绪这种东西是很难掌控的,有时遇到没见过的题会慌张,有时又会被面试官的语气干扰了思考。但是只要在面试中,就还有机会。

    在无法静心思考的时候可以拿出纸笔先自己想想思路,没必要一看题没见过就想着面试官能够给予提示。你在遇到问题时的思考态度反而更能打动面试官。

    2、尝试交流

    在短暂的思考过后,如果有了初步的思路可以试着跟面试官探讨。不必急于向面试官求证你的思路是否正确,更重要的是能够具有逻辑性和条理性的表达清楚自己的想法。

    就算这个时候你的思路不正确,也会让面试官产生“你还挺有想法的”的判断,对你的印象也会加分。

    3、展现足够的代码能力

    手撕代码我认为是有两方面的考察的,一是算法思维,二是代码能力。很多时候我们都是有了代码能力,但是没有具备足够的算法思维。

    所以当在没有想到完整问题的解法的时候,可以先尝试写些基本的处理代码,起码能够让面试官觉得你还是经常写代码的,只是可能这个时候状态不好,没有思路。

    这不是取巧,而是尽可能的为自己争取一点机会吧。

    4、要有思考过程

    有时候手撕的代码可能刚好你刷过,甚至你一不小心还对代码很熟练。这当然是个好事情,但是你并不能显得自己是背过代码的感觉。

    面试官一般都很反感这种行为,你这个时候可以先试着讲述整个算法思路,而不是急于在一两分钟内把这个算法整出来。

    5、思维比把解决难题强

    我经常听到同学说“那个谁谁在面试的时候,手撕代码题贼简单,所以面试才能过;不像我这么惨,出了一道leetcode困难的题,才把我刷了。”当然这种说法可能也有一定的原因吧,但是我情愿相信是思维能力差了点。

    能做出难题的确很厉害,但是人家能做简单题不代表做不了难题。我的意思其实是在面试的时候,不要因为题目难度而放弃了思考。

    我曾经在现场面试美团的时候,二面面试官就出了两道算法题,我一道都没写出来。但是我在面试的时候每一题都给出了好几种思路,虽然代码最终都没时间写完,但是也的确展示了自己的一部分能力吧。

    最后在HR面的时候还听到二面面试官跟别的面试官在闲聊,说 “ 面了这么多人,也就那个×××(我的名字)表现还不错 ” 。我都惊了…本来以为肯定挂了。

     

    综上所述,准备算法还是需要坚持+规划的。在面试前每天都需要刷点题找找手感,状态好呢就刷点难题,状态不好就刷点老题或者容易题。坚持下来,肯定会有所收获的,共勉。


    推荐阅读

    •   吴师兄实名吐槽 LeetCode 上的一道题目。。。•   面试字节跳动时,我竟然遇到了原题……•   Leetcode 惊现马化腾每天刷题 ?为啥大佬都这么努力!•   为什么 MySQL 使用 B+ 树•   一道简简单单的字节跳动算法面试题•   新手使用 GitHub 必备的两个神器•   卧槽!红警代码竟然开源了!!!


    欢迎关注我的公众号“五分钟学算法”,如果喜欢,麻烦点一下“在看”~

    展开全文
  • LC-learning leetcode 刷题,学习互助。希望大家都能找个好工作。 不局限于leetcode,包含不同领域算法讨论和学习。 通过解题的形式,巩固基础语法、数据结构以及算法相关知识。 仓库建立初衷来自 等大佬的建议,...
  • 数据结构与算法LeetCode刷题(Python)

    千次阅读 2018-10-07 11:59:37
    1、《面试算法LeetCode刷题班》 - 小象学院 2、csujedihy / lc-all-solutions 一、链表    1. 链表的必备知识要点(包括基础知识、刷题中使用的STL等知识)  2. 链表逆序(LeetCode 92 ,206. Reverse Linked...

    参考资料:

    1、《面试算法LeetCode刷题班》 - 小象学院

    2、csujedihy / lc-all-solutions

    一、链表

     

         1.  链表的必备知识要点(包括基础知识、刷题中使用的STL等知识)

         2.  链表逆序(LeetCode 92 ,206. Reverse Linked List 1,2)

         3.  求两个链表的交点(LeetCode 160. Intersection of Two Linked Lists)

         4.  链表的节点交换(LeetCode 24. Swap Nodes in Pairs)

         5.  链表求环(LeetCode 141 ,142. Linked List Cycle 1,2)

         6.  链表重新构造(LeetCode 86. Partition List) 

         7.  复杂的链表复制(LeetCode 138. Copy List with Random Pointer)

         8.  排序链表合并(2个与多个) (LeetCode 21,23 Merge Two(k) Sorted ListsLeetCode)

     

    二、栈、队列、堆

     

         1.  栈、队列知识要点与实现(数组、链表)

         2.  使用队列实现栈(LeetCode 232. Implement Queue using Stacks)

         3.  使用栈实现队列(LeetCode 225. Implement Stack using Queues)

         4.  包含min函数的栈(LeetCode 155. Min Stack)

         5.  简单的计算器(栈的应用)( LeetCode 224. Basic Calculator)

         6.  堆(优先级队列)知识要点与实现

         7.  数组中第K大的数(堆的应用) (LeetCode 215. Kth Largest Element in an Array)

         8.  寻找中位数(堆的应用)( LeetCode 295 Find Median from Data Stream)

     

    三、贪心

     

         1.  贪心算法知识要点,刷题必备的STL知识

         2.  贪心题目1(LeetCode 455. Assign Cookies)

         3.  贪心题目2(LeetCode 402. Remove K Digits)

         4.  贪心题目3(LeetCode 134. Gas Station)

         5.  贪心题目4(LeetCode 135. Candy)

         6.  贪心题目5(LeetCode 502. IPO)

         7.  贪心题目6(LeetCode 321. Create Maximum Number)

         8.  贪心题目7(codeforces 582A GCD Table)

     

    四、递归、分制、回溯

     

         1.  递归的知识要点,回溯算法

         2.  生成组合数(LeetCode 39. Combination Sum, LeetCode 40. Combination Sum II)

         3.  生成排列数(LeetCode 46. Permutations, LeetCode 47. Permutations II)

         4.  N皇后问题(LeetCode 51. N-Queens, LeetCode 52. N-Queens II)

         5.  分制算法知识要点

         6.  快速排序算法与经典实现

         7.  不同的加括号方法(LeetCode 241. Different Ways to Add Parentheses)

         8.  两个数组的中位数(LeetCode 4. Median of Two Sorted Arrays)

     

    五、树与图

     

         1.  树与图的数据结构与基本算法

         2.  树遍历的回调函数实现,并使用自动机概念实现非递归树前、中、后遍历

         3.  树与链表的转换(LeetCode 114. Flatten Binary Tree to Linked List)

         4.  最近的公共祖先(LeetCode 236. Lowest Common Ancestor of a Binary Tree)

         5.  树的层次遍历应用(LeetCode 199. Binary Tree Right Side View)

         6.  树的改造(LeetCode 117. Populating Next Right Pointers in Each Node 1,2)

         7.  图的复制(LeetCode 133. Clone Graph)

         8.  图的搜索与应用(LeetCode 207.Course Schedule)

     

    六、二分查找、二叉排序树、位运算的应用

     

         1.  二分查找、二叉排序树的知识要点

         2.  数组的二分查找(LeetCode 33 ,81 Search in Rotated Sorted Array 1,2)

         3.  区间二分查找(LeetCode 34. Search for a Range)

         4.  排序链表转换为二叉排序树(LeetCode 109. Convert Sorted List to B- Search Tree)

         5.  二叉排序树的遍历与改造(LeetCode 538 Convert BST to Greater Tree)

         6.  二叉排序树中的第K大的数(LeetCode 230. Kth Smallest Element in a BST)

         7.  位运算的知识要点

         8.  使用位运算表示集合(LeetCode 78. Subsets)

         9.  位运算应用题目(LeetCode 136,137,260. Single Number1,2,3)

     

    七、哈希表与字符串

     

         1.  哈希表与字符串知识要点

         2.  哈希题目 (LeetCode 290. Word Pattern)

         3.  哈希与字符串综合 (LeetCode 3.Longest Substring Without Repeating Characters)

         4.  哈希与字符串综合 (LeetCode 76. Minimum Window Substring)

         5.  哈希与字符串综合 (LeetCode 30. Substring with Concatenation of All Words)

         6.  字符串题目 (LeetCode 459. Repeated Substring Pattern)

         7.  字符串题目 (LeetCode 468. Validate IP Address)

     

    八、搜索

     

         1.  深度优先搜索与广度优先搜索算法

         2.  深搜题目 (LeetCode 200. Number of Islands)

         3.  深搜题目 (LeetCode 473. Matchsticks to Square)

         4.  深搜题目 (LeetCode 491. Increasing Subsequences)

         5.  广搜题目 (LeetCode 126,127 Word Ladder 1,2)

         6.  广搜题目 (LeetCode 417. Pacific Atlantic Water Flow)

         7.  广搜题目 (LeetCode 407. Trapping Rain Water II)

     

    九、动态规划

     

         1.  动态规划知识要点

         2.  动态规划题目1(LeetCode 120. Triangle)

         3.  动态规划题目2(LeetCode 53. Maximum Subarray)

         4.  动态规划题目3(LeetCode 198,213. House Robber 1,2)

         5.  动态规划题目4(LeetCode 322. Coin Change)

         6.  动态规划题目5(LeetCode 72. Edit Distance)

         7.  动态规划题目6(LeetCode 174. Dungeon Game)

         8.  动态规划题目7(codeforces 711C Coloring Trees)

     

    十、复杂数据结构

     

         1.  Trie树的构造与基本算法

         2.  Trie树的构造 (LeetCode 208. Implement Trie (Prefix Tree))

         3.  Trie树的应用 (LeetCode 212. Word Search II)

         4.  并查集的基本算法

         5.  并查集的应用 (LeetCode 547. Friend Circles)

         6.  线段树与树状数组

         7.  线段树与树状数组的应用(LeetCode 307. Range Sum Query – Mutable)

    展开全文
  • 一 创建数组 常用四种方式 1 ...一般数组有序的时候可以考虑 2 二分法 分,就硬分,注意要low 和 high对撞跳出while(low )循环 3 滑动窗口(sliding window) 目的 减少while循环 一般数组中的定长问题 lc 209 1456
  • LC刷题记录2

    2020-04-20 10:27:46
    无重复字符的最长子串 类kmp算法,可以用unordered_map建立 对应关系 进一步优化,用 vector table(128,-1) char c = s[i]; int pos = (int) c; 用数组优化map 代码如下: class Solution { public: int ...
  • LC刷题记录1

    2020-03-24 15:50:58
    小白刷题第一篇,仅做学习笔记只用。 9.回文数 转换为字符串 to_string函数,这是C++11新增的:C++11标准增加了全局函数std::to_string,以及std::stoi/stol/stoll等等函数(这几个就是string转int,long,以及long ...
  • 用c语言写了下很简单的哈希表算法,效果还不错 结果: Success Runtime: 4 ms, faster than 99.60% of C online submissions for Two Sum. Memory Usage: 7.5 MB, less than 91.67% of C online submissions ...
  • kim终于要学习贪心算法啦啦啦。。。 若前面能达到的最远距离都小于当前点,那么当前点及后面的点就都不可达——力扣大神 大神,我悟了! public boolean canJump(int[] nums) { int far = 0; for(int i = 0...
  • 分发饼干(lc.455):Easy2.分发糖果(lc.135):Hard3. 无重叠区间(lc.435):Medium 1. 分发饼干(lc.455):Easy 题目链接 描述: 假设你是一位很棒的家长,想要给你的孩子们一些小饼干。但是,每个孩子最多只能...
  • LC algo questions. 初衷: 解决,总结,分享我们的Leetcode刷题过程。互相监督,共同进步。 规则: 每天至少解决一道中/难题或三道简单题,并附如下解析: 解决了哪道题? 做题过程中遇到了哪些困难? 解题思路/...
  • 字母异位词分组(lc.49):Medium 1. 字母异位词分组(lc.49):Medium 题目链接 给定一个字符串数组,将字母异位词组合在一起。字母异位词指字母相同,但排列不同的字符串。 示例: 输入: [“eat”, “tea”, ...
  • 对于map的遍历 for(auto &[key,value] : map) 详见lc.677 8.边界易出错 如果一个二维数组的n,m都可以取0,那么不能定义长度用 int n = a.size(); int m =a[0].size(); 9.map.count(n) unordered_map::count()是C++...
  • 很多朋友后台留言:刷题陷入瓶颈,做了500多道题还拿不到offer。应大家的要求,今天分享一份北大算法大神令狐冲的《LeetCode刷题模板》,包含了算法和数据结构的代码模板,可作为刷题的...
  • 70/300 LRU缓存机制   运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作: 获取数据 get 和 写入数据 put 。  ...获取数据 get(key) - 如果密钥 (key) 存在于缓存...
  • 可以看出来性能并不算好,还有用哈希表的办法,但是比较麻烦就没写,总体来说没想到O(n)的算法。 看solution发现有一种叫做Boyer-Moore Voting Algorithm的多数决算法,只需要遍历一遍,方法是设置一个count一个...
  • 斐波那契数列问题是经典的动态规划问题,但是看到了更有趣的解法,这里不提出普通的循环或者递归的算法了,先从子底而上的动态规划算法开始: Success Runtime: 0 ms, faster than 100.00% of C++ online...
  • 179. Largest Number Given a list of non-negative integers nums, arrange them such that they form the largest number. Note: The result may be very large, so you need to return a string instead of an ...
  • 其实没什么算法知识,我写的代码比较枯燥。不过我找到一个很简洁的代码,也很有趣给大家参考一下: Success Runtime: 4 ms, faster than 94.20% of C++ online submissions for Integer to Roman. ...
  • 也是一道简单的题不涉及什么算法但是要注意int数据的溢出问题 结果: Success Runtime: 4 ms, faster than 100.00% of C++ online submissions for Reverse Integer. Memory Usage: 8 MB, less ...
  • 原题: Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up...之后又试了试讨论区的所谓100%算法基本上都是靠运气的那种,拿来就是20ms,想了想不找好算法了。
  • 实现获取下一个排列的函数,算法需要将给定数字序列重新排列成字典序中下一个更大的排列。   如果不存在下一个更大的排列,则将数字重新排列成最小的排列(即升序排列)。   必须原地修改,只允许使用额外...
  • 心里翻了一个白眼,就是让我不用原地算法,我也不会啊。。 class Solution : def rotate_01 ( self , nums : List [ int ] , k : int ) - > None : """ Do not return anything, modify ...
  • 43/300 最大子序和   ...给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。...如果你已经实现复杂度为 O(n) 的解法,尝试使用更为精妙的分...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 507
精华内容 202
关键字:

lc算法刷题