找回密码
 立即注册
  • QQ空间
  • 回复
  • 收藏

算法基础知识 目录

admin 2019-6-13 05:06 112人围观 C++相关

前言

本课程是由《CS算法面试系列》直播课转化而来。主要包含以下内容:

1,实现基本数据结构(面试常考,而做题没有)

2,Java 源码分析,Java 基础补充(面试常考,而做题没有)

3,在做题中的应用(Leetcode 题目)

4,Java 基础(零基础起步,一天搞定)

5,做题技巧,做题模版

虽说是“基础知识”,但讲的内容都是面试曾经考过的内容。

并不是像学校里以讲知识为主,而是最贴近于面试,以面试为导向,中间穿插了大量面试出现的基础知识的问题。

也同样适用于零基础,转专业的同学,在《前提章 Java 基础知识》额外为大家从头讲 Java,以最快速度,在最短时间内让大家快速上手 Java 能做题。同样,真正的做到从零开始。

希望可以与大家一起进步。

谢谢大家!

Edward Shi

试看链接:https://www.youtube.com/playlist?list=PLvyIyKZVcfAkX03_vs5Rz5TSvghy3fdqY

算法基础知识(上)(20小时左右)

第一章课程介绍


1-1 课程介绍

CS 算法面试系列(直播课)转化过来的全新课程

1-2 如何最快速的刷题

个人总结的最快速的刷题方法

1-3 刷题常见问题

刷题学生经常问的7个问题

1-4 Java 编程风格

这个是我之前录的视频,主要是 Google Java 编程规范

出处:http://hawstein.com/posts/google-java-style.html


第二章算法,时间 & 空间复杂度

介绍算法和数据结构,而时间,空间复杂度,是算法面试中必考的问题,一旦打错必挂,所以必须要打好基础。另外,本章告诉大家 Java 一共有多少中可以调用的数据结构,我们要学习多少种数据结构。

数据结构,并不是漫无边际的。


2-1 算法和数据结构

算法特性,数据结构特性,Java 框架基本接口和实现

2-2 时间复杂度

最好/最坏/平均 时间复杂度,Leetcode 中的时间复杂度

2-3 空间复杂度

常见空间复杂度,三种空间复杂度


第三章算法必备基础

讲解具体数据结构前的必备基础知识,再次探讨时间/空间复杂度,了解一些通用的基本算法:递归算法,分治法。

很多童鞋经常搞不清递归的时间/空间复杂度,在这里告诉了大家怎么一次解决这个问题,让大家可以一看就知道递归的时间和空间复杂度。


3-1 数据量级

O(logn), O(sqrt(n)), O(n), O(nlogn) 等对应数据量大小

3-2 递归

斐波那契数列,递归三步骤,

3-3 递归的时间和空间复杂度

递归树,怎么一次看清递归时间/空间复杂度

3-4 重复调用怎么办

万能 follow up:函数重复调用时间复杂度过高怎么办

3-5 迭代

算法中的迭代

3-6 分治法

分治策略,分治法三步骤,合并排序

3-7 特殊的时间和空间复杂度

二分查找时间复杂度,数学题中的幂,开放等特殊复杂度


第四章数组

数组这个结构很多人不是非常在意,但在面试之中,一旦考察基础知识,最常问的问题就是“ArrayList 和 LinkedList”到底有什么区别。这就需要我们对于 Java 源码有足够的了解,甚至有的让当场自己写一个动态数组,那么自己如何实现动态数组呢?这一章都给了解答。

还有一些面试中经常考察的概念:均摊时间复杂度,到底是怎么一回事,和平均时间复杂度的区别呢?这些都是面试中经常出现,我们需要掌握的。


4-1 数组介绍

一维,二维数组,数组分析

4-2 实现数组 - 基本方法

实现构造函数,isEmpty() 等

4-3 实现数组 - 增加

实现 add() 两种方法

4-4 实现数组 - 查找

实现 contains 方法

4-5 实现数组 - 修改

实现 get set 方法

4-6 实现数组 - 删除

实现 remove 两种方法

4-7 实现数组 - 优化和测试

如何扩容 resize,打印已有数组

4-8 数组的时间复杂度

分析数组各个部分时间复杂度

