问题[рекурсия]

const tree = [
    {
        v: 5,
        c: [
            {
                v:10,
                c: [
                    {
                        v:11,
                    }
                ]
            },
            {
                v:7,
                c: [
                    {
                        v:5,
                        c: [
                            {
                                v:1
                            }
                        ]
                    }
                ]
            }
        ]
    },
    {
        v: 5,
        c: [
            {
                v:10
            },
            {
                v:15
            }
        ]
    }
]

function treeSum(tree) {
    let sum = 0;
    
    for (let i = 0; i < tree.length; i++) {
        sum+= tree[i].v;
        if (!tree[i].c) {
            return tree[i].v;
        }
         sum += treeSum(tree[i].c)
        
    }
 /*    tree.forEach((node,index)=>{
         index;
        sum += node.v
        if (!node.c) {
            return node.v;
        }
         sum += treeSum(node.c)
        
    }) */
 /* c foreach все работает*/
  return sum
} 

有这样的功能

    def get_line_list(d, a=[]):
        for i in d:
            if type(i) != list:
                a.append(i)
            else:
                get_line_list(i)
        return a
    
    
    print(get_line_list([1, 2, [True, False], ["Москва", "Уфа", [100, 101], ['True', [-2, -1]]], 7.89]))

第一个参数是一个多维列表，第二个参数是一个空列表，您需要将第一个元素中的所有元素移入其中，同时解包它们，以便列表最终是一维的。

问题：这里的递归函数在什么时候解包列表？这是怎么发生的？

第二个问题：递归这个话题需要操心多少，在实践中经常用到吗？这是某种黑暗，我想知道是否值得忍受和理解它？

我理解 if (*(s+1))，指向数组下一个元素的指针，直到它变为 NULL，但我不明白为什么函数返回数组的反转。你能解释一下吗。

void reverse(const char* s) {
    if (*(s + 1))
        reverse(s + 1);
    std::cout << *s;
}
int main() 
{ 
    char Arr[100] = {"Я изучаю язык программирования С++"};
    reverse(Arr);
    return 0;
}

请解释为什么是第二个循环。如果没有它，那么只有数组进入res，但根据我的逻辑，那里应该有值。此外，如果它不是一个数组，但例如res最初将是一个字符串，那么它是到达那里的值，如第二个示例所示。我的手往下。

let a = [[[2]], [2], [[3]], [4]];

function flatten(array) {
  const res = [];
  for (let i = 0; i < array.length; i++) {
    if (Array.isArray(array[i])) {
      const flat = flatten(array[i]);

      for (let j = 0; j < flat.length; j++) {
        res.push(flat[j]);
      }
    } else {
      res.push(array[i]);
    }
  }

  return res;
}


console.log(flatten(a));

let a = [[[2]], [2], [[3]], [4]];
function fn(arg) {
  let res = '';
  for (let i = 0; i < arg.length; i++) {
    if (Array.isArray(arg[i])) {
      let y = fn(arg[i]);

      res+=(y);
    } else {
      res+=(arg[i]);
    }
  }

  return res;
}

console.log(fn(a));

问题如下 - 我需要列出二叉搜索树的所有元素 - 我通过递归编写代码，但它不能正常工作。出于某种原因，该方法不想递归地输入自己，而只是跳过带有条目的行。可能是什么问题呢？

public IEnumerator<T> GetEnumerator()
        {
            if (Root == null)
                yield break;
            foreach (var node in HelpMethod(Root))
                yield return node;
        }
        private IEnumerable<T> HelpMethod(Node<T> subTree)
        {
            if (subTree.Left != null)
                HelpMethod(subTree.Left);
            yield return subTree.Value;
            if (subTree.Right != null)
                HelpMethod(subTree.Right);
        }