├── Algorithmic
├── 动态规划算法
│ └── README.md
├── 排序算法
│ └── README.md
├── 查找算法
│ └── README.md
├── 算法学习方法.md
├── 贪心算法
│ └── README.md
└── 递归算法
│ └── README.md
├── Data Structure
├── interview.md
├── 位
│ └── README.md
├── 哈希表
│ └── README.md
├── 图
│ └── README.md
├── 堆
│ └── README.md
├── 字符串
│ └── README.md
├── 数据结构和算法概述
│ └── README.md
├── 数据结构学习方法.md
├── 数组
│ └── README.md
├── 栈
│ └── README.md
├── 树
│ ├── README.md
│ └── 二叉树.md
├── 矩阵
│ └── README.md
├── 递归
│ └── README.md
├── 链表
│ └── README.md
├── 队列
│ └── README.md
└── 集合
│ └── README.md
├── Interview
└── README.md
├── LeetCode算法面试
├── 1004. 最大连续 1 的个数 III(滑动窗口)---Max Consecutive Ones III.md
├── 102 二叉树的层序遍历(中等)binary-tree-level-order-traversal.md
├── 103 二叉树的锯齿形层次遍历(中等)---binary-tree-zigzag-level-order-traversal.md
├── 105. 从前序与中序遍历序列构造二叉树(中等)---Construct Binary Tree from Preorder and Inorder Traversal.md
├── 106 从中序与后序遍历序列构造二叉树(中等)---Construct Binary Tree from Inorder and Postorder Traversal.md
├── 1081 不同字符的最小子序列（字典树 中等）---Smallest Subsequence of Distinct Characters .md
├── 1234. 替换子串得到平衡字符串(滑动窗口)---Replace the Substring for Balanced String.md
├── 1248. 统计「优美子数组」(滑动窗口)---Count Number of Nice Subarrays.md
├── 1358 包含所有三种字符的子字符串数目(滑动窗口)---Number of Substrings Containing All Three Characters.md
├── 144 二叉树的前序遍历(简单)---binary-tree-preorder-traversal.md
├── 145 二叉树的后序遍历 (简单)---binary-tree-postorder-traversal.md
├── 159 至多包含两个不同字符的最长子串(滑动窗口)---Longest Substring with At Most Two Distinct Characters.md
├── 199 二叉树的右视图(中等) ---binary-tree-right-side-view.md
├── 209 长度最小的子数组(滑动窗口 中等) ---Minimum Size Subarray Sum.md
├── 239 滑动窗口最大值 ---Sliding Window Maximum .md
├── 252 会议室（easy）---Meeting Rooms.md
├── 253 会议室 II(Medium)--- Meeting Rooms II .md
├── 3 无重复字符的最长子串(滑动窗口)---Longest Substring Without Repeating Characters.md
├── 316 去除重复字母(字典树 困难)---Remove Duplicate Letters.md
├── 321 拼接最大数(字典树 困难)---Create Maximum Number.md
├── 340 至多包含 K 个不同字符的最长子串( 滑动窗口)--- Longest Substring with At Most K Distinct Characters .md
├── 395 至少有 K 个重复字符的最长子串 (滑动窗口) ---Longest Substring with At Least K Repeating Characters .md
├── 402 移掉 K 位数字(字典树 中等)---Remove K Digits.md
├── 424 替换后的最长重复字符(滑动窗口)---Longest Repeating Character Replacement.md
├── 438. 找到字符串中所有字母异位词(滑动窗口)---Find All Anagrams in a String .md
├── 467. 环绕字符串中唯一的子字符串( 滑动窗口 中等)---Unique Substrings in Wraparound String.md
├── 480 滑动窗口中位数(滑动窗口)---Sliding Window Median.md
├── 488 祖玛游戏---Zuma Game.md
├── 729 我的日程安排表 I(Medium)---My Calendar I.md
├── 731 我的日程安排表 II(Medium)---My Calendar II .md
├── 732 我的日程安排表 III(Hard)---My Calendar III .md
├── 76. 最小覆盖子串(滑动窗口)---Minimum Window Substring .md
├── 795. 区间子数组个数(滑动窗口 中等)---Number of Subarrays with Bounded Maximum .md
├── 862 和至少为 K 的最短子数组(滑动窗口) ---Shortest Subarray with Sum at Least K.md
├── 889. 根据前序和后序遍历构造二叉树(中等)---Construct Binary Tree from Preorder and Postorder Traversal.md
├── 904. 水果成篮(滑动窗口)---Fruit Into Baskets .md
├── 930. 和相同的二元子数组(滑动窗口)---Binary Subarrays With Sum.md
├── 94 二叉树的中序遍历(简单)---binary-tree-inorder-traversal.md
├── 992. K 个不同整数的子数组(滑动窗口)---Subarrays with K Different Integers.md
├── README.md
├── 数据结构部分
│ ├── LeetCode---树 tree.md
│ ├── README.md
│ └── 二叉树.md
├── 算法部分
│ └── README.md
└── 经典题型分类
│ ├── 1. Pattern: Sliding window，滑动窗口类型
│ └── README.md
│ ├── 10. Pattern: Subsets，子集类型，一般都是使用多重DFS
│ └── README.md
│ ├── 11. Pattern: Modified Binary Search，改造过的二分
│ └── README.md
│ ├── 12. Pattern: Top ‘K’ Elements，前K个系列
│ └── README.md
│ ├── 13. Pattern: K-way merge，多路归并
│ └── README.md
│ ├── 14. Pattern: 0 mod 1 Knapsack (Dynamic Programming)
│ └── README.md
│ ├── 15. Pattern: Topological Sort (Graph)，拓扑排序类型
│ └── README.md
│ ├── 2 Pattern: Two Pointers
│ └── README.md
│ ├── 3. Pattern: Fast & Slow pointers, 快慢指针类型
│ └── README.md
│ ├── 4. Pattern: Merge Intervals，区间合并类型
│ └── README.md
│ ├── 5. Pattern: Cyclic Sort，循环排序
│ └── README.md
│ ├── 6. Pattern: In-place Reversal of a LinkedList，链表翻转
│ └── README.md
│ ├── 7. Pattern: Tree Breadth First Search，树上的BFS
│ └── README.md
│ ├── 8. Pattern: Tree Depth First Search，树上的DFS
│ └── README.md
│ ├── 9. Pattern: Two Heaps，双堆类型
│ └── README.md
│ └── README.md
├── README.md
├── java 算法例子程序
└── README.md
└── 数学
└── README.md
/Algorithmic/动态规划算法/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | [Grokking Dynamic Programming Patterns for Coding Interviews](https://www.educative.io/courses/grokking-dynamic-programming-patterns-for-coding-interviews?aff=K7qB)|
4 | ---|
5 |
6 | # 视频
7 |
8 | [【动态规划专题班】动态规划入门 Introduction to Dynamic Programming](https://www.youtube.com/watch?v=j4eab7N3Hfs)|[动态规划的套路 by wisdompeak](https://www.youtube.com/watch?v=FLbqgyJ-70I)|[ACM大神是怎么解决动态规划的？搞定DP看这就够了](https://mp.weixin.qq.com/s/dZKDpkZoVcYwIlmSnMjKWg)|
9 | ---|---|---|
10 |
11 | [青云算法动态规划专题讲座](https://www.youtube.com/watch?v=eLQzAKMWY8U)|[动态规划(重置版)](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/dynamic-programming)|
12 | ---|---|
13 |
14 | [背包问题九讲](https://www.kancloud.cn/kancloud/pack/70124)|
15 | ----|
16 |
17 | * 动态规划
18 | * 动态规划的问题
19 | 1. 0/1 Knapsack, 0/1背包，6个题
20 | * 0/1 Knapsack，0/1背包问题
21 | * Equal Subset Sum Partition，相等子集划分问题
22 | * Subset Sum，子集和问题
23 | * Minimum Subset Sum Difference，子集和的最小差问题
24 | * Count of Subset Sum，相等子集和的个数问题
25 | * Target Sum，寻找目标和的问题
26 | 2. Unbounded Knapsack，无限背包，5个题
27 | * Unbounded Knapsack，无限背包
28 | * Rod Cutting，切钢条问题
29 | * Coin Change，换硬币问题
30 | * Minimum Coin Change，凑齐每个数需要的最少硬币问题
31 | * Maximum Ribbon Cut，丝带的最大值切法
32 | 3. Fibonacci Numbers，斐波那契数列，6个题
33 | * Fibonacci numbers，斐波那契数列问题
34 | * Staircase，爬楼梯问题
35 | * Number factors，分解因子问题
36 | * Minimum jumps to reach the end，蛙跳最小步数问题
37 | * Minimum jumps with fee，蛙跳带有代价的问题
38 | * House thief，偷房子问题
39 | 4. Palindromic Subsequence，回文子系列，5个题
40 | * Longest Palindromic Subsequence，最长回文子序列
41 | * Longest Palindromic Substring，最长回文子字符串
42 | * Count of Palindromic Substrings，最长子字符串的个数问题
43 | * Minimum Deletions in a String to make it a Palindrome，怎么删掉最少字符构成回文
44 | * Palindromic Partitioning，怎么分配字符，形成回文
45 | 5. Longest Common Substring，最长子字符串系列，13个题
46 | * Longest Common Substring，最长相同子串
47 | * Longest Common Subsequence，最长相同子序列
48 | * Minimum Deletions & Insertions to Transform a String into another，字符串变换
49 | * Longest Increasing Subsequence，最长上升子序列
50 | * Maximum Sum Increasing Subsequence，最长上升子序列和
51 | * Shortest Common Super-sequence，最短超级子序列
52 | * Minimum Deletions to Make a Sequence Sorted，最少删除变换出子序列
53 | * Longest Repeating Subsequence，最长重复子序列
54 | * Subsequence Pattern Matching，子序列匹配
55 | * Longest Bitonic Subsequence，最长字节子序列
56 | * Longest Alternating Subsequence，最长交差变换子序列
57 | * Edit Distance，编辑距离
58 | * Strings Interleaving，交织字符串
59 |
60 | * 背包问题系列
61 | * [背包问题总结篇](https://mp.weixin.qq.com/s/ZOehl3U1mDiyOQjFG1wNJA)
62 | * 打家劫舍系列
63 | * 股票系列
64 | * [动态规划：股票系列总结篇](https://mp.weixin.qq.com/s/sC5XyEtDQWkonKnbCvZhDw)
65 | * 子序列系列
66 | * [动态规划总结篇之一](https://mp.weixin.qq.com/s/ES1SXf54047496YnNdeirA)
67 | * [动态规划总结篇之二](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247489282&idx=1&sn=770ff33965357e822addc2b88cf31697&chksm=f9a22453ced5ad4519176cb274d005ebfe3a2e7dd2b2698787100c77950aa3b97c8ff47d15e7&scene=178&cur_album_id=1485825793120387074#rd)
68 |
--------------------------------------------------------------------------------
/Algorithmic/排序算法/README.md:
--------------------------------------------------------------------------------
1 | # 目录
2 |
3 | # 参考书
4 | 写给大家看的算法.pdf
5 | * [基本排序算法类模板](https://rovo98.github.io/posts/57d02cec/)
6 | * 排序算法
7 | * 内部排序 只使用内存
8 | * 插入排序---向有序数据里正确位置插入数据
9 | * 直接插入排序
10 | * 直接插入排序 算法基本思想
11 | * 直接插入排序 算法的时间复杂度
12 | * 直接插入排序 算法的空间复杂度
13 | * 直接插入排序 算法的稳定性
14 | * 折半插入排序
15 | * 折半插入排序 算法基本思想
16 | * 折半插入排序 算法的时间复杂度
17 | * 折半插入排序 算法的空间复杂度
18 | * 折半插入排序 算法的稳定性
19 | * 希尔排序---改进排序效率
20 | * 希尔排序 算法基本思想
21 | * 希尔排序 算法的时间复杂度
22 | * 希尔排序 算法的空间复杂度
23 | * 希尔排序 算法的稳定性
24 | * 选择排序---每次找出一个最大（最小）值
25 | * 简单选择排序
26 | * 简单选择排序 算法基本思想
27 | * 简单选择排序 算法的时间复杂度
28 | * 简单选择排序 算法的空间复杂度
29 | * 简单选择排序 算法的稳定性
30 | * 堆排序
31 | * 堆排序 算法基本思想
32 | * [一个优化的堆排序 每次降序提取元素建立从右到左的有序序列](http://www.nowamagic.net/librarys/veda/detail/1169)
33 | * 堆排序 算法的时间复杂度
34 | * 堆排序 算法的空间复杂度
35 | * 堆排序 算法的稳定性
36 | * 交换排序
37 | * 冒泡排序---像冒泡一样进行相邻数据的交换
38 | * 冒泡排序 算法基本思想
39 | * 冒泡排序 算法的时间复杂度
40 | * 冒泡排序 算法的空间复杂度
41 | * 冒泡排序 算法的稳定性
42 | * 快速排序---最快的排序算法
43 | * [快速排序 算法基本思想](https://rovo98.github.io/posts/d9de8e4c/)
44 | * [快速排序里的学问：从猜数字开始 猜数字里的算法思想](http://www.nowamagic.net/librarys/veda/detail/2387)
45 | * [快速排序里的学问：再看看称球问题 根据问题选择N分法](http://www.nowamagic.net/librarys/veda/detail/2388)
46 | * [快速排序里的学问：信息熵 从信息熵角度去理解问题](http://www.nowamagic.net/librarys/veda/special/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F%E9%87%8C%E7%9A%84%E5%AD%A6%E9%97%AE)
47 | * [快速排序里的学问：快速排序的过程 理解快速排序的工作机制](http://www.nowamagic.net/librarys/veda/detail/2390)
48 | * [快速排序里的学问：霍尔与快速排序 再次深入理解快速排序](http://www.nowamagic.net/librarys/veda/detail/2391)
49 | * [快速排序里的学问：霍尔快排的实现 霍尔快排的C语言实现](http://www.nowamagic.net/librarys/veda/detail/2396)
50 | * [快速排序里的学问：枢纽元选择与算法效率 枢纽元选择也有学问](http://www.nowamagic.net/librarys/veda/detail/2397)
51 | * [快速排序里的学问：随机化快排 选择随机数作为枢纽元](http://www.nowamagic.net/librarys/veda/detail/2398)
52 | * [快排序优化](https://rovo98.github.io/posts/6dcc34f7/)
53 | * 快速排序 算法的时间复杂度
54 | * 快速排序 算法的空间复杂度
55 | * 快速排序 算法的稳定性
56 | * 归并排序---把几个有序数据合并并进行排序
57 | * [归并排序 算法基本思想](https://rovo98.github.io/posts/1368334/)
58 | * 归并排序 算法的时间复杂度
59 | * 归并排序 算法的空间复杂度
60 | * 归并排序 算法的稳定性
61 | * 桶式排序
62 | * 桶式排序 算法基本思想
63 | * 桶式排序 算法的时间复杂度
64 | * 桶式排序 算法的空间复杂度
65 | * 桶式排序 算法的稳定性
66 | * 基数排序
67 | * 基数排序 算法基本思想
68 | * 基数排序 算法的时间复杂度
69 | * 基数排序 算法的空间复杂度
70 | * 基数排序 算法的稳定性
71 | * 稳定排序
72 | * 分割排序
73 | * 逆序数排序
74 | * 最小成本排序
75 | * 外部排序 内存和外存结合使用
76 | * 外存信息的存取
77 | * 外部排序的方法
78 | * 多路平衡归并的实现
79 | * 置换选择排序
80 | * 最佳归并树
81 |
82 | # 内容
83 |
84 |
--------------------------------------------------------------------------------
/Algorithmic/查找算法/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | # 目录
4 |
5 | * 查找算法
6 | * [基本查找算法 ](https://rovo98.github.io/posts/d83777d2/)
7 | * [静态查找---只作查找操作的查找表](https://segmentfault.com/a/1190000022654107)
8 | * [顺序查找算法](http://data.biancheng.net/view/54.html)
9 | * 有序表查找
10 | * [二分查找算法(非递归)](http://data.biancheng.net/view/55.html)
11 | * 静态树表的查找
12 | * [分块查找算法（索引顺序查找）](http://data.biancheng.net/view/56.html)
13 | * 插值查找算法
14 | * 奜波那契(黄金分割法)查找算法
15 | * [动态查找---在查找过程中同时插入查找表中不存在的数据元素, 或者从查找表中删除已经存在的某个数据元素](https://segmentfault.com/a/1190000022654107)
16 | * 键树查找算法（双链树和字典树）
17 | * B-树和B+树
18 | * 二叉排序树查找算法（二叉查找树）
19 | * 平衡二叉树查找算法（AVL树）
20 | * 红黑树查找算法(更高级的二叉查找树)
21 | * 哈希表查找---实现高效查找
22 | * 多路查找树B树
23 | * 数据结构中的查找算法
24 | * 字符串结构中的查找算法
25 | * 在字符串中搜索部份字符串的字符串搜索算法
26 | * KMP---高效字符串搜索算法
27 | * BM---逆向比较的字符串搜索算法
28 | * 顺序表结构中的查找算法
29 | * 链表结构中的查找算法
30 | * 树结构中的查找算法
31 | * 图结构中的查找算法
32 |
33 |
34 |
35 |
36 |
--------------------------------------------------------------------------------
/Algorithmic/算法学习方法.md:
--------------------------------------------------------------------------------
1 |
2 | 1) 首先学习一门语言，例如C/C++或者Java，初学者学C++比较普遍。
3 | 2) 学一本数据结构，数据结构书有很多，具体看什么书最好，因人而异，尽管很多人觉得严的书难以理解，但是无法否认，严的书是权威，所以仍然推荐严的数据结构，只不过要结合博客图解看，那就简单易懂了。
4 | 注意人邮版的更好一点。数据结构图解博客：http://blog.csdn.net/rainchxy。
5 |
6 | 3) 然后看算法入门书《趣学算法》，这本书图解多，有大量图解，问题分析，实战演练，适合入门者快速掌握经典算法。
7 | 4) 然后再看《算法导论》就简单多了。
8 | 然后选择自己感兴趣的分支，以机器学习为例，首先看看李航的《统计学习方法》，了解一下统计学习方法，因为目前的机器学习是基于统计的，建议学一下python/R，
9 | 然后看看《机器学习实战》，这本书简单易懂，适合入门。
10 | 接着学习什么，就根据自己工作岗位需要了
11 |
12 |
13 | # 有用的书
14 |
15 | ## 第一名
16 | 原书名：The Art of Computer Programming
17 | 中文名：计算机程序设计艺术
18 | 作者：Donald E.Knuth
19 | 难度：★★★★★
20 | 个人评价：★★★★★
21 | 推荐程度：★★★
22 |
23 | 本书是算法分析的经典名作（用经典不太恰当，应该是圣经或史诗），被科学美国人列为20世纪12大科学名著之一（和Dirac的量子力学，Einstein 的广义相对论，von Neumann 的博弈论的著作等齐名）。其亮点在于其超乎寻常的数学技巧，要求读者拥有极高的数学修养，只要你坚持忍耐，一旦读懂了，你的算法和程序设计水平也会达到更高的档次，你会对程序设计有一种截然不同的体会和领悟，就是“道”(Tao)。
24 |
25 | 书的排版很漂亮（得益于作者的Tex系统），看起来很舒服。作者的文笔很好，写得生动活泼,读起来荡气回肠(英文版)。习题多且精华，触及算法和程序本质，书后有几乎所有习题的答案（占了整全书篇幅的1/4），书中的分析方法体现了作者严谨的风格。不过本书的程序不是用我们熟悉的高级语言描述的，而是作者设计的MIX语言。
26 |
27 | 整套书原计划出七卷，现在出了三卷：基本算法，半数值算法，排序和搜索，第四卷组合算法跳票了20年，Knuth称在2008年推出。本书有中文版，不过建议读者选用英文版，因为都学到这个程度了，英语应该不会有大困难了。
28 |
29 | 引用一句话“在我们的有生之年，可能会看到C++的消亡，但Knuth和他的程序设计艺术，将永远留在我们的心里。”
30 |
31 | ## 第二名
32 | 原书名：Introduction to Algorithms
33 | 中文名：算法导论
34 | 作者：Thomas H.Cormen,Charles E.Leiserson,Ronald L.Rivest,Clifford Stein
35 | 难度：★★★
36 | 个人评价：★★★★★
37 | 推荐程度：★★★★★
38 |
39 | 本书俗称CLRS（作者名字的简写），算法的经典教材，堪称算法分析著作中的“独孤九剑”。作者之一Ronald L.Rivest 由于其在公开秘钥密码算法RSA上的贡献获得了ACM图灵奖。
40 |
41 | 全书内容全面，结构清晰，6个部分1000多页把数据结构算法的主要内容都包含了。作者用图表，伪码解释每一个算法，通俗易懂而不失严谨性，英文比较简单，语言流畅，因此，与TAOCP相比，这本书更适合初学者，不要求读者拥有很强的数学背景和丰富的编程经验。
42 |
43 | 书中习题安排合理，难度适中，在网上有全部习题的答案，网上还有作者在MIT讲述本书的课程的录像，可谓资源丰富，值得注意的是书中每一章后面都有一个Chapter notes,了解一下历史，看一下作者推荐的材料是不错的（如果你能找到的话）。
44 |
45 | ## 第三名
46 | 原书名：Data Structures and Algorithms Analysis in C/C++/JAVA
47 | 中文名：数据结构与算法分析——C语言描述/C++描述/Java语言描述
48 | 作者：Mark Allen Weiss
49 | 难度：★★★
50 | 个人评价：★★★★★
51 | 推荐程度：★★★★★
52 |
53 | 《数据结构与算法分析——C语言描述》（Data Structures and Algorithms Analysis in C）第二版，Mark Allen Weiss著，天津师范大学冯舜玺译，机械工业出版社。Weiss教授的数据结构经典教材三部曲之一，其中的C语言描述版本，也就是本书，被称为20世纪最重要的30本计算机教材之一。Mark Allen Weiss（马克?爱伦?韦斯），1987年在普林斯顿大学获得计算机科学博士学位，师从著名算法大师Robert Sedgewick，现任美国佛罗里达国际大学计算与信息科学学院教授。他曾经担任全美AP（Advanced Placement）考试计算机学科委员会的主席（2000-2004）。他的主要研究方向是数据结构，算法和教育学。中文版翻译质量很好。数学公式太多。网上可以下载书中代码，但是没有输出结果，也没有习题答案。
54 |
55 | 《数据结构与算法分析——C++描述》（Data Structures and Algorithms Analysis in C++）第三版，Mark Allen Weiss著，张怀勇等译，机械工业出版社。Weiss教授的数据结构经典教材三部曲之一。
56 |
57 | 《数据结构与算法分析——Java语言描述》（Data Structures and Algorithms Analysis in Java）第二版，Mark Allen Weiss著，天津师范大学冯舜玺译，机械工业出版社。Weiss教授的数据结构经典教材三部曲之一。
58 |
59 | ## 第四名
60 | 原书名：Introduction to The Design & Analysis of Algorithms
61 | 中文名：算法设计与分析基础
62 | 作者：Anany Levitin
63 | 难度：★★★
64 | 个人评价：★★★★
65 | 推荐程度：★★★★
66 |
67 | 算法书的另一种写法，以方法为主线，如Brute-Force, Divide-and-Conquer, Greedy techniques，书里面有很多有趣的习题
68 |
69 | ## 第五名
70 | 原书名：Data Structures, Algorithms, and Applications in C+
71 | 中文名：数据结构算法与应用-C++语言描述
72 | 作者：Sartej Sahni 译者：汪诗林等
73 | 难度：★★★
74 | 个人评价：★★★
75 | 推荐程度：★★★
76 |
77 | 不少人推荐这本书，但我个人觉得这书不怎么样，中文版翻译水平差强人意，数据结构算法部分把该讲的都讲了，但没什么突出的地方，反而C++倒说了不少，代码的水平也不怎么样。
78 |
79 | 从ACCU的评价上看，书中的实现与BOOST和STL相比相去甚远。不过这书有很多实际问题，可以看一看。
80 |
81 | ## 第六名
82 | 原书名： Programming Pearls
83 | 中文名： 编程珠玑
84 | 作者： Jon Bentley
85 | 难度：★★★
86 | 个人评价：★★★★
87 | 推荐程度：★★★★
88 |
89 | 编程珠玑：学习算法不仅需要像Alogrithms，算法导论这样的重量级的内功心法，像《编程之美》、《编程珠玑》这样的轻量级的轻功身法也必不可少。
90 |
91 | 前些年网上不是很流行像“给你10亿个数，找到最大的n个”或者“给你10亿个数，找出现次数最多的那个数”之类的百度面试题吗？看了此书你就知道怎么解决了。
92 |
93 | 相比于《编程之美》来说，本书中的示例技巧性略低一些，但是也更有实际应用价值一些。
94 |
95 | ## 第七名
96 | 原书名：Algorithm Design
97 | 中文名： 算法设计
98 | 作者： Jon Kleinberg / Éva Tardos
99 | 难度：★★★
100 | 个人评价：★★★★
101 | 推荐程度：★★★★
102 |
103 | Algorithm Design 算法设计 很经典的一本书，很久之前看的。个人觉得“算法设计”比“算法导论”好。
104 |
105 | 纸更好，看起来舒服多了。
106 | “算法导论”太详细了，如果纠结与细节经常导致失去重点。“算法设计”只有关键的过程证明，反而容易掌握重点。
107 | 我是先看到“算法导论”后看的“算法设计”，看“算法设计”的时候还是很享受这本书的，同时也把知识巩固了一遍
108 |
109 | ## 第八名
110 | 原书名：算法艺术与信息学竞赛
111 | 中文名： 算法艺术与信息学竞赛
112 | 作者： 刘汝佳
113 | 难度：★★★
114 | 个人评价：★★★★
115 | 推荐程度：★★★★
116 |
117 | 算法艺术与信息学竞赛：如果算法导论是九阳神功，那这本无疑就是九阴真经。
118 |
119 | 本书是专为参加一些诸如ACM之类程序设计比赛的同学而写的，江湖人称“黑书”。里面讲的都是一些在编程比赛中常用的算法、数据结构，以及一些数论和计算几何等。我虽然并不搞竞赛，但也从此书中受益颇多。
120 |
121 | ## 第九名
122 | 原书名：Algorithms in C,Algorithms in C++,Algorithms in Java
123 | 中文名：算法I-IV（C实现），算法V（C实现）（C++实现）（Java实现）
124 | 作者：Robert Sedgewick
125 | 难度：★★★
126 | 个人评价：★★★★★
127 | 推荐程度：★★★★
128 |
129 | Robert Sedgwick是Knuth的学生，现在是princeton的教授。这是三个系列，与上面用伪码描述算法不同，本书用现今流行的语言C，C++，Java描述.那么选拿哪一种语言好呢？从算法的角度看，任何高级语言都是没区别的，虽然实现算法的时候，到了语言相关的层面会有一些细微区别，但影响不大。
130 |
131 | 个人推荐C++的，因为价钱最便宜：）。本书的一个特点就是例子取得很好，代码很清晰。有中文版
132 |
133 | ## 第十名
134 | 原书名：Algorithms Design Techniques and Analysis
135 | 中文名：算法设计技巧与分析
136 | 作者：M.H.Alsuwaiyel
137 | 难度：★★★★
138 | 个人评价：★★★★
139 | 推荐程度：★★★★
140 |
141 | 这本书对一般算法书较少涉及的概率算法和近似算法作了重要的补充
142 |
143 | ## 第十一名
144 | 原书名：
145 | 中文名：算法与数据结构
146 | 作者：傅清祥 王晓东
147 | 难度：★★★
148 | 个人评价：★★★★
149 | 推荐程度：★★★★
150 |
151 | 这本是国人写的最好的数据结构算法书之一，讲得很细致。最后的三章：复杂性，并行算法，高级专题有一些有趣的东西，是这些高级内容的很好的导论。
152 |
153 | ## 第十二名
154 | 原书名：
155 | 中文名：数据结构(C语言版)
156 | 作者：严蔚敏 吴伟民
157 | ---------------------
158 | 作者：MayeF
159 | 来源：CSDN
160 | 原文：https://blog.csdn.net/Mayerlucky/article/details/50372810
161 | 版权声明：本文为博主原创文章，转载请附上博文链接！
162 |
--------------------------------------------------------------------------------
/Algorithmic/贪心算法/README.md:
--------------------------------------------------------------------------------
1 |
2 | * [贪心算法：总结篇](https://mp.weixin.qq.com/s/ItyoYNr0moGEYeRtcjZL3Q)
3 |
--------------------------------------------------------------------------------
/Algorithmic/递归算法/README.md:
--------------------------------------------------------------------------------
1 | [回溯算法总结！](https://mp.weixin.qq.com/s/r73thpBnK1tXndFDtlsdCQ)|
2 | ---|
3 |
4 | * [递归算法](https://zhuanlan.zhihu.com/p/81952290)
5 | * [组合]
6 | * [分割]
7 | * [子集]
8 | * [排列]
9 | * 棋盘问题
10 | *
11 | * [回溯算法总结](https://mp.weixin.qq.com/s/r73thpBnK1tXndFDtlsdCQ)
12 |
13 |
14 |
15 |
--------------------------------------------------------------------------------
/Data Structure/interview.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | # 有用的参考
7 |
8 | * [Java常见数据结构面试题（带答案）](https://www.jb51.net/article/122998.htm)
9 | * [JAVA实现链表面试题](https://www.jb51.net/article/71885.htm)
10 |
--------------------------------------------------------------------------------
/Data Structure/位/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | * [位运算的套路](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/bit)
4 |
5 |
6 | # 参考书
7 |
8 | 《数据结构与算法经典问题解析：Java语言描述(原书第2版）》.pdf
9 |
--------------------------------------------------------------------------------
/Data Structure/哈希表/README.md:
--------------------------------------------------------------------------------
1 |
2 | * [哈希表定义](https://oi-wiki.org/ds/hash/)
3 | * 源码分析
4 | * HashMap源码分析
5 | * LinkedHasMap源码分析
6 | * HashTable源码分析
7 | * HashSet源码分析
8 | * HashCode源码分析
9 | * Equals源码分析
10 | * LinkList源码分析
11 | * ArrayList源码分析
12 | * TreeMap源码分析
13 | |[9. 哈希表：总结篇](https://mp.weixin.qq.com/s/1s91yXtarL-PkX07BfnwLg)||
14 | ---
15 |
16 | |1. 直接寻址||
17 | |2. 散列函数||
18 | |3. 开放地址法||
19 | |4. 链接法||
20 | |5. 再hash法||
21 | |6. Bloom Filter||
22 | |7. [HashMap底层原理](https://www.bilibili.com/video/BV1uW411N7CG)||
23 | |8. 源码分析||
24 | |---HashTable源码分析||
25 | |---[HashMap源码分析]()||
26 | |---HashSet源码分析||
27 | |---HashCode源码分析||
28 | |---[LinkedHashMap源码分析]()||
29 | |---Equals源码分析||
30 | |---[LinkList源码分析]()||
31 | |---[ArrayList 源码分析]()||
32 | |---[TreeMap源码分析]()||
33 |
34 | *
35 |
--------------------------------------------------------------------------------
/Data Structure/图/README.md:
--------------------------------------------------------------------------------
1 |
2 | # 参考书
3 | 我的第一本算法书.pdf
4 |
5 |
6 | # 目录
7 |
8 | * 图的概述
9 | * [什么是连通图，（强）连通图详解](http://data.biancheng.net/view/201.html)
10 | * [什么是生成树，生成树（生成森林）详解](http://data.biancheng.net/view/202.html)
11 | * 图的存储结构
12 | * [图的分类](http://data.biancheng.net/view/200.html)
13 | * 完全图
14 | * [连通图](http://data.biancheng.net/view/201.html)
15 | * [重连通图 ](http://data.biancheng.net/view/42.html)
16 | * 稀疏图
17 | * 稠密图
18 | * 图存储结构分类
19 | * [图的顺序存储结构(数组表示法)](http://data.biancheng.net/view/37.html)
20 | * [图的邻接表存储结构](http://data.biancheng.net/view/203.html)
21 | * [图的十字链表存储结构](http://data.biancheng.net/view/204.html)
22 | * [图的邻接多重表存储](http://data.biancheng.net/view/205.html)
23 | * 图的算法
24 | * 图的搜索算法
25 | * [深度优先搜索（DFS、深搜）](http://data.biancheng.net/view/39.html)
26 | * [深度优先生成树](http://data.biancheng.net/view/45.html)
27 | * [回溯是 DFS 中的一种技巧](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/backtrack)
28 | * [小岛问题是 DFS 的子专题](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/island)
29 | * [广度优先搜索（BFS、广搜）]((http://data.biancheng.net/view/39.html))
30 | * [广度优先生成树](http://data.biancheng.net/view/45.html)
31 | * [关键路径](http://data.biancheng.net/view/44.html)
32 | * AOE网
33 | * 关键路径核心算法
34 | * 最短路径搜索算法
35 | * Dijkstra算法---（狄克西特拉算法）
36 | * A* 算法
37 | * 弗洛伊德算法
38 | * Bellman-Ford算法---（贝尔曼-福特算法）
39 | * Floyd-Warshall算法
40 | * 拓扑排序算法
41 | * AOV网
42 | * 拓扑排序核心算法
43 | * DFS实现
44 | * BFS实现
45 | * 时间复杂度
46 | * 最小生成树算法
47 | * Prim算法
48 | * Kruskal算法
49 | * 并查集
50 | * Quick Find
51 | * Quick Union
52 | * Union Find
53 | * 二分图匹配
54 |
55 |
56 |
--------------------------------------------------------------------------------
/Data Structure/堆/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | [几乎刷完了力扣所有的堆题，我发现了这些东西（上）](https://lucifer.ren/blog/2020/12/26/heap/)|[几乎刷完了力扣所有的堆题，我发现了这些东西(下)](https://lucifer.ren/blog/2021/01/19/heap-2/)|
4 | ---|---|
5 |
6 | # 目录
7 |
8 | * [堆](#堆)
9 | * [堆的数组实现](#堆的数组实现)
10 | * 堆的链表实现
11 | * Heapify过程
12 | * 排序算法时间下界
13 | * 优先队列
14 | * 二叉堆
15 | * 最大堆
16 | * 最小堆
17 | * 索引堆
18 | * stack源码分析
19 | * PriorityQueue源码分析
20 | * [堆的操作](#堆的操作)
21 | * [堆的构建(创建一个空堆，基于数组的构建)](#堆的构建)
22 | * [堆的插入(插入到堆尾，再自下向上调整为最小堆)](#堆的插入)
23 | * [堆的删除(删除堆顶元素并用堆尾元素添补，再自上向下调整为最小堆)](#堆的删除)
24 | * [堆排序(时间复杂度：O(nlgn),空间复杂度O(1),不稳定)：升序排序一般用最大堆，不断地将堆顶元素放到数组最后并缩小堆的范围](#堆排序)
25 | * [堆的打印(树的前序遍历的应用)](#堆的打印)
26 |
27 |
28 |
29 | # 内容
30 |
31 | # 堆
32 | 堆结构实际上是一个完全二叉树，能方便地从中取出最小/大元素，其包含两个要素，即存储数组heap[]和堆大小size。
33 |
34 | ## 堆的数组实现
35 | ## 堆的操作
36 | ### 堆的构建
37 | ### 堆的插入
38 | ### 堆的删除
39 | ### 堆排序
40 | ### 堆的打印
41 |
--------------------------------------------------------------------------------
/Data Structure/字符串/README.md:
--------------------------------------------------------------------------------
1 |
2 | * [串存储结构的具体实现](#串存储结构的具体实现)
3 | * [定长顺序存储](http://data.biancheng.net/view/176.html)
4 | * [堆分配存储](http://data.biancheng.net/view/177.html)
5 | * [块链存储](http://data.biancheng.net/view/178.html)
6 | * BF算法（串模式匹配算法）
7 | * KMP算法（快速模式匹配算法）
8 | * [亲身体验一下KMP算法 KMP快速字符串查找算法](http://www.nowamagic.net/librarys/veda/detail/1137)
9 |
10 | * 前缀树（字典树）
11 | * 后缀树
12 | * [字符串：总结篇](https://mp.weixin.qq.com/s/gtycjyDtblmytvBRFlCZJg)
13 |
14 |
15 | # 串存储结构的具体实现
16 |
17 | 存储一个字符串，数据结构包含以下 3 种具体存储结构：
18 | 1. 定长顺序存储：实际上就是用普通数组（又称静态数组）存储。例如 C 语言使用普通数据存储字符串的代码为 char a[20] = "data.biancheng.net"；
19 | 2. 堆分配存储：用动态数组存储字符串；
20 | 3. 块链存储：用链表存储字符串；
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 | # 有用的参考
33 |
34 | * [字符串逆序的各种实现算法 字符串逆序有很多种实现方式](http://www.nowamagic.net/librarys/veda/detail/1057)
35 |
--------------------------------------------------------------------------------
/Data Structure/数据结构和算法概述/README.md:
--------------------------------------------------------------------------------
1 | 数据结构我们可以从逻辑上分为线性结构和非线性结构。线性结构有数组，栈，链表等， 非线性结构有树，图等。其实我们可以称树为一种半线性结构。
2 |
3 | 需要注意的是，线性和非线性不代表存储结构是线性的还是非线性的，这两者没有任何关系，它只是一种逻辑上的划分。
4 | 比如我们可以用数组去存储二叉树。
5 |
6 | 一般而言，有前驱和后继的就是线性数据结构。比如数组和链表。
7 |
8 | 其实一叉树就是链表
9 |
10 |
11 | **要评价一个算法的效率，以其绝对执行时间来衡量是不合理的，一个算法的“工作量”可以靠代码中的关键部分来确定，这些关键部分称为基本操作，通过统计算法中基本操作重复执行的次数就可近拟地得到算法的执行效率，用O(n)表示，称为时间复杂度**
12 |
--------------------------------------------------------------------------------
/Data Structure/数据结构学习方法.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | # 数据结构与算法学习的路径
4 |
5 | * [从入门到修仙的算法之路](https://mp.weixin.qq.com/s?__biz=MzI5MzYzMDAwNw==&mid=2247484319&idx=1&sn=11f9bce35fae40dd2ed54b2b3c785425&chksm=ec6e7ac7db19f3d14c11cd9e6e03f4ef2d31d45332979cf44711f15213dd964d8ced00643260&token=516051101&lang=zh_CN#rd)
6 |
7 | * [如果时光倒流，我会这样学算法](https://mp.weixin.qq.com/s?__biz=MzI5MzYzMDAwNw==&mid=2247483728&idx=1&sn=da73111b02f90df1c9f251b6c6c1e23f&chksm=ec6e7808db19f11e18e677096da7e9049c741cf4f5a6d08003c0d396ae41176aa2a2d80f8ec8&scene=21#wechat_redirect)
8 |
9 | * [算法学习方法](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Algorithmic/算法学习方法.md)
10 | * [算法成神之路](https://mp.weixin.qq.com/s?__biz=MzU4MjQ3NzEyNA==&mid=2247483872&idx=1&sn=3c6af181bfe4e9471c7052bdb09006a6&chksm=fdb6f5cbcac17cdd5420bc21948d49b9bfe8d43cada0306d587f3a5dfa88fe0a6c27766231ef&scene=7#rd)
11 |
12 | * [左程云：程序员该如何学习算法](https://www.nowcoder.com/discuss/61529)
13 |
14 | * [别再埋头刷LeetCode之：北美算法面试的题目分类，按类型和规律刷题，事半功倍](https://zhuanlan.zhihu.com/p/161204634)
15 |
16 | # 数据结构与算法学习的目的
17 |
18 | ### 1） 会数据结构的基本操作
19 |
20 | 这是最基础的要求，学会各种数据结构的基本操作，取值、查找、插入、删除等。先看图解，理解各种数据结构的定义，操作方法，然后看代码，尝试自己动手上机运行，
21 | 逐渐掌握基本操作。初学时，要想理解数据结构，一定要学会画图，通过画图形象表达，更能体会其中的数据结构关系。因此，初学阶段学习利器：画图，理解，画图。
22 |
23 | ### 2） 会利用数据结构，解决实际问题
24 |
25 | 在掌握了书上的基本操作之后，就可以尝试利用数据结构解决一些实际问题了，先学经典应用问题的解决方法，体会数据结构的使用方法，然后再做题，独立设计数据结构
26 | 解决问题。要想熟练应用就必须做大量的题，从做题中体会其中的方法。最好进行专项练习，比如线性表问题，二叉树问题，图问题，该阶段学习利器：做题，反思，做题。
27 |
28 | ### 3） 熟练使用和改进数据结构，优化算法
29 |
30 | 这是最高境界了，也是学习数据结构的精髓所在，单独学习数据结构是无法达到这种境界的。它需要在学习算法的过程中慢慢修炼。在学习算法的同时，逐步熟练应用、
31 | 改进，慢慢体会不同数据结构和算法策略的算法复杂性，最终学会利用数据结构改进和优化算法。该阶段已经在数据结构之上，通过在ACM测试系统上刷各种算法题，体会
32 | 利用数据结构改进优化算法。该阶段学习利器：刷题，总结，刷题。
33 |
34 |
35 |
--------------------------------------------------------------------------------
/Data Structure/数组/README.md:
--------------------------------------------------------------------------------
1 |
2 | | **[数组理论知识](#数组理论知识) ** | |
3 | | :--- | :---: |
4 | | **[数组的经典题目--解题思想](#数组的经典题目)** | |
5 | | :--- | :---: |
6 | | 1 **数组是一种顺序存储结构，能存储线性结构和非线性结构**| [无代码] |
7 | | 1-1-0 稀疏数组| |
8 | | 1-1-0 [环形数组(CircularArray)](https://blog.csdn.net/sinat_36246371/article/details/78836336)||
9 | | 1-1-0 [后缀数组](https://oi-wiki.org/string/sa/)||
10 | | 1-1-0 [广义表](http://data.biancheng.net/view/190.html)||
11 | | 1-1-1 数组模拟队列||
12 | | 1-1-2 数组模拟环型队列||
13 | | 1-1-5 用数组实现链表结构代码|[无代码]|
14 | | --- 用数组实现链表结构的时间复杂度||
15 | | 1-1-6 用数组实现树结构代码| [无代码]|
16 | | --- 用数组实现树结构时间复杂度| [无代码]|
17 | | 1-1-7 用数组实现图结构代码| [无代码]|
18 | |--- 用数组实现图结构时间复杂度| [无代码]|
19 | | 2 **数组的操作** | [无代码] |
20 | | 2-1 **一维数组的操作**| [无代码] |
21 | | 2-1-1 数组元素的查找操作 | [无代码] |
22 | | 2-1-2 数组元素的增加操作 | [无代码] |
23 | | 2-1-2-1 顺序存储结构的增加操作||
24 | | 2-1-2-1-1 插入到顺序表的表头||
25 | | 2-1-2-1-2 在顺序表的中间位置插入元素||
26 | | 2-1-2-1-3 在顺序表中的最后位置插入元素||
27 | | 2-1-2-2 链式存储结构的增加操作||
28 | | 2-1-2-2-1 插入到链式存储结构的表头||
29 | | 2-1-2-2-2 在链式存储结构的中间位置插入元素||
30 | | 2-1-2-2-3 在链式存储结构的最后位置插入元素||
31 | | 2-1-3 数组元素的更新操作 | [无代码] |
32 | | 2-1-3-1 顺序存储结构的更新操作||
33 | | 2-1-3-2 链式存储结构的更新操作||
34 | | 2-1-4 数组元素的删除操作 | [无代码] |
35 | | 2-1-4-1 顺序存储结构的删除操作||
36 | | 2-1-4-2 链式存储结构的删除操作||
37 | | 2-2 **二维数组(矩阵)的操作** | [无代码] |
38 | | 2-2-1 矩阵类型||
39 | | 2-2-1-1 [对称矩阵](http://data.biancheng.net/view/183.html)||
40 | | 2-2-1-2 [上（下）三角矩阵](http://data.biancheng.net/view/183.html) ||
41 | | 2-2-1-3 [稀疏矩阵](http://data.biancheng.net/view/183.html) ||
42 | | 2-2-1 矩阵操作||
43 | | 2-2-1 矩阵相加| [无代码] |
44 | | 2-2-1 矩阵相乘| [无代码] |
45 | | 2-2-1 转置矩阵| [无代码] |
46 | | 3 **优化数组的存储方式**| [无代码] |
47 | | 3-1 [将多维数组存储在一维内存空间的存储方式](http://data.biancheng.net/view/182.html)| [无代码] |
48 | | 3-1 二维数组(矩阵)的存储方式|[无代码] |
49 | | 3-1-1 规则矩阵压缩代码| [无代码] |
50 | |[二维数组的地址分布究竟是什么样的](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247487411&idx=2&sn=f36c6a5364a976b36f3d6eb22d1d9195&chksm=f9a23ce2ced5b5f4db53d9a5d577364a1ce6eebfd3e3489f2573ee9f8133fdf199f398bc8daa&scene=178&cur_album_id=1485825793120387074#rd)||
51 | | 3-1-2 稀疏矩阵压缩存储（3种方式）| [无代码] |
52 | | 3-1-2 1. [三元组顺序表](http://data.biancheng.net/view/184.html) ||
53 | | 3-1-2 2. [行逻辑链接的顺序表](http://data.biancheng.net/view/185.html)||
54 | | 3-1-2 3. [十字链表](http://data.biancheng.net/view/186.html)||
55 | | 3-1-3 01矩阵压缩代码| [无代码] |
56 | | 4 **数组排序与顺序统计**| [无代码] |
57 | | 5 **数组的查找** ||
58 | | 5-1 线性查找||
59 | | 5-2 二分查找||
60 |
61 |
62 | ## 数组理论知识
63 |
64 | [程序员算法面试中，必须掌握的数组理论知识](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247483956&idx=1&sn=2e63f2ed9d6711fb3485533c178a4ad0&scene=21#wechat_redirect)|
65 | ---|
66 |
67 | 
68 |
69 |
70 | 一维数组是存放在连续内存空间上的相同类型数据的集合，二维数组其实就是一个矩阵，二位数组中其实是一个线性数组存放着 其他数组的首地址，所以二维数据在内存中array[3][4]不是 3*4 的连续地址空间，
71 | 而是四条连续的地址空间组成
72 |
73 | ## [数组的经典题目](https://mp.weixin.qq.com/s/LIfQFRJBH5ENTZpvixHEmg)
74 |
75 | 1. 二分法思想： [数组：每次遇到二分法，都是一看就会，一写就废](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484289&idx=1&sn=929fee0ac9f308a863a4fc4e2e44506e&scene=21#wechat_redirect)
76 | 2. 双指针法思想: [数组：就移除个元素很难么？](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484304&idx=1&sn=ad2e11d171f74ad772fd23b10142e3f3&scene=21#wechat_redirect)
77 | 3. 滑动窗口思想: [数组：滑动窗口拯救了你](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484315&idx=1&sn=414b885abba34abfd8d9f35c9f61b857&scene=21#wechat_redirect)
78 | 4. 模拟行为思想: [数组：这个循环可以转懵很多人！](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484331&idx=1&sn=dc41b2ba53227743f6a1b0433f9db6ef&scene=21#wechat_redirect)
79 |
80 |
81 |
82 |
83 | # 参考
84 |
85 | 程序设计中实用的数据结构.pdf
86 |
87 | 图解数据结构.pdf
88 |
--------------------------------------------------------------------------------
/Data Structure/栈/README.md:
--------------------------------------------------------------------------------
1 |
2 | # 目录
3 |
4 | * [栈 (顺序栈/链式栈) 的数据结构及其相关算法：栈结构包含两个要素，即栈顶指针top和栈大小size，具体操作包括：](#栈)
5 | * [栈的顺序存储结构](#栈的顺序存储结构)
6 | * [栈的链式存储结构](#栈的链式存储结构)
7 | * 链栈--- 链栈实际上就是一个只能采用头插法插入或删除数据的链表
8 | * [单调栈](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/monotone-stack)
9 | * [两栈共享空间](https://zhuanlan.zhihu.com/p/114688589)
10 | * [Java集合中的栈](https://my.oschina.net/Clarences/blog/1594597)
11 | * [栈的操作](#栈的操作)
12 | - [压栈操作push](#压栈操作push)
13 | - [弹栈操作pop](#弹栈操作pop)
14 | - [查看栈顶元素peek](#查看栈顶元素peek)
15 | - [查看栈的大小](#查看栈的大小)
16 | - [查看栈是否为空](#查看栈是否为空)
17 | - [查看栈的最小元素(O(1)时间复杂度)](#查看栈的最小元素时间复杂度)
18 | - 栈的排序
19 | - 栈的查找
20 |
21 |
22 | # 内容
23 | -----
24 |
25 | # 栈
26 | ## 栈的顺序存储结构
27 | ## 栈的链式存储结构
28 | ## 两栈共享空间
29 | ## Java集合中的栈
30 | ## 栈的操作
31 | ### 压栈操作push
32 | ### 弹栈操作pop
33 | ### 查看栈顶元素peek
34 | ### 查看栈的大小
35 | ### 查看栈是否为空
36 | ### 查看栈的最小元素时间复杂度
37 |
38 |
39 |
--------------------------------------------------------------------------------
/Data Structure/树/README.md:
--------------------------------------------------------------------------------
1 |
2 | **在二叉树题目选择什么遍历顺序是不少同学头疼的事情,
3 | 涉及到二叉树的构造，无论普通二叉树还是二叉搜索树一定前序，都是先构造中节点。
4 | 求普通二叉树的属性，一般是后序，一般要通过递归函数的返回值做计算。
5 | 求二叉搜索树的属性，一定是中序了，要不白瞎了有序性了。
6 | 注意在普通二叉树的属性中，我用的是一般为后序，例如单纯求深度就用前序， 二叉树：找所有路径也用了前序，这是为了方便让父节点指向子节点。
7 | 所以求普通二叉树的属性还是要具体问题具体分析**
8 |
9 |
10 |
11 | [几乎刷完了力扣所有的树题，我发现了这些东西](https://lucifer.ren/blog/2020/11/23/tree/)|
12 | ---|
13 |
14 |
15 | # 目录
16 |
17 | * 树的概述
18 | * 1 树的存储结构
19 | * 树的顺序存储
20 | * 树的链表存储
21 | * 树的基本操作
22 | * [树的双亲表示法](http://data.biancheng.net/view/196.html)
23 | * [树的孩子表示法](http://data.biancheng.net/view/197.html)
24 | * [树的孩子兄弟表示法详解](http://data.biancheng.net/view/198.html)
25 | * 2 [二叉树](http://data.biancheng.net/view/192.html)
26 | * [2.1 二叉树的理论基础](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484643&idx=1&sn=a8b3878fe8c72309145acaa50bf8fa4e&scene=21#wechat_redirect)
27 | * 2.2 二叉树类型
28 | * [满二叉树](http://data.biancheng.net/view/192.html)
29 | * [完全二叉树](http://data.biancheng.net/view/192.html)
30 | * [二叉搜索树](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484643&idx=1&sn=a8b3878fe8c72309145acaa50bf8fa4e&scene=21#wechat_redirect)
31 | * [平衡二叉搜索树（AVL树）](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484643&idx=1&sn=a8b3878fe8c72309145acaa50bf8fa4e&scene=21#wechat_redirect)
32 | * [平衡二叉树专题](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/balanced-tree)
33 | * 2.3 二叉树存储结构
34 | * [二叉树的顺序存储](http://data.biancheng.net/view/193.html)
35 | * [二叉树二叉链表存储](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484643&idx=1&sn=a8b3878fe8c72309145acaa50bf8fa4e&scene=21#wechat_redirect)
36 | * 二叉树的三叉链表存储
37 | * 2.4 二叉树的属性
38 | * [二叉树：是否对称](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484775&idx=1&sn=8acc987b8e87f2f322c26bba47bb4867&scene=21#wechat_redirect)
39 | * 递归方法：后序，比较的是根节点的左子树与右子树是不是相互翻转
40 | * 迭代方法：使用队列/栈将两个节点顺序放入容器中进行比较
41 | * [二叉树：求最大深度](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484791&idx=1&sn=2e9f1308520a74441c66fe60691ce241&scene=21#wechat_redirect)
42 | * 递归方法：后序，求根节点最大高度就是最大深度，通过递归函数的返回值做计算树的高度
43 | * 迭代方法：层序遍历
44 | * [二叉树：求最小深度](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484806&idx=1&sn=a643f2a63896706e0cc12a2db6d4fe85&scene=21#wechat_redirect)
45 | * 递归方法：后序，求根节点最小高度就是最小深度，注意最小深度的定义
46 | * 迭代方法：层序遍历
47 | * [二叉树：求有多少个节点](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484827&idx=1&sn=5b784b8814bc971451c86492e74e5fbb&scene=21#wechat_redirect)
48 | * 递归方法：后序，通过递归函数的返回值计算节点数量
49 | * 迭代方法：层序遍历
50 | * [二叉树：是否平衡](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484841&idx=1&sn=fd1380e74ed46c7267b069f3578e2d3a&scene=21#wechat_redirect)
51 | * 递归方法：后序，注意后序求高度和前序求深度，递归过程判断高度差
52 | * 迭代方法：效率很低，不推荐
53 | * [二叉树：找所有路径](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484854&idx=1&sn=bbe5222821da342cae923b1e36bb160c&scene=21#wechat_redirect)
54 | * 递归方法：前序，方便让父节点指向子节点，涉及回溯处理根节点到叶子的所有路径
55 | * 迭代方法：一个栈模拟递归，一个栈来存放对应的遍历路径
56 | * [二叉树：递归中如何隐藏着回溯](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484885&idx=1&sn=590b824ec73eb65de22a7dcc98134d26&scene=21#wechat_redirect)
57 | * [二叉树：求左叶子之和](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484897&idx=1&sn=fbf25da0459ebaec7cc550109fd106b4&scene=21#wechat_redirect)
58 | * 递归方法：后序，必须三层约束条件，才能判断是否是左叶子。
59 | * 迭代方法：直接模拟后序遍历
60 | * [二叉树：求左下角的值](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484911&idx=1&sn=d493e4c5465aa59192ab58d336e588f9&scene=21#wechat_redirect)
61 | * 递归方法：顺序无所谓，优先左孩子搜索，同时找深度最大的叶子节点。
62 | * 迭代方法：层序遍历找最后一行最左边
63 | * [二叉树：求路径总和](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484927&idx=1&sn=476c0cfc2b04d14fe5c32605a2676b9f&scene=21#wechat_redirect)
64 | * 递归方法：顺序无所谓，递归函数返回值为bool类型是为了搜索一条边，没有返回值是搜索整棵树。
65 | * 迭代方法：栈里元素不仅要记录节点指针，还要记录从头结点到该节点的路径数值总和
66 | * [二叉树：公共祖先问题](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247485072&idx=1&sn=1e6c6d28a70ad0f6986ca5f850b74abe&scene=21#wechat_redirect)
67 | * 递归：后序，回溯，找到左子树出现目标值，右子树节点目标值的节点。
68 | * 迭代：不适合模拟回溯
69 | * 2.5 二叉树的基本操作
70 | * [构造二叉树](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484950&idx=1&sn=3900f9433d36dd5406fc1ccb1df07703&scene=21#wechat_redirect)
71 | * 递归：前序，重点在于找分割点，分左右区间构造
72 | * 迭代：比较复杂，意义不大
73 | * [构造最大的二叉树](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484963&idx=1&sn=f0e1e21dc5cda3e6223ba6e4b46593c7&scene=21#wechat_redirect)
74 | * 递归：前序，分割点为数组最大值，分左右区间构造
75 | * 迭代：比较复杂，意义不大
76 | * [翻转二叉树](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484731&idx=1&sn=aa7da461e9c03eb00b3fdbfbfe17e7dc&scene=21#wechat_redirect)
77 | * 递归：前序，交换左右孩子
78 | * 迭代：直接模拟前序遍历
79 | * [合并两个二叉树](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484988&idx=1&sn=03bc66ed9af4f5ddf7891d06b0a850f3&scene=21#wechat_redirect)
80 | * 递归：前序，同时操作两个树的节点，注意合并的规则
81 | * 迭代：使用队列，类似层序遍历
82 | * 2.6 二叉搜索树的属性
83 | * [二叉搜索树中的搜索](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247485012&idx=1&sn=971ad48e3be136ed9e8d10c1e8a25111&scene=21#wechat_redirect)
84 | * 递归：二叉搜索树的递归是有方向的
85 | * 迭代：因为有方向，所以迭代法很简单
86 | * [是不是二叉搜索树](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247485028&idx=1&sn=87e2fe177dd794c0c27d57cb1169f3ce&scene=21#wechat_redirect)
87 | * 递归：中序，相当于变成了判断一个序列是不是递增的
88 | * 迭代：模拟中序，逻辑相同
89 | * [求二叉搜索树的最小绝对差](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247485040&idx=1&sn=5076aed483d61d710eaf3db626df9c4e&scene=21#wechat_redirect)
90 | * 递归：中序，双指针操作
91 | * 迭代：模拟中序，逻辑相同
92 | * [求二叉搜索树的众数](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247485055&idx=1&sn=0f3064622d80255348bfec1d8f222dd3&scene=21#wechat_redirect)
93 | * 递归：中序，清空结果集的技巧，遍历一遍便可求众数集合
94 | * 迭代：模拟中序，逻辑相同
95 | * [二叉搜索树转成累加树](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247485212&idx=1&sn=8f88ae1db8680f906489cbef942f23f8&scene=21#wechat_redirect)
96 | * 递归：中序，双指针操作累加
97 | * 迭代：模拟中序，逻辑相同
98 | * [二叉搜索树的公共祖先问题](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247485103&idx=1&sn=9cd0d08e1c52497b80c1dea395c63d1d&scene=21#wechat_redirect)
99 | * 递归：顺序无所谓，如果节点的数值在目标区间就是最近公共祖先
100 | * 迭代：按序遍历
101 | * 2.7 二叉搜索树的基本操作
102 | * [构造二叉搜索树](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247485194&idx=1&sn=5d28e786feca7c956763269e9ed00f50&scene=21#wechat_redirect)
103 | * 递归：前序，数组中间节点分割
104 | * 迭代：较复杂，通过三个队列来模拟
105 | * [二叉搜索树中的插入操作](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247485117&idx=1&sn=8f34c86fb6e8adea26189c7beb1ffafc&scene=21#wechat_redirect)
106 | * 递归：顺序无所谓，通过递归函数返回值添加节点
107 | * 迭代：按序遍历，需要记录插入父节点，这样才能做插入操作
108 | * [二叉搜索树中的删除操作](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247485135&idx=1&sn=57d1de0ec50e5ccbd4cfd7703de59a8d&scene=21#wechat_redirect)
109 | * 递归：前序，想清楚删除非叶子节点的情况
110 | * 迭代：有序遍历，较复杂
111 | * [修剪二叉搜索树](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247485155&idx=1&sn=0ceeecc5ca1385049b39a81bedcaecfa&scene=21#wechat_redirect)
112 | * 递归：前序，数组中间节点分割
113 | * 迭代：较复杂，通过三个队列来模拟
114 | * 二叉搜索树的构建 基于数组的构建 插入构建
115 | * 二叉搜索树的插入 插入到合适位置，插入后仍然是一颗二叉搜索树 递归算法
116 | * 二叉搜索树的删除(分为删除节点为叶子节点、左子树为空、右子树为空、左右子树均不为空等四个方面，递归算法，删除后仍然是一颗二叉搜索树)
117 | * 二叉搜索树的搜索 Olgn 递归算法](#二叉搜索树的搜索-Olgn-递归算法
118 | * 二叉搜索树的遍历，特别是中序遍历 遍历结果为升序序列 递归算法
119 | * 二叉搜索树的打印 树的前序遍历的应用 递归算法
120 | * 以广义表形式的字符串构建二叉树
121 | * 根据二叉树的前序 中序或中序 后序遍历结果构建二叉树
122 | * 根据二叉树的根结点复制一颗二叉树
123 | * 二叉树的结点总数
124 | * 二叉树的根结点、孩子节点的获取
125 | * 以广义表的形式打印二叉树
126 | * 判断两颗二叉树是否相等
127 | * [n个结点构造多少种树](http://data.biancheng.net/view/35.html)
128 | * [遍历二叉树](https://www.kancloud.cn/fe_lucifer/leetcode/1996365)
129 | * [二叉树的遍历](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/binary-tree-traversal)
130 | * 普通二叉树的遍历---如果算法中多次涉及到对二叉树的遍历，普通的二叉树就**需要使用栈结构**做重复性的操作
131 | * [深度优先遍历---先往深走，遇到叶子节点再往回走，这里的前中后序，其实指的就是中间节点的遍历顺序，中间节点的顺序就是所谓的遍历方式](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484643&idx=1&sn=a8b3878fe8c72309145acaa50bf8fa4e&scene=21#wechat_redirect)
132 | * [前序遍历---中左右，中间节点在前](http://data.biancheng.net/view/143.html)
133 | * [实现前序遍历的方法一：递归法](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484654&idx=1&sn=0c22c8b8771acc2387bf37ac255749f0&scene=21#wechat_redirect)
134 | * [实现前序遍历的方法二：迭代法,借助栈使用非递归的方式来实现 ](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484677&idx=1&sn=e04b4a5baa7a3f6b090947bfa8aea97a&scene=21#wechat_redirect)
135 | * [二叉树：前中后序: 迭代法统一风格](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484687&idx=1&sn=85cd297b3c9927467e4048b1f50aa938&scene=21#wechat_redirect)
136 | * [中序遍历---左中右，中间节点在中](http://data.biancheng.net/view/144.html)
137 | * [实现中序遍历的方法一：递归法](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484654&idx=1&sn=0c22c8b8771acc2387bf37ac255749f0&scene=21#wechat_redirect)
138 | * [实现中序遍历的方法二：迭代法, 借助栈使用非递归的方式来实现 ](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484677&idx=1&sn=e04b4a5baa7a3f6b090947bfa8aea97a&scene=21#wechat_redirect)
139 | * [二叉树：前中后序: 迭代法统一风格](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484687&idx=1&sn=85cd297b3c9927467e4048b1f50aa938&scene=21#wechat_redirect)
140 | * [后序遍历---左右中，中间节点在后](http://data.biancheng.net/view/145.html)
141 | * [实现后序遍历的方法一：递归法](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484654&idx=1&sn=0c22c8b8771acc2387bf37ac255749f0&scene=21#wechat_redirect)
142 | * [实现后序遍历的方法二：迭代法, 借助栈使用非递归的方式来实现 ](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484677&idx=1&sn=e04b4a5baa7a3f6b090947bfa8aea97a&scene=21#wechat_redirect)
143 | * [二叉树：前中后序: 迭代法统一风格](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484687&idx=1&sn=85cd297b3c9927467e4048b1f50aa938&scene=21#wechat_redirect)
144 | * 广度优先遍历---一层一层的去遍历
145 | * [广度优先按层遍历](http://data.biancheng.net/view/27.html)
146 | * [实现广度优先遍历的方法：使用队列来实现，需要先进先出的结构，才能一层一层的来遍历二叉树 ](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484713&idx=1&sn=2072608d432def7457fdfa27b73d8193&scene=21#wechat_redirect)
147 | * [线索二叉树的遍历---线索二叉树**不需要使用栈结构**，在遍历的同时，使用二叉树中空闲的内存空间记录某些结点的前趋和后继元素的位置（不是全部）](http://data.biancheng.net/view/28.html)
148 | * [双向线索二叉树的遍历](http://data.biancheng.net/view/29.html)
149 | * 排序二叉树
150 | * [二叉树：总结篇](https://mp.weixin.qq.com/s/-ZJn3jJVdF683ap90yIj4Q)
151 | * 3 平衡二叉树（AVL树）
152 | * [平衡二叉树专题](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/balanced-tree)
153 | * [4 B-Tree](https://www.cnblogs.com/dongguacai/p/7239599.html)
154 | * 5 [红黑树](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247487806&idx=1&sn=0bfb1e78b0297883857958bfe73cd375&chksm=f9a2226fced5ab792d28daf4c7d1ba9a447670de97891d218f257bff8133c86e8c7e3edd43d9&scene=178&cur_album_id=1485825793120387074#rd)
155 | * 6 特殊树
156 | * 6.1 区间树
157 | * [6.2 前缀树---字典树](https://oi-wiki.org/string/trie/)
158 | * [前缀树应用](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/trie)
159 | * [字典序列删除](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/selected/a-deleted)
160 | * [6.3 后缀平衡树](https://oi-wiki.org/string/suffix-bst/)
161 | * 6.4 最小生成树
162 | * 6.5 树状数组
163 | * [8 回文树](https://oi-wiki.org/string/pam/)
164 | * [9 哈夫曼树](http://data.biancheng.net/view/33.html)
165 | * [哈夫曼编码和游程编码](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/run-length-encode-and-huffman-encode)
166 | * [10 并查集](https://oi-wiki.org/ds/dsu/)
167 | * [并查集应用](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/union-find)
168 | * [11 森林---由 m（m >= 0）个互不相交的树组成的集合被称为森林]()
169 | * 转换方法
170 | * [森林 树和二叉树的转换](http://data.biancheng.net/view/199.html)
171 | * 树转换为二叉树
172 | * 二叉树转换树
173 | * 森林转换为二叉树
174 | * 二叉树转换森林
175 | * 树和森林的遍历
176 |
177 |
178 | # 内容
179 |
180 |
181 |
182 | # 有用的参考
183 |
184 | * [数据结构 - 二叉树学习笔记](https://mrbird.cc/%E4%BA%8C%E5%8F%89%E6%A0%91%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0.html)
185 |
--------------------------------------------------------------------------------
/Data Structure/树/二叉树.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | * [二叉树的遍历算法](https://www.kancloud.cn/fe_lucifer/leetcode/1996365)
4 | * [二叉树：总结篇](https://mp.weixin.qq.com/s/-ZJn3jJVdF683ap90yIj4Q)
5 |
--------------------------------------------------------------------------------
/Data Structure/矩阵/README.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/Data Structure/递归/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | # 有用的参考
7 |
8 | * [漫谈递归系列1：递归的思想 用归纳法来理解递归](http://www.nowamagic.net/librarys/veda/detail/2314)
9 | * [漫谈递归系列2：递归需要满足的两个条件 还是拿斐波那契数列来做例子](http://www.nowamagic.net/librarys/veda/detail/2314)
10 | * [漫谈递归系列3：字符串回文现象的递归判断 回文符合递归的两个条件](http://www.nowamagic.net/librarys/veda/detail/2316)
11 | * [漫谈递归系列4：二分查找算法的递归实现 用递归写一个二分查找](http://www.nowamagic.net/librarys/veda/detail/2317)
12 | * [漫谈递归系列5：递归的效率问题 效率和开销问题是递归最大的缺点](http://www.nowamagic.net/librarys/veda/detail/2321)
13 | * [漫谈递归系列6：递归与循环 大部分递归可以转化为循环](http://www.nowamagic.net/librarys/veda/detail/2322)
14 | * [漫谈递归系列7：循环与迭代是一回事吗？ 理清递归、迭代、循环的概念](http://www.nowamagic.net/librarys/veda/detail/2324)
15 | * [漫谈递归系列8: 递归计算过程与迭代计算过程 编程需要了解的基础知识](http://www.nowamagic.net/librarys/veda/detail/2280)
16 | * [漫谈递归系列9：从斐波那契开始了解尾递归 对尾递归的大概了解](http://www.nowamagic.net/librarys/veda/detail/2325)
17 | * [漫谈递归系列10：尾递归与CPS 尾递归就是Continuation Passing Style](http://www.nowamagic.net/librarys/veda/detail/2331)
18 | * [漫谈递归：补充一些Continuation的知识 Continuation在函数式编程是非常自然的](http://www.nowamagic.net/librarys/veda/detail/2332)
19 | * [漫谈递归：PHP里的尾递归及其优化 PHP编译器没有对尾递归进行优化](http://www.nowamagic.net/librarys/veda/detail/2334)
20 | * [漫谈递归：从汇编看尾递归的优化 尾递归的编译器优化](http://www.nowamagic.net/librarys/veda/detail/2336)
21 |
--------------------------------------------------------------------------------
/Data Structure/链表/README.md:
--------------------------------------------------------------------------------
1 |
2 | [几乎刷完了力扣所有的链表题，我发现了这些东西](https://lucifer.ren/blog/2020/11/08/linked-list/)|[链表：总结篇](https://mp.weixin.qq.com/s/vK0JjSTHfpAbs8evz5hH8A)|
3 | ---|---|
4 |
5 | # 目录
6 |
7 | * [线性表---LinkList]()
8 | * [1 链表的理论基础](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247488536&idx=2&sn=74702c7d7fb54b18199bc50d8e660d6a&scene=21#wechat_redirect)
9 | * 2 线性表的顺序存储结构
10 | * 3 线性表的链式存储结构
11 | * [4 顺序表和链表优缺点](http://data.biancheng.net/view/162.html)
12 | * [静态链表和动态链表的区别](https://blog.csdn.net/zhengqijun_/article/details/78192888#:~:text=%E9%9D%99%E6%80%81%E9%93%BE%E8%A1%A8%E5%92%8C%E5%8A%A8%E6%80%81%E9%93%BE%E8%A1%A8%E6%98%AF%E7%BA%BF%E6%80%A7%E8%A1%A8%E9%93%BE%E5%BC%8F,%E9%A2%84%E5%85%88%E5%88%86%E9%85%8D%E5%9C%B0%E5%9D%80%E7%A9%BA%E9%97%B4%E5%A4%A7%E5%B0%8F%E3%80%82&text=2%E3%80%81%E5%8A%A8%E6%80%81%E9%93%BE%E8%A1%A8%E6%98%AF%E7%94%A8,%E7%9A%84%E9%95%BF%E5%BA%A6%E4%B8%8A%E6%B2%A1%E6%9C%89%E9%99%90%E5%88%B6%E3%80%82)
13 | * 5 线性表的基本操作
14 | * 5.1 单链表
15 | * [链表：听说用虚拟头节点会方便很多？](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484132&idx=1&sn=032d3d00bdfb7179941306a2aa50c9f1&scene=21#wechat_redirect)
16 | * [链表的建立](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484144&idx=1&sn=d2783ac63a1e93f7fc7d174308f6b400&scene=21#wechat_redirect)
17 | * [链表的增加](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484144&idx=1&sn=d2783ac63a1e93f7fc7d174308f6b400&scene=21#wechat_redirect)
18 | * [链表的删除](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484144&idx=1&sn=d2783ac63a1e93f7fc7d174308f6b400&scene=21#wechat_redirect)
19 | * [删除链表倒数第N个节点，怎么删](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247488822&idx=2&sn=f431fba72493f4527d379bd077364a54&scene=21#wechat_redirect)
20 | * [时间复杂度为O(1)的删除链表结点方法 从分析与思考中找到答案](http://www.nowamagic.net/librarys/veda/detail/261)
21 | * [链表的更改](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484144&idx=1&sn=d2783ac63a1e93f7fc7d174308f6b400&scene=21#wechat_redirect)
22 | * [链表是否为空](#链表是否为空)
23 | * [链表的大小](#链表的大小)
24 | * [链表的打印输出](#链表的打印输出)
25 | * [删除链表重复节点](#删除链表重复节点)
26 | * [链表倒数第K个元素](#链表倒数第K个元素)
27 | * 单链表的反转
28 | * 双指针法链表的反转
29 | * 递归法链表的反转
30 | * [单链表的反转方法一](http://c.biancheng.net/view/8105.html)
31 | * [单链表的反转方法二](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484158&idx=1&sn=60a756f681e2edeab28962c70b603ef9&scene=21#wechat_redirect)
32 | - [链表的倒序输出](#链表的倒序输出)
33 | - [链表的中间节点](#链表的中间节点)
34 | - [ 如何判断链表中有环](https://blog.csdn.net/sinat_35261315/article/details/79205157)
35 | - [链表节点的删除(不知道头结点的情况下](#链表节点的删除不知道头结点的情况下)
36 | - [ 如何判断两个单链表相交](https://www.nowcoder.com/questionTerminal/db55f7f21127403cb268ffad9d23af37)
37 | - [链表相交，找出交点](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247488961&idx=2&sn=b14c2e7b54a8e44b0135128978685a8b&scene=21#wechat_redirect)
38 | - [链表的交点](#链表的交点)
39 | - [多项式的列表表示法](#多项式的列表表示法)
40 |
41 | * [5.2 静态链表---StaticLinkList 兼顾了顺序表和链表的优点于一身，可以看做是顺序表和链表的升级版](http://data.biancheng.net/view/163.html)
42 |
43 | * [5.3 双向链表---LinkListDouble](#双向链表)
44 | - 双向链表的建立
45 | - 双向链表的节点插入
46 | - 添加至表头
47 | - 添加至表的中间位置
48 | - 添加至表尾
49 | - 双向链表的节点删除
50 | * [5.4 环链表---LinkListConnect](#环链表)
51 | - 环型链表的建立
52 | - 环型链表的节点插入
53 | - 环型链表的节点删除
54 | - 环型链表的串联
55 | - 环型链表表示稀疏矩阵
56 | - [在链表如何找环，以及如何找环的入口位置](https://mp.weixin.qq.com/s?__biz=MzUxNjY5NTYxNA==&mid=2247484171&idx=1&sn=72ba729f2f4b696dfc4987e232f1ad2d&scene=21#wechat_redirect)
57 | * [5.5 双向环链表]()
58 | * 6 链栈---LinkStack
59 | * 7 两栈共享空间---DoubleStack
60 | * [8 线性表的分析](#线性表的分析)
61 | * [线性表的实现分析](#线性表的实现分析)
62 | * [线性表的功能](#线性表的功能)
63 | * [跳表](https://oi-wiki.org/ds/skiplist/)
64 | * [9 链表：总结篇](https://mp.weixin.qq.com/s/vK0JjSTHfpAbs8evz5hH8A)
65 |
66 | # 内容
67 | ---
68 |
69 | ## 线性表的基本操作
70 | ## 线性表的顺序存储结构
71 |
72 | 线性表的顺序存储结构比较适合元素个数不太变化，而更多是存取数据的应用
73 |
74 | 线性表的顺序存储结构的优缺点：
75 |
76 | 优点：
77 |
78 | 1. 可快速存取表中任一位置的元素
79 |
80 |
81 | 缺点：
82 |
83 | 1. 插入和删除需要移动大量元素
84 |
85 | 2. 有存储空间的“碎片”
86 |
87 |
88 |
89 | ## 线性表的链式存储结构
90 | ### 单链表
91 | 单向链表的数据结构及其相关算法：单向链表结构包含两个要素，即头结点head和链表大小size，具体操作包括
92 | #### 链表的建立
93 | #### 链表的增加
94 | #### 链表的删除
95 | #### 链表的更改
96 | #### 链表是否为空
97 | #### 链表的大小
98 | #### 链表的打印输出
99 | #### 删除链表重复节点
100 | #### 链表倒数第K个元素
101 | #### 链表的反转
102 | #### 链表的倒序输出
103 | #### 链表的中间节点
104 | #### 链表是否有环
105 | #### 链表节点的删除不知道头结点的情况下
106 | #### 链表是否相交
107 | #### 链表的交点
108 | #### 多项式的列表表示法
109 |
110 | ### 静态链表
111 | ### 双向链表
112 | ### 环链表
113 | ## 线性表的分析
114 | ### 线性表的实现分析
115 | ### 线性表的功能
116 |
--------------------------------------------------------------------------------
/Data Structure/队列/README.md:
--------------------------------------------------------------------------------
1 | # 目录
2 |
3 | * [队列](#队列)
4 | * [系统性能百倍提升典型案例分析：高性能队列Disruptor](https://www.jianshu.com/p/03d1930f9b90)
5 | * [基于数组的队列实现](#基于数组的队列实现)
6 | * 基于循环数组的队列实现
7 | * [基于链表的队列实现](#基于数组的队列实现)
8 | * [基于栈的队列实现](#基于栈的队列实现)
9 | * [循环队列](https://www.jianshu.com/p/6b88855017d5)
10 | * 优先级队列----优先级队列其实是一个堆，堆就是一棵完全二叉树
11 | * 链队列---LinkQueue
12 | * ArrayBlockingQueue
13 | * 双向队列
14 | * Queue源码分析
15 | * Deque源码分析
16 | * [Java集合中的队列](#Java集合中的队列)
17 | * [队列操作](#队列操作)
18 | - [入队操作put](#入队操作put)
19 | - [出队操作pop](#出队操作pop)
20 | - [查看队头元素peek](#查看队头元素peek)
21 | - [查看队列的大小](#查看队列的大小)
22 | - [查看队列是否为空](#查看队列是否为空)
23 |
24 |
25 |
26 | # 内容
27 |
28 | ## 队列
29 | 基于数组的实现、基于链表的实现和基于栈的实现)的数据结构及其相关算法：队列结构包含三个要素，即队头指针head、队尾指针rear和队列大小size
30 | ## 基于数组的队列实现
31 | ## 基于数组的队列实现
32 | ## 基于栈的队列实现
33 | ## 环队列
34 | ## Java集合中的队列
35 | ## 队列操作
36 | ### 入队操作put
37 | ### 出队操作pop
38 | ### 查看队头元素peek
39 | ### 查看队列的大小
40 | ### 查看队列是否为空
41 |
42 |
--------------------------------------------------------------------------------
/Data Structure/集合/README.md:
--------------------------------------------------------------------------------
1 |
2 | # java 集合框架
3 |
4 |
--------------------------------------------------------------------------------
/Interview/README.md:
--------------------------------------------------------------------------------
1 |
2 | 数据结构和算法分析，对于一名程序员来说，会比不会好而且在工作中绝对能派上用场。数组、链表是基础，栈和队列深入一些但也不难，树挺重要的，比较重要的树AVL树、红黑树，可以不了解它们的具体实现，但是要知道什么是二叉查找树、什么是平衡树，AVL树和红黑树的区别
3 |
4 | ---
5 |
6 | # 基础类型(Primitives)
7 |
8 |
9 | 基础类型(Primitives)与封装类型(Wrappers)的区别在哪里？
10 |
11 | 1 传递方式不同
12 |
13 | 封装类是引用类型。基本类型（原始数据类型）在传递参数时都是按值传递，而封装类型是按引用传递的(其实“引用也是按值传递的”，传递的是对象的地址)。由于包装类型都是final修饰的不可变量，因此没有提供改变它值的方法，增加了对“按引用传递”的理解难度。
14 | int是基本类型，直接存放数值；Integer是类，产生对象时用一个引用指向这个对象。
15 |
16 | 2 封装类可以有方法和属性
17 |
18 | 封装类可以有方法和属性，利用这些方法和属性来处理数据，如Integer.parseInt(Strings)。基本数据类型都是final修饰的，不能继承扩展新的类、新的方法。
19 |
20 | 3 默认值不同
21 |
22 | 基本类型跟封装类型的默认值是不一样的。如int i,i的预设为0；Integer j，j的预设为null,因为封装类产生的是对象，对象默认值为null。
23 |
24 | 4 存储位置
25 |
26 | 基本类型在内存中是存储在栈中，引用类型的引用（值的地址）存储在栈中，而实际的对象（值）是存在堆中。
27 | 基本数据类型的好处就是速度快（不涉及到对象的构造和回收），封装类的目的主要是更好的处理数据之间的转换。JDK5.0开始可以自动封包了，基本数据类型可以自动封装成封装类。
28 |
29 | * [基础类型(Primitives)与封装类型(Wrappers)的区别](https://blog.csdn.net/xzp_12345/article/details/79038251)
30 |
31 |
32 |
33 |
34 | 简述九种基本数据类型的大小，以及他们的封装类。
35 |
36 |
37 |
38 |
39 |
40 | w
41 | 延伸关于Integer和int的比较 ：
42 |
43 | 由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。
44 |
45 | ```java
46 |
47 | Integer i = new Integer(100);
48 | Integer j = new Integer(100);
49 | System.out.print(i == j); //false
50 |
51 | ```
52 |
53 | Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）
54 |
55 | ```java
56 |
57 | Integer i = new Integer(100);
58 | int j = 100；
59 | System.out.print(i == j); //true
60 |
61 | ```
62 |
63 | 非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）
64 |
65 | ```java
66 | Integer i = new Integer(100);
67 | Integer j = 100;
68 | System.out.print(i == j); //false
69 |
70 | ```
71 |
72 | 对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false
73 |
74 | ```java
75 |
76 | Integer i = 100;
77 | Integer j = 100;
78 | System.out.print(i == j); //true
79 | Integer i = 128;
80 | Integer j = 128;
81 | System.out.print(i == j); //false
82 |
83 | ```
84 |
85 | 对于第4条的原因：
86 | java在编译Integer i = 100 ;时，会翻译成为Integer i = Integer.valueOf(100)；，而java API中对Integer类型的valueOf的定义如下：
87 |
88 | ```java
89 |
90 | public static Integer valueOf(int i){
91 | assert IntegerCache.high >= 127;
92 | if (i >= IntegerCache.low && i <= IntegerCache.high){
93 | return IntegerCache.cache[i + (-IntegerCache.low)];
94 | }
95 | return new Integer(i);
96 | }
97 |
98 | ```
99 |
100 | java对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了。
101 |
102 |
103 |
104 | parseInt()
105 | parseInt()将把该字符之前的字符串转换成数字。parseInt()方法还有基模式，可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。基是由parseInt()方法的第二个参数指定的，所以要解析十六进制的值，当然，对二进制、八进制，甚至十进制（默认模式），都可以这样调用parseInt()方法。
106 | 如果十进制数包含前导0，那么最好采用基数10，这样才不会意外地得到八进制的值。
107 |
108 | ```java
109 |
110 | static int parseInt(String s)
111 | static int parseInt(String s, int radix)
112 |
113 | ```
114 |
115 | * [int和Integer的区别](https://www.cnblogs.com/guodongdidi/p/6953217.html)
116 |
117 |
118 |
119 |
120 |
121 | 如何去小数四舍五入保留小数点后两位？
122 |
123 | //使用银行家算法
124 | BigDecimal i = d.multiply(r).setScale(2,RoundingMode.HALF_EVEN);
125 |
126 | 推荐使用BigDecimal ，并且采用setScale方法来设置精确度，同时使用RoundingMode.HALF_UP表示使用最近数字舍入法则来近似计算。在这里我们可以看出BigDecimal和四舍五入是绝妙的搭配。
127 |
128 | * [java的四舍五入](https://www.cnblogs.com/chenssy/p/3366632.html)
129 |
130 |
131 |
132 |
133 | char 型变量中能不能存贮一个中文汉字，为什么？
134 |
135 | char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。
136 |
137 | 补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。
138 |
139 |
140 |
141 |
142 | # 类型转换
143 |
144 |
145 | 怎样将 bytes 转换为 long 类型
146 |
147 | ```java
148 |
149 | public static long bytes2long(byte[] b) {
150 | long temp = 0;
151 | long res = 0;
152 | for (int i=0;i<8;i++) {
153 | res <<= 8;
154 | temp = b[i] & 0xff;
155 | res |= temp;
156 | }
157 | return res;
158 | }
159 |
160 | ```
161 |
162 |
163 |
164 |
165 | .怎么将 string 转成 byte
166 |
167 | ```java
168 |
169 | string s = "Hello!!";
170 | byte[] b = new byte[1024*1024];
171 | b = System.Text.Encoding.ASCII.GetBytes(s);
172 | //当string含有中文字符时用 System.Text.Encoding.UTF8.GetBytes(s);
173 | sock.Send(b);
174 |
175 | ```
176 |
177 |
178 |
179 | .怎么将 byte 转换为 String
180 |
181 | ```java
182 |
183 | byte[] b1 = new byte[1024*1024*2];
184 | sock.Receive(b1);
185 | string s1 = System.Text.Encoding.ASCII.GetString(b1);
186 |
187 | ```
188 |
189 | // System.Text.Encoding.UTF8.GetString(b1);
190 |
191 |
192 |
193 | 注意： 在把byte数组转换成string的时候，由于byte数组有2M的字节，所以转换后得到的字符串s1也会填充到2M的字符（用\0来填充）
194 | 所以，为了避免这个问题，可以使用Receive返回的字节数来确定接收到byte的长度
195 |
196 | ```java
197 |
198 | int length = sock.Receive(b1);
199 | string s1 = System.Text.Encoding.ASCII.GetString(b1, 0, length);
200 | //这样，s1就为byte实际的值
201 |
202 | ```
203 |
204 |
205 |
206 |
207 | 如何将数值型字符转换为数字
208 |
209 | **string和int之间的转换**
210 |
211 | string转换成int : Integer.valueOf("12")
212 |
213 | int转换成string : String.valueOf(12)
214 |
215 | **char转int之间的转换**
216 |
217 | 首先将char转换成string
218 |
219 | String str=String.valueOf('2')
220 |
221 | Integer.valueof(str) 或者Integer.PaseInt(str)
222 |
223 | Integer.valueof返回的是Integer对象，Integer.paseInt返回的是int
224 |
225 |
226 |
227 |
228 | 我们能将 int 强制转换为 byte 类型的变量吗？如果该值大于 byte 类型的范围，将会出现什么现象
229 |
230 | **1. Byte转int**
231 |
232 | ```java
233 |
234 | public static int bytes2int(byte[] bytes) {
235 | int num = bytes[0] & 0xFF;
236 | num |= ((bytes[1] << 8) & 0xFF00);
237 | num |= ((bytes[2] << 16) & 0xFF0000);
238 | num |= ((bytes[3] << 24) & 0xFF000000);
239 | return num;
240 | }
241 |
242 | ```
243 |
244 | **2. int转 byte**
245 |
246 | ```java
247 |
248 | public static byte[] int2bytes(int i) {
249 | byte[] b = new byte[4];
250 | b[0] = (byte) (0xff&i);
251 | b[1] = (byte) ((0xff00&i) >> 8);
252 | b[2] = (byte) ((0xff0000&i) >> 16);
253 | b[3] = (byte) ((0xff000000&i) >> 24);
254 | return b;
255 | }
256 |
257 | ```
258 |
259 |
260 |
261 |
262 | 能在不进行强制转换的情况下将一个 double 值赋值给 long 类型的变量吗?
263 |
264 | ```java
265 |
266 | public static void main(String[] args) {
267 | double d = 88.88;
268 | long l = Math.round(d);
269 | System.out.println(l);
270 |
271 | long ll = 100L;
272 | double dd = (double) ll;
273 | System.out.println(dd);
274 | }
275 |
276 | ```
277 |
278 |
279 |
280 |
281 | # 数组
282 |
283 |
284 | 如何权衡是使用无序的数组还是有序的数组
285 |
286 | 在数据偏向查找操作的时候用有序数组快一些，在数据偏向插入的时候，无序数组好一些。删除操作效率一样。
287 |
288 |
289 |
290 |
291 |
292 |
293 | 怎么判断数组是 null 还是为空
294 |
295 | （无论使用哪种类型的数组，数组标识符其实只是一个引用，指向在堆中创建的一个真实对象 Int[] A =new int[10];new 一下就是实例化了，开辟了内存空间，基本数据类型的元素会被赋初始值，数组建立后长度不能改变，但是还是可以重新赋值）
296 |
297 | 有如下两个变量定义：
298 |
299 | 1 int[] zero = new int[0];
300 |
301 | 2 int[] nil = null;
302 |
303 | 这两种定义有什么区别呢？
304 |
305 | zero是一个长度为0的数组，我们称之为“空数组”，空数组也是一个对象，只是包含元素个数为0。nil是一个数组类型的空引用。
306 |
307 |
308 |
309 |
310 | Array 和 ArrayList有什么区别？什么时候应该使用Array而不是ArrayList?
311 |
312 | 1）精辟阐述：
313 |
314 | 可以将 ArrayList想象成一种“会自动扩增容量的Array”。
315 |
316 | 2）Array（[]）：最高效；但是其容量固定且无法动态改变；
317 |
318 | ArrayList： 容量可动态增长；但牺牲效率；
319 |
320 | 3）建议：
321 | 基于效率和类型检验，应尽可能使用Array，无法确定数组大小时才使用ArrayList！
322 |
323 | 不过当你试着解决更一般化的问题时，Array的功能就可能过于受限。
324 |
325 | 4）Java中一切皆对象，Array也是对象。不论你所使用得Array型别为何，Array名称本身实际上是个reference，指向heap之内得某个实际对象。这个对象可经
326 | 由“Array初始化语法”被自动产生，也可以以new表达式手动产生。
327 |
328 | 5）Array可做为函数返回值，因为它本身是对象的reference；
329 |
330 | 6）对象数组与基本类型数组在运用上几乎一模一样，唯一差别在于，前者持有得是reference，后者直接持有基本型别之值；
331 |
332 | 例如：
333 |
334 | ```java
335 | string [] staff=new string[100];
336 | int [] num=new int[10];
337 |
338 | ```
339 |
340 | 7）容器所持有的其实是一个reference指向Object，进而才能存储任意型别。当然这不包括基本型别，因为基本型别并不继承自任何classes。
341 |
342 | 8）面对Array，我们可以直接持有基本型别数值的Array（例如：int [] num;),也可以持有reference（指向对象）的Array；但是容器类仅能持有reference（指向对象），若要将基本型别置于容器内，需要使用wrapper类。但是wrapper类使用起来可能不很容易上手，此外，primitives Array的效率比起“容纳基本型别之外覆类（的reference）”的容器好太多了。
343 |
344 | 当然，如果你的操作对象是基本型别，而且需要在空间不足时自动扩增容量，Array便不适合，此时就得使用外覆类的容器了。
345 |
346 | 9）某些情况下，容器类即使没有转型至原来的型别，仍然可以运作无误。有一种情况尤其特别：编译器对String class提供了一些额外的支持，使它可以平滑运作。
347 |
348 | 10）对数组的一些基本操作，像排序、搜索与比较等是很常见的。因此在Java中提供了Arrays类协助这几个操作
349 |
350 | sort(),binarySearch(),equals(),fill(),asList().
351 |
352 | 不过Arrays类没有提供删除方法，而ArrayList中有remove()方法，不知道是否是不需要在Array中做删除等操作的原因（因为此时应该使用链表）。
353 |
354 | 11）ArrayList的使用也很简单：产生ArrayList，利用add()将对象置入，利用get(i）配合索引值将它们取出。这一切就和Array的使用方式完全相同，只不过少了[]而已。
355 |
356 | 换一种简单说法：
357 |
358 | 1）效率：
359 |
360 | 数组扩容是对ArrayList效率影响比较大的一个因素。
361 |
362 | 每当执行Add、AddRange、Insert、InsertRange等添加元素的方法，都会检查内部数组的容量是否不够了，如果是，它就会以当前容量的两倍来重新构建一个数组，将旧元素Copy到新数组中，然后丢弃旧数组，在这个临界点的扩容操作，应该来说是比较影响效率的。
363 |
364 | ArrayList是Array的复杂版本
365 |
366 | ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚至于ArrayList的许多方法，如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。
367 |
368 | 2）类型识别：
369 |
370 | ArrayList存入对象时，抛弃类型信息，所有对象屏蔽为Object，编译时不检查类型，但是运行时会报错。但是现在有jdk1.5后引入泛型来进行编译检查类型，如错存入了不同类型会直接报错。
371 |
372 | ArrayList与数组的区别主要就是由于动态增容的效率问题了
373 |
374 | 3）ArrayList可以存任何Object，如String等。
375 |
376 |
377 |
378 |
379 | 数组和链表数据结构描述，各自的时间复杂度
380 |
381 | 数组是将元素在内存中连续存放，由于每个元素占用内存相同，可以通过下标迅速访问数组中任何元素。但是如果要在数组中增加一个元素，需要移动大量元素，在内存中空出一个元素的空间，然后将要增加的元素放在其中。同样的道理，如果想删除一个元素，同样需要移动大量元素去填掉被移动的元素。如果应用需要快速访问数据，很少插入和删除元素，就应该用数组。
382 |
383 | 链表中的元素在内存中不是顺序存储的，而是通过存在元素中的指针联系到一起，每个结点包括两个部分：一个是存储 数据元素的数据域，另一个是存储下一个结点地址的 指针。 如果要访问链表中一个元素，需要从第一个元素开始，一直找到需要的元素位置。但是增加和删除一个元素对于链表数据结构就非常简单了，只要修改元素中的指针就可以了。如果应用需要经常插入和删除元素你就需要用链表。
384 |
385 |
386 | 内存存储区别
387 |
388 | 数组从栈中分配空间, 对于程序员方便快速,但自由度小。链表从堆中分配空间, 自由度大但申请管理比较麻烦.
389 |
390 | 逻辑结构区别
391 |
392 | 数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费。
393 |
394 | 链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项）
395 |
396 | 总结
397 | 1、存取方式上，数组可以顺序存取或者随机存取，而链表只能顺序存取；
398 |
399 | 2、存储位置上，数组逻辑上相邻的元素在物理存储位置上也相邻，而链表不一定；
400 |
401 | 3、存储空间上，链表由于带有指针域，存储密度不如数组大；
402 |
403 | 4、按序号查找时，数组可以随机访问，时间复杂度为O(1)，而链表不支持随机访问，平均需要O(n)；
404 |
405 | 5、按值查找时，若数组无序，数组和链表时间复杂度均为O(1)，但是当数组有序时，可以采用折半查找将时间复杂度降为O(logn)；
406 |
407 | 6、插入和删除时，数组平均需要移动n/2个元素，而链表只需修改指针即可；
408 |
409 | 7、空间分配方面：
410 |
411 | 数组在静态存储分配情形下，存储元素数量受限制，动态存储分配情形下，虽然存储空间可以扩充，但需要移动大量元素，导致操作效率降低，而且如果内存中没有更大块连续存储空间将导致分配失败；
412 |
413 | 链表存储的节点空间只在需要的时候申请分配，只要内存中有空间就可以分配，操作比较灵活高效；
414 |
415 | 数组有没有length()这个方法? String有没有length()这个方法
416 |
417 |
418 |
419 |
420 | 为什麽数组从栈中分配空间？
421 |
422 | * [数组是分配在栈中的](https://blog.csdn.net/lcl19970203/article/details/54428358)
423 |
424 |
425 |
426 | # 队列
427 |
428 |
429 | 队列和栈是什么，列出它们的区别
430 |
431 | 队列（Queue）：是限定只能在表的一端进行插入和在另一端进行删除操作的线性表；
432 |
433 | 栈（Stack）：是限定只能在表的一端进行插入和删除操作的线性表。
434 |
435 | 区别如下：
436 |
437 | **规则不同**
438 |
439 | 1. 队列：先进先出（First In First Out）FIFO
440 |
441 | 2. 栈：先进后出（First In Last Out ）FILO
442 |
443 | **对插入和删除操作的限定不同**
444 |
445 | 1. 队列：只能在表的一端进行插入，并在表的另一端进行删除；
446 |
447 | 2. 栈：只能在表的一端插入和删除。
448 |
449 | **遍历数据速度不同**
450 |
451 | 1. 队列：基于地址指针进行遍历，而且可以从头部或者尾部进行遍历，但不能同时遍历，无需开辟空间，因为在遍历的过程中不影响数据结构，所以遍历速度要快；
452 |
453 | 2. 栈：只能从顶部取数据，也就是说最先进入栈底的，需要遍历整个栈才能取出来，而且在遍历数据的同时需要为数据开辟临时空间，保持数据在遍历前的一致性
454 |
455 |
456 |
457 |
458 | BlockingQueue是什么
459 |
460 | 阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。
461 |
462 | * [Java中的阻塞队列](http://www.importnew.com/17537.html)
463 |
464 |
465 |
466 |
467 |
468 | Java里的7种阻塞队列是什么
469 |
470 | JDK7提供了7个阻塞队列。分别是
471 |
472 | 1. ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。
473 |
474 | 2. LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。
475 |
476 | 3. PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。
477 |
478 | 4. DelayQueue：一个使用优先级队列实现的无界阻塞队列。
479 |
480 | 5. SynchronousQueue：一个不存储元素的阻塞队列。
481 |
482 | 6. LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。
483 |
484 | 7. LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。
485 |
486 | **ArrayBlockingQueue**
487 |
488 | ArrayBlockingQueue是一个用数组实现的有界阻塞队列。此队列按照先进先出（FIFO）的原则对元素进行排序。默认情况下不保证访问者公平的访问队列，所谓公平访问队列是指阻塞的所有生产者线程或消费者线程，当队列可用时，可以按照阻塞的先后顺序访问队列，即先阻塞的生产者线程，可以先往队列里插入元素，先阻塞的消费者线程，可以先从队列里获取元素。通常情况下为了保证公平性会降低吞吐量。我们可以使用以下代码创建一个公平的阻塞队列：
489 |
490 | 1
491 | ArrayBlockingQueue fairQueue = new ArrayBlockingQueue(1000,true);
492 | 访问者的公平性是使用可重入锁实现的，代码如下：
493 |
494 | ```java
495 | public ArrayBlockingQueue(int capacity, boolean fair) {
496 | if (capacity <= 0)
497 | throw new IllegalArgumentException();
498 | this.items = new Object[capacity];
499 | lock = new ReentrantLock(fair);
500 | notEmpty = lock.newCondition();
501 | notFull = lock.newCondition();
502 | }
503 |
504 | ```
505 |
506 | **LinkedBlockingQueue**
507 |
508 | LinkedBlockingQueue是一个用链表实现的有界阻塞队列。此队列的默认和最大长度为Integer.MAX_VALUE。此队列按照先进先出的原则对元素进行排序。
509 |
510 | **PriorityBlockingQueue**
511 |
512 | PriorityBlockingQueue是一个支持优先级的无界队列。默认情况下元素采取自然顺序排列，也可以通过比较器comparator来指定元素的排序规则。元素按照升序排列。
513 |
514 | **DelayQueue**
515 |
516 | DelayQueue是一个支持延时获取元素的无界阻塞队列。队列使用PriorityQueue来实现。队列中的元素必须实现Delayed接口，在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素。我们可以将DelayQueue运用在以下应用场景：
517 |
518 | 缓存系统的设计：可以用DelayQueue保存缓存元素的有效期，使用一个线程循环查询DelayQueue，一旦能从DelayQueue中获取元素时，表示缓存有效期到了。
519 | 定时任务调度。使用DelayQueue保存当天将会执行的任务和执行时间，一旦从DelayQueue中获取到任务就开始执行，从比如TimerQueue就是使用DelayQueue实现的。
520 | 队列中的Delayed必须实现compareTo来指定元素的顺序。比如让延时时间最长的放在队列的末尾。实现代码如下：
521 |
522 | ```java
523 |
524 | public int compareTo(Delayed other) {
525 | if (other == this) // compare zero ONLY if same object
526 | return 0;
527 | if (other instanceof ScheduledFutureTask) {
528 | ScheduledFutureTask x = (ScheduledFutureTask)other;
529 | long diff = time - x.time;
530 | if (diff < 0)
531 | return -1;
532 | else if (diff > 0)
533 | return 1;
534 | else if (sequenceNumber < x.sequenceNumber)
535 | return -1;
536 | else
537 | return 1;
538 | }
539 | long d = (getDelay(TimeUnit.NANOSECONDS) -
540 | other.getDelay(TimeUnit.NANOSECONDS));
541 | return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
542 | }
543 |
544 | ```
545 |
546 | **如何实现Delayed接口**
547 |
548 | 我们可以参考ScheduledThreadPoolExecutor里ScheduledFutureTask类。这个类实现了Delayed接口。首先：在对象创建的时候，使用time记录前对象什么时候可以使用，代码如下：
549 |
550 | ```java
551 |
552 | ScheduledFutureTask(Runnable r, V result, long ns, long period) {
553 | super(r, result);
554 | this.time = ns;
555 | this.period = period;
556 | this.sequenceNumber = sequencer.getAndIncrement();
557 | }
558 |
559 | ```
560 |
561 | 然后使用getDelay可以查询当前元素还需要延时多久，代码如下：
562 |
563 | ```java
564 |
565 | public long getDelay(TimeUnit unit) {
566 | return unit.convert(time - now(), TimeUnit.NANOSECONDS);
567 | }
568 |
569 | ```
570 |
571 | 通过构造函数可以看出延迟时间参数ns的单位是纳秒，自己设计的时候最好使用纳秒，因为getDelay时可以指定任意单位，一旦以纳秒作为单位，而延时的时间又精确不到纳秒就麻烦了。使用时请注意当time小于当前时间时，getDelay会返回负数。
572 |
573 | ***如何实现延时队列***
574 |
575 | 延时队列的实现很简单，当消费者从队列里获取元素时，如果元素没有达到延时时间，就阻塞当前线程。
576 |
577 | ```java
578 |
579 | long delay = first.getDelay(TimeUnit.NANOSECONDS);
580 | if (delay <= 0)
581 | return q.poll();
582 | else if (leader != null)
583 | available.await();
584 |
585 | ```
586 |
587 | **SynchronousQueue**
588 |
589 | SynchronousQueue是一个不存储元素的阻塞队列。每一个put操作必须等待一个take操作，否则不能继续添加元素。SynchronousQueue可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线程。队列本身并不存储任何元素，非常适合于传递性场景,比如在一个线程中使用的数据，传递给另外一个线程使用，SynchronousQueue的吞吐量高于LinkedBlockingQueue 和 ArrayBlockingQueue。
590 |
591 | **LinkedTransferQueue**
592 |
593 | LinkedTransferQueue是一个由链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列LinkedTransferQueue多了tryTransfer和transfer方法。
594 |
595 | transfer方法。如果当前有消费者正在等待接收元素（消费者使用take()方法或带时间限制的poll()方法时），transfer方法可以把生产者传入的元素立刻transfer（传输）给消费者。如果没有消费者在等待接收元素，transfer方法会将元素存放在队列的tail节点，并等到该元素被消费者消费了才返回。transfer方法的关键代码如下：
596 |
597 | ```java
598 |
599 | Node pred = tryAppend(s, haveData);
600 | return awaitMatch(s, pred, e, (how == TIMED), nanos);
601 |
602 | ```
603 |
604 | 第一行代码是试图把存放当前元素的s节点作为tail节点。第二行代码是让CPU自旋等待消费者消费元素。因为自旋会消耗CPU，所以自旋一定的次数后使用Thread.yield()方法来暂停当前正在执行的线程，并执行其他线程。
605 |
606 | tryTransfer方法。则是用来试探下生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素，则返回false。和transfer方法的区别是tryTransfer方法无论消费者是否接收，方法立即返回。而transfer方法是必须等到消费者消费了才返回。
607 |
608 | 对于带有时间限制的tryTransfer(E e, long timeout, TimeUnit unit)方法，则是试图把生产者传入的元素直接传给消费者，但是如果没有消费者消费该元素则等待指定的时间再返回，如果超时还没消费元素，则返回false，如果在超时时间内消费了元素，则返回true。
609 |
610 | **LinkedBlockingDeque**
611 |
612 | LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列。所谓双向队列指的你可以从队列的两端插入和移出元素。双端队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。相比其他的阻塞队列，LinkedBlockingDeque多了addFirst，addLast，offerFirst，offerLast，peekFirst，peekLast等方法，以First单词结尾的方法，表示插入，获取（peek）或移除双端队列的第一个元素。以Last单词结尾的方法，表示插入，获取或移除双端队列的最后一个元素。另外插入方法add等同于addLast，移除方法remove等效于removeFirst。但是take方法却等同于takeFirst，不知道是不是Jdk的bug，使用时还是用带有First和Last后缀的方法更清楚。在初始化LinkedBlockingDeque时可以初始化队列的容量，用来防止其再扩容时过渡膨胀。另外双向阻塞队列可以运用在“工作窃取”模式中。
613 |
614 |
615 |
616 |
617 | 阻塞队列的实现原理
618 |
619 | 如果队列是空的，消费者会一直等待，当生产者添加元素时候，消费者是如何知道当前队列有元素的呢？如果让你来设计阻塞队列你会如何设计，让生产者和消费者能够高效率的进行通讯呢？让我们先来看看JDK是如何实现的。
620 |
621 | 使用通知模式实现。所谓通知模式，就是当生产者往满的队列里添加元素时会阻塞住生产者，当消费者消费了一个队列中的元素后，会通知生产者当前队列可用。通过查看JDK源码发现ArrayBlockingQueue使用了Condition来实现，代码如下：
622 |
623 | ```java
624 |
625 | private final Condition notFull;
626 | private final Condition notEmpty;
627 |
628 | public ArrayBlockingQueue(int capacity, boolean fair) {
629 | //省略其他代码
630 | notEmpty = lock.newCondition();
631 | notFull = lock.newCondition();
632 | }
633 |
634 | public void put(E e) throws InterruptedException {
635 | checkNotNull(e);
636 | final ReentrantLock lock = this.lock;
637 | lock.lockInterruptibly();
638 | try {
639 | while (count == items.length)
640 | notFull.await();
641 | insert(e);
642 | } finally {
643 | lock.unlock();
644 | }
645 | }
646 |
647 | public E take() throws InterruptedException {
648 | final ReentrantLock lock = this.lock;
649 | lock.lockInterruptibly();
650 | try {
651 | while (count == 0)
652 | notEmpty.await();
653 | return extract();
654 | } finally {
655 | lock.unlock();
656 | }
657 | }
658 |
659 | private void insert(E x) {
660 | items[putIndex] = x;
661 | putIndex = inc(putIndex);
662 | ++count;
663 | notEmpty.signal();
664 | }
665 |
666 | ```
667 |
668 | 当我们往队列里插入一个元素时，如果队列不可用，阻塞生产者主要通过LockSupport.park(this);来实现
669 |
670 | ```java
671 |
672 | public final void await() throws InterruptedException {
673 | if (Thread.interrupted())
674 | throw new InterruptedException();
675 | Node node = addConditionWaiter();
676 | int savedState = fullyRelease(node);
677 | int interruptMode = 0;
678 | while (!isOnSyncQueue(node)) {
679 | LockSupport.park(this);
680 | if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
681 | break;
682 | }
683 | if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
684 | interruptMode = REINTERRUPT;
685 | if (node.nextWaiter != null) // clean up if cancelled
686 | unlinkCancelledWaiters();
687 | if (interruptMode != 0)
688 |
689 | reportInterruptAfterWait(interruptMode);
690 | }
691 |
692 | ```
693 |
694 | 继续进入源码，发现调用setBlocker先保存下将要阻塞的线程，然后调用unsafe.park阻塞当前线程。
695 |
696 | ```java
697 |
698 | public static void park(Object blocker) {
699 | Thread t = Thread.currentThread();
700 | setBlocker(t, blocker);
701 | unsafe.park(false, 0L);
702 | setBlocker(t, null);
703 | }
704 |
705 | ```
706 |
707 | unsafe.park是个native方法，代码如下：
708 |
709 | 1
710 | public native void park(boolean isAbsolute, long time);
711 | park这个方法会阻塞当前线程，只有以下四种情况中的一种发生时，该方法才会返回。
712 |
713 | 与park对应的unpark执行或已经执行时。注意：已经执行是指unpark先执行，然后再执行的park。
714 | 线程被中断时。
715 | 如果参数中的time不是零，等待了指定的毫秒数时。
716 | 发生异常现象时。这些异常事先无法确定。
717 | 我们继续看一下JVM是如何实现park方法的，park在不同的操作系统使用不同的方式实现，在linux下是使用的是系统方法pthread_cond_wait实现。实现代码在JVM源码路径src/os/linux/vm/os_linux.cpp里的 os::PlatformEvent::park方法，代码如下：
718 |
719 | ```java
720 |
721 | void os::PlatformEvent::park() {
722 | int v ;
723 | for (;;) {
724 | v = _Event ;
725 | if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
726 | }
727 | guarantee (v >= 0, "invariant") ;
728 | if (v == 0) {
729 | // Do this the hard way by blocking ...
730 | int status = pthread_mutex_lock(_mutex);
731 | assert_status(status == 0, status, "mutex_lock");
732 | guarantee (_nParked == 0, "invariant") ;
733 | ++ _nParked ;
734 | while (_Event < 0) {
735 | status = pthread_cond_wait(_cond, _mutex);
736 | // for some reason, under 2.7 lwp_cond_wait() may return ETIME ...
737 | // Treat this the same as if the wait was interrupted
738 | if (status == ETIME) { status = EINTR; }
739 | assert_status(status == 0 || status == EINTR, status, "cond_wait");
740 | }
741 | -- _nParked ;
742 |
743 | // In theory we could move the ST of 0 into _Event past the unlock(),
744 | // but then we'd need a MEMBAR after the ST.
745 | _Event = 0 ;
746 | status = pthread_mutex_unlock(_mutex);
747 | assert_status(status == 0, status, "mutex_unlock");
748 | }
749 | guarantee (_Event >= 0, "invariant") ;
750 | }
751 |
752 | }
753 |
754 | ```
755 |
756 | pthread_cond_wait是一个多线程的条件变量函数，cond是condition的缩写，字面意思可以理解为线程在等待一个条件发生，这个条件是一个全局变量。这个方法接收两个参数，一个共享变量_cond，一个互斥量_mutex。而unpark方法在linux下是使用pthread_cond_signal实现的。park 在windows下则是使用WaitForSingleObject实现的。
757 |
758 | 当队列满时，生产者往阻塞队列里插入一个元素，生产者线程会进入WAITING (parking)状态。我们可以使用jstack dump阻塞的生产者线程看到这点：
759 |
760 | ```java
761 | "main" prio=5 tid=0x00007fc83c000000 nid=0x10164e000 waiting on condition [0x000000010164d000]
762 | java.lang.Thread.State: WAITING (parking)
763 | at sun.misc.Unsafe.park(Native Method)
764 | - parking to wait for <0x0000000140559fe8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
765 | at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
766 | at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
767 | at java.util.concurrent.ArrayBlockingQueue.put(ArrayBlockingQueue.java:324)
768 | at blockingqueue.ArrayBlockingQueueTest.main(ArrayBlockingQueueTest.java:11)
769 |
770 | ```
771 |
772 |
773 |
774 |
775 | 简述 ConcurrentLinkedQueue LinkedBlockingQueue 的用处和不同之处
776 |
777 | **阻塞队列：线程安全**
778 |
779 | 按 FIFO（先进先出）排序元素。队列的头部是在队列中时间最长的元素。队列的尾部是在队列中时间最短的元素。新元素插入到队列的尾部，并且队列检索操作会获得位于队列头部的元素。链接队列的吞吐量通常要高于基于数组的队列，但是在大多数并发应用程序中，其可预知的性能要低。
780 |
781 | 注意：
782 |
783 | 1、必须要使用take()方法在获取的时候达成阻塞结果
784 |
785 | 2、使用poll()方法将产生非阻塞效果
786 |
787 | **非阻塞队列**
788 |
789 | 基于链接节点的、无界的、线程安全。此队列按照 FIFO（先进先出）原则对元素进行排序。队列的头部 是队列中时间最长的元素。队列的尾部 是队列中时间最短的元素。新的元素插入到队列的尾部，队列检索操作从队列头部获得元素。当许多线程共享访问一个公共 collection 时，ConcurrentLinkedQueue是一个恰当的选择。此队列不允许 null 元素。
790 |
791 | 在并发编程中，一般推荐使用阻塞队列，这样实现可以尽量地避免程序出现意外的错误。阻塞队列使用最经典的场景就是socket客户端数据的读取和解析，读取数据的线程不断将数据放入队列，然后解析线程不断从队列取数据解析。还有其他类似的场景，只要符合生产者-消费者模型的都可以使用阻塞队列。
792 |
793 | 使用非阻塞队列，虽然能即时返回结果（消费结果），但必须自行编码解决返回为空的情况处理（以及消费重试等问题）。另外他们都是线程安全的，不用考虑线程同步问题。
794 |
795 | * [《JAVA阻塞队列以及非阻塞队列的区别》](https://www.cnblogs.com/starcrm/p/4998067.html)
796 |
797 |
798 |
799 |
800 | ArrayList、Vector、LinkedList的存储性能和特性
801 |
802 | ArrayList 和Vector他们底层的实现都是一样的，都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢。
803 |
804 | Vector中的方法由于添加了synchronized修饰，因此Vector是线程安全的容器，但性能上较ArrayList差，因此已经是Java中的遗留容器。
805 |
806 | LinkedList使用双向链表实现存储（将内存中零散的内存单元通过附加的引用关联起来，形成一个可以按序号索引的线性结构，这种链式存储方式与数组的连续存储方式相比，内存的利用率更高），按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
807 |
808 | Vector属于遗留容器（Java早期的版本中提供的容器，除此之外，Hashtable、Dictionary、BitSet、Stack、Properties都是遗留容器），已经不推荐使用，但是由于ArrayList和LinkedListed都是非线程安全的，如果遇到多个线程操作同一个容器的场景，则可以通过工具类Collections中的synchronized List方法将其转换成线程安全的容器后再使用（这是对装潢模式的应用，将已有对象传入另一个类的构造器中创建新的对象来增强实现）。
809 |
810 |
811 |
812 |
813 | # String
814 |
815 |
816 | ByteBuffer 与 StringBuffer有什么区别
817 |
818 |
819 |
820 |
821 |
822 | # Collections
823 |
824 |
825 | 介绍Java中的Collection FrameWork。集合类框架的基本接口有哪些？
826 |
827 | 总共有两大接口：Collection 和Map ，一个元素集合，一个是键值对集合；
828 |
829 | 其中List和Set接口继承了Collection接口，一个是有序元素集合，一个是无序元素集合；
830 |
831 | ArrayList和LinkedList实现了List接口，HashSet实现了Set接口，这几个都比较常用；
832 |
833 | HashMap和HashTable实现了Map接口，并且HashTable是线程安全的，但是HashMap性能更好；
834 |
835 |
836 |
837 |
838 | 集合类框架的最佳实践有哪些
839 |
840 | 根据应用的需要合理的选择集合的类型对性能非常重要
841 |
842 | 假如元素的大小是固定的，而且能事先知道，我们就该用Array而不是ArrayList.
843 |
844 | 有些集合类允许指定初始容量。因此，如果我们能估计出存储元素的数目，我们可以设置初始容量来避免重新计算hash值或者扩容.
845 |
846 | 为了类型安全，可读性和健壮性的原因总要使用翻新。同时，使用泛型还能皮面运行时的ClassCastException.
847 |
848 | 使用JDK提供的不变类（immutable class）作为Map的键可以避免为我们自己的类实现hashCode()和equals()方法。
849 |
850 | 编程的时候接口优于实现。
851 |
852 | 底层的集合实际上是空的情况下返回长度是0的集合或者是数组，不要返回null.
853 |
854 |
855 |
856 |
857 | 为什么 Collection 不从 Cloneable 和 Serializable 接口继承?
858 |
859 | Collection接口指定一组对象，对象即为它的元素。如何维护这些元素由Collection的具体实现决定。例如，一些如List的Collection实现允许重复的元素，而其它的如Set就不允许。很多Collection实现有一个公有的clone方法。然而，把它放到集合的所有实现中也是没有意义的。这是因为Collection是一个抽象表现。
860 |
861 | 重要的是实现，克隆（cloning）或者序列化（serialization）的语义和含义是跟具体的实现相关的。**因此应该由集合类的具体实现类来决定如何被克隆或者序列化。**
862 |
863 |
864 |
865 |
866 | 说出几点 Java 中使用 Collections 的最佳实践？
867 |
868 | ）使用正确的集合类，例如，如果不需要同步列表，使用 ArrayList 而不是 Vector。
869 |
870 | b）优先使用并发集合，而不是对集合进行同步。并发集合提供更好的可扩展性。
871 |
872 | c）使用接口代表和访问集合，如使用List存储 ArrayList，使用 Map 存储 HashMap 等等。
873 |
874 | d）使用迭代器来循环集合。
875 |
876 | e）使用集合的时候使用泛型
877 |
878 |
879 |
880 | # 有用的参考
881 |
882 | * [数据结构面试](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/interview.md)
883 | * [算法面试](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Algorithmic/interview.md)
884 |
--------------------------------------------------------------------------------
/LeetCode算法面试/1004. 最大连续 1 的个数 III(滑动窗口)---Max Consecutive Ones III.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/102 二叉树的层序遍历(中等)binary-tree-level-order-traversal.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | # 有用的参考
5 |
6 | * [102.二叉树的层序遍历---binary-tree-level-order-traversal](https://www.kancloud.cn/fe_lucifer/leetcode/1996472)
7 |
--------------------------------------------------------------------------------
/LeetCode算法面试/103 二叉树的锯齿形层次遍历(中等)---binary-tree-zigzag-level-order-traversal.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | # 有用的参考
6 |
7 | * [103 二叉树的锯齿形层次遍历---binary-tree-zigzag-level-order-traversal](https://www.kancloud.cn/fe_lucifer/leetcode/1996473)
8 |
--------------------------------------------------------------------------------
/LeetCode算法面试/105. 从前序与中序遍历序列构造二叉树(中等)---Construct Binary Tree from Preorder and Inorder Traversal.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | # 有用的参考
6 |
7 | * [105. 从前序与中序遍历序列构造二叉树(中等)---Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/azl397985856/leetcode/blob/1fce788bab7e7e2a10a6dfb0ee55a2bb09424b0b/selected/construct-binary-tree.md)
8 |
--------------------------------------------------------------------------------
/LeetCode算法面试/106 从中序与后序遍历序列构造二叉树(中等)---Construct Binary Tree from Inorder and Postorder Traversal.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | # 有用的参考
5 |
6 | * [106 从中序与后序遍历序列构造二叉树(中等)---Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/azl397985856/leetcode/blob/1fce788bab7e7e2a10a6dfb0ee55a2bb09424b0b/selected/construct-binary-tree.md)
7 |
--------------------------------------------------------------------------------
/LeetCode算法面试/1081 不同字符的最小子序列（字典树 中等）---Smallest Subsequence of Distinct Characters .md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/1234. 替换子串得到平衡字符串(滑动窗口)---Replace the Substring for Balanced String.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/1248. 统计「优美子数组」(滑动窗口)---Count Number of Nice Subarrays.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/1358 包含所有三种字符的子字符串数目(滑动窗口)---Number of Substrings Containing All Three Characters.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/144 二叉树的前序遍历(简单)---binary-tree-preorder-traversal.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | # 有用的参考
7 |
8 | * [144 二叉树的前序遍历(简单)---binary-tree-preorder-traversal](https://www.kancloud.cn/fe_lucifer/leetcode/1996479)
9 |
--------------------------------------------------------------------------------
/LeetCode算法面试/145 二叉树的后序遍历 (简单)---binary-tree-postorder-traversal.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | # 有用的参考
6 |
7 | * [145 二叉树的后序遍历 (简单)---binary-tree-postorder-traversal](https://www.kancloud.cn/fe_lucifer/leetcode/1996555)
8 |
--------------------------------------------------------------------------------
/LeetCode算法面试/159 至多包含两个不同字符的最长子串(滑动窗口)---Longest Substring with At Most Two Distinct Characters.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/199 二叉树的右视图(中等) ---binary-tree-right-side-view.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | # 有用的参考
7 |
8 | * [199 二叉树的右视图(中等) ---binary-tree-right-side-view](https://www.kancloud.cn/fe_lucifer/leetcode/1996482)
9 |
--------------------------------------------------------------------------------
/LeetCode算法面试/209 长度最小的子数组(滑动窗口 中等) ---Minimum Size Subarray Sum.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/LeetCode算法面试/239 滑动窗口最大值 ---Sliding Window Maximum .md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/LeetCode算法面试/252 会议室（easy）---Meeting Rooms.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/253 会议室 II(Medium)--- Meeting Rooms II .md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/3 无重复字符的最长子串(滑动窗口)---Longest Substring Without Repeating Characters.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/316 去除重复字母(字典树 困难)---Remove Duplicate Letters.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/321 拼接最大数(字典树 困难)---Create Maximum Number.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/340 至多包含 K 个不同字符的最长子串( 滑动窗口)--- Longest Substring with At Most K Distinct Characters .md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/395 至少有 K 个重复字符的最长子串 (滑动窗口) ---Longest Substring with At Least K Repeating Characters .md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/402 移掉 K 位数字(字典树 中等)---Remove K Digits.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/424 替换后的最长重复字符(滑动窗口)---Longest Repeating Character Replacement.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/438. 找到字符串中所有字母异位词(滑动窗口)---Find All Anagrams in a String .md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/467. 环绕字符串中唯一的子字符串( 滑动窗口 中等)---Unique Substrings in Wraparound String.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 | # 有用的参考
12 |
13 | * [467. 环绕字符串中唯一的子字符串(中等)---Unique Substrings in Wraparound String ](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/selected/atmostk)
14 |
--------------------------------------------------------------------------------
/LeetCode算法面试/480 滑动窗口中位数(滑动窗口)---Sliding Window Median.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/488 祖玛游戏---Zuma Game.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | # 有用的参考
7 |
8 | * [488 祖玛游戏---Zuma Game](https://github.com/azl397985856/leetcode/blob/1fce788bab7e7e2a10a6dfb0ee55a2bb09424b0b/selected/zuma-game.md)
9 |
--------------------------------------------------------------------------------
/LeetCode算法面试/729 我的日程安排表 I(Medium)---My Calendar I.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | # 有用的参考
5 |
6 | * [729 我的日程安排表 I(Medium)---My Calendar I ](https://github.com/azl397985856/leetcode/blob/1fce788bab7e7e2a10a6dfb0ee55a2bb09424b0b/selected/schedule-topic.md)
7 |
--------------------------------------------------------------------------------
/LeetCode算法面试/731 我的日程安排表 II(Medium)---My Calendar II .md:
--------------------------------------------------------------------------------
1 |
2 |
3 | # 有用的参考
4 |
5 | * [731 我的日程安排表 II(Medium)---My Calendar II ](https://github.com/azl397985856/leetcode/blob/1fce788bab7e7e2a10a6dfb0ee55a2bb09424b0b/selected/schedule-topic.md)
6 |
--------------------------------------------------------------------------------
/LeetCode算法面试/732 我的日程安排表 III(Hard)---My Calendar III .md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | # 有用的参考
6 |
7 | * [732 我的日程安排表 III(Hard)---My Calendar III ](https://github.com/azl397985856/leetcode/blob/1fce788bab7e7e2a10a6dfb0ee55a2bb09424b0b/selected/schedule-topic.md)
8 |
--------------------------------------------------------------------------------
/LeetCode算法面试/76. 最小覆盖子串(滑动窗口)---Minimum Window Substring .md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/795. 区间子数组个数(滑动窗口 中等)---Number of Subarrays with Bounded Maximum .md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | # 有用的参考
7 |
8 | * [795. 区间子数组个数(滑动窗口 中等)---Number of Subarrays with Bounded Maximum](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/selected/atmostk)
9 |
--------------------------------------------------------------------------------
/LeetCode算法面试/862 和至少为 K 的最短子数组(滑动窗口) ---Shortest Subarray with Sum at Least K.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/889. 根据前序和后序遍历构造二叉树(中等)---Construct Binary Tree from Preorder and Postorder Traversal.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | # 有用的参考
5 |
6 | * [889. 根据前序和后序遍历构造二叉树(中等)---Construct Binary Tree from Preorder and Postorder Traversal](https://github.com/azl397985856/leetcode/blob/1fce788bab7e7e2a10a6dfb0ee55a2bb09424b0b/selected/construct-binary-tree.md)
7 |
--------------------------------------------------------------------------------
/LeetCode算法面试/904. 水果成篮(滑动窗口)---Fruit Into Baskets .md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | # 有用的参考
8 |
9 | * [904. 水果成篮(中等)](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/selected/atmostk)
10 |
--------------------------------------------------------------------------------
/LeetCode算法面试/930. 和相同的二元子数组(滑动窗口)---Binary Subarrays With Sum.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/94 二叉树的中序遍历(简单)---binary-tree-inorder-traversal.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 | # 有用的参考
11 |
12 | * [0094. 二叉树的中序遍历](https://www.kancloud.cn/fe_lucifer/leetcode/1996468)
13 |
--------------------------------------------------------------------------------
/LeetCode算法面试/992. K 个不同整数的子数组(滑动窗口)---Subarrays with K Different Integers.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | # 有用的参考
9 |
10 | * [992. K 个不同整数的子数组（困难）---Subarrays with K Different Integers)](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/selected/atmostk)
11 |
--------------------------------------------------------------------------------
/LeetCode算法面试/README.md:
--------------------------------------------------------------------------------
1 |
2 | # LeetCode
3 | * [0. 高频题](#0-高频题)
4 | * [1. 基础篇](#1-基础篇)
5 | * [1.1 数据结构部分 ](#1A-数据结构部分)
6 | * [1.2 算法部分](#1B-算法部分)
7 | * [2. 进阶篇](#2-进阶篇)
8 | * [3. 专题篇](#3-专题篇)
9 | * [3.1 经典题型分类](#3A-经典题型分类)
10 | * [4. 公司篇](#4-公司篇)
11 |
12 | ---
13 | # 怎样刷leetCode
14 | * [土妹刷leetCode系列](https://www.youtube.com/watch?v=d6XqH991bB8&list=PLeRPcJf8vjt1LPbXt7xfJ7Sv-6B57F3IV&index=2)
15 |
16 | # 0-高频题
17 |
18 | # 1 基础篇
19 | ## 1A 数据结构部分
20 | * 位操作
21 | * 数学
22 | * 线性结构
23 | * 栈 Stack
24 | * 队列 Queue
25 | * 链表 Linked List
26 | * 数组 Array
27 | * 字符串处理
28 | * 非线性结构
29 | * 哈希表 Hash Table
30 | * 矩阵（二维或多维数组）
31 | * 堆 Heap
32 | * 二叉堆
33 | * [树](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E9%83%A8%E5%88%86/LeetCode---%E6%A0%91%20tree.md)
34 | * [二叉树](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E9%83%A8%E5%88%86/%E4%BA%8C%E5%8F%89%E6%A0%91.md)
35 | * 四叉树
36 | * 八叉树
37 | * k-d树(k维的树结构)
38 | * 二叉搜索树
39 | * 二叉平衡树
40 | * AVL(高度平衡树)
41 | * 红黑树
42 | * 并查集
43 | * 特殊树
44 | * 树状数组
45 | * 字典树 Trie（前缀树）
46 | * [316 去除重复字母(困难)---Remove Duplicate Letters](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/316%20%E5%8E%BB%E9%99%A4%E9%87%8D%E5%A4%8D%E5%AD%97%E6%AF%8D(%E5%AD%97%E5%85%B8%E6%A0%91%20%E5%9B%B0%E9%9A%BE)---Remove%20Duplicate%20Letters.md)
47 | * [321 拼接最大数(困难)---Create Maximum Number](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/321%20%E6%8B%BC%E6%8E%A5%E6%9C%80%E5%A4%A7%E6%95%B0(%E5%AD%97%E5%85%B8%E6%A0%91%20%E5%9B%B0%E9%9A%BE)---Create%20Maximum%20Number.md)
48 | * [402 移掉 K 位数字(中等)---Remove K Digits](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/402%20%E7%A7%BB%E6%8E%89%20K%20%E4%BD%8D%E6%95%B0%E5%AD%97(%E5%AD%97%E5%85%B8%E6%A0%91%20%E4%B8%AD%E7%AD%89)---Remove%20K%20Digits.md)
49 | * [1081 不同字符的最小子序列（中等）---Smallest Subsequence of Distinct Characters ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/1081%20%E4%B8%8D%E5%90%8C%E5%AD%97%E7%AC%A6%E7%9A%84%E6%9C%80%E5%B0%8F%E5%AD%90%E5%BA%8F%E5%88%97%EF%BC%88%E5%AD%97%E5%85%B8%E6%A0%91%20%E4%B8%AD%E7%AD%89%EF%BC%89---Smallest%20Subsequence%20of%20Distinct%20Characters%20.md)
50 | * 线段树
51 | * 图
52 | * 最短路径
53 | * 最小生成树
54 | * 并查集 Union Find
55 | * 图形
56 | * 点
57 | * 线
58 | * 面
59 |
60 | ## 1B 算法部分
61 | * 1B.1 基础算法
62 | * 枚举算法
63 | * 模拟算法
64 | * 分治算法 Divide Conquer
65 | * 二分搜索算法 Binary Search
66 | * 贪心算法
67 | * 前缀和 & 差分算法
68 | * 倍增算法
69 | * 构造算法
70 | * 1B.2 排序算法
71 | * 内部排序 只使用内存
72 | * 插入排序
73 | * 直接插入排序
74 | * 折半插入排序
75 | * 希尔排序
76 | * 选择排序
77 | * 简单选择排序
78 | * 堆排序
79 | * 快速排序
80 | * 冒泡排序
81 | * 归并排序
82 | * 桶式排序
83 | * 基数排序
84 | * 计数排序
85 | * 快排 Quick Sort
86 | * 外部排序 内存和外存结合使用
87 | * [外存信息的存取](#外存信息的存取)
88 | * [外部排序的方法](#外部排序的方法)
89 | * [多路平衡归并的实现](#多路平衡归并的实现)
90 | * [置换选择排序](#置换选择排序)
91 | * [最佳归并树](#最佳归并树)
92 | * 1B.3 查找算法
93 | * 数据结构中的查找算法
94 | * 顺序表结构中的查找算法
95 | * 链表结构中的查找算法
96 | * 树结构中的查找算法
97 | * 图结构中的查找算法
98 | * 回溯法 Backtracking
99 | * 排列
100 | * 子集
101 | * 组合
102 | * 插值查找算法
103 | * 递归算法
104 | * 奜波那契(黄金分割法)查找算法
105 | * 宽度优先搜索算法 Breadth First Search
106 | * 深度优先搜索算法 Depth First Search
107 | * [线性索引查找](#线性索引查找)
108 | * [多路查找树B树](#多路查找树B树)
109 | * 平衡二叉数算法
110 | * [静态查找表](#静态查找表)
111 | * [顺序表查找](#顺序表查找)
112 | * [有序表查找](#有序表查找)
113 | * [静态树表的查找](#静态树表的查找)
114 | * [索引顺序表的查找](#索引顺序表的查找)
115 | * [动态查找表](#动态查找表)
116 | * [键树](#键树)
117 | * [B_树和B+树](#B_树和B+树)
118 | * [二叉排序树](#二叉排序树)
119 | * 1B.4 双指针 Two Pointers
120 | * 1B.5 动态规划 Dynamic Programming
121 | * 背包问题
122 | * 最长子序列
123 | * 1B.6 扫描线 Scan-line algorithm
124 |
125 |
126 | # 2 进阶篇
127 | * Trie
128 | * KMP & RK
129 | * 跳表
130 | * 剪枝
131 | * 高频面试题
132 |
133 | # 3 专题篇
134 | ## 3A 经典题型分类
135 |
136 | * [1 Pattern: Sliding Window---滑动窗口类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/1.%20Pattern:%20Sliding%20window%EF%BC%8C%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E7%B1%BB%E5%9E%8B/README.md)
137 | * [2 Pattern: Two Pointers---双指针类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/2%20Pattern:%20Two%20Pointers/README.md)
138 | * [3 Pattern: Fast & Slow pointers---快慢指针类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/3.%20Pattern:%20Fast%20%26%20Slow%20pointers%2C%20%E5%BF%AB%E6%85%A2%E6%8C%87%E9%92%88%E7%B1%BB%E5%9E%8B/README.md)
139 | * [4 Pattern: Merge Intervals---区间合并类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/4.%20Pattern:%20Merge%20Intervals%EF%BC%8C%E5%8C%BA%E9%97%B4%E5%90%88%E5%B9%B6%E7%B1%BB%E5%9E%8B/README.md)
140 | * [5 Pattern: Cyclic Sort---循环排序](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/5.%20Pattern:%20Cyclic%20Sort%EF%BC%8C%E5%BE%AA%E7%8E%AF%E6%8E%92%E5%BA%8F/README.md)
141 | * [6 Pattern: In-place Reversal of a LinkedList---链表翻转](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/6.%20Pattern:%20In-place%20Reversal%20of%20a%20LinkedList%EF%BC%8C%E9%93%BE%E8%A1%A8%E7%BF%BB%E8%BD%AC/README.md)
142 | * [7 Pattern: Tree Breadth First Search---树上的BFS](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/7.%20Pattern:%20Tree%20Breadth%20First%20Search%EF%BC%8C%E6%A0%91%E4%B8%8A%E7%9A%84BFS/README.md)
143 | * [8 Pattern: Tree Depth First Search---树上的DFS](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/8.%20Pattern:%20Tree%20Depth%20First%20Search%EF%BC%8C%E6%A0%91%E4%B8%8A%E7%9A%84DFS/README.md)
144 | * [9 Pattern: Two Heaps---双堆类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/9.%20Pattern:%20Two%20Heaps%EF%BC%8C%E5%8F%8C%E5%A0%86%E7%B1%BB%E5%9E%8B/README.md)
145 | * [10 Pattern: Subsets---子集类型，一般都是使用多重DFS](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/10.%20Pattern:%20Subsets%EF%BC%8C%E5%AD%90%E9%9B%86%E7%B1%BB%E5%9E%8B%EF%BC%8C%E4%B8%80%E8%88%AC%E9%83%BD%E6%98%AF%E4%BD%BF%E7%94%A8%E5%A4%9A%E9%87%8DDFS/README.md)
146 | * [11 Pattern: Modified Binary Search---改造过的二分](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/11.%20Pattern:%20Modified%20Binary%20Search%EF%BC%8C%E6%94%B9%E9%80%A0%E8%BF%87%E7%9A%84%E4%BA%8C%E5%88%86/README.md)
147 | * [12 Pattern: Top 'K' Elements---前K个系列](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/12.%20Pattern:%20Top%20%E2%80%98K%E2%80%99%20Elements%EF%BC%8C%E5%89%8DK%E4%B8%AA%E7%B3%BB%E5%88%97/README.md)
148 | * [13 Pattern: K-way merge---多路归并](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/13.%20Pattern:%20K-way%20merge%EF%BC%8C%E5%A4%9A%E8%B7%AF%E5%BD%92%E5%B9%B6/README.md)
149 | * [14 Pattern : 0/1 Knapsack (Dynamic Programming)---0/1背包类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/14.%20Pattern:%200%20mod%201%20Knapsack%20(Dynamic%20Programming)/README.md)
150 | * [15 Pattern: Topological Sort (Graph)---拓扑排序类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/15.%20Pattern:%20Topological%20Sort%20(Graph)%EF%BC%8C%E6%8B%93%E6%89%91%E6%8E%92%E5%BA%8F%E7%B1%BB%E5%9E%8B/README.md)
151 | * 日程安排专题
152 | * [252 会议室（easy）---Meeting Rooms ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/252%20%E4%BC%9A%E8%AE%AE%E5%AE%A4%EF%BC%88easy%EF%BC%89---Meeting%20Rooms.md)
153 | * [253 会议室 II(Medium)--- Meeting Rooms II ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/253%20%E4%BC%9A%E8%AE%AE%E5%AE%A4%20II(Medium)---%09Meeting%20Rooms%20II%20%20%20.md)
154 | * [729 我的日程安排表 I(Medium)---My Calendar I ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/729%20%E6%88%91%E7%9A%84%E6%97%A5%E7%A8%8B%E5%AE%89%E6%8E%92%E8%A1%A8%20I(Medium)---My%20Calendar%20I.md)
155 | * [731 我的日程安排表 II(Medium)---My Calendar II ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/731%20%E6%88%91%E7%9A%84%E6%97%A5%E7%A8%8B%E5%AE%89%E6%8E%92%E8%A1%A8%20II(Medium)---My%20Calendar%20II%20.md)
156 | * [732 我的日程安排表 III(Hard)---My Calendar III ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/732%20%E6%88%91%E7%9A%84%E6%97%A5%E7%A8%8B%E5%AE%89%E6%8E%92%E8%A1%A8%20III(Hard)---My%20Calendar%20III%20%20.md)
157 | * 16 二分法
158 | * 17 Pattern: Bitwise XOR
159 |
160 | # 4 公司篇
161 |
162 | * [公司篇汇总](https://leetcode.jp/problems.php)
163 |
164 |
165 |
--------------------------------------------------------------------------------
/LeetCode算法面试/数据结构部分/LeetCode---树 tree.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | # 二叉树遍历
4 |
5 | * [94.binary-tree-inorder-traversal](https://www.kancloud.cn/fe_lucifer/leetcode/1996468)
6 | * [102.binary-tree-level-order-traversal](https://www.kancloud.cn/fe_lucifer/leetcode/1996472)
7 | * [103.binary-tree-zigzag-level-order-traversal](https://www.kancloud.cn/fe_lucifer/leetcode/1996473)
8 | * [144.binary-tree-preorder-traversal](https://www.kancloud.cn/fe_lucifer/leetcode/1996479)
9 | * [145.binary-tree-postorder-traversal](https://www.kancloud.cn/fe_lucifer/leetcode/1996555)
10 | * [199.binary-tree-right-side-view](https://www.kancloud.cn/fe_lucifer/leetcode/1996482)
11 |
--------------------------------------------------------------------------------
/LeetCode算法面试/数据结构部分/README.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/数据结构部分/二叉树.md:
--------------------------------------------------------------------------------
1 | * [二叉树构造](#二叉树构造)
2 | * [二叉树遍历](#二叉树遍历)
3 |
4 |
5 | # 二叉树构造
6 |
7 | * [105. 从前序与中序遍历序列构造二叉树(中等)---Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/105.%20%E4%BB%8E%E5%89%8D%E5%BA%8F%E4%B8%8E%E4%B8%AD%E5%BA%8F%E9%81%8D%E5%8E%86%E5%BA%8F%E5%88%97%E6%9E%84%E9%80%A0%E4%BA%8C%E5%8F%89%E6%A0%91(%E4%B8%AD%E7%AD%89)---Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal.md)
8 | * [106. 从中序与后序遍历序列构造二叉树---Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/106%20%20%E4%BB%8E%E4%B8%AD%E5%BA%8F%E4%B8%8E%E5%90%8E%E5%BA%8F%E9%81%8D%E5%8E%86%E5%BA%8F%E5%88%97%E6%9E%84%E9%80%A0%E4%BA%8C%E5%8F%89%E6%A0%91(%E4%B8%AD%E7%AD%89)---Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.md)
9 | * [889. 根据前序和后序遍历构造二叉树--Construct Binary Tree from Preorder and Postorder Traversal](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/889.%20%E6%A0%B9%E6%8D%AE%E5%89%8D%E5%BA%8F%E5%92%8C%E5%90%8E%E5%BA%8F%E9%81%8D%E5%8E%86%E6%9E%84%E9%80%A0%E4%BA%8C%E5%8F%89%E6%A0%91(%E4%B8%AD%E7%AD%89)---Construct%20Binary%20Tree%20from%20Preorder%20and%20Postorder%20Traversal.md)
10 |
11 | # 二叉树遍历
12 |
13 | * [94.二叉树的中序遍历---binary-tree-inorder-traversal](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/94%20%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E4%B8%AD%E5%BA%8F%E9%81%8D%E5%8E%86(%E7%AE%80%E5%8D%95)---binary-tree-inorder-traversal.md)
14 | * [102.二叉树的层序遍历(中等)---binary-tree-level-order-traversal](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/102%20%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E5%BA%8F%E9%81%8D%E5%8E%86(%E4%B8%AD%E7%AD%89)binary-tree-level-order-traversal.md)
15 | * [103.二叉树的锯齿形层次遍历(中等)---binary-tree-zigzag-level-order-traversal](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/103%20%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E9%94%AF%E9%BD%BF%E5%BD%A2%E5%B1%82%E6%AC%A1%E9%81%8D%E5%8E%86(%E4%B8%AD%E7%AD%89)---binary-tree-zigzag-level-order-traversal.md)
16 | * [144.二叉树的前序遍历(简单)---binary-tree-preorder-traversal](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/144%20%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%89%8D%E5%BA%8F%E9%81%8D%E5%8E%86(%E7%AE%80%E5%8D%95)---binary-tree-preorder-traversal.md)
17 | * [145.二叉树的后序遍历 (简单)---binary-tree-postorder-traversal](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/145%20%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%90%8E%E5%BA%8F%E9%81%8D%E5%8E%86%20(%E7%AE%80%E5%8D%95)---binary-tree-postorder-traversal.md)
18 | * [199.二叉树的右视图(中等)---binary-tree-right-side-view](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/199%20%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%8F%B3%E8%A7%86%E5%9B%BE(%E4%B8%AD%E7%AD%89)%20%20---binary-tree-right-side-view.md)
19 |
--------------------------------------------------------------------------------
/LeetCode算法面试/算法部分/README.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/1. Pattern: Sliding window，滑动窗口类型/README.md:
--------------------------------------------------------------------------------
1 | **Буча, Мотижин, Житомирська траса - братська могила, катівня та спалена техніка**
2 |
3 |
4 | [滑动窗口（思路 + 模板）](https://www.kancloud.cn/fe_lucifer/leetcode/1996373)|
5 | ---|
6 |
7 | ---
8 |
9 | 
10 |
11 |
12 | **滑动窗口类型的题目经常是用来执行数组或是链表上某个区间（窗口）上的操作。比如找最长的全为1的子数组长度。滑动窗口一般从第一个元素开始，一直往右边一个一个元素挪动。当然了，根据题目要求，我们可能有固定窗口大小的情况，也有窗口的大小变化的情况**
13 |
14 | 下面是一些我们用来判断我们可能需要上滑动窗口策略的方法：
15 |
16 | * 这个问题的输入是一些线性结构：比如链表呀，数组啊，字符串啊之类的
17 | * 让你去求最长/最短子字符串或是某些特定的长度要求
18 |
19 | **经典题目：**
20 | * [一文带你 AC 十道题【滑动窗口】](https://lucifer.ren/blog/2020/03/16/slide-window/)
21 | * [3 无重复字符的最长子串---Longest Substring Without Repeating Characters ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/3%20%E6%97%A0%E9%87%8D%E5%A4%8D%E5%AD%97%E7%AC%A6%E7%9A%84%E6%9C%80%E9%95%BF%E5%AD%90%E4%B8%B2(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Longest%20Substring%20Without%20Repeating%20Characters.md)
22 | * [76. 最小覆盖子串---Minimum Window Substring ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/76.%20%E6%9C%80%E5%B0%8F%E8%A6%86%E7%9B%96%E5%AD%90%E4%B8%B2(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Minimum%20Window%20Substring%20.md)
23 | * [159 至多包含两个不同字符的最长子串---Longest Substring with At Most Two Distinct Characters ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/159%20%E8%87%B3%E5%A4%9A%E5%8C%85%E5%90%AB%E4%B8%A4%E4%B8%AA%E4%B8%8D%E5%90%8C%E5%AD%97%E7%AC%A6%E7%9A%84%E6%9C%80%E9%95%BF%E5%AD%90%E4%B8%B2(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.md)
24 | * [209 长度最小的子数组(滑动窗口 中等) ---Minimum Size Subarray Sum](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/209%20%E9%95%BF%E5%BA%A6%E6%9C%80%E5%B0%8F%E7%9A%84%E5%AD%90%E6%95%B0%E7%BB%84(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%20%E4%B8%AD%E7%AD%89)%20---Minimum%20Size%20Subarray%20Sum.md)
25 | * [239 滑动窗口最大值 ---Sliding Window Maximum ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/239%20%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E6%9C%80%E5%A4%A7%E5%80%BC%20---Sliding%20Window%20Maximum%20.md)
26 | * [340 至多包含 K 个不同字符的最长子串( 滑动窗口)--- Longest Substring with At Most K Distinct Characters](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/340%20%E8%87%B3%E5%A4%9A%E5%8C%85%E5%90%AB%20K%20%E4%B8%AA%E4%B8%8D%E5%90%8C%E5%AD%97%E7%AC%A6%E7%9A%84%E6%9C%80%E9%95%BF%E5%AD%90%E4%B8%B2(%09%20%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---%20Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters%20.md)
27 | * [395 至少有 K 个重复字符的最长子串 (滑动窗口) ---Longest Substring with At Least K Repeating Characters](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/395%20%E8%87%B3%E5%B0%91%E6%9C%89%20K%20%E4%B8%AA%E9%87%8D%E5%A4%8D%E5%AD%97%E7%AC%A6%E7%9A%84%E6%9C%80%E9%95%BF%E5%AD%90%E4%B8%B2%20(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)%20---Longest%20Substring%20with%20At%20Least%20K%20Repeating%20Characters%20%20%20%20.md)
28 | * [ 424 替换后的最长重复字符---Longest Repeating Character Replacement ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/424%09%E6%9B%BF%E6%8D%A2%E5%90%8E%E7%9A%84%E6%9C%80%E9%95%BF%E9%87%8D%E5%A4%8D%E5%AD%97%E7%AC%A6(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Longest%20Repeating%20Character%20Replacement.md)
29 | * [438. 找到字符串中所有字母异位词---Find All Anagrams in a String ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/438.%20%E6%89%BE%E5%88%B0%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%E6%89%80%E6%9C%89%E5%AD%97%E6%AF%8D%E5%BC%82%E4%BD%8D%E8%AF%8D(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Find%20All%20Anagrams%20in%20a%20String%20.md)
30 | * [467. 环绕字符串中唯一的子字符串(中等)---Unique Substrings in Wraparound String ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/467.%20%E7%8E%AF%E7%BB%95%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%E5%94%AF%E4%B8%80%E7%9A%84%E5%AD%90%E5%AD%97%E7%AC%A6%E4%B8%B2(%20%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%20%E4%B8%AD%E7%AD%89)---Unique%20Substrings%20in%20Wraparound%20String.md)
31 | * [480 滑动窗口中位数---Sliding Window Median ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/480%20%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E4%B8%AD%E4%BD%8D%E6%95%B0(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Sliding%20Window%20Median.md)
32 | * [795. 区间子数组个数(滑动窗口 中等)---Number of Subarrays with Bounded Maximum](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/795.%20%E5%8C%BA%E9%97%B4%E5%AD%90%E6%95%B0%E7%BB%84%E4%B8%AA%E6%95%B0(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%20%E4%B8%AD%E7%AD%89)---Number%20of%20Subarrays%20with%20Bounded%20Maximum%20%20.md)
33 | * [862 和至少为 K 的最短子数组 ---Shortest Subarray with Sum at Least K](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/862%20%E5%92%8C%E8%87%B3%E5%B0%91%E4%B8%BA%20K%20%E7%9A%84%E6%9C%80%E7%9F%AD%E5%AD%90%E6%95%B0%E7%BB%84(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)%20%20---Shortest%20Subarray%20with%20Sum%20at%20Least%20K.md)
34 | * [904. 水果成篮---Fruit Into Baskets ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/904.%20%E6%B0%B4%E6%9E%9C%E6%88%90%E7%AF%AE(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Fruit%20Into%20Baskets%20.md)
35 | * [930. 和相同的二元子数组---Binary Subarrays With Sum](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/930.%20%E5%92%8C%E7%9B%B8%E5%90%8C%E7%9A%84%E4%BA%8C%E5%85%83%E5%AD%90%E6%95%B0%E7%BB%84(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Binary%20Subarrays%20With%20Sum.md)
36 | * [992. K 个不同整数的子数组---Subarrays with K Different Integers ](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/992.%20K%20%E4%B8%AA%E4%B8%8D%E5%90%8C%E6%95%B4%E6%95%B0%E7%9A%84%E5%AD%90%E6%95%B0%E7%BB%84(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Subarrays%20with%20K%20Different%20Integers.md)
37 | * [1004. 最大连续 1 的个数 III---Max Consecutive Ones III](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/1004.%20%E6%9C%80%E5%A4%A7%E8%BF%9E%E7%BB%AD%201%20%E7%9A%84%E4%B8%AA%E6%95%B0%20III(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Max%20Consecutive%20Ones%20III.md)
38 | * [1234. 替换子串得到平衡字符串---Replace the Substring for Balanced String](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/1234.%20%E6%9B%BF%E6%8D%A2%E5%AD%90%E4%B8%B2%E5%BE%97%E5%88%B0%E5%B9%B3%E8%A1%A1%E5%AD%97%E7%AC%A6%E4%B8%B2(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Replace%20the%20Substring%20for%20Balanced%20String.md)
39 | * [1248. 统计「优美子数组」---Count Number of Nice Subarrays](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/1248.%20%E7%BB%9F%E8%AE%A1%E3%80%8C%E4%BC%98%E7%BE%8E%E5%AD%90%E6%95%B0%E7%BB%84%E3%80%8D(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Count%20Number%20of%20Nice%20Subarrays.md)
40 | * [1358 包含所有三种字符的子字符串数目---Number of Substrings Containing All Three Characters](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/1358%20%E5%8C%85%E5%90%AB%E6%89%80%E6%9C%89%E4%B8%89%E7%A7%8D%E5%AD%97%E7%AC%A6%E7%9A%84%E5%AD%90%E5%AD%97%E7%AC%A6%E4%B8%B2%E6%95%B0%E7%9B%AE(%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3)---Number%20of%20Substrings%20Containing%20All%20Three%20Characters.md)
41 |
42 |
43 | Maximum Sum Subarray of Size K (easy)
44 |
45 | Smallest Subarray with a given sum (easy)
46 |
47 | Longest Substring with K Distinct Characters (medium)
48 |
49 |
50 | No-repeat Substring (hard)
51 |
52 | Longest Substring with Same Letters after Replacement (hard)
53 |
54 | Longest Subarray with Ones after Replacement (hard)
55 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/10. Pattern: Subsets，子集类型，一般都是使用多重DFS/README.md:
--------------------------------------------------------------------------------
1 | 超级多的编程面试问题都会涉及到排列和组合问题。子集问题模式讲的是用BFS来处理这些问题。
2 |
3 | 这个模式是这样的：
4 |
5 | 给一组数字 [1, 5, 3]
6 |
7 | 我们从空集开始：[[]]
8 | 把第一个数（1），加到之前已经存在的集合中：[[], [1]];
9 | 把第二个数（5），加到之前的集合中得到：[[], [1], [5], [1,5]];
10 | 再加第三个数（3），则有：[[], [1], [5], [1,5], [3], [1,3], [5,3], [1,5,3]].
11 | 该模式的详细步骤如下：
12 |
13 |
14 | 
15 |
16 | 如果判断这种子集模式：
17 |
18 | * 问题需要咱们去找数字的组合或是排列
19 |
20 |
21 | **经典题目：**
22 |
23 | Subsets (easy)
24 |
25 | Subsets With Duplicates (easy)
26 |
27 | Permutations (medium)
28 |
29 | String Permutations by changing case (medium)
30 |
31 | Balanced Parentheses (hard)
32 |
33 | Unique Generalized Abbreviations (hard)
34 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/11. Pattern: Modified Binary Search，改造过的二分/README.md:
--------------------------------------------------------------------------------
1 | 当你需要解决的问题的输入是排好序的数组，链表，或是排好序的矩阵，要求咱们寻找某些特定元素。这个时候的不二选择就是二分搜索。这种模式是一种超级牛的用二分来解决问题的方式。
2 |
3 | 对于一组满足上升排列的数集来说，这种模式的步骤是这样的：
4 |
5 | 首先，算出左右端点的中点。最简单的方式是这样的：middle = (start + end) / 2。但这种计算方式有不小的概率会出现整数越界。因此一般都推荐另外这种写法：middle = start + (end — start) / 2
6 | 如果要找的目标改好和中点所在的数值相等，我们返回中点的下标就行
7 | 如果目标不等的话：我们就有两种移动方式了
8 | 如果目标比中点在的值小（key < arr[middle]）：将下一步搜索空间放到左边（end = middle - 1）
9 | 如果比中点的值大，则继续在右边搜索，丢弃左边：left = middle + 1
10 | 图示该过程的话，如下图所示
11 |
12 | 
13 |
14 | **经典题目：**
15 |
16 | Order-agnostic Binary Search (easy)
17 |
18 | Ceiling of a Number (medium)
19 |
20 | Next Letter (medium)
21 |
22 | Number Range (medium)
23 |
24 | Search in a Sorted Infinite Array (medium)
25 |
26 | Minimum Difference Element (medium)
27 |
28 | Bitonic Array Maximum (easy)
29 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/12. Pattern: Top ‘K’ Elements，前K个系列/README.md:
--------------------------------------------------------------------------------
1 | **任何让我们求解最大/最小/最频繁的K个元素的题，都遵循这种模式。用来记录这种前K类型的最佳数据结构就是堆了（译者注：在Java中，改了个名，叫优先队列（PriorityQueue））。这种模式借助堆来解决很多这
2 | 种前K个数值的问题。**
3 |
4 | 这个模式是这样的：
5 |
6 | * 根据题目要求，将K个元素插入到最小堆或是最大堆。
7 | * 遍历剩下的还没访问的元素，如果当前出来到的这个元素比堆顶元素大，那咱们把堆顶元素先删除，再加当前元素进去。
8 |
9 | 
10 |
11 | 注意这种模式下，咱们不需要去排序数组，因为堆具有这种良好的局部有序性，这对咱们需要解决问题就够了。
12 |
13 | 识别最大K个元素模式：
14 |
15 | * 如果你需要求最大/最小/最频繁的前K个元素
16 | * 如果你需要通过排序去找一个特定的数
17 |
18 |
19 | **经典题目：**
20 |
21 | Top ‘K’ Numbers (easy)
22 |
23 | Kth Smallest Number (easy)
24 |
25 | ‘K’ Closest Points to the Origin (easy)
26 |
27 | Connect Ropes (easy)
28 |
29 | Top ‘K’ Frequent Numbers (medium)
30 |
31 | Frequency Sort (medium)
32 |
33 | Kth Largest Number in a Stream (medium)
34 |
35 | ‘K’ Closest Numbers (medium)
36 |
37 | Maximum Distinct Elements (medium)
38 |
39 | Sum of Elements (medium)
40 |
41 | Rearrange String (hard)
42 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/13. Pattern: K-way merge，多路归并/README.md:
--------------------------------------------------------------------------------
1 | **K路归并能帮咱们解决那些涉及到多组排好序的数组的问题。每当你的输入是K个排好序的数组，你就可以用堆来高效顺序遍历其中所有数组的所有元素。你可以将每个数组中最小的一个元素加入到最小堆中，从而得到全
2 | 局最小值。当我们拿到这个全局最小值之后，再从该元素所在的数组里取出其后面紧挨着的元素，加入堆。如此往复直到处理完所有的元素**
3 |
4 | 
5 |
6 | 该模式是这样的运行的：
7 |
8 | 1. 把每个数组中的第一个元素都加入最小堆中
9 |
10 | 2. 取出堆顶元素（全局最小），将该元素放入排好序的结果集合里面
11 |
12 | 3. 将刚取出的元素所在的数组里面的下一个元素加入堆
13 |
14 | 4. 重复步骤2，3，直到处理完所有数字
15 |
16 | **识别K路归并：**
17 |
18 | * 该问题的输入是排好序的数组，链表或是矩阵
19 | * 如果问题让咱们合并多个排好序的集合，或是需要找这些集合中最小的元素
20 |
21 |
22 | **经典题目：**
23 |
24 | Merge K Sorted Lists (medium)
25 |
26 | Kth Smallest Number in M Sorted Lists (Medium)
27 |
28 | Kth Smallest Number in a Sorted Matrix (Hard)
29 |
30 | Smallest Number Range (Hard)
31 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/14. Pattern: 0 mod 1 Knapsack (Dynamic Programming)/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | **经典题目：**
5 |
6 | 0/1 Knapsack (medium)
7 |
8 | Equal Subset Sum Partition (medium)
9 |
10 | Subset Sum (medium)
11 |
12 | Minimum Subset Sum Difference (hard)
13 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/15. Pattern: Topological Sort (Graph)，拓扑排序类型/README.md:
--------------------------------------------------------------------------------
1 | 拓扑排序模式用来寻找一种线性的顺序，这些元素之间具有依懒性。比如，如果事件B依赖于事件A，那A在拓扑排序顺序中排在B的前面。
2 |
3 | 这种模式定义了一种简单方式来理解拓扑排序这种技术。
4 |
5 | 这种模式是这样奏效的：
6 |
7 | 初始化
8 | a) 借助于HashMap将图保存成邻接表形式。
9 | b) 找到所有的起点，用HashMap来帮助记录每个节点的入度
10 | 创建图，找到每个节点的入度
11 | a) 利用输入，把图建好，然后遍历一下图，将入度信息记录在HashMap中
12 | 找所有的起点
13 | a) 所有入度为0的节点，都是有效的起点，而且我们讲他们都加入到一个队列中
14 | 排序
15 | a) 对每个起点，执行以下步骤
16 | —i) 把它加到结果的顺序中
17 | — ii)将其在图中的孩子节点取到
18 | — iii)将其孩子的入度减少1
19 | — iv)如果孩子的入度变为0，则改孩子节点成为起点，将其加入队列中
20 | b) 重复（a）过程，直到起点队列为空。
21 |
22 |
23 | 
24 |
25 |
26 | 拓扑排序模式识别：
27 |
28 | * 待解决的问题需要处理无环图
29 | * 你需要以一种有序的秩序更新输入元素
30 | * 需要处理的输入遵循某种特定的顺序
31 |
32 | **经典题目：**
33 |
34 | Topological Sort (medium)
35 |
36 | Tasks Scheduling (medium)
37 |
38 | Tasks Scheduling Order (medium)
39 |
40 | All Tasks Scheduling Orders (hard)
41 |
42 | Alien Dictionary (hard)
43 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/2 Pattern: Two Pointers/README.md:
--------------------------------------------------------------------------------
1 |
2 | [双指针法：总结篇！](https://mp.weixin.qq.com/s/_p7grwjISfMh0U65uOyCjA)|[双指针](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/91/two-pointers)|
3 | ---|
4 |
5 | ---
6 |
7 | 
8 |
9 | **双指针是这样的模式：两个指针朝着左右方向移动（双指针分为同向双指针和异向双指针），直到他们有一个或是两个都满足某种条件。双指针通常用在排好序的数组或是链表中寻找对子。比如，你需要去比较数组中每个元素和其他元素的关系时，你就需要用到双指针了。我们需要双指针的原因是：如果你只用一个指针的话，你得来回跑才能在数组中找到你需要的答案。这一个指针来来回回的过程就很耗时和浪费空间了 — 这是考虑算法的复杂度分析的时候的重要概念。虽然brute force一个指针的解法可能会奏效，但时间复杂度一般会是O(n²)。在很多情况下，双指针能帮助我们找到空间或是时间复杂度更低的解。**
10 |
11 |
12 | 识别使用双指针的招数：
13 |
14 | * 一般来说，数组或是链表是排好序的，你得在里头找一些组合满足某种限制条件
15 | * 这种组合可能是一对数，三个数，或是一个子数组
16 |
17 |
18 | **经典题目：**
19 |
20 | Pair with Target Sum (easy)
21 |
22 | Remove Duplicates (easy)
23 |
24 | Squaring a Sorted Array (easy)
25 |
26 | Triplet Sum to Zero (medium)
27 |
28 | Triplet Sum Close to Target (medium)
29 |
30 | Triplets with Smaller Sum (medium)
31 |
32 | Subarrays with Product Less than a Target (medium)
33 |
34 | Dutch National Flag Problem (medium)
35 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/3. Pattern: Fast & Slow pointers, 快慢指针类型/README.md:
--------------------------------------------------------------------------------
1 | 
2 |
3 | **这种模式，有一个非常出门的名字，叫龟兔赛跑。咱们肯定都知道龟兔赛跑啦。但还是再解释一下快慢指针：这种算法的两个指针的在数组上（或是链表上，序列上）的移动速度不一样。还别说，这种方法在解决有环的链表和数组时特别有用。
4 | 通过控制指针不同的移动速度（比如在环形链表上），这种算法证明了他们肯定会相遇的。快的一个指针肯定会追上慢的一个（可以想象成跑道上面跑得快的人套圈跑得慢的人）。**
5 |
6 |
7 | 咋知道需要用快慢指针模式勒？
8 |
9 | * 问题需要处理环上的问题，比如环形链表和环形数组
10 | * 当你需要知道链表的长度或是某个特别位置的信息的时候
11 | * 那啥时候用快慢指针而不是上面的双指针呢？
12 |
13 | 有些情形下，咱们不应该用双指针，比如我们在单链表上不能往回移动的时候。一个典型的需要用到快慢指针的模式的是当你需要去判断一个链表是否是回文的时候。
14 |
15 | **经典题目：**
16 |
17 | LinkedList Cycle (easy)
18 |
19 | Start of LinkedList Cycle (medium)
20 |
21 | Happy Number (medium)
22 |
23 | Middle of the LinkedList (easy)
24 |
25 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/4. Pattern: Merge Intervals，区间合并类型/README.md:
--------------------------------------------------------------------------------
1 |
2 | 
3 |
4 | **区间合并模式是一个用来处理有区间重叠的很高效的技术。在设计到区间的很多问题中，通常咱们需要要么判断是否有重叠，要么合并区间，如果他们重叠的话。这个模式是这么起作用的：
5 | 给两个区间，一个是a，另外一个是b。别小看就两个区间，他们之间的关系能跑出来6种情况。详细的就看图啦。**
6 |
7 | 理解和识别这六种情况，灰常重要。因为这能帮你解决一大堆问题。这些问题从插入区间到优化区间合并都有。
8 |
9 | 怎么识别啥时候用合并区间模式呀？
10 |
11 | * 当你需要产生一堆相互之间没有交集的区间的时候
12 | * 当你听到重叠区间的时候
13 |
14 |
15 | **经典题目：**
16 |
17 | Merge Intervals (medium)
18 |
19 | Insert Interval (medium)
20 |
21 | Intervals Intersection (medium)
22 |
23 | Conflicting Appointments (medium)
24 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/5. Pattern: Cyclic Sort，循环排序/README.md:
--------------------------------------------------------------------------------
1 | **这种模式讲述的是一直很好玩的方法：可以用来处理数组中的数值限定在一定的区间的问题。这种模式一个个遍历数组中的元素，如果当前这个数它不在其应该在的位置的话，咱们就把它和它应该在的那个位置上的数
2 | 交换一下。你可以尝试将该数放到其正确的位置上，但这复杂度就会是O(n^2)。这样的话，可能就不是最优解了。因此循环排序的优势就体现出来了**
3 |
4 | 
5 |
6 | 咋鉴别这种模式？
7 |
8 | * 这些问题一般设计到排序好的数组，而且数值一般满足于一定的区间
9 | * 如果问题让你需要在排好序/翻转过的数组中，寻找丢失的/重复的/最小的元素
10 |
11 |
12 | **经典题目：**
13 |
14 | Cyclic Sort (easy)
15 |
16 | Find the Missing Number (easy)
17 |
18 | Find all Missing Numbers (easy)
19 |
20 | Find the Duplicate Number (easy)
21 |
22 | Find all Duplicate Numbers (easy)
23 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/6. Pattern: In-place Reversal of a LinkedList，链表翻转/README.md:
--------------------------------------------------------------------------------
1 | **在众多问题中，题目可能需要你去翻转链表中某一段的节点。通常，要求都是你得原地翻转，就是重复使用这些已经建好的节点，而不使用额外的空间。这个时候，原地翻转模式就要发挥威力了。
2 | 这种模式每次就翻转一个节点。一般需要用到多个变量，一个变量指向头结点（下图中的current），另外一个（previous）则指向咱们刚刚处理完的那个节点。在这种固定步长的方式下，你需要先将当前
3 | 节点（current）指向前一个节点（previous），再移动到下一个。同时，你需要将previous总是更新到你刚刚新鲜处理完的节点，以保证正确性。**
4 |
5 |
6 | 
7 |
8 | 咱们怎么去甄别这种模式呢？
9 |
10 | * 如果你被问到需要去翻转链表，要求不能使用额外空间的时候
11 |
12 | **经典题目：**
13 |
14 | Reverse a LinkedList (easy)
15 |
16 | Reverse a Sub-list (medium)
17 |
18 | Reverse every K-element Sub-list (medium)
19 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/7. Pattern: Tree Breadth First Search，树上的BFS/README.md:
--------------------------------------------------------------------------------
1 | **这种模式基于宽搜（Breadth First Search (BFS)），适用于需要遍历一颗树。借助于队列数据结构，从而能保证树的节点按照他们的层数打印出来。打印完当前层所有元素，才能执行到下一层。所有这种需要遍历树且
2 | 需要一层一层遍历的问题，都能用这种模式高效解决。这种树上的BFS模式是通过把根节点加到队列中，然后不断遍历直到队列为空。每一次循环中，我们都会把队头结点拿出来（remove），然后对其进行必要的操作。在删
3 | 除每个节点的同时，其孩子节点，都会被加到队列中**
4 |
5 |
6 | 识别树上的BFS模式：
7 |
8 | * 如果你被问到去遍历树，需要按层操作的方式（也称作层序遍历）
9 |
10 | **经典题目：**
11 |
12 | Binary Tree Level Order Traversal (easy)
13 |
14 | Reverse Level Order Traversal (easy)
15 |
16 | Zigzag Traversal (medium)
17 |
18 | Level Averages in a Binary Tree (easy)
19 |
20 | Minimum Depth of a Binary Tree (easy)
21 |
22 | Level Order Successor (easy)
23 |
24 | Connect Level Order Siblings (medium)
25 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/8. Pattern: Tree Depth First Search，树上的DFS/README.md:
--------------------------------------------------------------------------------
1 | **树形DFS基于深搜（Depth First Search (DFS)）技术来实现树的遍历。咱们可以用递归（或是显示栈，如果你想用迭代方式的话）来记录遍历过程中访问过的父节点。该模式的运行方式是从根节点开始，如果该节点
2 | 不是叶子节点，我们需要干三件事：**
3 |
4 | **需要区别我们是先处理根节点（pre-order，前序），**
5 |
6 | **处理孩子节点之间处理根节点（in-order，中序），**
7 |
8 | **还是处理完所有孩子再处理根节点（post-order，后序）。**
9 |
10 | **递归处理当前节点的左右孩子。****
11 |
12 |
13 | 识别树形DFS：
14 |
15 | 你需要按前中后序的DFS方式遍历树
16 | 如果该问题的解一般离叶子节点比较近。
17 | 经典题目：
18 |
19 | Binary Tree Path Sum (easy)
20 |
21 | All Paths for a Sum (medium)
22 |
23 | Sum of Path Numbers (medium)
24 |
25 | Path With Given Sequence (medium)
26 |
27 | Count Paths for a Sum (medium)
28 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/9. Pattern: Two Heaps，双堆类型/README.md:
--------------------------------------------------------------------------------
1 | **很多问题中，我们被告知，我们拿到一大把可以分成两队的数字。为了解决这个问题，我们感兴趣的是，怎么把数字分成两半？使得：小的数字都放在一起，大的放在另外一半。双堆模式就能高效解决此类问题。
2 | 正如名字所示，该模式用到了两个堆，是不是很难猜？一个最小堆用来找最小元素；一个最大堆，拿到最大元素。这种模式将一半的元素放在最大堆中，这样你可以从这一堆中秒找到最大元素。同理，把剩下一半丢到最小堆
3 | 中，O(1)时间找到他们中的最小元素。通过这样的方式，这一大堆元素的中位数就可以从两个堆的堆顶拿到数字，从而计算出来。**
4 |
5 | 判断双堆模式的秘诀：
6 |
7 | * 这种模式在优先队列，计划安排问题（Scheduling）中有奇效
8 | * 如果问题让你找一组数中的最大/最小/中位数
9 | * 有时候，这种模式在涉及到二叉树数据结构时也特别有用
10 |
11 |
12 | **经典题目：**
13 |
14 | Find the Median of a Number Stream (medium)
15 |
16 | Sliding Window Median (hard)
17 |
18 | Maximize Capital (hard)
19 |
--------------------------------------------------------------------------------
/LeetCode算法面试/经典题型分类/README.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 
2 |
3 | # Data-Structure-and-Algorithmic
4 |
5 | **第一阶段按照 tag 去刷， 第二阶段则要一题多解，多题同解，挖掘题目背后的东西**
6 |
7 | **去年找互联网的工作，刷了两遍LeetCode，只做了前200道。面试过程中碰到的算法题基本都被秒杀了。最后拿了9个offer。我是按Tag来刷的。链表，二叉树，回溯，深度宽度优先遍历，图，贪心，动规，数组，哈希表……每个tag由easy到hard，每道题先自己思考，不会的参考了一个开源的解答或者参考Discuss或者博客。开始的时候自己独立思考的时间比较长，后来没了耐心，不会的题目就马上看解答了。一般题目解法有多种，这时候最好尝试一下其他的做法，至少要知道思路。比如有关图的题目就会有DFS和BFS两种解法。Discuss里一般都会有高质量的解答。关键是每道题都要弄明白。一开始用IDE，跑出正确结果，再在线默写代码。后来写的多了，直接在线写代码了。这是一个自然的过程，做的多了就有“手感”了。总结一下，按tag由易到难，每道题弄清楚，知道其他的解法，这是核心！搞定了核心，**
8 |
9 | **前200题是最经典的。前期可以先积累量，把前两百题刷完 刷够量之后，对算法有了一个大概的理解。然后再精刷。最好先按tag刷。分类总结下自己需要刷的tag。然后按出现频率排序，再按这个顺序刷。最后面试前再刷要面试的那个公司的高频题。**
10 |
11 | **分享一下身边大神的刷题顺序：**
12 |
13 | **如果你时间比较紧迫，为了找工作而刷题，我建议你先刷热门推荐，一共两百多道题。**
14 |
15 | **在 https://leetcode-cn.com/problemset/all/ 页面的右侧。先刷热题 HOT 100，再刷精选 TOP 面试题，之后刷其他的题。如果你时间比较充裕，那我建议你：按从低到高的难度分组刷按 tag 分类刷定期复习，重做之前刷过的题**
16 |
17 | **刷题方法：**
18 |
19 | 第一遍：可以先思考，之后看参考答案刷，结合其他人的题解刷。思考、总结并掌握本题的类型，思考方式，最优题解。
20 |
21 | 第二遍：先思考，回忆最优解法，并与之前自己写过的解答作比对，总结问题和方法。
22 |
23 | 第三遍：提升刷题速度，拿出一个题，就能够知道其考察重点，解题方法，在短时间内写出解答。定期总结：按照题目类型进行总结：针对一类问题，总结有哪些解题方法，哪种方法是最优的，为什么。总结重点：有些题你刷了好多遍都还是不会，那就要重点关注，多思考解决方法，不断练习强结合图解刷题：有些人认为刷题比较枯燥，比较抽象。那你可以结合动画图解刷题。**
24 |
25 |
26 | # 算法工具网站
27 |
28 | * [可视化的数据结构 - 各种算法动画演示](https://visualgo.net/en)
29 | * [ Algorithm Visualizer，做得很好](https://algorithm-visualizer.org/divide-and-conquer/bucket-sort)
30 |
31 |
32 | # 算法视频
33 | * [Learn Data Structures and Algorithms for free](https://www.youtube.com/watch?v=CBYHwZcbD-s&t=165s)
34 | * [Top 7 Algorithms for Coding Interviews Explained SIMPLY](https://www.youtube.com/watch?v=kp3fCihUXEg)
35 | # 在线模拟环境
36 | * [豆包MarsCode AI的刷题助手---在刷题过程中，遇到代码问题，先让AI给出思路，不行再给出参考代码](https://www.marscode.cn/practice/kd0dekkw5oj749?problem_id=7414004855077847084)
37 | * [SQL在线模拟环境---很好⽤的 SQL 练习平台](https://sqlzoo.net/)
38 | * [正则表达式练习平台](https://regexone.com/)
39 | * [测试正则表达式的平台](https://regexr.com/)
40 | * [Git在线练习平台](https://github.com/pcottle/learnGitBranching)
41 |
42 |
43 | # 在线书籍
44 | ## 1 入门系列---这些书籍通过图片、打比方等通俗易懂的方法来讲述，让你能达到懂一些基础算法，线性表，堆栈，队列，树，图，DP算法，背包问题等，不要求会实现，但是看过以下这些书对于之后实现算法打下坚实的思维基础
45 | * 啊哈！算法.PDF---本书中涉及到的数据结构有栈、队列、链表、树、并查集、堆和图等；涉及到的算法有排序、枚举、深度和广度优先搜索、图的遍历，当然还有图论中不可以缺少的四种最短路径算法、两种最小生成树算法、割点与割边算法、二分图的最大匹配算法等
46 | * [算法图解---这本图解书很容易看懂，不枯燥](https://weread.qq.com/web/reader/fbf32b80715c0184fbff41f)
47 | * 趣学算法.PDF---非常好的一本书，图解多，思路清晰，不仅讲了问题分析算法设计的过程，还讲了如何优化算法
48 | * [大话数据结构](https://weread.qq.com/web/bookDetail/f7c324d0813ab6bb7g017833)
49 | * 学习算法思想 修炼编程内功视频---这样精致的课程很难找到第二个
50 | ## 2 基础系列---通过基本入门算法书的调教，你已经逐渐体会到了算法的魅力，现在正是时候去阅读基础系列踏入算法的领域
51 | * 算法导论.pdf---本书将严谨性和全面性融为一体，深入讨论各类算法，并着力使这些算法的设计和分析能为各个层次的读者接受
52 | * 数据结构与算法 Java版
53 | * 数据结构与算法：Python语言描述
54 | * 学习JavaScrit数据结构与算法（第2版）
55 | * 数据结构与算法分析：C语言描述（原书第2版）
56 | * 数据结构与算法分析:C++描述(第3版)
57 | ## 3 进阶系列---想要参加面试，那就需要阅读以下书籍进行准备了
58 | * [剑指Offer：名企面试官精讲典型编程题（第2版）---剖析了80个典型的编程面试题，系统整理基础知识、代码质量、解题思路、优化效率和综合能力这5个面试要点](https://weread.qq.com/web/bookDetail/4e132bc07263ff664e11075)
59 | * 算法谜题---算法谜题，就是能够直接或间接地采用算法来加以解决的谜题。求解算法谜题是培养和锻炼算法思维能力一种最有效和最有乐趣的途径
60 | * 编程之法 面试和算法心得
61 |
62 | ## 4 高手系列
63 | * 编程珠玑（第2版•修订版）---融深邃思想、实战技术与趣味轶事于一炉的奇书，带你真正领略计算机科学之美
64 | * 程序员实用算法---重点关注的是实用、立即可用的代码，并且广泛讨论了可移植性和特定于实现的细节,介绍了一些有用但很少被讨论的算法，它们可用于语音查找、日期、B树和索引文件、数据压缩、任意精度的算术、校验和与数据验证，并且还最全面地介绍了查找例程、排序算法和数据结构
65 | * 编程之美
66 | * 数据挖掘原理与算法---覆盖面最广，除了所有书都有的内容外，还包括FOIL算法和空间数据挖掘等
67 | * 集体智慧编程
68 |
69 | * [算法之美](https://weread.qq.com/web/reader/d5c329b071543c05d5c796f)
70 | * [算法练营： 海量图解 2021](https://weread.qq.com/web/reader/5f2320c0725a69455f288dd)
71 | * [趣学数据结构](https://weread.qq.com/web/reader/5fd32df071a525855fd4932)
72 | * [零基础学算法（第4版）---2020](https://weread.qq.com/web/reader/a363257071eeef84a36a574)
73 |
74 | * [算法（第4版）](https://weread.qq.com/web/reader/7cc32910718ff66b7cc8d9d)
75 | * [数据结构与算法图解](https://weread.qq.com/web/reader/689329a0718ff663689395d)
76 | * [算法训练营： 海量图解 + 竟刷题（入门篇）2021](https://weread.qq.com/web/reader/5f2320c0725a69455f288dd)
77 | * [剑指Offer(专项突破版)： 数据结构与算法名企面试题精解 2021](https://weread.qq.com/web/reader/4e132bc07263ff664e11075)
78 | * [程序员代码面试指南： IT名企算法与数据结构题目最优解（第2版）2021](https://weread.qq.com/web/reader/1be32b907184877a1be90a2)
79 | * [未来算法：下一个十年赢在算法 ---诸葛越 2021](https://weread.qq.com/web/reader/f4c32ff0725a7243f4cbaaf)
80 | * [计算机数学： 算法基础，线性代数与图论 2016](https://weread.qq.com/web/reader/07f3263071f07c9a07faf77)
81 | * [程序员数学： 用Python学透线性代数和微分](https://weread.qq.com/web/reader/818320a0728a4acc8189214)
82 | * [程序员必会的40种算法](https://weread.qq.com/web/reader/81c32340726e823581c0f80)
83 |
84 | # 从逻辑上分，数据结构分为线性和非线性两大类。
85 |
86 | 线性数据结构包括数组、链表、栈、队列。
87 |
88 | 非线性结构包括树、哈希表、堆、图。**
89 |
90 | # [数据结构与算法教程---付费教程](http://data.biancheng.net/)
91 | # [数据结构与算法面试](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/tree/master/Interview)
92 | # [数据结构和算法的学习方法路径](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%AD%A6%E4%B9%A0%E6%96%B9%E6%B3%95.md)
93 | # [LeetCode按照怎样的顺序来刷题比较好？](https://www.zhihu.com/question/36738189/answer/908664455)
94 | # [LeetCode 刷题攻略---一个超级详细的刷题顺序](https://github.com/stevenli91748/leetcode-master)
95 | # [刷完 900 多道算法题的首次总结：LeetCode 应该怎么刷？](https://blog.csdn.net/fuxuemingzhu/article/details/105183554)
96 | * [负雪明烛---阿里巴巴工程师 7 年写了 1000 多篇 LeetCode 题解](https://blog.csdn.net/fuxuemingzhu?type=blog)
97 | * [李威威---中文力扣的大 V，对力扣题目掌握很全面，写得题解非常详细，对题目举一反三](https://liweiwei1419.gitee.io/leetcode-algo/)
98 | * [花花酱---基本每个题都有博客和视频，强烈推荐看他的视频](https://zxi.mytechroad.com/blog/)
99 | * [Grandyang---在博客园更新了几乎所有力扣题目，收获了 1200万 阅读](https://grandyang.com/)
100 | * [土妹: 1600多道题目，刷哪些？什么顺序？刷多少？难度怎么分配？](https://www.youtube.com/watch?v=d6XqH991bB8&list=PLeRPcJf8vjt1LPbXt7xfJ7Sv-6B57F3IV&index=2)
101 | # [刷完 LeetCode 是什么水平？按照怎样的顺序来刷题比较好？](https://zhuanlan.zhihu.com/p/258542340)
102 | # [LeetCode CookBook---霜神是前阿里巴巴资深后端工程师](https://books.halfrost.com/leetcode/)
103 | # [别再埋头刷LeetCode之：北美算法面试的题目分类，按类型和规律刷题，事半功倍---LeetCode经典题目](https://www.zhihu.com/question/36738189/answer/908664455)
104 | # [刷leetcode不知道从哪里刷起？？ 来看看，BAT工程师已经把刷题题目顺序都排好了，每道题还带详细题解---代码随想录](https://zhuanlan.zhihu.com/p/339849416)
105 | # [如何系统地学习算法](https://www.zhihu.com/question/20588261/answer/756044375?utm_source=wechat_session&utm_medium=social&utm_oi=991812777480134656&utm_content=first)
106 | # [如何正确高效地使用LeetCode](https://www.zhihu.com/question/26580300)
107 | # [可以查答案的网址：LeetCode / LintCode 答案查询](https://www.jiuzhang.com/solution/)
108 | # [西法的刷题秘籍](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/)
109 | # [来和大家聊聊我是如何刷题的（第一弹）](https://lucifer.ren/blog/2020/11/29/shuati-silu/)
110 | # [来和大家聊聊我是如何刷题的（第二弹）](https://lucifer.ren/blog/2020/12/12/shuati-silu2/)
111 | # [来和大家聊聊我是如何刷题的（第三弹）](https://lucifer.ren/blog/2020/12/21/shuati-silu3/)
112 | # [面试算法题的快速思考方法 面对一个问题，改如何下手思考将其解决](http://www.nowamagic.net/librarys/veda/detail/1018)
113 | # [为何我刷了很多，遇到新的题还是唯唯诺诺，无法重拳出击](https://lucifer.ren/blog/2021/04/06/out-of-science/)
114 | ---
115 | 
116 | 
117 |
118 | ---
119 | [【干货】程序员面试一定要掌握的10个算法 | LeetCode 刷题清单 | 100小时+刷题经验分享 [上]](https://www.youtube.com/watch?v=3toa_cJu49g)|
120 | ---|
121 |
122 | [小白都能懂的学算法方法！我刷了 1000 道，LeetCode 入门不难！【程序员鱼皮】](https://www.youtube.com/watch?v=UJLLP-6WGMo)|
123 | ---|
124 | [Grokking the Coding Interview: Patterns for Coding Questions----Leetcode刷题顺序,看这一篇就够了](https://www.educative.io/courses/grokking-the-coding-interview?aff=K7qB)|
125 | ---|
126 |
127 | [Data Structures](https://www.geeksforgeeks.org/data-structures/?ref=shm)|[algorithms](https://www.geeksforgeeks.org/fundamentals-of-algorithms/?ref=shm)|
128 | ---|---|
129 |
130 | [Interviews---Your personal guide to Software Engineering technical interviews 在线炼习](https://github.com/kdn251/interviews)|[Cracking the Coding Interview 6th Ed. Solutions](https://github.com/careercup/CtCI-6th-Edition)|[data structures and algorithms interviews 在线炼习](https://practice.geeksforgeeks.org/explore?page=1&curated[]=1&sortBy=submissions)|
131 | ---|---|---|
132 |
133 | [GitHub上很火的算法可视化项目---在线动态演示算法的网站，可以很清楚的看到算法运行的整个过程](https://www.bmabk.com/index.php/post/2602.html)|
134 | ---|
135 |
136 |
137 | [very good algorithmic](https://www.youtube.com/user/mycodeschool)|
138 | ----|
139 |
140 |
141 | [java 算法例子程序](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/java%20%E7%AE%97%E6%B3%95%E4%BE%8B%E5%AD%90%E7%A8%8B%E5%BA%8F/README.md)|[数据结构精讲：从原理到实战](https://www.kancloud.cn/alex_wsc/datastructure)|[leetcode笔记](https://www.kancloud.cn/digest/leetcodeojs)|
142 | ---|---|---|
143 |
144 | [代码随想录算法训练营](https://github.com/youngyangyang04/leetcode-master)|
145 | ---|
146 |
147 | [算法快速入门教程（多语言实现）](http://c.biancheng.net/algorithm/)|[Python机器学习算法入门教程](http://c.biancheng.net/ml_alg/)|[数据结构与算法/leetcode/lintcode题解](https://www.kancloud.cn/kancloud/data-structure-and-algorithm-notes)|[前Google工程师，5万+人跟着学的《数据结构和算法之美》专栏作者
148 | ](https://github.com/cockshark/alog)|
149 | ---|----|---|---|
150 |
151 | [数据结构与算法学习整理大纲](https://www.coollf.com/archives/article-15)|[ labuladong 的算法小抄](https://github.com/labuladong/fucking-algorithm)|[leetcode笔记](https://www.kancloud.cn/digest/leetcodeojs)|
152 | ---|---|---|
153 |
154 | [精尽数据结构与算法学习指南](http://svip.iocoder.cn/Data-Structures-and-Algorithms/tutorials/)|[九章算法官方频道](https://www.youtube.com/channel/UCdBXs_F9YlBodIH7eK0BYfQ/videos)|[X Code---系统设计 和 算法](https://www.youtube.com/channel/UCicSh3qMeTmYybY7wdiTjmg)|[经验分享 这 5 个自学算法的工具和网站你知道几个？](https://zhuanlan.zhihu.com/p/365816763)|
155 | ---|---|---|---|
156 |
157 | [来Offer---LaiOffer](https://www.youtube.com/channel/UC12XyYzyyZwFiIgafl_Ga6w/videos)|[Java数据结构与算法教程](https://www.jb51.net/Special/632.htm)|[花花酱算法---很好](https://www.youtube.com/channel/UC5xDNEcvb1vgw3lE21Ack2Q)|[九章算法---令狐冲的算法小抄](https://github.com/ninechapter-algorithm/linghu-algorithm-templete?utm_source=wechat_session&utm_medium=social&utm_oi=991812777480134656)|
158 | ---|---|---|---|
159 |
160 | [OI Wiki---致力于成为一个免费开放且持续更新的 编程竞赛 (competitive programming) 知识整合站点,准备了竞赛中的基础知识、常见题型、解题思路以及常用工具等](https://oi-wiki.org/)|
161 | ---|
162 |
163 | [LeetCode CookBook---霜神是前阿里巴巴资深后端工程师](https://books.halfrost.com/leetcode/)|[用java表示数据结构和算法](https://my.oschina.net/Clarences?tab=newest&catalogId=5691177)|[算法总结](https://jasonkayzk.github.io/algorithm/)|
164 | ---|---|---|
165 |
166 | [图解 Java 中的数据结构及原理，傻瓜也能看懂](https://mp.weixin.qq.com/s/2t_XO3G1v1jx7q0-9YU0YA)|[leetcode-master---本项目是一套完整的刷题计划，旨在帮助大家少走弯路，循序渐进学算法](https://github.com/stevenli91748/leetcode-master)|
167 | ---|---|
168 |
169 | # 算法的免费学习资源
170 |
171 |
172 | [可以查询各个公司算法面试高频题的网站](https://codetop.cc/#/home)|[lintcode](https://www.lintcode.com/)|[leetcode](https://leetcode.com/explore/)|[leetcode 中文](https://leetcode-cn.com/)|[牛客网](https://www.nowcoder.com/)|
173 | ---|---|---|---|---|
174 |
175 |
176 | [Github top 12 ---All Algorithms implemented in Java](https://github.com/TheAlgorithms/Java)|[专门为刚开始刷题的同学准备的算法基地](https://github.com/chefyuan/algorithm-base)|[洛谷---为广大算法竞赛选手、程序设计爱好者以及院校企业机构提供算法题库、社区、训练工具、在线教育为一体的解决方案,国内著名的题库与社区](https://www.luogu.com.cn/)|
177 | ---|---|---|
178 |
179 |
180 | # Online Judge System(OJ)---在线判题系统
181 |
182 | [各家的在线判题系统---POJ是ACM选手首选OJ，输入模式也是ACM模式](https://blog.nowcoder.net/n/3753f38e875b457fa052e149693005ad?from=nowcoder_improve)|
183 | ---|
184 |
185 |
186 | ---
187 |
188 | [FB面试官揭秘算法面试速成技巧 — 怎样做到 Bug Free 和刷100题等于别人刷300题](https://www.youtube.com/watch?v=gWg_gz8rrcM)|[LeetCode 算法面试题解](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/README.md)|
189 | ---|---|
190 |
191 |
192 |
193 | # 目录
194 |
195 | **数据之间的关系有 3 种，分别是 "一对一"、"一对多" 和 "多对多"，前两种关系的数据可分别用线性表和树结构存储，后一种"多对多"逻辑关系数据的结构——图存储结构**
196 |
197 | * [第一篇 数学 计算几何篇](#第一篇-数学篇-计算几何篇)
198 | * [第二篇 数据结构篇](#第二篇-数据结构篇)
199 | * [第三篇 算法篇](#第三篇-算法篇)
200 | * [第四篇 专题篇](#第四篇-专题篇)
201 |
202 | # [第一篇 数学篇 计算几何篇](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/%E6%95%B0%E5%AD%A6/README.md)
203 |
204 |
205 | # 数组、链表、栈、队列、散列表、二叉树、堆、跳表、图、Trie树
206 |
207 | # 第二篇 数据结构篇
208 | |[Data Structures and Algorithms in Java ](https://www.youtube.com/watch?v=6iCHf7OZn6c&list=PL6Zs6LgrJj3tDXv8a_elC6eT_4R5gfX4d&index=1)||
209 | | **第一章 数据结构和算法概述** ||
210 | | :--- | :---: |
211 | | [1-1 数据结构和算法的关系](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%92%8C%E7%AE%97%E6%B3%95%E6%A6%82%E8%BF%B0/README.md) | |
212 | |[1-1 数据结构的逻辑结构和物理结构](https://blog.csdn.net/xiaotaiyangzuishuai/article/details/78341314#:~:text=%E6%95%B0%E6%8D%AE%E7%9A%84%E9%80%BB%E8%BE%91%E7%BB%93%E6%9E%84%E6%8C%87,%E7%BB%93%E6%9E%84%EF%BC%8C%E6%88%96%E7%A7%B0%E5%AD%98%E5%82%A8%E7%BB%93%E6%9E%84%E3%80%82&text=%E6%A0%88%E5%8F%AA%E6%98%AF%E4%B8%80%E7%A7%8D%E6%8A%BD%E8%B1%A1,%E5%AD%98%E5%82%A8%E7%BB%93%E6%9E%84%E4%B8%BA%E9%93%BE%E6%A0%88%E3%80%82)||
213 | | 1-2 线性结构和非线性结构 | |
214 | | [1-3 算法的时间复杂度](https://zhuanlan.zhihu.com/p/50479555)| |
215 | | 1-3-1 [关于时间复杂度，你不知道的都在这里](https://mp.weixin.qq.com/s/LWBfehW1gMuEnXtQjJo-sw)||
216 | | 1-3-2 [O(n)的算法居然超时了，此时的n究竟是多大？](https://mp.weixin.qq.com/s/73ryNsuPFvBQkt6BbhNzLA)||
217 | | 1-3-3 [通过一道面试题目，讲一讲递归算法的时间复杂度！](https://mp.weixin.qq.com/s/I6ZXFbw09NR31F5CJR_geQ)||
218 | | [1-4 算法的空间复杂度](https://www.cxyxiaowu.com/1959.html)| |
219 | | 1-4-1 [关于空间复杂度，可能有几个疑问？](https://mp.weixin.qq.com/s/IPv4pTD6UxKkFBkgeDCZyg)||
220 | | 1-4-2 [可能对递归理解的还不够！还差得远！](https://mp.weixin.qq.com/s/zLeRB-GPc3q4DG-a5cQLVw)||
221 | | 1-4-3 [刷了这么多题，你了解自己代码的内存消耗么](https://mp.weixin.qq.com/s/IFZQCxJlI7-_dOC25xIOYQ)||
222 | |[动态连通性问题算法](https://rovo98.github.io/posts/b3f33dac/)||
223 | | **6种逻辑结构**| |
224 | | **[第二章 集合逻辑结构篇](https://github.com/stevenli91748/JAVA-Architecture/blob/master/Java%20fundamental/%E9%9B%86%E5%90%88.md)**||
225 | | **线性逻辑结构篇**| |
226 | | **第三章 静(动)态数组和矩阵(Array)---“一对一”逻辑关系的数据，最佳的存储方式是使用线性表** | |
227 | | 3-1 静态数组||
228 | | [3-1-1 稀蔬SPARESARRAY数组](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E6%95%B0%E7%BB%84/README.md)| |
229 | | [3-1-2 矩阵---二维数组 多维数组逻辑结构篇](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E6%95%B0%E7%BB%84/README.md) | |
230 | | 3-2 [动态数组(dynamic array)](https://blog.csdn.net/siasboy/article/details/6525352?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-6.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-6.control)||
231 | | 3-2-0 [在Java中如何使用动态数组](https://blog.csdn.net/weixin_30552635/article/details/95143774?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-0&spm=1001.2101.3001.4242) ||
232 | | 3-2-0 [如何在Java中使用静态数组构建动态数组](https://blog.csdn.net/weixin_26705651/article/details/108497745?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control)||
233 | | 3-4 [数组：总结篇](https://mp.weixin.qq.com/s/LIfQFRJBH5ENTZpvixHEmg)||
234 | | **第四章 [链表(Linked list)---“一对一”逻辑关系的数据，最佳的存储方式是使用线性表](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E9%93%BE%E8%A1%A8/README.md)**| |
235 | | 3-0 [静态链表和动态链表的区别](https://blog.csdn.net/zhengqijun_/article/details/78192888#:~:text=%E9%9D%99%E6%80%81%E9%93%BE%E8%A1%A8%E5%92%8C%E5%8A%A8%E6%80%81%E9%93%BE%E8%A1%A8%E6%98%AF%E7%BA%BF%E6%80%A7%E8%A1%A8%E9%93%BE%E5%BC%8F,%E9%A2%84%E5%85%88%E5%88%86%E9%85%8D%E5%9C%B0%E5%9D%80%E7%A9%BA%E9%97%B4%E5%A4%A7%E5%B0%8F%E3%80%82&text=2%E3%80%81%E5%8A%A8%E6%80%81%E9%93%BE%E8%A1%A8%E6%98%AF%E7%94%A8,%E7%9A%84%E9%95%BF%E5%BA%A6%E4%B8%8A%E6%B2%A1%E6%9C%89%E9%99%90%E5%88%B6%E3%80%82)||
236 | | 3-1 静态链表||
237 | | 3-1-1 单向链表(singly linked list)| |
238 | | 3-1-2 双向链表(doubly linked list)| |
239 | | 3-1-3 环型链表| |
240 | | 3-1-4 双向环链表||
241 | | 3-2 动态链表 ||
242 | | 3-3 链表反转||
243 | | 3-4 有序链表||
244 | | 3-6 [链表：总结篇](https://mp.weixin.qq.com/s/vK0JjSTHfpAbs8evz5hH8A)||
245 | | **[第五章 字符串---“一对一”逻辑关系的数据，最佳的存储方式是使用线性表](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E5%AD%97%E7%AC%A6%E4%B8%B2/README.md)**| |
246 | | ||
247 | | **[第六章 位运算](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E4%BD%8D/README.md)**| |
248 | | 5-1 利用位运算实现集合|---|
249 | | **第七章 栈 队列---“一对一”逻辑关系的数据，最佳的存储方式是使用线性表**| |
250 | | 5-1 [栈](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E6%A0%88/README.md) | |
251 | | 5-2 [队列](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E9%98%9F%E5%88%97/README.md) | |
252 | |[5-3 栈与队列：总结篇](https://mp.weixin.qq.com/s/xBcHyvHlWq4P13fzxEtkPg)||
253 | |---|---|
254 | | **[第八章 散列表](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E9%80%92%E5%BD%92/README.md)**| |
255 | |排列||
256 | |子集||
257 | |组合||
258 | |---|---|
259 | | **[第九章 排序算法](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Algorithmic/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95/README.md)**| |
260 | |7-1 内部排序 只使用内存||
261 | |7-1-1 冒泡排序| |
262 | |7-1-1-1 冒泡排序 算法基本思想||
263 | |7-1-1-1 冒泡排序 算法的时间复杂度||
264 | |7-1-1-1 冒泡排序 算法的空间复杂度||
265 | |7-1-1-1 冒泡排序 算法的稳定性||
266 | |7-1-2 插入排序| |
267 | |7-1-2-1 直接插入排序||
268 | |7-1-2-1 直接插入排序 算法基本思想||
269 | |7-1-2-1 直接插入排序 算法的时间复杂度||
270 | |7-1-2-1 直接插入排序 算法的空间复杂度||
271 | |7-1-2-1 直接插入排序 算法的稳定性||
272 | |7-1-3 选择排序| |
273 | |7-1-3-1 [简单选择排序 算法基本思想](#简单选择排序-算法基本思想)||
274 | |7-1-3-1 [简单选择排序 算法的时间复杂度](#简单选择排序-算法的时间复杂度)||
275 | |7-1-3-1 [简单选择排序 算法的空间复杂度](#简单选择排序-算法的空间复杂度)||
276 | |7-1-3-1 [简单选择排序 算法的稳定性](#简单选择排序-算法的稳定性)||
277 | |7-1-4 希尔排序| |
278 | |7-1-5 稳定排序||
279 | |7-1-6 快速排序| |
280 | |7-1-7 归并排序| |
281 | |7-1-8 基数排序| |
282 | |7-1-9 分割排序||
283 | |7-1-10 逆序数排序||
284 | |7-1-11 最小成本排序||
285 | |[7-2 外部排序 针对于体积过大以至内存装不下的文件，在对其包含的记录进行排序时所用到的算法](http://data.biancheng.net/out_sort/)||
286 | | 7-2-1 多路平衡归并排序算法（多路归并排序、胜者树、败者树）||
287 | | 7-2-2 置换选择排序算法||
288 | | 7-2-3 最佳归并树||
289 | |---|---|
290 | | **[第十章 查找算法](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Algorithmic/%E6%9F%A5%E6%89%BE%E7%AE%97%E6%B3%95/README.md)**| |
291 | | 1 [顺序查找算法](http://data.biancheng.net/view/54.html)| |
292 | | 2 [二分查找算法(非递归)](http://data.biancheng.net/view/55.html)| |
293 | | ---[二分法专题](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/91/binary-search)||
294 | | ---二分查找算法(非递归)的应用场景 | |
295 | | ---二分查找算法(非递归)的解决方案的基本步骤| |
296 | | ---二分查找算法(非递归)的代码实现| |
297 | | ---二分查找算法(非递归)的时间复杂度| |
298 | | ---二分查找算法(非递归)的空间复杂度| |
299 | | 3 [分块查找算法（索引顺序查找）](http://data.biancheng.net/view/56.html)||
300 | | 4 静态树表查找算法||
301 | | 5 二叉排序树查找算法（二叉查找树）||
302 | | 6 红黑树查找算法(更高级的二叉查找树)||
303 | | 7 平衡二叉树查找算法（AVL树）||
304 | | 8 B-树查找算法||
305 | | 9 B+树查找算法||
306 | | 10 键树查找算法（双链树和字典树）||
307 | | 11 插值查找算法| |
308 | | 12 奜波那契(黄金分割法)查找算法| |
309 | | 数据结构中的查找算法| |
310 | | --顺序表结构中的查找算法| |
311 | | --数组结构中的查找算法||
312 | | --链表结构中的查找算法| |
313 | | --树结构中的查找算法| |
314 | | --图结构中的查找算法| |
315 | |---|---|
316 | | **非线性结构篇**| |
317 | | **[第十一章 哈希表](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E5%93%88%E5%B8%8C%E8%A1%A8/README.md)**| |
318 | |1. 直接寻址||
319 | |2. 散列函数||
320 | |3. 开放地址法||
321 | |4. 链接法||
322 | |5. 再hash法||
323 | |6. Bloom Filter||
324 | |7. [HashMap底层原理](https://www.bilibili.com/video/BV1uW411N7CG)||
325 | |8. 源码分析||
326 | |---HashTable源码分析||
327 | |---[HashMap源码分析]()||
328 | |---HashSet源码分析||
329 | |---HashCode源码分析||
330 | |---[LinkedHashMap源码分析]()||
331 | |---Equals源码分析||
332 | |---[LinkList源码分析]()||
333 | |---[ArrayList 源码分析]()||
334 | |---[TreeMap源码分析]()||
335 | |[9. 哈希表：总结篇](https://mp.weixin.qq.com/s/1s91yXtarL-PkX07BfnwLg)||
336 | |---|---|
337 | | **第十三章 [堆](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E5%A0%86/README.md)**| |
338 | |---|---|
339 | | **[第十四章 树逻辑结构篇---“一对多”逻辑关系数据的结构,是一种非线性存储结构](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E6%A0%91/README.md)**| |
340 | | **[第十五章 图逻辑结构篇---多对多"逻辑关系数据的结构](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E5%9B%BE/README.md)**| |
341 | |**图的搜索**||
342 | | 广度优先搜索算法| |
343 | | 深度优先搜索| |
344 | | 最短路径搜索||
345 | | ---Dijkstra算法（狄克西特拉算法）||
346 | | ---A* 算法||
347 | | ---Bellman-Ford算法（贝尔曼-福特算法）||
348 | | ---Floyd-Warshall算法||
349 | |拓扑排序||
350 | |---DFS实现||
351 | |---BFS实现||
352 | |---时间复杂度||
353 | |并查集||
354 | |---Quick Find||
355 | |---Quick Union||
356 | |---Union Find||
357 | |最小生成树||
358 | |---Prim算法||
359 | |---Kruskal算法||
360 | | 10-1 二分图匹配| [无代码]|
361 | | 10-2 | [无代码]|
362 | |---|---|
363 | |---|---|
364 |
365 |
366 | # 递归、排序、二分查找、搜索、哈希算法、贪心算法、分治算法、回溯算法、动态规划、字符串匹配算法
367 |
368 | # 第三篇 算法篇
369 | | **第十六章 基本算法思想**||
370 | |---|---|
371 | | 枚举算法思想||
372 | | 模拟算法思想 | |
373 | | 递推算法思想 | |
374 | | 递归算法思想 | |
375 | | 分治算法思想 | |
376 | | 概率算法思想 | |
377 | | 贪心算法思想| |
378 | | 动态规划算法思想||
379 | | 排序算法思想||
380 | | 试探算法思想||
381 | | 二分算法思想 ||
382 | | 倍增算法思想||
383 | | 构造算法思想||
384 | | 前缀和 & 差分算法思想||
385 | |---|---|
386 | | **第十七章 程序员常用算法**| |
387 | | [递归算法](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Algorithmic/%E9%80%92%E5%BD%92%E7%AE%97%E6%B3%95/README.md)| |
388 | | [一篇总结带你彻底搞透回溯算法](https://mp.weixin.qq.com/s/r73thpBnK1tXndFDtlsdCQ) ||
389 | | 顺序查找算法||
390 | | **[第九章 排序算法](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Algorithmic/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95/README.md)**| |
391 | |7-1 内部排序 只使用内存||
392 | |7-1-1 冒泡排序| |
393 | |7-1-1-1 冒泡排序 算法基本思想||
394 | |7-1-1-1 冒泡排序 算法的时间复杂度||
395 | |7-1-1-1 冒泡排序 算法的空间复杂度||
396 | |7-1-1-1 冒泡排序 算法的稳定性||
397 | |7-1-2 插入排序| |
398 | |7-1-2-1 直接插入排序||
399 | |7-1-2-1 直接插入排序 算法基本思想||
400 | |7-1-2-1 直接插入排序 算法的时间复杂度||
401 | |7-1-2-1 直接插入排序 算法的空间复杂度||
402 | |7-1-2-1 直接插入排序 算法的稳定性||
403 | |7-1-3 选择排序| |
404 | |7-1-3-1 [简单选择排序 算法基本思想](#简单选择排序-算法基本思想)||
405 | |7-1-3-1 [简单选择排序 算法的时间复杂度](#简单选择排序-算法的时间复杂度)||
406 | |7-1-3-1 [简单选择排序 算法的空间复杂度](#简单选择排序-算法的空间复杂度)||
407 | |7-1-3-1 [简单选择排序 算法的稳定性](#简单选择排序-算法的稳定性)||
408 | |7-1-4 希尔排序| |
409 | |7-1-5 稳定排序||
410 | |7-1-6 快速排序| |
411 | |7-1-7 归并排序| |
412 | |7-1-8 基数排序| |
413 | |7-1-9 分割排序||
414 | |7-1-10 逆序数排序||
415 | |7-1-11 最小成本排序||
416 | |[7-2 外部排序 针对于体积过大以至内存装不下的文件，在对其包含的记录进行排序时所用到的算法](http://data.biancheng.net/out_sort/)||
417 | | 7-2-1 多路平衡归并排序算法（多路归并排序、胜者树、败者树）||
418 | | 7-2-2 置换选择排序算法||
419 | | 7-2-3 最佳归并树||
420 | |---|---|
421 | | **[第十章 查找算法](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Algorithmic/%E6%9F%A5%E6%89%BE%E7%AE%97%E6%B3%95/README.md)**| |
422 | | 1 [顺序查找算法](http://data.biancheng.net/view/54.html)| |
423 | | 2 [二分查找算法(非递归)](http://data.biancheng.net/view/55.html)| |
424 | | ---[二分法专题](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/91/binary-search)||
425 | | ---二分查找算法(非递归)的应用场景 | |
426 | | ---二分查找算法(非递归)的解决方案的基本步骤| |
427 | | ---二分查找算法(非递归)的代码实现| |
428 | | ---二分查找算法(非递归)的时间复杂度| |
429 | | ---二分查找算法(非递归)的空间复杂度| |
430 | | 3 [分块查找算法（索引顺序查找）](http://data.biancheng.net/view/56.html)||
431 | | 4 静态树表查找算法||
432 | | 5 二叉排序树查找算法（二叉查找树）||
433 | | 6 红黑树查找算法(更高级的二叉查找树)||
434 | | 7 平衡二叉树查找算法（AVL树）||
435 | | 8 B-树查找算法||
436 | | 9 B+树查找算法||
437 | | 10 键树查找算法（双链树和字典树）||
438 | | 11 插值查找算法| |
439 | | 12 奜波那契(黄金分割法)查找算法| |
440 | | 数据结构中的查找算法| |
441 | | --顺序表结构中的查找算法| |
442 | | --数组结构中的查找算法||
443 | | --链表结构中的查找算法| |
444 | | --树结构中的查找算法| |
445 | | --图结构中的查找算法| |
446 | |---|---|
447 | | 分治算法 | |
448 | | ---[用分治法求数组中的最值 分治算法的一个简单应用](http://www.nowamagic.net/librarys/veda/detail/257)||
449 | | [动态规划算法](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Algorithmic/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%E7%AE%97%E6%B3%95/README.md)| |
450 | | 枚举算法||
451 | | [贪心算法](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Algorithmic/%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95/README.md)| |
452 | | KMP算法---字符串||
453 | | ---[亲身体验一下KMP算法 KMP快速字符串查找算法](http://www.nowamagic.net/librarys/veda/detail/1137) ||
454 | | 普里姆算法---图||
455 | | [RSA加密算法原理](https://www.kancloud.cn/kancloud/rsa_algorithm/48493)||
456 | | 克鲁斯卡尔算法---图| |
457 | | 迪杰斯特拉算法---图| |
458 | | 弗洛伊德算法---图| |
459 | | 马踏棋盘算法| |
460 | | 贝尔曼-福特算法---图| |
461 | | k-Means算法---图| |
462 | | 欧几里得算法| |
463 | | 近拟算法| |
464 | | 数论算法||
465 | | 图算法||
466 | |[图像处理算法](https://www.kancloud.cn/digest/imageproebow/122462)||
467 | | B62 序列号生成算法| [文章](https://youyou-tech.com/2019/11/23/%E5%BA%8F%E5%88%97%E5%8F%B7%E7%94%9F%E6%88%90%E7%9A%84%E5%8F%A6%E4%B8%80%E7%A7%8D%E7%8E%A9%E6%B3%95-62%E8%BF%9B%E5%88%B6%E5%A6%82%E4%BD%95%E7%8E%A9%EF%BC%9F/) |
468 | | 修剪与搜索算法| |
469 | | 计算几何算法| |
470 | | 问题转换算法| |
471 | | 并行算法| |
472 | | 安全算法| |
473 | | 推荐算法| |
474 | | 遗传算法| |
475 | | 分布式算法| |
476 | | 数据挖掘10大算法| |
477 | | 网络流算法| |
478 | | [漏桶算法](https://weread.qq.com/web/reader/c9932ea07163ff6ac993e0dkd9d320f022ed9d4f495e456)||
479 | | [令牌桶算法](https://weread.qq.com/web/reader/c9932ea07163ff6ac993e0dkd9d320f022ed9d4f495e456)||
480 | |[分布式一致性算法：Raft](https://yasinshaw.com/articles/33) OR [raft 图解 (秒懂)---疯狂创客圈](https://www.cnblogs.com/crazymakercircle/p/14343154.html)||
481 | |[分布式一致性算法：Paxos](https://yasinshaw.com/articles/32) OR [Paxos 图解 (秒懂)---疯狂创客圈](https://www.cnblogs.com/crazymakercircle/p/14341015.html)||
482 | |空间定位算法||
483 | |---|---|
484 |
485 |
486 | # 第四篇 专题篇
487 | | **专题类型**||
488 | |---|---|
489 | | []()||
490 | | [ Pattern: Sliding Window---滑动窗口类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/1.%20Pattern:%20Sliding%20window%EF%BC%8C%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E7%B1%BB%E5%9E%8B/README.md)||
491 | | [ Pattern: Two Pointers---双指针类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/2%20Pattern:%20Two%20Pointers/README.md)||
492 | | [ Pattern: Fast & Slow pointers---快慢指针类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/3.%20Pattern:%20Fast%20%26%20Slow%20pointers%2C%20%E5%BF%AB%E6%85%A2%E6%8C%87%E9%92%88%E7%B1%BB%E5%9E%8B/README.md)||
493 | | [ Pattern: Merge Intervals---区间合并类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/4.%20Pattern:%20Merge%20Intervals%EF%BC%8C%E5%8C%BA%E9%97%B4%E5%90%88%E5%B9%B6%E7%B1%BB%E5%9E%8B/README.md)||
494 | | [ Pattern: Cyclic Sort---循环排序](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/5.%20Pattern:%20Cyclic%20Sort%EF%BC%8C%E5%BE%AA%E7%8E%AF%E6%8E%92%E5%BA%8F/README.md)||
495 | | [ Pattern: In-place Reversal of a LinkedList---链表翻转](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/6.%20Pattern:%20In-place%20Reversal%20of%20a%20LinkedList%EF%BC%8C%E9%93%BE%E8%A1%A8%E7%BF%BB%E8%BD%AC/README.md)||
496 | | [ Pattern: Tree Breadth First Search---树上的BFS](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/7.%20Pattern:%20Tree%20Breadth%20First%20Search%EF%BC%8C%E6%A0%91%E4%B8%8A%E7%9A%84BFS/README.md)||
497 | | [ Pattern: Tree Depth First Search---树上的DFS](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/8.%20Pattern:%20Tree%20Depth%20First%20Search%EF%BC%8C%E6%A0%91%E4%B8%8A%E7%9A%84DFS/README.md)||
498 | | [ Pattern: Two Heaps---双堆类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/9.%20Pattern:%20Two%20Heaps%EF%BC%8C%E5%8F%8C%E5%A0%86%E7%B1%BB%E5%9E%8B/README.md)||
499 | | [ Pattern: Subsets---子集类型，一般都是使用多重DFS](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/10.%20Pattern:%20Subsets%EF%BC%8C%E5%AD%90%E9%9B%86%E7%B1%BB%E5%9E%8B%EF%BC%8C%E4%B8%80%E8%88%AC%E9%83%BD%E6%98%AF%E4%BD%BF%E7%94%A8%E5%A4%9A%E9%87%8DDFS/README.md)||
500 | | [ Pattern: Modified Binary Search---改造过的二分](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/11.%20Pattern:%20Modified%20Binary%20Search%EF%BC%8C%E6%94%B9%E9%80%A0%E8%BF%87%E7%9A%84%E4%BA%8C%E5%88%86/README.md)||
501 | | [ Pattern: Top 'K' Elements---前K个系列](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/12.%20Pattern:%20Top%20%E2%80%98K%E2%80%99%20Elements%EF%BC%8C%E5%89%8DK%E4%B8%AA%E7%B3%BB%E5%88%97/README.md)||
502 | | [ Pattern: K-way merge---多路归并](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/13.%20Pattern:%20K-way%20merge%EF%BC%8C%E5%A4%9A%E8%B7%AF%E5%BD%92%E5%B9%B6/README.md)||
503 | | [ Pattern : 0/1 Knapsack (Dynamic Programming)---0/1背包类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/14.%20Pattern:%200%20mod%201%20Knapsack%20(Dynamic%20Programming)/README.md)||
504 | | [ Pattern: Topological Sort (Graph)---拓扑排序类型](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/LeetCode%E7%AE%97%E6%B3%95%E9%9D%A2%E8%AF%95/%E7%BB%8F%E5%85%B8%E9%A2%98%E5%9E%8B%E5%88%86%E7%B1%BB/15.%20Pattern:%20Topological%20Sort%20(Graph)%EF%BC%8C%E6%8B%93%E6%89%91%E6%8E%92%E5%BA%8F%E7%B1%BB%E5%9E%8B/README.md)||
505 | | [布隆过滤器专题](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/bloom-filter)||
506 | | [小岛问题专题](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/island)||
507 | | [最大公约数专题](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/gcd)||
508 | | [蓄水池抽样专题](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/reservoid-sampling)||
509 | | [二分法专题](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/91/binary-search)||
510 | | [日程安排表专题](https://github.com/azl397985856/leetcode/blob/1fce788bab7e7e2a10a6dfb0ee55a2bb09424b0b/selected/schedule-topic.md)||
511 | | Pattern: Bitwise XOR||
512 | |---|---|
513 |
514 | ----------------------------------------------------
515 | 参考资料
516 |
517 | 我的第一本算法书.pdf
518 | 尚硅谷 韩顺平 图解JAVA数据结构和算法.pdf
519 | 算法设计.pdf
520 | 图解算法.pdf
521 | 算法基础 第5版.pdf
522 | 趣学算法.pdf
523 | 算法图解.pdf
524 | java常用算法手册 第三版本.pdf
525 | 算法问题实战策略.pdf (很多题目练习)
526 | 天qing2019数据结构.pdf
527 |
528 |
529 | # 有用的参考qing
530 |
531 | * [图解 Java 中的数据结构及原理，傻瓜也能看懂](https://mp.weixin.qq.com/s/2t_XO3G1v1jx7q0-9YU0YA)
532 |
533 | ## 数据结构
534 | * 数学数据结构
535 | * 4种逻辑结构
536 | * [1. 集合结构](#集合结构)
537 | * [集合](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E9%9B%86%E5%90%88.md)
538 | * [2. 线性结构](#线性结构)
539 | * [数组](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E6%95%B0%E7%BB%84.md)
540 | * [线性表](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E7%BA%BF%E6%80%A7%E8%A1%A8.md)
541 | * 线性表的基本操作
542 | * 线性表的顺序存储结构
543 | * 线性表的链式存储结构
544 | * 单链表
545 | * 静态链表
546 | * 双向链表
547 | * 环链表
548 | * 线性表的分析
549 | * 线性表的实现分析
550 | * 线性表的功能
551 | * 矩阵
552 | * 栈与队列
553 | * [堆](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E5%A0%86.md)
554 | * [栈](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E6%A0%88.md)
555 | * 栈的常用操作
556 | * 栈的顺序存储结构
557 | * 栈的链式存储结构
558 | * 两栈共享空间
559 | * Java集合中的栈
560 | * [队列](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E9%98%9F%E5%88%97.md)
561 | * [串](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E4%B8%B2.md)
562 | * 串的存储结构
563 |
564 | * [散列](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E6%95%A3%E5%88%97.md)
565 | * 散列的概念
566 |
567 | * [3. 树型结构](#树型结构)
568 | * [树](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E6%A0%91.md)
569 | * 树的概述
570 | * 树的存储结构
571 | * 树的链表存储
572 | * 树的基本操作
573 | * 父节点表示法
574 | * 子节点表示法
575 | * 二叉树
576 | * 二叉树的基本操作
577 | * 二叉树的顺序存储
578 | * 二叉树二叉链表存储
579 | * 二叉树的三叉链表存储
580 | * 遍历二叉树
581 | * 先序遍历
582 | * 中序遍历
583 | * 后序遍历
584 | * 广度优先（按层）遍历
585 | * 排序二叉树
586 | * 红黑树
587 | * [红黑树](https://weread.qq.com/web/reader/df532740723982c7df583bfkd9d320f022ed9d4f495e456)
588 | * 森林
589 | * 转换方法
590 | * 森林 树和二叉树的转换
591 | * 哈夫曼树
592 | * 哈夫曼树的概念
593 | * [4. 图型结构](#图型结构)
594 | * [图](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Data%20Structure/%E5%9B%BE.md)
595 | * 图的存储结构
596 | * 图的遍历
597 | * 物理结构
598 | * 顺序存储结构
599 | * 链式存储结构
600 | * [排序](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Algorithmic/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95.md)
601 | * [内部排序 只使用内存](#内部排序-只使用内存)
602 |
603 | * [查找](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Algorithmic/%E6%9F%A5%E6%89%BE.md)
604 |
605 |
606 |
607 |
608 | ## 算法
609 | ## [算法的学习方法](https://github.com/stevenli91748/Data-Structure-and-Algorithmic/blob/master/Algorithmic/%E7%AE%97%E6%B3%95%E5%AD%A6%E4%B9%A0%E6%96%B9%E6%B3%95.md)
610 |
611 | * 算法设计
612 | * 贪心算法
613 | * 分而治之策略
614 | * 动态规划
615 | * 修剪与搜索法
616 | * 树搜索法
617 | * 问题转换法
618 | * 图算法
619 | * 计算几何法
620 | * 网络流
621 | * 近拟算法
622 | * 随机算c
623 |
624 | * 一致性哈希算法
625 |
626 | * [一致性哈希算法1](https://www.cnblogs.com/color-my-life/p/5799903.html)
627 | * [一致性哈希算法2](https://www.cnblogs.com/lpfuture/p/5796398.html)
628 | * [分布式缓存一致性哈希算法](https://www.cnblogs.com/mikevictor07/p/4458736.html)
629 | * [一致性哈希算法----nginx负载均衡器配置之一](https://www.cnblogs.com/FengGeBlog/p/10615345.html)
630 |
631 |
632 |
633 | # leetCode视频
634 | * [Edward Shi的LeetCode 题解视频](https://www.youtube.com/channel/UCTWuRL33U8xBPqk3LehXjFw)
635 | * [一周刷爆LeetCode，算法大神左神（左程云）耗时100天打造算法与数据结构基础到高级全家桶教程](https://www.bilibili.com/video/BV13g41157hK?spm_id_from=333.851.b_7265636f6d6d656e64.4)
636 | * [LeetCode All in One 题目讲解汇总](https://www.cnblogs.com/grandyang/p/4606334.html)
637 | * [Leetcode刷题顺序，看这一篇就够了](https://zhuanlan.zhihu.com/p/161036474)
638 | * [如何科学的刷 LeetCode ](https://zhuanlan.zhihu.com/p/96883783)
639 | * [白板讲题：如何十倍提升刷题效率，把算法题刷透？](https://www.youtube.com/watch?v=cIoGuSCU14A)
640 | * [LeetCode按照怎样的顺序来刷题比较好？](https://www.zhihu.com/question/36738189/answer/797854274?utm_source=wechat_session&utm_medium=social&utm_oi=991812777480134656)
641 | * [你会这100道算法题就够了](https://www.youtube.com/watch?v=yRpp-D7NlOQ&t=236s)
642 | * [如何最快速的刷题](https://www.youtube.com/watch?v=HlIu_kf_KH0&t=1917s)
643 | * [花花酱 LeetCode 全系例](https://www.youtube.com/c/HuaHuaLeetCode/videos)
644 | * [LeetCode使用介绍](https://blog.csdn.net/seabiscuityj/article/details/80730733)
645 | * [免费刷LeetCode的网站](https://leetcode.jp/problems.php?page_index=1&sort=0000&keyword=&company=)
646 | * [LeetCode到底应该怎么刷？面试应该注意哪些问题？大公司到底怎么进？来看看LC大神们的刷题攻略](https://zhuanlan.zhihu.com/p/98580817)
647 | * [LeetCode中的easy medium类形的题目](https://leetcode.com/discuss/career/449135/How-to-effectively-use-LeetCode-to-prepare-for-interviews!!)
648 | * [高效刷题，如何使用LeetCode来准备美国硅谷技术公司面试，拿到Offer](https://www.youtube.com/watch?v=XObufhWMQ1o)
649 | * [油管上最好的Java 版本 LeetCode逐题详解](https://www.bilibili.com/video/av51692387/?spm_id_from=333.788.videocard.4)
650 | * [Leetcode刷题大全](https://www.bilibili.com/video/av68783564/?spm_id_from=333.788.videocard.2)
651 | * [算法刷题 leetcode（Java版）](https://www.bilibili.com/video/BV1Hb411g7Jb/?spm_id_from=333.788.videocard.7)
652 | * [如何高效刷题](https://www.youtube.com/watch?v=QcLGNFBb8YI)
653 | * [左神算法 初级](https://www.bilibili.com/video/BV1KJ411E76p/?spm_id_from=333.788.videocard.17)
654 | * [算法刷题教程](https://www.bilibili.com/video/BV1v4411W7aU/?spm_id_from=333.788.videocard.3)
655 | * [Leetcode 简略题解 - 共567题](https://zhuanlan.zhihu.com/p/25697275)
656 | * [leetcode题解](https://mp.weixin.qq.com/s/vG0URwp8gI4jOkZlG5Vp6g)
657 | * [1500道LeetCode解题汇总目录](https://blog.csdn.net/qq_21201267/article/details/100577842)
658 | * [900 多道LeetCode All in One 题目讲解汇总](https://www.cnblogs.com/grandyang/p/4606334.html)
659 | * [推荐4个基于 Java 语言的 Leetcode 题解项目！算法面试不愁了！](https://juejin.im/post/5edb5989f265da771066dea9)
660 | * [用动画的形式演示 LeetCode 上的题目的项目](https://github.com/MisterBooo/LeetCodeAnimation)
661 |
662 | 算法公众号
663 |
664 | 微信号：labuladong
665 |
666 |
667 | 刷题目录
668 |
669 | https://github.com/CyC2018/CS-Notes/b...
670 |
671 | 推荐的学习频道👍🏻
672 |
673 | Youtube ：Back To Back SWE
674 |
675 | https://www.youtube.com/channel/UCmJz...
676 |
677 | B站：
678 |
679 | 1. 花花酱
680 |
681 | https://www.youtube.com/c/HuaHuaLeetCode/videos
682 |
683 | 花花酱youtube传送门: https://www.youtube.com/c/HuaHuaLeetCode/videos
684 |
685 | 2. 小Q刷题
686 |
687 | https://space.bilibili.com/149758?fro...
688 |
689 | 3.绵羊教授
690 |
691 | https://space.bilibili.com/354892788?...
692 |
693 | 绵羊教授youtube传送门: https://www.youtube.com/channel/UCB7X04ICYJ_LMyFN3045wPw
694 |
695 | # 算法视频
696 | * [Algorithms Full Course || Design and Analysis of Algorithms](https://www.youtube.com/watch?v=D6Q_wHrzxDs&t=160s)
697 | * [Data Structures Easy to Advanced Course - Full Tutorial from a Google Engineer](https://www.youtube.com/watch?v=RBSGKlAvoiM&t=566s)
698 | * [Data Structures for Beginners Full Course Tutorial](https://www.youtube.com/watch?v=YOfXMQnUlZY)
699 | * [揭秘 Google 工程师的4个学习算法的小窍门](https://www.bilibili.com/video/BV1V7411g76u/?spm_id_from=333.788.videocard.14)
700 | * [Google面试官讲算法：如何吃透算法，获得Hire？](https://www.youtube.com/watch?v=JU2ZpooE9PM&t=6s)
701 | * [尚硅谷-韩顺平图解Java数据结构和算法](https://www.bilibili.com/video/av54029771?from=search&seid=14417099915885539219)
702 | * [斯坦福大学】算法设计与分析（第 1 部分）# Algorithms Design and Analysis](https://www.bilibili.com/video/av60729219/?spm_id_from=333.788.videocard.3)
703 | * [斯坦福大学】算法设计与分析（第二版） Algorithms Design and Analysis, Part 2](https://www.bilibili.com/video/av60098061/?spm_id_from=333.788.videocard.6)
704 |
705 | * [数据结构与算法365天特训营（带视频+源码课件）](https://www.bilibili.com/video/av60287175/?spm_id_from=333.788.videocard.1)
706 | * [BAT算法特训](https://www.bilibili.com/video/av57622237/?spm_id_from=333.788.videocard.3)
707 | * [十大算法精讲](https://www.bilibili.com/video/av62628269/?spm_id_from=333.788.videocard.2)
708 | * [剑指offer-数据结构与算法（全套无水印）](https://www.bilibili.com/video/av64288683/?spm_id_from=333.788.videocard.4)
709 | * [算法第四版 english](https://www.bilibili.com/video/BV1jx411U768/?spm_id_from=333.788.videocard.1)
710 | * [算法导论-麻省理工](https://www.bilibili.com/video/av48922404/?spm_id_from=333.788.videocard.0)
711 | * [Standfort 算法](https://www.youtube.com/watch?v=D6Q_wHrzxDs)
712 |
713 |
714 |
715 | # 参考书籍
716 |
717 |
718 |
719 | * [编程马拉松算法目录](https://blog.csdn.net/derrantcm/article/details/51512284)
720 | * [【LeetCode-面试算法经典-Java实现】【所有题目目录索引】](https://wangjunchao.blog.csdn.net/article/details/46905087)
721 | * [【剑指Offer学习】【所有面试题汇总】](https://wangjunchao.blog.csdn.net/article/details/46887821)
722 | * []()
723 | * []()
724 | * [300分钟搞定数据结构与算法](https://www.kancloud.cn/alex_wsc/dataalg)
725 | * [整理得吐血了，二叉树、红黑树、B&B+树超齐全，快速搞定数据结构](https://cloud.tencent.com/developer/article/1669288?from=article.detail.1758476)
726 | * [关于如何学习算法，这些文章可以帮助你！](https://zhuanlan.zhihu.com/p/115770442)
727 | * [码农找工作之：秒杀算法面试必须掌握的14种模式](https://zhuanlan.zhihu.com/p/90664857)
728 | * [程序员一般喜欢浏览哪些网站呢？](https://www.zhihu.com/question/283272958/answer/598956527?utm_source=wechat_session&utm_medium=social&utm_oi=991812777480134656)
729 | * [算法与数据结构+一点点ACM从入门到进阶吐血整理推荐书单（珍藏版）](https://pymlovelyq.github.io/2018/10/06/Algorithm/)
730 | * [从入门到修仙的算法之路](https://mp.weixin.qq.com/s?__biz=MzI5MzYzMDAwNw==&mid=2247484319&idx=1&sn=11f9bce35fae40dd2ed54b2b3c785425&chksm=ec6e7ac7db19f3d14c11cd9e6e03f4ef2d31d45332979cf44711f15213dd964d8ced00643260&token=516051101&lang=zh_CN#rd)
731 | * https://github.com/githubofrico
732 | * [可视化的数据结构 - 各种算法动画演示](https://visualgo.net/en)
733 | * [Algomation：查看、创建和分享算法的学习平台](http://hao.jobbole.com/algomation/)
734 | * [ Algorithm Visualizer，做得很好](https://algorithm-visualizer.org/divide-and-conquer/bucket-sort)
735 | * [[数据结构与算法]超级详细解读基本排序算法（不看后悔，带排序演示动画）](https://blog.csdn.net/david_520042/article/details/52784620)
736 | * [剖析八种经典排序算法](https://blog.csdn.net/l953972252/article/details/51284884)
737 | * [https://github.com/zhuli19901106/leetcode-2](https://github.com/zhuli19901106/leetcode-2)
738 | * [看动画学算法](https://github.com/MisterBooo/LeetCodeAnimation)
739 | * [Java排序算法详解及示例汇总——超详细](https://blog.csdn.net/sd09044901guic/article/details/80613053)
740 | * [程序员必须掌握的核心算法有哪些](https://blog.csdn.net/m0_37907797/article/details/102661778?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task)
741 | * [那些年，我们又爱又恨的HashMap，你掌握了吗？](https://www.jianshu.com/p/42c8ebbf83d5)
742 | * [怎么学好数据结构？](https://www.zhihu.com/question/19830721/answer/1515924094?utm_source=wechat_session&utm_medium=social&utm_oi=991812777480134656&utm_content=group3_Answer&utm_campaign=shareopn)
743 | * [数据结构当中的图怎么都弄不懂怎么办？](https://www.zhihu.com/question/53064373/answer/133956550?utm_source=wechat_session&utm_medium=social&s_r=0)
744 | * [学 [数据结构、算法] 的资源推荐](https://zhuanlan.zhihu.com/p/23191006?utm_source=wechat_session&utm_medium=social&utm_oi=991812777480134656)
745 | * [有哪些学习算法的网站推荐？](https://www.zhihu.com/question/20368410/answer/19628560?utm_source=wechat_session&utm_medium=social&utm_oi=991812777480134656&utm_content=group3_Answer&utm_campaign=shareopn)
746 | * [24张图，九大数据结构安排得明明白白！](https://mp.weixin.qq.com/s/ZVwIUN-xf9FuxOFXW8H3Nw)
747 | * [十大经典排序算法大梳理 (动图+代码)](https://mp.weixin.qq.com/s/ekGdneZrMa23ALxt5mvKpQ)
748 | * [数据结构里各种难啃的“树”，一文搞懂它](https://mp.weixin.qq.com/s/k4-RaW4ROlo6chSXsO_4AA)
749 | * [一篇文章彻底学会递归思路解题！](https://mp.weixin.qq.com/s/-V0jBkPoZHYC2jLfSnQ6-g)
750 | * [推荐两位谷歌大佬的算法刷题笔记！](https://bbs.cvmart.net/topics/4079)
751 | * [花了一个月的时间在一个oj网站只刷了这些题，从此入门了绝大多数算法](https://zhuanlan.zhihu.com/p/163681526)
752 | * [数据结构中的6种「树」](https://mp.weixin.qq.com/s/3u6I8XSmp_M8wIw__tDrLQ)
753 |
754 |
755 |
--------------------------------------------------------------------------------
/java 算法例子程序/README.md:
--------------------------------------------------------------------------------
1 |
2 | * [Java 数字签名算法](https://mrbird.cc/Java-%E6%95%B0%E5%AD%97%E7%AD%BE%E5%90%8D%E7%AE%97%E6%B3%95.html)
3 | * [Java 非对称加密算法RSA](https://mrbird.cc/Java-%E9%9D%9E%E5%AF%B9%E7%A7%B0%E5%8A%A0%E5%AF%86%E7%AE%97%E6%B3%95.html)
4 | * [Java 对称加密算法](https://mrbird.cc/Java-%E5%AF%B9%E7%A7%B0%E5%8A%A0%E5%AF%86%E7%AE%97%E6%B3%95.html)
5 | * [Java 消息摘要算法](https://mrbird.cc/Java-%E6%91%98%E8%A6%81%E7%AE%97%E6%B3%95.html)
6 | * [Java Base64算法](https://mrbird.cc/Java-Base64%E7%AE%97%E6%B3%95.html)
7 |
8 |
9 |
--------------------------------------------------------------------------------
/数学/README.md:
--------------------------------------------------------------------------------
1 |
2 | * [数学](https://oi-wiki.org/math/poly/intro/)
3 | * [符号](https://oi-wiki.org/math/notation/)
4 | * [复数](https://oi-wiki.org/math/complex/)
5 | * [位运算](https://oi-wiki.org/math/bit/)
6 | * [快速幂](https://oi-wiki.org/math/quick-pow/)
7 | * [进位制](https://oi-wiki.org/math/base/)
8 | * [高精度计算](https://oi-wiki.org/math/bignum/)
9 | * [平衡三进制](https://oi-wiki.org/math/balanced-ternary/)
10 | * 数论
11 | * [素数](https://oi-wiki.org/math/prime/)
12 | * [Meissel-Lehmer 算法](https://oi-wiki.org/math/meissel-lehmer/)
13 | * [最大公约数](https://oi-wiki.org/math/gcd/)
14 | * [欧拉函数](https://oi-wiki.org/math/euler/)
15 | * [筛法](https://oi-wiki.org/math/sieve/)
16 | * [欧拉定理 & 费马小定理](https://oi-wiki.org/math/fermat/)
17 | * [类欧几里德算法](https://oi-wiki.org/math/euclidean/)
18 | * [裴蜀定理](https://oi-wiki.org/math/bezouts/)
19 | * [乘法逆元](https://oi-wiki.org/math/inverse/)
20 | * [线性同余方程](https://oi-wiki.org/math/linear-equation/)
21 | * [中国剩余定理](https://oi-wiki.org/math/crt/)
22 | * [二次剩余](https://oi-wiki.org/math/quad-residue/)
23 | * [BSGS](https://oi-wiki.org/math/bsgs/)
24 | * [原根](https://oi-wiki.org/math/primitive-root/)
25 | * [卢卡斯定理](https://oi-wiki.org/math/lucas/)
26 | * [莫比乌斯反演](https://oi-wiki.org/math/mobius/)
27 | * [杜教筛](https://oi-wiki.org/math/du/)
28 | * [Powerful Number 筛](https://oi-wiki.org/math/powerful-number/)
29 | * [Min_25 筛](https://oi-wiki.org/math/min-25/)
30 | * [洲阁筛](https://oi-wiki.org/math/zhou/)
31 | * [分解质因数](https://oi-wiki.org/math/pollard-rho/)
32 | * [连分数](https://oi-wiki.org/math/continued-fraction/)
33 | * [Stern-Brocot 树与 Farey 序列](https://oi-wiki.org/math/stern-brocot/)
34 | * [Pell 方程 ](https://oi-wiki.org/math/pell-equation/)
35 | * 多项式
36 | * [多项式部分简介](https://oi-wiki.org/math/poly/intro/)
37 | * [拉格朗日插值](https://oi-wiki.org/math/poly/lagrange/)
38 | * [快速傅里叶变换](https://oi-wiki.org/math/poly/fft/)
39 | * [快速数论变换](https://oi-wiki.org/math/poly/ntt/)
40 | * [快速沃尔什变换](https://oi-wiki.org/math/poly/fwt/)
41 | * [多项式求逆](https://oi-wiki.org/math/poly/inv/)
42 | * [多项式开方](https://oi-wiki.org/math/poly/sqrt/)
43 | * [多项式除法 取模](https://oi-wiki.org/math/poly/div-mod/)
44 | * [多项式对数函数 指数函数](https://oi-wiki.org/math/poly/ln-exp/)
45 | * [多项式牛顿迭代](https://oi-wiki.org/math/poly/newton/)
46 | * [多项式多点求值 快速插值](https://oi-wiki.org/math/poly/multipoint-eval-interpolation/)
47 | * [多项式三角函数](https://oi-wiki.org/math/poly/tri-func/)
48 | * [多项式反三角函数](https://oi-wiki.org/math/poly/inv-tri-func/)
49 | * [常系数齐次线性递推 ](https://oi-wiki.org/math/linear-recurrence/)
50 | * 生成函数
51 | * 线性代数
52 | * 线性规划
53 | * 组合数学
54 | * [概率初步](https://oi-wiki.org/math/expectation/)
55 | * [置换群](https://oi-wiki.org/math/permutation-group/)
56 | * [斐波那契数列](https://oi-wiki.org/math/fibonacci/)
57 | * [博弈论](https://oi-wiki.org/math/game-theory/)
58 | * [牛顿迭代法](https://oi-wiki.org/math/newton/)
59 | * [数值积分](https://oi-wiki.org/math/integral/)
60 | * [分段打表](https://oi-wiki.org/math/dictionary/)
61 | * [计算几何部分](https://oi-wiki.org/geometry/)
62 | * 计算几何部分简介
63 | * [二维计算几何基础](https://oi-wiki.org/geometry/2d/)
64 | * 三维计算几何基础
65 | * [极坐标系](https://oi-wiki.org/geometry/polar-coordinate/)
66 | * [距离](https://oi-wiki.org/geometry/distance/)
67 | * [Pick 定理](https://oi-wiki.org/geometry/pick/)
68 | * [三角剖分](https://oi-wiki.org/geometry/triangulation/)
69 | * [凸包](https://oi-wiki.org/geometry/convex-hull/)
70 | * [扫描线](https://oi-wiki.org/geometry/scanning/)
71 | * 旋转卡壳
72 | * [半平面交](https://oi-wiki.org/geometry/half-plane/)
73 | * [平面最近点对](https://oi-wiki.org/geometry/nearest-points/)
74 | * [随机增量法](https://oi-wiki.org/geometry/random-incremental/)
75 | * [反演变换](https://oi-wiki.org/geometry/inverse/)
76 | * 计算几何杂项
77 |
78 |
--------------------------------------------------------------------------------