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

Fix indentation and update array.md

Browse Source
pull/367/head
krahets 2 years ago
parent ae53c59183
commit 5541fe5964
3 changed files with 64 additions and 44 deletions
Show Stats Download Patch File Download Diff File

10
docs/chapter_array_and_linkedlist/array.md
Unescape View File

@ -14,7 +14,7 @@ comments: true
观察上图，我们发现 **数组首元素的索引为 $0$** 。你可能会想，这并不符合日常习惯，首个元素的索引为什么不是 $1$ 呢，这不是更加自然吗？我认同你的想法，但请先记住这个设定，后面讲内存地址计算时，我会尝试解答这个问题。
**数组有多种初始化写法**。根据实际需要，选代码最短的那一种就好。
**数组初始化**。一般会用到无初始值、给定初始值两种写法，可根据需求选取。在不给定初始值的情况下，一般所有元素会被初始化为默认值 $0$ 。
=== "Java"
@ -28,8 +28,12 @@ comments: true
```cpp title="array.cpp"
/* 初始化数组 */
int* arr = new int[5];
int* nums = new int[5] { 1, 3, 2, 5, 4 };
// 存储在栈上
int arr[5];
int nums[5] { 1, 3, 2, 5, 4 };
// 存储在堆上
int* arr1 = new int[5];
int* nums1 = new int[5] { 1, 3, 2, 5, 4 };
```
=== "Python"

20
docs/chapter_graph/graph_operations.md
Unescape View File

@ -129,7 +129,7 @@ comments: true
```java title="graph_adjacency_list.java"
[class]{Vertex}-[func]{}
[class]{GraphAdjList}-[func]{}
```
@ -137,7 +137,7 @@ comments: true
```cpp title="graph_adjacency_list.cpp"
[class]{Vertex}-[func]{}
[class]{GraphAdjList}-[func]{}
```
@ -145,7 +145,7 @@ comments: true
```python title="graph_adjacency_list.py"
[class]{Vertex}-[func]{}
[class]{GraphAdjList}-[func]{}
```
@ -153,7 +153,7 @@ comments: true
```go title="graph_adjacency_list.go"
[class]{vertex}-[func]{}
[class]{graphAdjList}-[func]{}
```
@ -161,7 +161,7 @@ comments: true
```javascript title="graph_adjacency_list.js"
[class]{Vertex}-[func]{}
[class]{GraphAdjList}-[func]{}
```
@ -169,7 +169,7 @@ comments: true
```typescript title="graph_adjacency_list.ts"
[class]{Vertex}-[func]{}
[class]{GraphAdjList}-[func]{}
```
@ -177,7 +177,7 @@ comments: true
```c title="graph_adjacency_list.c"
[class]{vertex}-[func]{}
[class]{graphAdjList}-[func]{}
```
@ -185,7 +185,7 @@ comments: true
```csharp title="graph_adjacency_list.cs"
[class]{Vertex}-[func]{}
[class]{GraphAdjList}-[func]{}
```
@ -193,7 +193,7 @@ comments: true
```swift title="graph_adjacency_list.swift"
[class]{Vertex}-[func]{}
[class]{GraphAdjList}-[func]{}
```
@ -201,7 +201,7 @@ comments: true
```zig title="graph_adjacency_list.zig"
[class]{Vertex}-[func]{}
[class]{GraphAdjList}-[func]{}
```

78
docs/chapter_tree/binary_tree_traversal.md
Unescape View File