4-9 数组动态化 + Lazy 思想

Lazy 思想介绍,铺垫 Segment Tree

4-10 均摊时间 VS 平均时间

介绍均摊时间复杂度,和平均时间复杂度区别

4-11 Java 源码分析 - ArrayList

分析 Java ArrayList 源码构造函数

4-12 Java 源码分析 - add()

分析 Java ArrayList 源码 add 方法

4-13 Java 源码分析 - contains & get & set

分析 Java ArrayList 源码 contains & get & set 方法

4-14 Java 源码分析 - remove()

分析 Java ArrayList 源码 remove 方法

4-15 Leetcode 相关题目

根据已有知识,做 Leetcode 题目


第五章基于比较的排序算法

在这一章中,我会介绍给大家我们常见的“基于比较的排序算法”,千万不要小瞧我们的排序算法!因为在算法题中,排序算法的思想在很多题目中都有体现,但只是童鞋们的基础不够好不知道而已,很多算法都是根据排序算法推衍而来的。

而且在这一章中,我会给大家介绍一些 Java 的基础,如何进行比较,Comparable 和 Comparator 的用法,这是在算法题中经常出现,必会的。

最后说一句,千万不要小瞧排序算法!


5-1 排序算法

排序算法介绍

5-2 冒泡排序

冒泡排序代码实现

5-3 排序算法的稳定性

什么是排序算法的稳定性

5-4 类中比较 Comparable 和 Comparator

如何写自定义比较函数,做题中常用

5-5 Leetcode 中的冒泡排序

Leetcode 中算法题的冒泡排序

5-6 选择排序

选择排序代码实现

5-7 Leetcode 中的选择排序

Leetcode 中算法题的选择排序

5-8 插入排序

插入排序代码实现

5-9 插入排序的二分优化

插入排序如何二分优化,代码实现

5-10 Leetcode 中的插入排序

Leetcode 中算法题的选择排序

5-11 合并排序

合并排序代码实现

5-12 Leetcode 中的合并排序

Leetcode 中算法题的合并排序

5-13 快速排序

快速排序代码实现

5-14 Leetcode 中的快速排序

Leetcode 中算法题的快速排序,什么是快速选择


第六章非比较的排序算法和 Java 数组相关源码

这一章会介绍“非比较的排序算法”,对比“基于比较的排序算法”,非比较在算法题中考察的更多。并在此章进行了排序算法的总结,和对于 Java 源码 Arrays 的分析,在做题中如何应用,如何在 Arrays.sort 中重写比较函数,这也是在面试中经常考察的要点。


6-1 计数排序

计数排序代码实现

6-2 Leetcode 中的计数排序

Leetcode 中算法题的计数排序

6-3 桶排序

桶排序代码实现

6-4 Leetcode 中的桶排序

Leetcode 中算法题的桶排序

6-5 排序算法总结和荷兰国旗问题

所有排序算法总结,介绍荷兰国旗问题

6-6 Java 源码 Collections 集合

分析 Java Collections 源码,查看主要方法

6-7 Java 源码 Arrays 方法

分析 Java Arrays 源码,查看主要方法

6-8 Java 源码 Arrays.sort 分析

分析 Java Arrays.sort 源码,看看源码的排序怎么写

6-9 Arrays.sort 比较

Arrays.sort 加入 Comparator 怎么写


第七章链表

在这一章中,详细介绍了链表这种数据结构,如何自己去实现一个链表的数据结构,这也是在面试中常常问到的点。而且对比了 ArrayList 和 LinkedList。

讲解了做题中一些初学者经常踩的坑,为什么 List<Integer> list = new LinkedList<>() 和 LinkedList<Integer> list = new LinkedList<>() 这两种写法到底有什么样的区别。


7-1 什么是链表

链表的结构,优缺点

7-2 链表的插入

实现链表的 add 方法

7-3 链表的删除

实现链表的 remove 方法

7-4 链表的更改

实现链表的 set 方法

7-5 链表的查找

实现链表的 get 方法

7-6 范型的更改

更改为 <E> 范型的形式,适应任何类型

7-7 时间复杂度和测试

探讨链表的各种操作的时间复杂度

7-8 静态,双向,循环,双向循环链表

