feat: add solutions for lc No.3831 (#5009)

Author: yanglbme

README.md

@@ -52,7 +52,7 @@
 - [乘积小于 K 的子数组](/solution/0700-0799/0713.Subarray%20Product%20Less%20Than%20K/README.md) - `双指针`
 - [位 1 的个数](/solution/0100-0199/0191.Number%20of%201%20Bits/README.md) - `位运算`、`lowbit`
 - [合并区间](/solution/0000-0099/0056.Merge%20Intervals/README.md) - `区间合并`
-      <!-- 排序算法、待补充 -->
+    <!-- 排序算法、待补充 -->
 
 ### 2. 数据结构
 

solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md

@@ -1008,7 +1008,6 @@ class TreapMultiSet<T = number> implements ITreapMultiSet<T> {
 
 #### Rust
 
-
 ```rust
 use std::collections::BTreeMap;
 

solution/3800-3899/3831.Median of a Binary Search Tree Level/README.md

@@ -0,0 +1,272 @@
+---
+comments: true
+difficulty: 中等
+edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3831.Median%20of%20a%20Binary%20Search%20Tree%20Level/README.md
+---
+
+<!-- problem:start -->
+
+# [3831. Median of a Binary Search Tree Level 🔒](https://leetcode.cn/problems/median-of-a-binary-search-tree-level)
+
+[English Version](/solution/3800-3899/3831.Median%20of%20a%20Binary%20Search%20Tree%20Level/README_EN.md)
+
+## 题目描述
+
+<!-- description:start -->
+
+<p>You are given the <code>root</code> of a <strong>Binary Search Tree (BST)</strong> and an integer <code>level</code>.</p>
+
+<p>The root node is at level 0. Each level represents the distance from the root.</p>
+
+<p>Return the <strong>median value</strong> of all node values present at the given <code>level</code>. If the level does not exist or contains no nodes, return -1.</p>
+
+<p>The <strong>median</strong> is defined as the middle element after sorting the values at that level in <strong>non-decreasing</strong> order. If the number of values at that level is even, return the <strong>upper</strong> median (the larger of the two middle elements after sorting).</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<p><img src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/3800-3899/3831.Median%20of%20a%20Binary%20Search%20Tree%20Level/images/screenshot-2026-01-27-at-20801pm.png" style="width: 180px; height: 182px;" /></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [4,null,5,null,7], level = 2</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">7</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The nodes at <code>level = 2</code> are <code>[7]</code>. The median value is 7.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<p><img src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/3800-3899/3831.Median%20of%20a%20Binary%20Search%20Tree%20Level/images/screenshot-2026-01-27-at-20926pm.png" style="width: 200px; height: 169px;" /></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [6,3,8], level = 1</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">8</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The nodes at <code>level = 1</code> are <code>[3, 8]</code>. There are two possible median values, so the larger one 8 is the answer.</p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<p><strong class="example">​​​​​​​​​​​​​​</strong><img src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/3800-3899/3831.Median%20of%20a%20Binary%20Search%20Tree%20Level/images/screenshot-2026-01-27-at-21001pm.png" style="width: 150px; height: 193px;" /></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [2,1], level = 2</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">-1</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>There is no node present at <code>level = 2</code>​​​​​​​, so the answer is -1.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 2 * 10<sup>5</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>6</sup></code></li>
+	<li><code>0 &lt;= level &lt;= 2 * 10<sup>​​​​​​​5</sup></code></li>
+</ul>
+
+<!-- description:end -->
+
+## 解法
+
+<!-- solution:start -->
+
+### 方法一：DFS
+
+我们注意到，题目要求我们找到二叉搜索树中某一层的节点值的中位数。由于中位数的定义是将节点值排序后取中间的值，而二叉搜索树的中序遍历本身就是有序的，因此我们可以通过中序遍历来收集指定层级的节点值。
+
+我们定义一个辅助函数 $\text{dfs}(root, i)$，其中 $root$ 是当前节点，而 $i$ 是当前节点的层级。在函数中，如果当前节点为空，则直接返回。否则，我们递归地遍历左子树，检查当前节点的层级是否等于目标层级，如果是，则将当前节点的值加入结果列表中，最后递归地遍历右子树。
+
+我们初始化一个空列表 $\text{nums}$ 来存储指定层级的节点值，并调用 $\text{dfs}(root, 0)$ 来开始遍历。最后，我们检查 $\text{nums}$ 是否为空，如果为空则返回 -1，否则返回 $\text{nums}$ 中间位置的值。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$，其中 $n$ 是树中节点的数量。
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def levelMedian(self, root: Optional[TreeNode], level: int) -> int:
+        def dfs(root: Optional[TreeNode], i: int):
+            if root is None:
+                return
+            dfs(root.left, i + 1)
+            if i == level:
+                nums.append(root.val)
+            dfs(root.right, i + 1)
+
+        nums = []
+        dfs(root, 0)
+        return nums[len(nums) // 2] if nums else -1
+```
+
+#### Java
+
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    private List<Integer> nums = new ArrayList<>();
+    private int level;
+
+    public int levelMedian(TreeNode root, int level) {
+        this.level = level;
+        dfs(root, 0);
+        return nums.isEmpty() ? -1 : nums.get(nums.size() / 2);
+    }
+
+    private void dfs(TreeNode root, int i) {
+        if (root == null) {
+            return;
+        }
+        dfs(root.left, i + 1);
+        if (i == level) {
+            nums.add(root.val);
+        }
+        dfs(root.right, i + 1);
+    }
+}
+```
+
+#### C++
+
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    int levelMedian(TreeNode* root, int level) {
+        vector<int> nums;
+
+        auto dfs = [&](this auto&& dfs, TreeNode* node, int i) -> void {
+            if (!node) {
+                return;
+            }
+            dfs(node->left, i + 1);
+            if (i == level) {
+                nums.push_back(node->val);
+            }
+            dfs(node->right, i + 1);
+        };
+
+        dfs(root, 0);
+        return nums.empty() ? -1 : nums[nums.size() / 2];
+    }
+};
+```
+
+#### Go
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func levelMedian(root *TreeNode, level int) int {
+	nums := make([]int, 0)
+
+	var dfs func(*TreeNode, int)
+	dfs = func(node *TreeNode, i int) {
+		if node == nil {
+			return
+		}
+		dfs(node.Left, i+1)
+		if i == level {
+			nums = append(nums, node.Val)
+		}
+		dfs(node.Right, i+1)
+	}
+
+	dfs(root, 0)
+	if len(nums) == 0 {
+		return -1
+	}
+	return nums[len(nums)/2]
+}
+```
+
+#### TypeScript
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+function levelMedian(root: TreeNode | null, level: number): number {
+    const nums: number[] = [];
+
+    const dfs = (node: TreeNode | null, i: number): void => {
+        if (node === null) {
+            return;
+        }
+        dfs(node.left, i + 1);
+        if (i === level) {
+            nums.push(node.val);
+        }
+        dfs(node.right, i + 1);
+    };
+
+    dfs(root, 0);
+    if (nums.length === 0) {
+        return -1;
+    }
+    return nums[nums.length >> 1];
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
+<!-- problem:end -->