@ -10,7 +10,7 @@ comments: true
## 7.2.1. 层序遍历
「层序遍历 Hierarchical-Order Traversal」从顶至底、一层一层地遍历二叉树，并在每层中按照从左到右的顺序访问结点。
「层序遍历 Level-Order Traversal」从顶至底、一层一层地遍历二叉树，并在每层中按照从左到右的顺序访问结点。
层序遍历本质上是「广度优先搜索 Breadth-First Traversal」，其体现着一种“一圈一圈向外”的层进遍历方式。
@ -18,68 +18,76 @@ comments: true
<p align="center"> Fig. 二叉树的层序遍历 </p>
### 实现代码
广度优先遍历一般借助「队列」来实现。队列的规则是“先进先出”，广度优先遍历的规则是 ”一层层平推“ ，两者背后的思想是一致的。
=== "Java"
```java title="binary_tree_bfs.java"
[class]{binary_tree_bfs}-[func]{hierOrder}
[class]{binary_tree_bfs}-[func]{levelOrder}
```
=== "C++"
```cpp title="binary_tree_bfs.cpp"
[class]{}-[func]{hierOrder}
[class]{}-[func]{levelOrder}
```
=== "Python"
```python title="binary_tree_bfs.py"
[class]{}-[func]{hier_order}
[class]{}-[func]{level_order}
```
=== "Go"
```go title="binary_tree_bfs.go"
[class]{}-[func]{hierOrder}
[class]{}-[func]{levelOrder}
```
=== "JavaScript"
```javascript title="binary_tree_bfs.js"
[class]{}-[func]{hierOrder}
[class]{}-[func]{levelOrder}
```
=== "TypeScript"
```typescript title="binary_tree_bfs.ts"
[class]{}-[func]{hierOrder}
[class]{}-[func]{levelOrder}
```
=== "C"
```c title="binary_tree_bfs.c"
[class]{}-[func]{hierOrder}
[class]{}-[func]{levelOrder}
```
=== "C#"
```csharp title="binary_tree_bfs.cs"
[class]{binary_tree_bfs}-[func]{hierOrder}
[class]{binary_tree_bfs}-[func]{levelOrder}
```
=== "Swift"
```swift title="binary_tree_bfs.swift"
[class]{}-[func]{hierOrder}
[class]{}-[func]{levelOrder}
```
=== "Zig"
```zig title="binary_tree_bfs.zig"
[class]{}-[func]{hierOrder}
[class]{}-[func]{levelOrder}
```
### 复杂度分析
**时间复杂度**：所有结点被访问一次，使用 $O(n)$ 时间，其中 $n$ 为结点数量。
**空间复杂度**：当为满二叉树时达到最差情况，遍历到最底层前，队列中最多同时存在 $\frac{n + 1}{2}$ 个结点，使用 $O(n)$ 空间。
## 7.2.2. 前序、中序、后序遍历
相对地，前、中、后序遍历皆属于「深度优先遍历 Depth-First Traversal」，其体现着一种“先走到尽头，再回头继续”的回溯遍历方式。
@ -100,13 +108,15 @@ comments: true
</div>
### 实现代码
=== "Java"
```java title="binary_tree_dfs.java"
[class]{binary_tree_dfs}-[func]{preOrder}
[class]{binary_tree_dfs}-[func]{inOrder}
[class]{binary_tree_dfs}-[func]{postOrder}
```
@ -114,9 +124,9 @@ comments: true
```cpp title="binary_tree_dfs.cpp"
[class]{}-[func]{preOrder}
[class]{}-[func]{inOrder}
[class]{}-[func]{postOrder}
```
@ -124,9 +134,9 @@ comments: true
```python title="binary_tree_dfs.py"
[class]{}-[func]{pre_order}
[class]{}-[func]{in_order}
[class]{}-[func]{post_order}
```
@ -134,9 +144,9 @@ comments: true
```go title="binary_tree_dfs.go"
[class]{}-[func]{preOrder}
[class]{}-[func]{inOrder}
[class]{}-[func]{postOrder}
```
@ -144,9 +154,9 @@ comments: true
```javascript title="binary_tree_dfs.js"
[class]{}-[func]{preOrder}
[class]{}-[func]{inOrder}
[class]{}-[func]{postOrder}
```
@ -154,9 +164,9 @@ comments: true
```typescript title="binary_tree_dfs.ts"
[class]{}-[func]{preOrder}
[class]{}-[func]{inOrder}
[class]{}-[func]{postOrder}
```
@ -164,9 +174,9 @@ comments: true
```c title="binary_tree_dfs.c"
[class]{}-[func]{preOrder}
[class]{}-[func]{inOrder}
[class]{}-[func]{postOrder}
```
@ -174,9 +184,9 @@ comments: true
```csharp title="binary_tree_dfs.cs"
[class]{binary_tree_dfs}-[func]{preOrder}
[class]{binary_tree_dfs}-[func]{inOrder}
[class]{binary_tree_dfs}-[func]{postOrder}
```
@ -184,9 +194,9 @@ comments: true
```swift title="binary_tree_dfs.swift"
[class]{}-[func]{preOrder}
[class]{}-[func]{inOrder}
[class]{}-[func]{postOrder}
```
@ -194,12 +204,18 @@ comments: true
```zig title="binary_tree_dfs.zig"
[class]{}-[func]{preOrder}
[class]{}-[func]{inOrder}
[class]{}-[func]{postOrder}
```
!!! note
使用循环一样可以实现前、中、后序遍历，但代码相对繁琐，有兴趣的同学可以自行实现。
### 复杂度分析
**时间复杂度**：所有结点被访问一次，使用 $O(n)$ 时间，其中 $n$ 为结点数量。
**空间复杂度**：当树退化为链表时达到最差情况，递归深度达到 $n$ ，系统使用 $O(n)$ 栈帧空间。

Write Preview
Loading…
Cancel
Save