森林（含树）求深度的递归示例

当然，这里是一个包含 `nextsibling` 有 `child` 的树结构示例：

### 树结构示例

```
        A
       /
      B
     / \
    C   D
       / \
      E   F
         /
        G
```

在孩子-兄弟表示法中：

- `A` 是根节点，`firstchild` 是 `B`。
- `B` 的 `firstchild` 是 `C`，`nextsibling` 是 `D`。
- `C` 没有孩子和兄弟。
- `D` 的 `firstchild` 是 `E`，`nextsibling` 是 `F`。
- `E` 没有孩子和兄弟。
- `F` 的 `firstchild` 是 `G`，`nextsibling` 是 `NULL`。
- `G` 没有孩子和兄弟。

### 递归计算过程

我们使用 `TreeDepth(CSTree *CST)` 来计算深度，假设函数名是 `TreeDepth`，`CST` 是当前节点指针。

#### 从根节点 A 开始

1. **`TreeDepth(A)`**:
   - `left = TreeDepth(B)`: 递归计算孩子 `B` 的深度。
   - `right = TreeDepth(NULL)`: `A` 没有兄弟，返回 `0`。
   - 比较 `left + 1` 和 `right`，返回 `max(left + 1, right)`。

#### 进入节点 B

2. **`TreeDepth(B)`**:
   - `left = TreeDepth(C)`: 递归计算孩子 `C` 的深度。
   - `right = TreeDepth(D)`: 递归计算兄弟 `D` 的深度。
   - 比较 `left + 1` 和 `right`，返回 `max(left + 1, right)`。

#### 进入节点 C

3. **`TreeDepth(C)`**:
   - `left = TreeDepth(NULL)`: `C` 没有孩子，返回 `0`。
   - `right = TreeDepth(NULL)`: `C` 没有兄弟，返回 `0`。
   - 返回 `1`。

返回到节点 B：
- `left = 1`（从 `C` 返回的结果）
- `right = TreeDepth(D)`

#### 进入节点 D

4. **`TreeDepth(D)`**:
   - `left = TreeDepth(E)`: 递归计算孩子 `E` 的深度。
   - `right = TreeDepth(F)`: 递归计算兄弟 `F` 的深度。
   - 比较 `left + 1` 和 `right`，返回 `max(left + 1, right)`。

#### 进入节点 E

5. **`TreeDepth(E)`**:
   - `left = TreeDepth(NULL)`: `E` 没有孩子，返回 `0`。
   - `right = TreeDepth(NULL)`: `E` 没有兄弟，返回 `0`。
   - 返回 `1`。

返回到节点 D：
- `left = 1`（从 `E` 返回的结果）
- `right = TreeDepth(F)`

#### 进入节点 F

6. **`TreeDepth(F)`**:
   - `left = TreeDepth(G)`: 递归计算孩子 `G` 的深度。
   - `right = TreeDepth(NULL)`: `F` 没有兄弟，返回 `0`。
   - 返回 `max(left + 1, right)`。

#### 进入节点 G

7. **`TreeDepth(G)`**:
   - `left = TreeDepth(NULL)`: `G` 没有孩子，返回 `0`。
   - `right = TreeDepth(NULL)`: `G` 没有兄弟，返回 `0`。
   - 返回 `1`。

返回到节点 F：
- `left = 1`（从 `G` 返回的结果）
- `right = 0`
- 返回 `max(1 + 1, 0) = 2`

返回到节点 D：
- `left = 1`
- `right = 2`（从 `F` 返回的结果）
- 返回 `max(1 + 1, 2) = 2`

返回到节点 B：
- `left = 1`
- `right = 2`（从 `D` 返回的结果）
- 返回 `max(1 + 1, 2) = 2

返回到根节点 A：
- `left = 2`（从 `B` 返回的结果）
- `right = 0`
- 返回 `max(2 + 1, 0) = 3`

最终结果：树的深度是 3。通过递归调用，逐步比较每个节点的孩子和兄弟方向的深度，找到最长路径，最终计算出整个树的深度。