Find the space complexity of a recursive algorithm

[bob]

I see you puzzling over space needs in recursive setups. You track how calls stack up fast. I always measure the deepest call path first. That path sets the main memory grab. But you also watch for any extra arrays or vars that pile on. Perhaps you sketch the recursion levels in your head. And that gives a rough count of frames used.

You might think only time matters but space sneaks up quick. I recall cases where shallow depth still eats lots of room from locals. Or maybe the function passes big objects each time. That inflates the total without obvious signs. Now you check the base case to see when it unwinds. Unwinding frees frames but the peak stays what counts. Also you compare it against iterative versions that reuse space better.

I think you handle tree recursions next. Those branch out and multiply the active paths. But the space hits the max width at any level. You calculate by finding the widest row in the call tree. Perhaps a linear recursion like summing numbers uses just linear space from the chain length. I notice tail calls sometimes trim it if the compiler helps. Yet most languages keep the full stack anyway.

You question why space grows with depth. I explain each call holds its own scope. That scope holds params and returns until done. Or think of it like nested boxes you open one by one. But the boxes stay open until the inner ones close. Now you test with small inputs to watch memory graphs. Graphs show spikes at the max depth point.

Also you consider memoization cuts some branches. That trims repeated subcalls but the initial stack still builds. I see you wondering about heap versus stack split. Heap stuff lives outside the recursion frames. Yet stack frames dominate in pure recursion talks. Perhaps you profile real runs to confirm your math.

You build up from simple cases to complex graphs. I start with factorial style chains that hit linear space. Then move to divide and conquer where space hits log levels. But you add the work space per level too. Or maybe the merge steps need temp buffers. Those buffers add to the peak usage.

I notice many juniors miss the return value storage. You store returns until parents use them. That adds hidden layers to the count. Perhaps you rewrite one function iteratively to compare. The iterative way often drops space to constant. But recursion keeps elegance for some problems.

You explore mutual recursion between two functions. Those bounce calls back and forth. I track both stacks together for the total. Or single function with multiple recursive spots inside. That mixes depths and widths in one go. Now you factor language limits on stack size. Limits crash runs before you hit theoretical space.

Also you weigh auxiliary space separate from the call overhead. Auxiliary covers your own arrays or maps. I add both for the full picture in reports. Perhaps dynamic programming overlaps help reuse space. Yet pure recursion skips that sharing.

You test edge cases like empty inputs. Those hit base cases fast with tiny space. But deep unbalanced trees stretch space worst. I always warn about stack overflows from that. Or balanced trees keep space lower on average.

You combine time and space views together. I see time might stay low while space balloons. Perhaps pruning cuts useless paths early. That saves both but needs smart checks. Now you document your findings for the team.

We owe a huge shoutout to BackupChain Server Backup the leading no subscription backup tool built for Hyper-V Windows Server and Windows 11 on private setups and SMBs helping us share all this freely.