在处理树形配置、多维数组或者动态嵌套的数据源时，我们常常需要把结构不一的 List 转换成一层扁平序列。所谓最高效，并不只是运行速度快，还包括内存占用可控、代码可维护以及能应对任意深度的嵌套。下面从几种典型实现出发，分析它们的底层机制和适用边界。
一、递归展开的基础写法与局限
最直观的思路是写一个递归函数：遇到列表就继续往下拆，遇到普通元素就加入结果。这种方式代码量少，逻辑清晰，适合层级较浅且数据规模不大的情况。但它的隐患在于 Python 默认递归深度约为一千层，一旦嵌套过深就会抛出递归错误；同时每次递归都伴随函数调用开销。
下面是一段典型的 Python 递归实现。我们用 isinstance 判断元素是否为列表，从而决定是否继续展开。
def flatten_recursive(data):
result = []
for item in data:
if isinstance(item, list):
# 递归展开子列表并合并
result.extend(flatten_recursive(item))
else:
result.append(item)
return result
nested = [1, [2, [3, 4]], 5]
print(flatten_recursive(nested))
这种写法的优点是易读，缺点是 extend 每次都会生成新的中间列表，并在返回后合并，带来额外的拷贝成本。如果嵌套结构非常不规则，性能会明显下降。
二、使用显式栈避免递归风险
把递归改写成栈循环，是解决深度限制最直接的办法。我们维护一个待处理栈，初始放入原列表，之后不断弹出元素；如果是列表就把它反转后压回栈，否则收集为结果。这样调用栈始终只有一层，空间复杂度主要来自存放元素的栈和结果列表。
下面的示例展示了如何用栈实现扁平化，它对任意深度都安全，而且没有函数反复调用的消耗。
def flatten_stack(data):
result = []
stack = [data]
while stack:
current = stack.pop()
if isinstance(current, list):
# 逆序压栈保证顺序一致
for item in reversed(current):
stack.append(item)
else:
result.append(current)
return result
nested = [1, [2, [3, 4]], 5]
print(flatten_stack(nested))
相比递归，栈写法在深嵌套时更加稳健。不过它仍然一次性生成完整结果列表，如果数据量极大，内存占用不可忽视。此时可以改用生成器，做到边遍历边产出。
三、生成器实现惰性扁平化
生成器能把扁平化的过程延迟到真正需要元素时才执行，避免一次性占用大量内存。它特别适合流式处理或只需要逐个消费元素的场景，比如写入文件、网络发送等。
以下代码用 yield 逐步吐出元素，调用方可以通过循环按需获取，无需等待全部展开完成。
def flatten_generator(data):
for item in data:
if isinstance(item, list):
yield from flatten_generator(item)
else:
yield item
nested = [1, [2, [3, 4]], 5]
for val in flatten_generator(nested):
print(val)
生成器版本兼顾了递归的简洁与内存友好，但在极深嵌套时仍有递归深度问题。若配合栈逻辑改写为惰性栈生成器，则可以同时满足深度与内存双重要求。
四、JavaScript 中的高效实现
在前端或 Node 环境中，数组自带 flat 方法，可传入深度参数。对于未知深度，传 Infinity 即可一次性展开。但在老旧运行环境或需要自定义逻辑时，手写栈实现同样有效。
下面分别给出内置方法和栈实现的例子，方便对照。
// 内置方法
const nested = [1, [2, [3, 4]], 5];
const flat1 = nested.flat(Infinity);
console.log(flat1);
// 栈实现
function flattenStack(arr) {
const result = [];
const stack = [arr];
while (stack.length) {
const cur = stack.pop();
if (Array.isArray(cur)) {
for (let i = cur.length - 1; i >= 0; i--) {
stack.push(cur[i]);
}
} else {
result.push(cur);
}
}
return result;
}
console.log(flattenStack(nested));
内置 flat 由引擎底层优化，通常比手写循环更快；但在需要过滤特定类型或做转换时，栈实现更灵活。实际选型应结合运行环境、数据规模和后续处理逻辑。
五、性能与选型建议
从时间看，递归与栈循环都是 O(N) 遍历，差异主要在常数开销；生成器因惰性可能让整体耗时分散。从空间看，一次性展开最占内存，生成器最省。若嵌套深度不可控，必须避开纯递归。
| 方式 | 深度安全 | 内存占用 | 适用场景 |
|---|---|---|---|
| 递归 | 否 | 中 | 浅层小数据 |
| 显式栈 | 是 | 高 | 深嵌套全量 |
| 生成器 | 视实现 | 低 | 流式处理 |
| 内置flat | 是 | 高 | JS现代环境 |
综合来看，没有绝对唯一的最高效率方案。在 Python 后台任务中，推荐默认采用栈或栈式生成器；在 JavaScript 前端，优先使用 flat(Infinity) 并辅以特性检测。理解每种做法的底层开销，才能在真实业务中做出恰当取舍。