Интересная статья по управлению памятью (JS)

дык и написал бы в заголовке что в JS

[QUOTE]знал, в том числе, о большей ресурсоемкости рекурсии по сравнению с циклом.[/QUOTE]И это сложно? Это [B]азы[/B]. И управление памятью здесь вообще ни причём. Всё дело в необходимости хранения адреса возврата, дублировании локальных переменных в каждом экземпляре функции и двойном цикле. [CPP]uint64 f1(int x)
{
int r=1;
int i=1;
for (i=1; i<=x; ++x)
{
r*=i;
}
}
uint64 f2(int x)
{
if (x==1)
{
return 1;
}
return x*f2(x-1);
}
int main ()
{
int f;
f=f1(10);
f=f2(10);
return 0;
}[/CPP]
В строке f=f1(10); вызывается 1 экземпляр функции, она имеет 1 адрес возврата, 1 параметр x, и 1 значение, 1 счётчик, 1 раз выполняет цикл. Итого: 6 величин, 10 шагов одного цикла. В строке f=f2(10); вызывается 10 экземпляров функции:
1-й экземпляр вызывается по f=f2(10),
2-й по return x*f2(x-1) в 1-м, эквивалентно return 10*f2(9),
3-й по return x*f2(x-1) во 2-м, эквивалентно return 9*f2(8),
4-й по return x*f2(x-1) в 3-м, эквивалентно return 8*f2(7),
5-й по return x*f2(x-1) в 4-м, эквивалентно return 7*f2(6),
6-й по return x*f2(x-1) в 5-м, эквивалентно return 6*f2(5),
7-й по return x*f2(x-1) в 6-м, эквивалентно return 5*f2(4),
8-й по return x*f2(x-1) в 7-м, эквивалентно return 4*f2(3),
9-й по return x*f2(x-1) в 8-м, эквивалентно return 3*f2(2),
10-й по return x*f2(x-1) в 9-м, эквивалентно return 2*f2(1),
вся цепочка уже эквивалентна циклу из 9-ти шагов, но каждый экземпляр имеет по параметру и хранит по адресу возврата, это уже 20 величин, го это ещё не всё, пока ни один из 9-ти первых экземпляров не знает, на что умножать x, так как f2(x-1) не известна, чтоб её получить нужны возвраты значений из 9-ти последних экземпляров:
10-й возвращает 1 в x*f2(x-1) в 9-м, 9-й подставляет и получает return 2*1,
9-й возвращает 2 в x*f2(x-1) в 8-м, 8-й подставляет и получает return 3*2,
8-й возвращает 2 в x*f2(x-1) в 7-м, 7-й подставляет и получает return 4*6,
7-й возвращает 2 в x*f2(x-1) в 6-м, 6-й подставляет и получает return 5*24,
6-й возвращает 2 в x*f2(x-1) в 5-м, 5-й подставляет и получает return 6*120,
5-й возвращает 2 в x*f2(x-1) в 4-м, 4-й подставляет и получает return 7*720,
4-й возвращает 2 в x*f2(x-1) в 3-м, 3-й подставляет и получает return 8*5040,
3-й возвращает 2 в x*f2(x-1) в 2-ом, 2-й подставляет и получает return 9*40320,
2-й возвращает 2 в x*f2(x-1) в 1-ом, 1-й подставляет и получает return 10*362880, это эквивалентно ещё одному циклу из 9-ти шагов, и того: 20 величин, 18 шагов в двух циклах, первый вызов первого экземпляра и последний возврат из него совпадают с циклической версией. Это не зависит ни от языка, ни от архитектуры, ни от схем управления памятью, это суть самой рекурсии. Но всё меняется, когда рекурсивны сами данные, например, при обходе дерева. Попытка заменить рекурсию циклом на таких задачах безтолку усложнит исходник, а запутавшийся программист имеет все шансы раздуть расход и памяти, и машинного времени до совсем уж гигантских значений. Сократить же ресурсоёмкость по сравнению с рекурсией в таких случаях не возможно, так как "съэкономленные" память и время тут же будут занята явными переменными и операциями для поддержки неявной рекурсии.