介绍静态链表,双向链表,循环链表,双向循环链表

7-9 Java 源码 LinkedList - add方法

Java 源码 LinkedList是怎么实现的,构造函数和add方法

7-10 Java 源码 LinkedList - remove方法

Java 源码 LinkedList是怎么实现的,remove 方法

7-11 Java 源码 LinkedList - get 和 set 方法

Java 源码 LinkedList是怎么实现的,get 和 set 方法

7-12 Java 源码接口 List

Java 源码 List 接口,我们自己也可以实现一个 List 接口

7-13 ArrayList VS LinkedList

ArrayList 和 LinkedList 相同,不同点对比


第八章栈

栈主要两种实现:顺序栈,链式栈。并且一定要理解栈和递归的关系,并在做题中如何把递归转化为迭代,这都是在做题中经常遇到的操作。


8-1 栈的介绍

栈的结构和应用

8-2 顺序栈的简单实现

用动态数组去实现栈结构

8-3 顺序栈的具体实现

用动态数组去实现栈结构具体代码实现

8-4 链式栈的具体实现

用链表去实现栈

8-5 Java 源码分析 Stack 和 Vector VS ArrayList

分析 Stack 源码,和 Vector 源码,并将 Vector 和 ArrayList 源码进行比较

8-6 栈和递归

栈和递归的关系

8-7 递归转化迭代

如果把递归转化为迭代

8-8 Leetcode 中的 Stack

Leetcode 中的 Stack 题目

8-9 题型讲解

此章对应的题型讲解


第九章队列

队列的应用在算法题中算是比较多的,但大多数都是对于队列的应用较多。在面试中,也经常会考如何自己手动实现一个队列,例如 Leetcode 的题目:

622,Design Circular Queue

641,Design Circular Deque

注意,队列并不是简单的 Queue,Deque这种双向队列我们也一定要会,学完这一章,在自我实现这一方面,会没有任何的问题。


9-1 什么是队列

队列的结构

9-2 Deque Queue Stack

Java 中的 Deque Queue Stack 的关系

9-3 Java 源码分析 Queue Deque

Java 源码 Queue Deque 是怎么继承的

9-4 链表实现队列代码实现

用链表实现队列代码

9-5 数组实现队列

用数组实现队列代码

9-6 循环队列介绍

什么是循环队列

9-7 循环队列的代码实现

循环队列的代码实现

9-8 Java 源码 ArrayDeque 分析

分析 ArrayDeque 源码,对比自己写的源码

9-9 Leetcode 中的 Queue 和 Stack

Leetcode 中的 Queue 的题目

9-10 队列的应用

队列的应用在哪里


前提章 Java 基础知识

Java 基础知识,这一章本不在教学计划内,但发现大多数学生 Java 基础实在不牢固,如果学一次 Java 正常时长的课,时间成本太大,所以用一章的内容,针对面试,给大家介绍 Java,在最短时间内,最快的理解上手,达到做题水平。


0-1 Java 和 Java 开发工具介绍

Java JDK 等概念,Intellij 介绍

0-2 Java 常用概念

变量等名称

0-3 Java 流程控制

for while if else 等语句

0-4 Java 运算符

+ - * / %

0-5 Java 的数组

数组初始化,长度,遍历

0-6 Java 的函数

函数参数,返回值等介绍

0-7 值传递和引用传递

面试重点,做题重点知识

0-8 面向对象和构造函数

对象,类的关系,构造函数

0-9 Java 三大特性:封装

怎样实现封装

0-10 Java 三大特性:继承

Java 的继承关系

0-11 重写和访问修饰符

函数 Override,修饰符访问权限

0-12 final 和填坑

Object 类,final 等作用

0-13 Java 三大特性:多态

向上转型,向下转型

0-14 接口

接口,1.8接口

0-15 抽象和内部类

抽象和接口区别,什么是内部类

0-16 异常介绍

异常的分类

0-17 异常处理 - try catch finally

try catch finally的用法

0-18 异常处理 throws throw

throws throw 的用法

0-19 自定义异常

如何自定义异常

0-20 结束(范型和 IDE Debug)

总结


算法基础知识(下)(18小时左右)

第一章课程介绍


1-1 课程介绍


