yetao
/
hello-algo
mirror of https://github.com/krahets/hello-algo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
pull/944/head
krahets 1 year ago
parent 33edc752c8
commit 221bec3ea3
4 changed files with 127 additions and 72 deletions
Show Stats Download Patch File Download Diff File

139
chapter_divide_and_conquer/build_binary_tree_problem.md
Unescape View File

@ -77,8 +77,7 @@ status: new
```python title="build_tree.py"
def dfs(
preorder: list[int],
inorder: list[int],
hmap: dict[int, int],
inorder_map: dict[int, int],
i: int,
l: int,
r: int,
@ -90,19 +89,19 @@ status: new
# 初始化根节点
root = TreeNode(preorder[i])
# 查询 m ，从而划分左右子树
m = hmap[preorder[i]]
m = inorder_map[preorder[i]]
# 子问题：构建左子树
root.left = dfs(preorder, inorder, hmap, i + 1, l, m - 1)
root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)
# 子问题：构建右子树
root.right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r)
root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)
# 返回根节点
return root
def build_tree(preorder: list[int], inorder: list[int]) -> TreeNode | None:
"""构建二叉树"""
# 初始化哈希表，存储 inorder 元素到索引的映射
hmap = {val: i for i, val in enumerate(inorder)}
root = dfs(preorder, inorder, hmap, 0, 0, len(inorder) - 1)
inorder_map = {val: i for i, val in enumerate(inorder)}
root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)
return root
```
@ -110,18 +109,18 @@ status: new
```cpp title="build_tree.cpp"
/* 构建二叉树：分治 */
TreeNode *dfs(vector<int> &preorder, vector<int> &inorder, unordered_map<int, int> &hmap, int i, int l, int r) {
TreeNode *dfs(vector<int> &preorder, unordered_map<int, int> &inorderMap, int i, int l, int r) {
// 子树区间为空时终止
if (r - l < 0)
return NULL;
// 初始化根节点
TreeNode *root = new TreeNode(preorder[i]);
// 查询 m ，从而划分左右子树
int m = hmap[preorder[i]];
int m = inorderMap[preorder[i]];
// 子问题：构建左子树
root->left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
root->left = dfs(preorder, inorderMap, i + 1, l, m - 1);
// 子问题：构建右子树
root->right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
root->right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
// 返回根节点
return root;
}
@ -129,11 +128,11 @@ status: new
/* 构建二叉树 */
TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
// 初始化哈希表，存储 inorder 元素到索引的映射
unordered_map<int, int> hmap;
unordered_map<int, int> inorderMap;
for (int i = 0; i < inorder.size(); i++) {
hmap[inorder[i]] = i;
inorderMap[inorder[i]] = i;
}
TreeNode *root = dfs(preorder, inorder, hmap, 0, 0, inorder.size() - 1);
TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);
return root;
}
```
@ -142,18 +141,18 @@ status: new
```java title="build_tree.java"
/* 构建二叉树：分治 */
TreeNode dfs(int[] preorder, int[] inorder, Map<Integer, Integer> hmap, int i, int l, int r) {
TreeNode dfs(int[] preorder, Map<Integer, Integer> inorderMap, int i, int l, int r) {
// 子树区间为空时终止
if (r - l < 0)
return null;
// 初始化根节点
TreeNode root = new TreeNode(preorder[i]);
// 查询 m ，从而划分左右子树
int m = hmap.get(preorder[i]);
int m = inorderMap.get(preorder[i]);
// 子问题：构建左子树
root.left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
// 子问题：构建右子树
root.right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
// 返回根节点
return root;
}
@ -161,11 +160,11 @@ status: new
/* 构建二叉树 */
TreeNode buildTree(int[] preorder, int[] inorder) {
// 初始化哈希表，存储 inorder 元素到索引的映射
Map<Integer, Integer> hmap = new HashMap<>();
Map<Integer, Integer> inorderMap = new HashMap<>();
for (int i = 0; i < inorder.length; i++) {
hmap.put(inorder[i], i);
inorderMap.put(inorder[i], i);
}
TreeNode root = dfs(preorder, inorder, hmap, 0, 0, inorder.length - 1);
TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
return root;
}
```
@ -174,18 +173,18 @@ status: new
```csharp title="build_tree.cs"
/* 构建二叉树：分治 */
TreeNode dfs(int[] preorder, int[] inorder, Dictionary<int, int> hmap, int i, int l, int r) {
TreeNode dfs(int[] preorder, Dictionary<int, int> inorderMap, int i, int l, int r) {
// 子树区间为空时终止
if (r - l < 0)
return null;
// 初始化根节点
TreeNode root = new TreeNode(preorder[i]);
// 查询 m ，从而划分左右子树
int m = hmap[preorder[i]];
int m = inorderMap[preorder[i]];
// 子问题：构建左子树
root.left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
// 子问题：构建右子树
root.right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
// 返回根节点
return root;
}
@ -193,11 +192,11 @@ status: new
/* 构建二叉树 */
TreeNode buildTree(int[] preorder, int[] inorder) {
// 初始化哈希表，存储 inorder 元素到索引的映射
Dictionary<int, int> hmap = new Dictionary<int, int>();
Dictionary<int, int> inorderMap = new Dictionary<int, int>();
for (int i = 0; i < inorder.Length; i++) {
hmap.TryAdd(inorder[i], i);
inorderMap.TryAdd(inorder[i], i);
}
TreeNode root = dfs(preorder, inorder, hmap, 0, 0, inorder.Length - 1);
TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.Length - 1);
return root;
}
```
@ -206,7 +205,7 @@ status: new
```go title="build_tree.go"
/* 构建二叉树：分治 */
func dfsBuildTree(preorder, inorder []int, hmap map[int]int, i, l, r int) *TreeNode {
func dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {
// 子树区间为空时终止
if r-l < 0 {
return nil
@ -214,11 +213,11 @@ status: new
// 初始化根节点
root := NewTreeNode(preorder[i])
// 查询 m ，从而划分左右子树
m := hmap[preorder[i]]
m := inorderMap[preorder[i]]
// 子问题：构建左子树
root.Left = dfsBuildTree(preorder, inorder, hmap, i+1, l, m-1)
root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)
// 子问题：构建右子树
root.Right = dfsBuildTree(preorder, inorder, hmap, i+1+m-l, m+1, r)
root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)
// 返回根节点
return root
}
@ -226,12 +225,12 @@ status: new
/* 构建二叉树 */
func buildTree(preorder, inorder []int) *TreeNode {
// 初始化哈希表，存储 inorder 元素到索引的映射
hmap := make(map[int]int, len(inorder))
inorderMap := make(map[int]int, len(inorder))
for i := 0; i < len(inorder); i++ {
hmap[inorder[i]] = i
inorderMap[inorder[i]] = i
}
root := dfsBuildTree(preorder, inorder, hmap, 0, 0, len(inorder)-1)
root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)
return root
}
```
@ -240,7 +239,7 @@ status: new
```swift title="build_tree.swift"
/* 构建二叉树：分治 */
func dfs(preorder: [Int], inorder: [Int], hmap: [Int: Int], i: Int, l: Int, r: Int) -> TreeNode? {
func dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -> TreeNode? {
// 子树区间为空时终止
if r - l < 0 {
return nil
@ -248,11 +247,11 @@ status: new
// 初始化根节点
let root = TreeNode(x: preorder[i])
// 查询 m ，从而划分左右子树
let m = hmap[preorder[i]]!
let m = inorderMap[preorder[i]]!
// 子问题：构建左子树
root.left = dfs(preorder: preorder, inorder: inorder, hmap: hmap, i: i + 1, l: l, r: m - 1)
root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)
// 子问题：构建右子树
root.right = dfs(preorder: preorder, inorder: inorder, hmap: hmap, i: i + 1 + m - l, l: m + 1, r: r)
root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)
// 返回根节点
return root
}
@ -260,8 +259,8 @@ status: new
/* 构建二叉树 */
func buildTree(preorder: [Int], inorder: [Int]) -> TreeNode? {
// 初始化哈希表，存储 inorder 元素到索引的映射
let hmap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }
return dfs(preorder: preorder, inorder: inorder, hmap: hmap, i: 0, l: 0, r: inorder.count - 1)
let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }
return dfs(preorder: preorder, inorderMap: inorderMap, i: 0, l: 0, r: inorder.count - 1)
}
```
@ -269,17 +268,17 @@ status: new
```javascript title="build_tree.js"
/* 构建二叉树：分治 */
function dfs(preorder, inorder, hmap, i, l, r) {
function dfs(preorder, inorderMap, i, l, r) {
// 子树区间为空时终止
if (r - l < 0) return null;
// 初始化根节点
const root = new TreeNode(preorder[i]);
// 查询 m ，从而划分左右子树
const m = hmap.get(preorder[i]);
const m = inorderMap.get(preorder[i]);
// 子问题：构建左子树
root.left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
// 子问题：构建右子树
root.right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
// 返回根节点
return root;
}
@ -287,11 +286,11 @@ status: new
/* 构建二叉树 */
function buildTree(preorder, inorder) {
// 初始化哈希表，存储 inorder 元素到索引的映射
let hmap = new Map();
let inorderMap = new Map();
for (let i = 0; i < inorder.length; i++) {
hmap.set(inorder[i], i);
inorderMap.set(inorder[i], i);
}
const root = dfs(preorder, inorder, hmap, 0, 0, inorder.length - 1);
const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
return root;
}
```
@ -302,8 +301,7 @@ status: new
/* 构建二叉树：分治 */
function dfs(
preorder: number[],
inorder: number[],
hmap: Map<number, number>,
inorderMap: Map<number, number>,
i: number,
l: number,
r: number
@ -313,11 +311,11 @@ status: new
// 初始化根节点
const root: TreeNode = new TreeNode(preorder[i]);
// 查询 m ，从而划分左右子树
const m = hmap.get(preorder[i]);
const m = inorderMap.get(preorder[i]);
// 子问题：构建左子树
root.left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
// 子问题：构建右子树
root.right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
// 返回根节点
return root;
}
@ -325,11 +323,11 @@ status: new
/* 构建二叉树 */
function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
// 初始化哈希表，存储 inorder 元素到索引的映射
let hmap = new Map<number, number>();
let inorderMap = new Map<number, number>();
for (let i = 0; i < inorder.length; i++) {
hmap.set(inorder[i], i);
inorderMap.set(inorder[i], i);
}
const root = dfs(preorder, inorder, hmap, 0, 0, inorder.length - 1);
const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
return root;
}
```
@ -340,8 +338,7 @@ status: new
/* 构建二叉树：分治 */
TreeNode? dfs(
List<int> preorder,
List<int> inorder,
Map<int, int> hmap,
Map<int, int> inorderMap,
int i,
int l,
int r,
@ -353,11 +350,11 @@ status: new
// 初始化根节点
TreeNode? root = TreeNode(preorder[i]);
// 查询 m ，从而划分左右子树
int m = hmap[preorder[i]]!;
int m = inorderMap[preorder[i]]!;
// 子问题：构建左子树
root.left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
// 子问题：构建右子树
root.right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
// 返回根节点
return root;
}
@ -365,11 +362,11 @@ status: new
/* 构建二叉树 */
TreeNode? buildTree(List<int> preorder, List<int> inorder) {
// 初始化哈希表，存储 inorder 元素到索引的映射
Map<int, int> hmap = {};
Map<int, int> inorderMap = {};
for (int i = 0; i < inorder.length; i++) {
hmap[inorder[i]] = i;
inorderMap[inorder[i]] = i;
}
TreeNode? root = dfs(preorder, inorder, hmap, 0, 0, inorder.length - 1);
TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
return root;
}
```
@ -378,17 +375,17 @@ status: new
```rust title="build_tree.rs"
/* 构建二叉树：分治 */
fn dfs(preorder: &[i32], inorder: &[i32], hmap: &HashMap<i32, i32>, i: i32, l: i32, r: i32) -> Option<Rc<RefCell<TreeNode>>> {
fn dfs(preorder: &[i32], inorderMap: &HashMap<i32, i32>, i: i32, l: i32, r: i32) -> Option<Rc<RefCell<TreeNode>>> {
// 子树区间为空时终止
if r - l < 0 { return None; }
// 初始化根节点
let root = TreeNode::new(preorder[i as usize]);
// 查询 m ，从而划分左右子树
let m = hmap.get(&preorder[i as usize]).unwrap();
let m = inorderMap.get(&preorder[i as usize]).unwrap();
// 子问题：构建左子树
root.borrow_mut().left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
root.borrow_mut().left = dfs(preorder, inorderMap, i + 1, l, m - 1);
// 子问题：构建右子树
root.borrow_mut().right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
root.borrow_mut().right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
// 返回根节点
Some(root)
}
@ -396,11 +393,11 @@ status: new
/* 构建二叉树 */
fn build_tree(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
// 初始化哈希表，存储 inorder 元素到索引的映射
let mut hmap: HashMap<i32, i32> = HashMap::new();
let mut inorderMap: HashMap<i32, i32> = HashMap::new();
for i in 0..inorder.len() {
hmap.insert(inorder[i], i as i32);
inorderMap.insert(inorder[i], i as i32);
}
let root = dfs(preorder, inorder, &hmap, 0, 0, inorder.len() as i32 - 1);
let root = dfs(preorder, &inorderMap, 0, 0, inorder.len() as i32 - 1);
root
}
```

