|
|
├─1、计算机基础知识" z$ C( D, B3 x0 B: L. _2 z
│ 1：算法的本质和为什么要学习算法.mp4! A/ f* J& ?: ^7 f. s
│ 2：算法基础知识_计算机中的一维坐标系和二维坐标系.mp4
│ 3：计算机基础知识_四方向向量和八方向向量.mp4
│ 4：计算机基础知识_算法复杂度的定义.mp41 S$ i4 K6 k* z; u$ B4 v( P
│ 5：计算机基础知识_什么是时间复杂度的频度.mp4$ _* H4 _) F+ `7 b6 E
│ 6：计算机基础知识_时间复杂度的定义.mp4
│ 7：计算机基础知识_时间复杂度_真题讲解.mp4% E# c1 [4 R" q0 \& v) _; {
│ 8：计算机基础知识_空间复杂度.mp4
│ 9：计算机基础知识_相关面试题_顺时针打印矩阵_思路.mp47 M% i7 O# z, M1 L+ M
│ 10：计算机基础知识_相关面试题_顺时针打印矩阵_代码.mp4% R$ q; y* `0 ~: a7 s8 t
│ 11：计算机基础知识_位运算的定义和常见的进制.mp4
│ 12：计算机基础知识_二进制与十进制.mp4* F! d2 V+ I6 i1 ?: @6 F2 L
│ 13：计算机基础知识_二进制数和十进制数的互相转化.mp43 { ^5 w( o6 f7 @. c
│ 14：计算机基础知识_通用的进制转换.mp4* K. S$ X0 i( G
│ 15：计算机基础知识_八进制及其转换.mp4
│ 16：计算机基础知识_十六进制及其转换.mp4
│ 17：位运算_位运算符和与运算.mp44 u% r3 \' s% q" t& ~0 s
│ 18：位运算_或运算.mp4% Y* ^! j7 A* q7 E2 a
│ 19：位运算_异或运算和取反运算.mp4+ z, P( Q0 u; w! Y8 t7 T
│ 20：位运算_原码.mp4- l) m! ?' { x W3 I
│ 21：位运算_反码.mp4
│ 22：补码及其求法.mp4: C4 P R" C2 g9 M
│ 23：位运算_补码的思想.mp42 T$ a# x$ C% X0 @6 [$ K( d1 z+ j
│ 24：位运算_模和同余的概念.mp46 k7 L' V1 G, p1 U5 `5 R
│ 25：位运算_补码的例子和定义.mp4
│ 26：位运算_补码溢出问题及其解决方法.mp4
│ 27：位运算_位运算的简单应用1.mp48 R9 C1 G# T! r- i1 u" S3 D
│ 28：位运算_位运算的简单应用2.mp4 S7 g; O) P; F4 l i/ e& R1 l4 {. h
│ 29：位运算_相关面试题_思路.mp4
│ 30：位运算_相关面试题_代码.mp49 h2 e/ K3 I' F: i3 o! ^( A
│ 7 y. E' J2 ^1 {% ~
├─2、数据结构
│ 1：递归的定义和应用条件.mp4! ?1 j. {3 m2 x, r3 V
│ 2：递归思想的内涵（重要！）.mp4. s' G( [+ o7 Q i
│ 3：数学归纳法理解递归.mp4) X6 ]# i- D& P- u
│ 4：递归的三个要素.mp4
│ 5：递归的两套模板.mp40 B0 J$ p- R1 P- x
│ 6：递归和循环的区别.mp44 e0 l% w- Z5 e8 ~. B) `
│ 7：递归打印1-100.mp4
│ 8：递归累加1-100.mp4
│ 9：递归_求斐波那契数列的第n项.mp4
│ 10：递归_爬楼梯问题_思路.mp4
│ 11：递归_爬楼梯问题_实现.mp4$ s) X- X$ G2 X0 {
│ 12：递归_全排列问题_思路.mp40 N- Y9 Z* y/ m1 T. ]0 E, m
│ 13：递归_全排列_代码.mp4$ e, }6 y5 I: P" ?1 A7 E
│ 14：递归_有重复数字的全排列_思路.mp4: @/ H B# E5 r8 @8 K4 y
│ 15：递归_有重复数字的全排列_代码.mp4
│ 16：数据结构_二分的本质.mp4
│ 17：数据结构_二分模板的讲解.mp4# a4 ]5 a: v& C5 R- a" I
│ 18：数据结构_二分的相关问题_求x的平方根思路.mp4
│ 19：数据结构_二分的相关问题_求x的平方根代码Java.mp4
│ 20：数据结构_var的使用和数组.mp4' f& E O% R3 h! t
│ 21：整数二分_二分定义和模板.mp49 r$ `9 O* B" `$ w5 n, |& U* {
│ 22：整数二分_二分的本质.mp4
│ 23：整数二分_二分的第二个模板.mp4$ x3 ^0 B0 m" P- q- \* O: Z
│ 24：整数二分_为什么第二个模板要加1.mp43 ?. n' `- g5 s
│ 25：整数二分_二分的第一个模板.mp4
│ 26：整数二分_面试题_求一个数的平方根_思路.mp4
│ 27：整数二分_面试题_求一个数的平方根_代码实现.mp4* P: B8 P7 h3 J. R% G& C0 K
│ 28：整数二分_为什么这道题不能用第一个模板.mp4
│ 29：数据结构_链表_动态链表的定义.mp4
│ 30：数据结构_链表_单向链表_结构体的实现.mp4* f4 J, V( H7 L ?2 b
│ 31：数据结构_链表_单向链表_结构体的实现C++.mp4
│ 32：数据结构_链表_单向链表_获取链表中某个节点的值.mp4. N* u- j. ^ m) `) k5 G" ^; |
│ 33：数据结构_链表_单向链表_在链表的头结点前添加节点.mp44 q0 ]8 n# a. @1 M6 m2 G, Q: A0 u
│ 34：数据结构_链表_单向链表_在链表的尾节点后添加节点.mp4# m1 y" E% v9 Y) P4 [
│ 35：数据结构_链表_单向链表_在链表的第index个节点前添加元素.mp4
│ 36：数据结构_链表_单向链表_删除链表的第index个节点.mp4
│ 37：数据结构_链表_单向链表_单向链表的实现.mp4
│ 38：数据结构_链表_双向链表_双链表的思想.mp4
│ 39：数据结构_链表_双向链表_双链表获取某个节点的元素.mp4
│ 40：数据结构_链表_双向链表_在链表的头节点前添加节点.mp4
│ 41：数据结构_链表_双向链表_在链表的尾节点后添加节点.mp42 x3 l% w' r0 m% J9 H% |9 @5 B
│ 42：数据结构_链表_双向链表_在第index节点前添加节点.mp4
│ 43：数据结构_链表_双向链表_删除第index个节点.mp4
│ 44：数据结构_链表_双向链表_双链表的实现.mp4
│ 45：数据结构的定义.mp40 a- O/ } o# N( w4 }
│ 46：链表_动态链表的定义_动态链表和静态链表的区别.mp4 K: _: D9 ~' ~0 k5 F# G4 |; o
│ 47：链表_单链表_单链表的定义和基本操作.mp4
│ 48：链表_单链表_初始化单链表.mp4, E5 }, p6 [4 g, O0 K9 D/ {, S
│ 49：链表_单链表_获取单链表中第index个节点.mp4
│ 50：链表_单链表_在第index个节点前添加节点.mp4
│ 51：链表_单链表_删除第index个节点.mp4* e3 E/ K' t- f3 O+ l
│ 52：链表_单链表_实现.mp4) }1 K" Y; u; G9 O
│ 53：链表_双链表_双链表的定义.mp43 C4 h( ^ A8 f0 H8 x8 n1 s+ Z
│ 54：链表_双链表_初始化双链表.mp4
│ 55：链表_双链表_获取双链表第index个节点.mp4: @8 _0 I- i! `0 s& A2 C% K6 t
│ 56：链表_双链表_添加节点.mp4; u6 X! a, k$ \! I- D. i
│ 57：双链表_删除第index个节点.mp4
│ 58：链表_双链表_实现.mp43 R f8 `, z4 F; L, d
│ 59：数据结构_栈的定义.mp4
│ 60：数据结构_单调栈的概念.mp48 p3 N6 n3 X+ s& E9 ~
│ 61：数据结构_单调栈案例_接雨水.mp44 D1 h9 q& B0 A) N' }, H1 g" d: t
│ 62：数据结构_单调栈_接雨水的思路.mp40 }9 T: W" D2 m1 Y; P2 e
│ 63：数据结构_单调栈_接雨水的代码实现.mp4
│ 64：数据结构_队列_队列的定义.mp4
│ 65：数据结构_队列_模拟队列.mp43 J! N' d- Q1 _* `% t
│ 66：数据结构_队列_单调队列_滑动窗口.mp4
│ 67：数据结构_队列_单调队列_滑动窗口思路.mp4
│ 68：数据结构_队列_单调队列_滑动窗口代码实现.mp4( Y% r! F; C) E1 x) X: f/ \9 C
│ 69：数据结构_队列_用栈实现队列思路.mp4, ^. H, \0 w/ b( \7 a0 K; m
│ 70：数据结构_用栈实现队列代码实现.mp42 \! K! A' `8 Q
│ 71：数据结构_用队列实现栈思路.mp4% b$ M1 n B- J2 u' N
│ 72：数据结构_用队列实现栈代码.mp4/ K4 j- ?1 _/ H' [1 A5 g l
│ 73：栈_栈的定义.mp4; Q6 D6 ~# ]3 c! {' x1 L( L, w$ a5 I
│ 74：栈_栈的基本操作.mp4
│ 75：栈_实现.mp4% V, C L, I& }1 q+ w" O/ A8 P
│ 76：队列_队列的定义和基本操作.mp41 Y/ Y J. a6 Z; P q
│ 77：队列_实现.mp4
│ 78：双端队列_定义.mp4
│ 79：双端队列_实现.mp4' J) O! Y' e. J! ]( k+ P- `
│ 80：树的介绍.mp4' A5 w; W0 D2 s+ G" t( S
│ 81：树的定义.mp4
│ 82：树的递归定义.mp49 X3 v# k, W9 _/ y) [% K/ T3 `
│ 83：树的学术名词.mp41 h, l e8 q- M/ o ^6 Y( a% D$ r1 l
│ 84：树的种类.mp47 P* _( C& i6 S4 B5 U5 s) m
│ 85：二叉树的遍历_定义.mp4
│ 86：二叉树的前序遍历_递归_思路 + 代码（C++）.mp44 ^/ r4 W3 t0 Y. ^: `( f
│ 87：二叉树的中序遍历_递归_思路 + 代码（C++）.mp4
│ 88：二叉树的后序遍历_递归_思路 + 代码（C++）.mp41 U8 C, g: A) k& d
│ 89：二叉树前序遍历_迭代思路.mp4
│ 90：二叉树的前序遍历_迭代版本的模拟过程.mp4
│ 91：二叉树前序遍历_迭代_代码（C++）.mp43 x4 q2 w# j+ n1 ]7 v! i/ h
│ 92：二叉树的中序遍历_迭代_思路.mp4
│ 93：二叉树的中序遍历_迭代_代码（C++）.mp46 [$ N) Y) o8 w* e" ?2 H8 x
│ 94：二叉树的后续遍历_迭代_思路_代码（C++）.mp4
│ 95：二叉树遍历的空间复杂度纠正.mp4
│ 96：树形数据结构_树的定义.mp4$ p( [& n. I' p+ E) V" f. j
│ 97：树形数据结构_树的递归定义和名词.mp40 K7 b8 U5 M7 a) B7 O
│ 98：树形数据结构_树的种类.mp4
│ 99：树形数据结构.mp4$ ^9 j1 W( F0 \) y5 Y% l
│ 100：树形数据结构_二叉树的基本形态.mp4% B+ Y, t7 V% a x6 ]
│ 101：树形数据结构_二叉树的性质.mp4' [0 O+ Z! L! r' l, E
│ 102：树形数据结构_树的遍历定义.mp44 v7 |6 s. J E& g) I
│ 103：树形数据结构_树的深度优先搜索定义.mp4
│ 104：树形数据结构_树的宽度优先搜索定义.mp4
│ 105：树形数据结构_二叉树的前序遍历递归思路.mp4% V5 w8 L" T, [1 e* D
│ 106：树型数据结构_二叉树的前序遍历递归代码.mp4
│ 107：树型数据结构_二叉树的前序遍历迭代思路.mp4& u; s; _ p$ V
│ 108：树型数据结构_二叉树的前序遍历_迭代模拟过程.mp4
│ 109：树形数据结构_二叉树的前序遍历迭代代码.mp46 x; t% ~8 C/ @4 N: X7 {
│ 110：树形数据结构_二叉树的前中后序遍历时间复杂度和空间复杂度分析.mp4
│ 111：树形数据结构_二叉树的中序遍历递归版.mp4
│ 112：树形数据结构_二叉树的中序遍历模拟.mp4
│ 113：树型数据结构_二叉树的中序遍历迭代代码java.mp4
│ 114：树形数据结构_二叉树的后序遍历_递归版java.mp4
│ 115：树型数据结构_二叉树的后序遍历_迭代思路.mp4* G0 v6 R+ |3 X( j% C) z3 s2 [
│ 116：树型数据结构_二叉树的后序遍历_迭代代码.mp4
│ 117：树形数据结构_二叉树的层序遍历介绍.mp4) I2 J2 D4 ^3 O) V6 v6 i
│ 118：树形数据结构_二叉树的层序遍历思路.mp4/ n; {- {$ z7 D1 K% z2 e6 O. ^
│ 119：树形数据结构_二叉树的层序遍历代码java.mp41 W$ t! M' i& t- `7 Z' P! h- X! \
│ 120：树型数据结构_二叉树的垂序遍历介绍.mp4' c3 Z; Z6 H# s( X! Q/ P
│ 121：树型数据结构_二叉树的垂序遍历思路.mp4
│ 122：树型数据结构_二叉树的垂序遍历代码java.mp4- d, d# A! j8 C" R$ }
│ 123：树型数据结构_N叉树的遍历特点.mp4
│ 124：树形数据结构_N叉树的前序遍历介绍.mp4( I( G- n5 M i, E+ ?% e8 D1 s
│ 125：树形数据结构_N叉树的前序遍历_递归代码java.mp4- Q% w' J% K3 ]/ \2 z0 R
│ 126：树形数据结构_N叉树的前序遍历迭代思路.mp4
│ 127：树形数据结构_N叉树的前序遍历迭代代码.mp49 L5 ~7 W7 J$ D# R
│ 128：树形数据结构_N叉树的后序遍历思路.mp4
│ 129：树形数据结构_N叉树的后序遍历_递归代码java.mp4; J Z9 Z2 D5 o/ Z
│ 130：树形数据结构_N叉树的后序遍历_迭代代码java.mp4; \' M' A% L5 |5 g2 h
│ 131：树形数据结构_N叉树的层序遍历思路.mp4
│ 132：树型数据结构_N叉树的层序遍历代码java.mp4
│ 133：树型数据结构_Trie树的定义.mp4- m o- q% H& X$ ?+ g- K2 S( n
│ 134：树形数据结构_Trie的代码实现java.mp47 @. c7 L5 P' W0 v8 Z
│ 135：树的介绍.mp4
│ 136：树的定义.mp48 @, e/ I" F. g5 h
│ 137：树的递归定义.mp4! X$ Y. [) Y/ N( e
│ 138：树的学术名词.mp4
│ 139：树的种类.mp4
│ 140：二叉树的遍历_定义.mp4. g% f3 [1 o" R6 G& t5 Z
│ 141：二叉树的前序遍历_递归_思路 + 代码（python）.mp4( y- D) m) ^7 G& z0 K$ R# l
│ 142：二叉树的中序遍历_递归_思路 + 代码（python）.mp4
│ 143：二叉树的后序遍历_递归_思路 + 代码（python）.mp4
│ 144：二叉树前序遍历_迭代_代码（python）.mp4
│ 145：二叉树的中序遍历_迭代_思路.mp40 r" e% Y/ b' N2 T
│ 146：二叉树的中序遍历_迭代_代码（python）.mp4! |+ k2 \( T% C; W, }3 P) k
│ 147：二叉树的后续遍历_迭代_思路_代码（python）.mp4
│ 148：二叉树的层序遍历_思路.mp4
│ 149：二叉树的层序遍历_代码（python）.mp4
│ 150：二叉树遍历的空间复杂度纠正.mp4
│ 151：哈希表_定义.mp4% d: M8 ?+ l8 m) }8 I9 h8 M! ?
│ 152：哈希表_基本概念.mp4
│ 153：哈希表_散列函数.mp4
│ 154：哈希表_处理哈希冲突常用方法.mp4
│ 155：哈希表_实现hashset思路.mp42 p% ^( b2 M4 o+ X: @* ^
│ 156：哈希表_hashset实现.mp4
│ 157：哈希表_hashmap_思路.mp4
│ 158：哈希表_hashmap_实现.mp4) |( ]" C* `. _# v. e& h u2 J! L
│ ( J4 ^ d' F! x `
├─3、排序算法* u. a' H+ M e
│ 1：介绍十大经典排序算法.mp4
│ 2：排序的定义.mp43 P+ N$ T. F# U- l4 h6 [
│ 3：十大排序的分类和排序算法的稳定性.mp4+ \/ J( q( T( i( q# k/ J' d; f
│ 4：冒泡排序的思路.mp4
│ 5：冒泡排序_实现（C++）.mp4
│ 6：选择排序_思路.mp4
│ 7：选择排序_实现（C++）.mp4
│ 8：插入排序_思路.mp4" p' n4 _# ]5 Q2 a+ x: @
│ 9：插入排序_代码实现（C++）.mp4' ~1 B+ X, D5 b
│ 10：桶排序_思路.mp4+ k/ D+ n6 k+ C$ B5 J: [' j1 _
│ 11：桶排序代码_实现（C++）.mp4; j) O: J Z5 u
│ 12：基数排序_思路.mp41 J) J$ v8 ^' H! l' W
│ 13：基数排序_实现（C++）.mp4
│ 14：快速排序_思路.mp4/ r% f1 B6 q! f4 ~$ R
│ 15：快速排序_实现（C++）.mp4: |' p1 J# n2 _
│ 16：归并排序_思路.mp4
│ 17：归并排序_实现（C++）.mp4: O i% Q9 z, x' a! W, k8 g
│ 18：堆排序_什么是数据结构堆.mp4( ~6 f0 M2 b( L9 }8 L2 [
│ 19：堆排序_堆的基本知识和操作初识.mp4
│ 20：堆排序_堆的核心操作_down操作和up操作_实现步骤.mp4
│ 21：堆排序_堆的其余操作_实现步骤.mp4
│ 22：堆排序_堆排序的思路和用到的操作.mp4. i3 f* c \' K: J7 e
│ 23：堆排序_实现（C++）.mp4* `; M U( H. I+ v% T9 x- p5 m
│ 24：基础算法大纲.mp4- H( f$ M9 ?! H/ K
│ 25：排序算法_什么是排序算法.mp4
│ 26：排序算法_算法的稳定性是什么.mp48 S% ^7 W$ l9 y( \. a+ A8 |
│ 27：排序算法_排序稳定性的好处.mp4
│ 28：排序算法_各排序的稳定性和时间空间复杂度.mp4
│ 29：排序算法_快速排序思路.mp4
│ 30：排序算法_快速排序代码实现（Java）.mp45 ^0 N$ W& _" R/ X S. c# z3 `
│ 31：排序算法_快速排序代码的一点补充（Java）.mp42 K8 _5 k( e; o- j3 k/ ^
│ 32：排序算法_快速排序稳定性分析.mp4
│ 33：排序算法_归并排序定义.mp4
│ 34：排序算法_归并排序的思路.mp4* ^& K u m0 N/ k$ o! t
│ 35：排序算法_归并排序代码实现（Java）.mp4
│ 36：排序算法_归并排序稳定性分析.mp41 M7 S4 z. i3 P k4 {- J
│ 37：排序算法_堆排序是什么.mp4 F6 r3 A; J. Z! X: Z/ G' W2 q+ w( J
│ 38：排序算法_堆的定义和小根堆的定义.mp4& V3 W. n" B6 T. x4 b0 j8 W+ b' T
│ 39：排序算法_小根堆的下移操作（down操作）.mp4$ C8 w& q: A2 _
│ 40：排序算法_小根堆的上移操作（up操作）.mp4" M( d u( X$ c5 z
│ 41：排序算法_小根堆的五个操作的实现思路.mp4
│ 42：排序算法_堆排序的基本思路.mp4
│ 43：排序算法_堆排序的建堆方式和时间复杂度证明.mp4! z: w2 c9 S8 f( _
│ 44：排序算法_down操作实现思路和时间复杂度分析.mp4
│ 45：排序算法_堆排序_堆排序代码实现（java）.mp4
│ 46：排序算法_堆排序_稳定性分析.mp4, O6 o* W$ k8 c5 i* u5 [
│ 47：介绍十大经典排序算法.mp4+ a" [4 J/ g5 `
│ 48：排序的定义.mp4
│ 49：十大排序的分类和排序算法的稳定性.mp4. M$ {! _6 t2 ~3 @
│ 50：冒泡排序的思路.mp45 o9 p G/ N5 i' r6 R
│ 51：冒泡排序_实现（python）.mp48 v7 K u; f& j) M. T5 }
│ 52：选择排序_思路.mp45 e$ z0 A0 }1 i/ a1 X$ R
│ 53：选择排序_实现（python）.mp4
│ 54：插入排序_思路.mp42 t. z6 w- a" \1 j- s
│ 55：插入排序_代码实现（python）.mp4
│ 56：希尔排序_思路.mp4
│ 57：希尔排序_实现（python）.mp4
│ 58：计数排序_思路.mp4
│ 59：计数排序_实现（python）.mp48 G' B b! Q1 ?2 i* Q
│ 60：快速排序_思路.mp42 o6 m A. l* c# `" e6 p5 A
│ 61：快速排序_实现（Python）.mp4; z7 |7 B5 d( `1 A% [
│ 62：归并排序_思路.mp4& t! b' z$ c! Q* v7 d( P
│ 63：归并排序_代码（python）.mp4+ _6 W' |; U/ L
│ 64：堆排序_什么是数据结构堆.mp4- T) J, I8 C: `4 \1 E! ~
│ 65：堆排序_堆的基本知识和操作初识.mp4/ h' [8 i4 F" k/ |) @, f
│ 66：堆排序_堆的核心操作_down操作和up操作_实现步骤.mp4
│ 67：堆排序_堆的其余操作_实现步骤.mp46 D2 x9 ^" U; _- J7 z
│ 68：堆排序_堆排序的思路和用到的操作.mp4
│ 69：堆排序_实现（python）.mp4
│
├─4、前缀和与差分
│ 1：讲算法前的一些话（一定要听）.mp4' d: h F0 V4 e1 p) `; J8 N
│ 2：前缀和算法_一维前缀和的定义和实现思路.mp4# c$ h6 ~" Z, h2 I
│ 3：前缀和算法_一维前缀和模板_代码实现（C++）.mp4- k2 J N; F# Y, O$ }
│ 4：前缀和算法_一维前缀和面试题_和为k的子数组思路.mp4* w O$ z2 ]5 H! |1 H, K
│ 5：前缀和算法_一维前缀和面试题_和为k的子数组代码（C++）.mp4* q ~% a# ^# n! G8 p: Z; d
│ 6：前缀和算法_二位前缀和如何求子区间的和.mp4
│ 7：前缀和算法_二维前缀和求前缀和数组.mp4
│ 8：前缀和算法_二位前缀和模板问题_思路（C++）.mp4
│ 9：前缀和算法_二维前缀和_模板题代码实现（C++）.mp47 [. R$ h! a/ ^3 t* x K6 k3 C+ G
│ 10：前缀和算法_二位前缀和_代码测试（C++）.mp4
│ 11：前缀和算法_二维前缀和_实时效果反馈和总结.mp4
│ 12：讲算法前的一些话（一定要听）.mp4; L" _- f) i O5 g8 a" V
│ 13：前缀和算法_一维前缀和的定义和实现思路.mp4
│ 14：前缀和算法_一维前缀和模板（Java）.mp4
│ 15：前缀和算法_一维前缀和面试题_和为k的子数组思路.mp4) K% a- z! z. d
│ 16：前缀和算法_一维前缀和面试题_和为k的子数组代码（Java）.mp49 P' J; P) N# [+ u8 U
│ 17：前缀和算法_二位前缀和如何求子区间的和.mp4
│ 18：前缀和算法_二维前缀和求前缀和数组.mp4; `1 d7 _4 V4 W; m
│ 19：前缀和算法_二位前缀和模板问题代码（Java）.mp4
│ 20：前缀和算法_二维前缀和_实时效果反馈和总结.mp4
│ 21：差分算法_一维差分_一维差分的定义.mp49 a* S5 i0 @1 ]+ J8 _! B
│ 22：差分算法_一维差分_一维差分的实现_思路.mp4% A4 |& V% E& r" l/ T
│ 23：差分算法_差分模板实现（C++）.mp4. w; h/ O. K& c
│ 24：差分算法_差分代码测试（C++）.mp4
│ 25：差分算法_二维差分的定义.mp4
│ 26：差分算法_二维差分的核心操作思路.mp4
│ 27：差分算法_构造差分数组的新思路和旧思路.mp4. @1 g0 A7 f" g+ D
│ 28：差分算法_二维差分_差分模板题讲解（C++）.mp4
│ 29：差分算法_一维差分_一维差分的定义.mp4# S* i. L% A5 A" F' K
│ 30：差分算法_一维差分_一维差分的实现.mp4& w( t' I6 v3 J; B; x/ `
│ 31：差分算法_一维差分模板问题实现（Java）.mp4
│ 32：差分算法_二维差分的定义.mp42 M Z: ] {# `; \
│ 33：差分算法_二维差分的核心操作思路.mp4
│ 34：差分算法_构造差分数组的新思路和旧思路.mp4
│ 35：差分算法_二维差分模板题代码实现（Java）.mp4
│ 36：差分算法_二为差分模板题构造差分数组的另一种方法代码实现（Java）.mp4
│
├─5、并查集算法( Z6 m( e9 O9 K1 {; \9 n8 f
│ 1：并查集算法_什么是并查集和作用.mp4
│ 2：并查集算法_为什么暴力合并会导致时间和空间过高.mp4
│ 3：并查集算法_并查集的初始化.mp4
│ 4：并查集算法_并查集的朴素查找操作.mp4
│ 5：并查集算法_并查集的合并操作.mp45 p' X6 X2 X+ B8 O' f8 _8 A) @
│ 6：并查集算法_路径压缩-查找算法的优化.mp40 i; |, ?. I& X* t
│ 7：并查集算法效果反馈.mp40 \8 X* d& j1 L& W: e2 c8 ~
│ 8：并查集算法题目理解.mp4
│ 9：并查集算法_并查集题目代码实现（Java）.mp43 u+ z6 t/ _8 Z- J. I: G
│
├─6、高精度算法（大数加减乘除）3 a6 u5 |. Y4 s; |3 x- x3 f' I! Z
│ 1：高精度算法（大数算法）_什么是高精度算法.mp4
│ 2：高精度算法_高精度加法的思路.mp4: P; G8 j8 t/ w7 Q
│ 3：高精度算法_高精度加法课堂反馈.mp45 g! I, `. D! }
│ 4：高精度算法_高精度加法实现1（C++）.mp4( B/ D& h6 x( X! }4 Y1 C0 J
│ 5：高精度算法_高精度加法_代码实现2（C++）.mp4
│ 6：高精度加法_大数加法代码测试（C++）.mp4
│ 7：高精度算法_高精度减法的第一个操作_比较两数大小的思路.mp41 r$ F( J" V* q
│ 8：高精度算法_高精度减法的第二个操作_减法实现和特殊情况.mp45 ]! X) m, E' U
│ 9：高精度算法_高精度减法_代码实现1（C++）.mp4% W. M9 C3 ~8 p# E
│ 10：高精度算法_高精度减法_代码实现2（C++）.mp4- L' @$ X8 Y8 z, L5 t7 V' v
│ 11：高精度算法_高精度减法_测试（C++）.mp43 } O5 U6 w% J: h) I
│ 12：高精度算法_高精度减法_测试（C++）.mp42 k( w" T( x! @, L% T8 X
│ 13：高精度算法_高精度乘法_高精度乘法思路1.mp41 g: m ^0 P N% ]/ g6 n+ P5 U
│ 14：高精度算法_高精度乘法_高精度乘法思路2.mp43 z" Y+ u/ H3 _9 [+ ^# S& ?) f6 ~
│ 15：高精度算法_高精度乘法_代码实现（C++）.mp4
│ 16：高精度算法_高精度乘法_测试（C++）.mp4/ i3 Q4 D4 s4 `, @
│ 17：高精度算法_高精度除法的思路和核心代码公式.mp4
│ 18：高精度算法_高精度除法_代码实现（C++）.mp4' B+ n* m- s9 t3 [
│ 19：高精度算法_高精度除法_测试（C++）.mp4 G+ s. T2 F0 R: \* Z
│ 20：高精度算法（大数算法）_什么是高精度算法.mp4
│ 21：高精度算法_高精度加法的思路.mp41 W" r% m" `' d. G& e; {' N
│ 22：高精度算法_高精度加法课堂反馈.mp4- ` Y, j* d$ o- B, C# {3 {) K
│ 23：高精度算法_高精度加法代码实现（Java）.mp4
│ 24：高精度算法_高精度加法原地修改代码实现（仅Java）.mp44 Q- I( z( ^) W( U' _
│ 25：高精度算法_高精度减法的第一个操作_比较两数大小的思路.mp4
│ 26：高精度算法_高精度减法的第二个操作_减法实现和特殊情况.mp4 Z8 A5 }/ a8 C" R- |) j
│ 27：高精度算法_高精度减法代码实现（Java）.mp4
│ 28：高精度算法_高精度减法原地修改代码实现（仅Java）.mp4
│ 29：高精度算法_高精度减法_高精度减法实现小数减大数代码实现（Java）.mp40 u. w" h1 H @) z" m: _
│ 30：高精度算法_高精度乘法_高精度乘法思路1.mp4! {5 b9 E. Z. {8 v
│ 31：高精度算法_高精度乘法_高精度乘法思路2.mp4, C" G) l4 f* {/ a" R" a
│ 32：高精度算法_高精度乘法代码实现（Java）.mp4
│ 33：高精度算法_高精度乘法原地修改代码实现（仅Java）.mp41 u" j. p# ^% h" Y+ v* x
│ 34：高精度算法_高精度除法的思路和核心代码公式.mp4
│ 35：高精度算法_高精度除法代码实现（Java）.mp4
│ 6 o( A6 q! k& B
├─7、图论算法基础
│ 1：图论_图论概述.mp4
│ 2：图论_有向图的定义.mp4
│ 3：图论_邻接表构建有向图思路.mp4
│ 4：图论_邻接矩阵构建有向图思路.mp4
│ 5：图论_有向图课后反馈.mp4
│ 6：图论_有向图课后反馈.mp47 `# O! K2 l- R
│ 7：图论_无向图的定义.mp4
│ 8：图论_邻接表构建无向图思路.mp4
│ 9：图论_邻接矩阵构建无向图的思路.mp4
│ 10：图论_连通图_连通图的定义.mp4
│ 11：图论_连通图_连通分量的定义.mp47 m6 b2 k: ^1 }0 X m. u" C1 j
│ 12：图论_连通图_强连通图和强连通分量.mp4/ d4 T/ I% K. J
│ 13：图论_连通图_弱连通图和单项连通图的定义.mp4; p7 V y4 b6 ~( G2 A( C
│ 14：图论_判断图是否是强连通图，弱连通图还是单项连通图思路.mp4% x, r1 }) B9 y4 H+ |2 H. f" h
│ 15：判断是否是强连通图、弱连通图还是单项连通图的代码_实现.mp4& H; Z7 @- `' W3 U1 U& S
│ 16：图论_生成树_生成树的定义.mp4
│ 17：图论_生成树_最小生成树的定义.mp4) @$ Y6 b& m1 u0 q
│ 18：图论_图论概述.mp42 ~: i8 r& H, O% Y" i/ Q
│ 19：图论_有向图的定义.mp4, z, A }* m; x; ~
│ 20：图论_邻接表构建有向图思路.mp4* s7 ?1 ^6 g+ Q3 T' v2 Q0 b
│ 21：图论_邻接矩阵构建有向图思路.mp4% x- }0 [; w; u0 n
│ 22：图论_有向图课后反馈.mp4
│ 23：图论_无向图的定义.mp4- T% _/ D0 g( H7 T$ L# Z- M
│ 24：图论_邻接表构建无向图思路.mp4: G! S# p4 l$ e8 }& `& n
│ 25：图论_邻接矩阵构建无向图的思路.mp4
│ 26：图论_连通图_连通图的定义.mp40 u# r. u9 p+ N8 W; f+ s
│ 27：图论_连通图_连通分量的定义.mp44 @3 O/ I4 S) v0 F
│ 28：图论_连通图_强连通图和强连通分量.mp42 _2 d. D1 W1 i( I; Z
│ 29：图论_连通图_弱连通图和单项连通图的定义.mp4' {: q, k7 ]$ O+ V
│ 30：图论_判断图是否是强连通图，弱连通图还是单项连通图思路.mp4
│ 31：图论_判断图是否为强连通图，弱连通图，单项连通图代码实现（Java）.mp4% a9 ?1 ~; k9 k
│ 32：图论_生成树_生成树的定义.mp4
│ 33：图论_生成树_最小生成树的定义.mp4- u! `+ M4 j0 A3 Q, f7 A- l
│ 34：图论_拓扑排序_什么是拓扑排序（拓扑序列）.mp4
│ 35：图论_拓扑排序_拓扑排序的思路.mp4
│ 36：图论_邻接表_邻接表的实现方式.mp4
│ 37：图论_数组模拟邻接表（链式前向星）.mp42 u9 M* O$ m( K# }2 Q9 ~* M
│ 38：图论_拓扑排序_数组模拟邻接表和数组模拟队列实现拓扑序列_代码实现1（C++）.mp4
│ 39：图论_拓扑排序_数组模拟邻接表和数组模拟队列实现拓扑序列_代码实现2（C++）.mp4- \7 }3 v& a7 q
│ 40：图论_拓扑排序_数组模拟邻接表和数组模拟队列实现拓扑序列_代码测试（C++）.mp4
│ 41：图论_拓扑排序_拓扑排序相关面试题_课程表思路讲解.mp43 _, F7 w$ m3 ?3 h' U2 I
│ 42：图论_拓扑排序_面试题课程表_代码实现（C++）.mp4
│ 43：图论_拓扑排序_效果反馈.mp4: z! h/ ^" ]' L: Z& W
│ 44：图论_拓扑排序_什么是拓扑排序（拓扑序列）.mp4" u! b: P4 K, a. G) s
│ 45：图论_拓扑排序_拓扑排序的思路.mp4
│ 46：图论_邻接表_邻接表的实现方式.mp45 n; w/ }# O6 `
│ 47：图论_数组模拟邻接表（链式前向星）.mp4
│ 48：图论_拓扑排序的代码实现1_用数组模拟邻接表和用数组模拟队列实现（Java）.mp41 r: Q9 a( Y. ^' k8 |9 D7 ?, z# i* i
│ 49：图论_STL，容器模拟邻接表的方式.mp4 w9 `. O% t" n0 p5 r
│ 50：图论_拓扑排序_拓扑排序的代码实现2_用容器实现邻接表的方式（Java）.mp4
│ 51：图论_拓扑排序_拓扑排序相关面试题_课程表思路讲解.mp4
│ 52：图论_拓扑排序_拓扑排序相关面试题_课程表代码实现（Java）.mp4
│ 53：图论_拓扑排序_效果反馈.mp40 P5 t; ?+ h7 P* ]
│ 7 b! }, _+ W" ]) {- R
├─8、图论算法提高
│ 1：图论_单源最短路算法_Dijkstra算法的定义.mp46 A/ ?& ^/ e ^7 Z2 t- U, n
│ 2：图论_单源最短路径算法_Dijkstra算法的思路准备过程.mp4
│ 3：图论_单源最短路径算法_Dijkstra算法的思路和步骤.mp4. G1 @# l& n( {8 o* ?
│ 4：图论_单元最短路径算法_Dijkstra算法总结.mp4' G% L1 H( f% P' P- @$ n! ]
│ 5：图论_单源最短路径算法_Dijkstra模板题讲解和思路.mp4
│ 6：图论_单元最短路径算法_Dijkstra算法模板题代码实现1（Java）.mp4" b Q, K3 E8 i" @" }
│ 7：图论_单源最短路径算法_Dijkstra算法模板题代码实现2（Java）.mp4
│ 8：图论_单源最短路径算法_Bellman Ford算法的优点.mp4
│ 9：图论_单元最短路径算法_Dijkstra算法为什么处理不了负权边的问题的案例.mp4
│ 10：图论_单源最短路径算法_Bellman Ford算法的变量定义和初始化的操作.mp4
│ 11：图论_单源最短路径算法_Bellman Ford算法_松弛操作的伪代码思路讲解。.mp4+ O1 U I' i; ^# p7 ?
│ 12：图论_单源最短路径算法_Bellman Ford算法过程_准备工作.mp4
│ 13：图论_单源最短路径算法_Bellman Ford算法_第一轮松弛操作步骤.mp4
│ 14：图论_单源最短路径算法_Bellman Ford算法过程_第二次松弛操作和最终结果.mp4
│ 15：图论_单源最短路径算法_Bellman Ford算法找负权回路的过程.mp4; k6 l G* B7 Y! @# {6 F
│ 16：图论_单源最短路径算法_Bellman Ford算法_为什么要迭代n - 1次.mp46 I4 O! U% c. X
│ 17：图论_Bellman Ford效果反馈和面试时如何考察Bellman Ford算法.mp4
│ 18：图论_单源最短路径算法_Bellman Ford算法相关问题.mp4
│ 19：图论_单源最短路径算法_Bellman Ford算法实现1（Java）.mp4
│ 20：图论_单源最短路径算法_Bellman Ford算法实现2（Java）.mp4% S# J% a$ G4 w) Q. w
│ 21：图论_单源最短路径算法_Bellman Ford算法_代码测试（Java）.mp4
│ 22：图论_单源最短路径_SPFA（Shortest Path First Algorithm）_Bellman Ford算法的优化_思路.mp4
│ 23：图论_单源最短路径算法_SPFA_BFS更新点的思路.mp4; r1 o* x* ~# N2 Y. D" a0 O! I
│ 24：图论_单源最短路径算法_SPFA_相关例题.mp4
│ 25：图论_单源最短路径算法_SPFA_全局变量的设定（Java）.mp4
│ 26：图论_单源最短路径算法_SPFA_邻接表法实现和main输入输出实现（Java）.mp4
│ 27：图论_单源最短路径算法_SPFA_SPFA实现（Java）.mp4
│ 28：图论_单源最短路径算法_SPFA_算法检测（Java）.mp4) R( e3 n; W6 M6 x. I$ V
│ 29：图论_单源最短路径算法_SPFA求负权回路的思路.mp4
│ 30：图论_单源最短路径算法_SPFA求负权回路的思路.mp4
│ 31：图论_单源最短路径算法_SPFA判断负权回路代码（Java）.mp4# d5 S: j/ U, p2 i, Y" S; t# x
│ 32：图论_单源最短路径算法_SPFA判断负权回路测试（Java）.mp47 Y4 u: f' t' A. ^& q: }7 H, f
│ 33：图论_单源最短路径算法_Bellman Ford树算法和SPF优化后的时间复杂度分析.mp4
│ 34：图论_多源最短路径算法_Floyd算法介绍.mp41 n$ X5 i( y3 Y8 L9 c& J
│ 35：图论_多源最短路径算法_Floyd算法核心代码详解.mp41 C+ `1 q8 T, ^ y' L) \6 Z
│ 36：图论_多源最短路径问题_Floyd相关问题.mp4
│ 37：图论_多源最短路问题_Floyd问题实现1（Java）.mp4
│ 38：图论_多源最短路径问题_Floyd问题实现2（Java）.mp45 y* m9 x: c) J
│ 39：多源最短路问题_Floyd算法测试（Java）.mp4+ e" f! L: b0 ^
│ 40：图论_最小生成树问题_Prim算法简介.mp4
│ 41：图论_最小生成树问题_Prim算法过程.mp4" Q {) c( l! U g7 z
│ 42：图论_最小生成树算法_Prim算法代码思路.mp4' T) p9 q+ v. l3 c# D; m1 j. M
│ 43：图论_最小生成树_Prim算法_代码实现1（Java）.mp4
│ 44：图论_最小生成树_prim算法实现2（Java）.mp4" C& ? R( O. U8 n: Z2 ~( n
│ 45：图论_最小生成树_prim算法测试（Java）.mp4
│ % V3 B( ~6 y. ` d) r& [
├─9、动态规划基础
│ 1：动态规划_再讲动态规划之前的话（一定要听）.mp4 a# [& \; ] Z6 L u
│ 2：动态规划_动态规划的基本定义和认知.mp4
│ 3：动态规划_解决动态规划问题的过程.mp4+ A" d6 G* P; U9 Z+ K/ V! J. Z0 ^
│ 4：动态规划_背包问题的介绍.mp49 f- r l# ~/ e, e: ~3 n; }
│ 5：动态规划_01背包问题经典例子思路讲解.mp4! U! e4 I8 \# j' C; |, M7 v1 I
│ 6：动态规划_01背包问题经典例子代码实现（C++）.mp4
│ 7：动态规划_01背包问题优化_二维优化一维的思想.mp4
│ 8：动态规划_01背包问题优化_一维状态枚举的思想和最终的状态方程.mp4. ]; R5 J4 s6 p2 N6 I/ H9 p
│ 9：动态规划_01背包问题优化_代码实现（C++）.mp4% S( r" z+ M, Q% u* z
│ 10：动态规划_01背包问题_记忆化搜索版本代码实现（不要求掌握）（C++）.mp4# Q' m @, z0 r! x! C& |
│ 11：动态规划_完全背包问题经典例子讲解.mp4( p6 W& d( L3 q3 E% i( l( r# W
│ 12：动态规划_完全背包问题例子代码实现（Java）.mp4
│ 13：动态规划_完全背包问题的第一层优化.mp4
│ 14：动态规划_完全背包问题的第二次优化.mp4
│ 15：动态规划_完全背包问题_最终优化版代码实现（Java）.mp4& F, }" Q h5 Z% P9 Z
│ 16：动态规划_完全背包问题_最终代码测试（Java）.mp4
│ 17：动态规划_多重背包问题_多重背包问题例子讲解.mp4& S: U, w* L) {! J6 B- w
│ 18：动态规划_多重背包问题_朴素版代码实现（Java）.mp49 B5 L7 L, B$ p0 `9 H4 X2 {. \
│ 19：动态规划_多重背包问题_朴素版代码测试（Java）.mp4
│ 20：动态规划_多重背包问题_第二个朴素实现方法_死拆为01背包问题_思路讲解.mp4
│ 21：动态规划_多重背包问题_死拆为01背包的代码实现（Java）.mp45 j. b/ S$ N' o1 j3 G0 B1 @
│ 22：动态规划_多重背包问题_死拆为01背包的代码测试（Java）.mp4
│ 23：动态规划_多重背包问题_决策学优化多重背包问题的思路.mp4
│ 24：动态规划_多重背包问题_最终优化版代码实现（Java）.mp4
│ 25：动态规划_多重背包问题_最终优化版代码测试（Java）.mp49 u) r, J2 f3 {. W5 ^0 O
│ 26：动态规划_多重背包问题_最终优化版代码测试（Java）.mp42 {$ H* |$ _% _; w
│ 27：动态规划_多重背包问题的补充.mp4
│ 28：动态规划_分组背包问题_思路.mp4
│ 29：动态规划_分组背包问题_代码（Java）.mp4
│ 6 Z1 c; b5 c$ D- j4 J
└─10、动态规划提高
1：动态规划_线性动态规划_经典例子_数字三角形问题.mp4
2：动态规划_线性动态规划_经典例题讲解_思路.mp4+ b, q. i4 n: L# Y
3：动态规划_线性动态规划_数字三角形代码实现（Java）.mp4
4：动态规划_线性动态规划_数字三角形代码的补充（Java）.mp48 ^0 m9 M9 H* {$ _- G6 b* v
5：动态规划_线性动态规划_数字三角形代码测试（Java）.mp4
6：动态规划_区间动态规划_基本定义.mp4
7：动态规划_区间动态规划_经典例题石子合并讲解.mp4( k- ?# G1 @, b
8：动态规划_区间动态规划_石子合并问题思路总结.mp4: U& V/ L( L) p- d
9：动态规划_区间动态规划_石子合并_代码实现（Java）.mp45 E8 @8 h7 I* v" c5 Q2 S5 e" f4 k+ H
10：动态规划_数位统计动态规划_计数问题讲解.mp43 T! J, c2 H! S# L+ q, \
11：动态规划_数位统计动态规划_思路讲解.mp45 J* ]& M5 k- {& ?4 D1 H, y9 y' N
12：动态规划_数位统计动态规划_思路讲解2.mp4
13：动态规划_数位动态规划_代码实现1（Java）.mp4
14：动态规划_数位统计动态规划_代码实现2（Java）.mp4
15：动态规划_数位统计动态规划_测试和debug（Java）.mp4* ^* z/ }$ b* x2 j% P4 t( h
下载地址vip会员回复可见：
|
|
发表于 2022-10-20 13:38:47
发表于 2022-10-20 13:40:18