第二章散列表基础知识


2-1 HashTable HashMap HashSet 简介

2-2 直接寻址表和散列表

2-3 散列函数

2-4 链接法

2-5 碰撞过多怎么办

2-6 开放地址法

2-7 再哈希法和小结


第三章散列表代码实现


3-1 hashCode 和 equals

3-2 链接法代码

3-3 开放定址法代码实现

3-4 HashTable 源码分析

3-5 HashMap 源码分析

3-6 HashSet 源码分析

3-7 LinkedHashMap 简介

3-8 Leetcode 实战练习题

3-9 Bloom Filter 布隆过滤器

3-10 Bloom Filter 布隆过滤器代码实现

3-11 做题须知


第四章堆


4-1 堆的介绍

4-2 保持堆的性质

4-3 其他函数的实现

4-4 Heapify 过程

4-5 堆排序

4-6 排序算法时间下界

4-7 PriorityQueue 源码分析

4-8 索引堆

4-9 索引堆应用


第五章图


5-1 图

5-2 图的表示

5-3 深度优先搜索原理

5-4 DFS 递归代码实现1

5-5 DFS 递归代码实现2

5-6 迭代代码实现

5-7 DFS 复杂度分析

5-8 广度优先搜索原理

5-9 BFS 代码实现

5-10 代码实现和 BFS 复杂度分析

5-11 遍历应用和实战演练


第六章拓扑排序


6-1 拓扑排序

6-2 DFS 实现拓扑排序

6-3 DFS 拓扑排序代码实现

6-4 BFS 实现拓扑排序

6-5 BFS 拓扑排序代码实现

6-6 拓扑排序复杂度


第七章并查集


7-1 Union Find 简介

7-2 Quick Find 实现

7-3 Quick Union 实现

7-4 Union Find 两种优化方式

7-5 Union Find 总结


第八章最小生成树


8-1 最小生成树介绍

8-2 Prim 算法介绍

8-3 边,图代码实现

8-4 Prim 代码实现

8-5 Kruskal 算法介绍

8-6 Kruskal 代码实现


第九章最短路径


9-1 最短路径介绍

9-2 Dijkstra 原理

9-3 Dijkstra 算法实现1

9-4 Dijkstra 算法实现2

9-5 Dijkstra 时间复杂度

9-6 Bellman-Ford 算法原理

9-7 Bellman-Ford 代码实现

9-8 Floyd-Warshall 算法介绍

9-9 图的总结


第十章树


10-1 树的概念

10-2 先序遍历

10-3 中序遍历

10-4 后序遍历

10-5 层次遍历

10-6 二叉树表示——链表形式

10-7 二叉查找树

10-8 二叉查找树的插入

10-9 二叉查找树的查询

10-10 二叉查找树的删除

10-11 补充和小结


第十一章 AVL树


11-1 AVL树

11-2 AVL树实现

11-3 AVL 的 LL 和 RR

11-4 AVL 的 LL 和 RR 代码实现

11-5 AVL 的 LR 和 RL 代码实现

11-6 AVL的删除和包含


第十二章红黑树


12-1 2-3树

12-2 2-3树与红黑树

12-3 基础代码

12-4 红黑树的加入

12-5 旋转,颜色反转颜色代码

12-6 插入代码实现

12-7 红黑树测试和总结

12-8 Java 中的红黑树——TreeMap

12-9 TreeMap 中的特有函数


第十三章结束语


13-1 结束语


试看链接:https://www.youtube.com/playlist?list=PLvyIyKZVcfAkX03_vs5Rz5TSvghy3fdqY

网站购买链接:https://cspiration.com/AlogrithmClass


----------------------------------------------------------------------------------------------------------------------
我们尊重原创,也注重分享,文章来源于微信公众号:北美CS求职,建议关注公众号查看原文。如若侵权请联系qter@qter.org。
----------------------------------------------------------------------------------------------------------------------

鲜花

握手

雷人

路过

鸡蛋

yafeilinux和他的朋友们微信公众号二维码

微信公众号

专注于Qt嵌入式Linux开发等。扫一扫立即关注。

Qt开源社区官方QQ群二维码

QQ交流群

欢迎加入QQ群大家庭,一起讨论学习!

我有话说......