33
chapter_hashing/hash_map.md
Unescape View File

@ -249,7 +249,26 @@ comments: true
=== "Rust"
```rust title="hash_map.rs"
use std::collections::HashMap;
/* 初始化哈希表 */
let mut map: HashMap<i32, String> = HashMap::new();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.insert(12836, "小哈".to_string());
map.insert(15937, "小啰".to_string());
map.insert(16750, "小算".to_string());
map.insert(13279, "小法".to_string());
map.insert(10583, "小鸭".to_string());
/* 查询操作 */
// 向哈希表中输入键 key ，得到值 value
let _name: Option<&String> = map.get(&15937);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
let _removed_value: Option<String> = map.remove(&10583);
```
=== "C"
@ -430,7 +449,21 @@ comments: true
=== "Rust"
```rust title="hash_map.rs"
/* 遍历哈希表 */
// 遍历键值对 Key->Value
for (key, value) in &map {
println!("{key} -> {value}");
}
// 单独遍历键 Key
for key in map.keys() {
println!("{key}");
}
// 单独遍历值 Value
for value in map.values() {
println!("{value}");
}
```
=== "C"

25
chapter_stack_and_queue/stack.md
Unescape View File

@ -276,7 +276,32 @@ comments: true
=== "Rust"
```rust title="stack.rs"
/* 初始化栈 */
// 把 Vec 当作栈来使用
let mut stack: Vec<i32> = Vec::new();
/* 元素入栈 */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
/* 访问栈顶元素 */
if let Some(top) = stack.get(stack.len() - 1) {
}
if let Some(top) = stack.last() {
}
/* 元素出栈 */
if let Some(pop) = stack.pop() {
}
/* 获取栈的长度 */
let size = stack.len();
/* 判断是否为空 */
let isEmpty = stack.is_empty();
```
=== "C"

2
chapter_tree/binary_search_tree.md
Unescape View File

@ -972,7 +972,7 @@ comments: true
cur = cur.left;
}
// 若无待删除节点，则直接返回
if (cur == null || pre == null)
if (cur == null)
return;
// 子节点数量 = 0 or 1
if (cur.left == null || cur.right == null) {

Write Preview
Loading…
Cancel
Save