本项目为原项目[algorithm-pattern](https://github.com/greyireland/algorithm-pattern) 的 Python3 语言实现版本，原项目使用 go 语言实现，目前已获 8k star。在原项目基础上，本项目添加了优先级队列，并查集，图相关算法等内容，基本覆盖了所有基础数据结构和算法，非常适合找工刷题的同学快速上手。以下为原项目 README。

算法模板，最科学的刷题方式，最快速的刷题路径，一个月从入门到 offer，你值得拥有 🐶~

-[go 语言入门](./introduction/golang.md)

-[使用 Python3 写算法题](./introduction/python.md)

-[算法快速入门](./introduction/quickstart.md)

-[二叉树](./data_structure/binary_tree.md)

-[链表](./data_structure/linked_list.md)

-[栈和队列](./data_structure/stack_queue.md)

-[优先级队列(堆)](./data_structure/heap.md)

-[优先级队列(堆)](./data_structure/heap.md)

-[并查集](./data_structure/union_find.md)

-[二进制](./data_structure/binary_op.md)

n=len(nums)

result= []

route= []

defbacktrack(start,k):

defbacktrack(start,k,route=[]):

iflen(route)== k:

result.append(route.copy())

n=len(nums)

result= []

route= []

defbacktrack(start,k):

defbacktrack(start,k,route=[]):

iflen(route)== k:

result.append(route.copy())

[reverse-string](https://leetcode-cn.com/problems/reverse-string/)

[swap-nodes-in-pairs](https://leetcode-cn.com/problems/swap-nodes-in-pairs/)

return head

[unique-binary-search-trees-ii](https://leetcode-cn.com/problems/unique-binary-search-trees-ii/)

return generateTrees_rec(1, n)if n>0else []

[fibonacci-number](https://leetcode-cn.com/problems/fibonacci-number/)

[permutation-in-string](https://leetcode-cn.com/problems/permutation-in-string/)

[find-all-anagrams-in-a-string](https://leetcode-cn.com/problems/find-all-anagrams-in-a-string/)

return results

[longest-substring-without-repeating-characters](https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/)

典型示例

[binary-search](https://leetcode-cn.com/problems/binary-search/)

所以用模板#3 就对了，详细的对比可以这边文章介绍：[二分搜索模板](https://leetcode-cn.com/explore/learn/card/binary-search/212/template-analysis/847/)

如果是最简单的二分搜索，不需要找第一个、最后一个位置、或者是没有重复元素，可以使用模板 1，代码更简洁

-如果是最简单的二分搜索，不需要找第一个、最后一个位置、或者是没有重复元素，可以使用模板 1，代码更简洁

模板 2：

-模板 2：

classSolution:

思路：核心点就是找第一个 target 的索引，和最后一个 target 的索引，所以用两次二分搜索分别找第一次和最后一次的位置

-思路：核心点就是找第一个 target 的索引，和最后一个 target 的索引，所以用两次二分搜索分别找第一次和最后一次的位置

return Range

- 使用模板 2 的解法

classSolution:

defsearchRange(self,nums,target):

Range= [-1,-1]

return Range

图 (graph) 是一种相当复杂的数据结构，相关算法也多种多样，以下总结一些比较基础且常见的图算法。

典型的多源最短路径问题，将所有源作为 BFS 的第一层即可

- 思路：典型的多源最短路径问题，将所有源作为 BFS 的第一层即可

inf=2147483647

思路：DFS 遍历连通分量找边界，从边界开始 BFS找最短路径

-思路：DFS 遍历连通分量找边界，从边界开始 BFS找最短路径

classSolution:

典型的多源最短路径问题，将所有源作为 BFS 的第一层即可

- 思路：典型的多源最短路径问题，将所有源作为 BFS 的第一层即可

inf=2147483647

思路：DFS 遍历连通分量找边界，从边界开始 BFS找最短路径

-思路：DFS 遍历连通分量找边界，从边界开始 BFS找最短路径

classSolution:

标准的单源最短路径问题，使用朴素的的 Dijikstra 算法即可，可以当成模板使用。

-标准的单源最短路径问题，使用朴素的 Dijikstra 算法即可。

classSolution:

在标准的单源最短路径问题上限制了路径的边数，因此需要同时维护当前 SPT 内每个结点最短路径的边数，当遇到边数更小的路径 (边权和可以更大) 时结点需要重新入堆，以更新后继在边数上限内没达到的结点。

-在标准的单源最短路径问题上限制了路径的边数，因此需要同时维护当前 SPT 内每个结点最短路径的边数，当遇到边数更小的路径 (边权和可以更大) 时结点需要重新入堆，以更新后继在边数上限内没达到的结点。

classSolution:

思路 1: sort 后取第 k 个，最简单直接，复杂度 O(N log N) 代码略

-思路 1: sort 后取第 k 个，最简单直接，复杂度 O(N log N) 代码略

思路 2: 使用最小堆，复杂度 O(N log k)

-思路 2: 使用最小堆，复杂度 O(N log k)

classSolution:

return min_heap[0]

思路 3: Quick select，方式类似于快排，每次 partition 后检查 pivot 是否为第 k 个元素，如果是则直接返回，如果比 k 大，则继续 partition 小于 pivot 的元素，如果比 k 小则继续 partition 大于 pivot 的元素。相较于快排，quick select 每次只需 partition 一侧，因此平均复杂度为 O(N)

-思路 3:[Quick select](https://en.wikipedia.org/wiki/Quickselect)，方式类似于快排，每次 partition 后检查 pivot 是否为第 k 个元素，如果是则直接返回，如果比 k 大，则继续 partition 小于 pivot 的元素，如果比 k 小则继续 partition 大于 pivot 的元素。相较于快排，quick select 每次只需 partition 一侧，因此平均复杂度为 O(N)。

classSolution:

[single-number](https://leetcode-cn.com/problems/single-number/)

return out

[single-number-ii](https://leetcode-cn.com/problems/single-number-ii/)

return seen_once

[single-number-iii](https://leetcode-cn.com/problems/single-number-iii/)

return [x, bitmask^x]

[number-of-1-bits](https://leetcode-cn.com/problems/number-of-1-bits/)

return num_ones

[counting-bits](https://leetcode-cn.com/problems/counting-bits/)

思路：利用上一题的解法容易想到 O(nk) 的解法，k 为位数。但是实际上可以利用动态规划将复杂度降到 O(n)，想法其实也很简单，即当前数的 1 个数等于比它少一个 1 的数的结果加 1。下面给出三种 DP 解法

-思路：利用上一题的解法容易想到 O(nk) 的解法，k 为位数。但是实际上可以利用动态规划将复杂度降到 O(n)，想法其实也很简单，即当前数的 1 个数等于比它少一个 1 的数的结果加 1。下面给出三种 DP 解法

return num_ones

[reverse-bits](https://leetcode-cn.com/problems/reverse-bits/)

return (byte*0x0202020202&0x010884422010)%1023

[bitwise-and-of-numbers-range](https://leetcode-cn.com/problems/bitwise-and-of-numbers-range/)