在编写递归算法时，开发者常常会遇到一个反直觉的现象：明明在每次递归调用时都向数组添加了元素，最终返回的却是一个空数组。这种现象背后隐藏着可变对象的引用传递这一关键机制。我们以经典的树形结构遍历为例，逐步拆解问题本质。

问题重现：一个"简单"的递归示例

javascript
function traverse(node, result = []) {
if (!node) return;

result.push(node.value); // 看似正确的操作
traverse(node.left, result);
traverse(node.right, result);

return result;
}

// 测试用例
const tree = {
value: 1,
left: { value: 2 },
right: { value: 3 }
};

console.log(traverse(tree)); // 期望输出 [1,2,3]，实际输出？

在Python中同样存在类似情况：python
def traverse(node, result=[]):
if not node:
return

result.append(node.value)
traverse(node.left, result)
traverse(node.right, result)

return result

现象解析：执行过程的全景透视

1. 首次调用时创建默认数组result=[]，假设其内存地址为0x001
2. 每次result.push()操作确实修改了0x001地址的数据
3. 递归返回时，所有操作都基于同一个内存地址的数组
4. 在特定语言（如Python）中，默认参数在函数定义时就被创建，导致更隐蔽的共享引用

核心陷阱：引用共享的三重罪

1. 同一性陷阱：所有递归层级操作的是同一个数组对象
   javascript console.log(result === arguments[1]); // 始终返回true
2. 回溯污染：当递归到达叶子节点开始回溯时，可能意外清空已收集的数据
3. 默认参数绑定（Python特有问题）：默认列表在函数定义时实例化，而非每次调用时

解决方案：三种可靠的处理模式

方案1：函数内局部实例化

javascript
function traverse(node) {
const result = []; // 每次调用创建新数组

function helper(n) {
if (!n) return;
result.push(n.value);
helper(n.left);
helper(n.right);
}

helper(node);
return result;
}

方案2：函数式纯递归（无副作用）

python
def traverse(node):
if not node:
return []

return (
    [node.value] 
    + traverse(node.left) 
    + traverse(node.right)
)

方案3：深度拷贝传递

javascript
function traverse(node, result = []) {
if (!node) return [...result]; // 返回新数组

result.push(node.value);
const left = traverse(node.left, [...result]);
const right = traverse(node.right, [...result]);

return [...left, ...right.filter(x => !left.includes(x))];
}

性能对比与选型建议

| 方案 | 时间复杂度 | 空间复杂度 | 适用场景 |
|-------------|------------|------------|------------------------|
| 局部实例化 | O(n) | O(h) | 大多数树遍历场景 |
| 函数式 | O(n²) | O(n) | 小型数据结构 |
| 深拷贝 | O(n) | O(n logn) | 需要完全隔离的调用栈 |

实践建议：对于超过1000个节点的深层数据结构，优先采用方案1；在函数式编程范式下可考虑方案2；方案3适用于需要严格隔离的并行处理场景。

扩展思考：其他语言的类似情况

• Java：ArrayList作为参数传递时同样存在引用共享
• C++：可以通过vector<T>&明确引用传递，或vector<T>值传递
• Rust：所有权机制天然防止此类问题，但需要显式处理clone()

理解这个陷阱的本质，有助于我们在处理更复杂的递归结构（如DOM树操作、JSON解析等场景）时避免落入类似的引用传递陷阱。