Complex Recursion Explained Simply

[@mandihaase2744]

Your videos are wonderful! Please keep providing new content - your explanations are incredibly easy to understand~

[@realmusagabriel]

especially the visualization! easy to understand

[@DennisPing]

I appreciate the multiple examples in this video. Thanks.

[@Eddie4k]

For the sum recursion problem, I implemented it using .pop() instead of slicing. def sum(arr): if len(arr) == 0: return 0 return arr.pop() + sum(arr)

[@JT-iw2cw]

I initially thought your approach was abstract and confusing, but on further thought it's enlightens how the recursion executes. Perhaps that's why we struggle with recursion in the first place, we look to the output rather than look at the steps to get there.

[@azizbenanaya8833]

thank you so much this is wonderful , but could you please organize the videos so that we can follow the right order and thanks again for your great effort .

[@yevheniiganusich5017]

I don't know why this channel doesn't have more subscribers!!!

[@sgsniper1]

Hi Alvin, one question, isn't the space complexity O(n^2) too? cuz it creates a new subarray in each call stack of n recursive calls, so it's n*n memory space overall.

[@xingyanglan6836]

no, it depends on if the recursion is “preorder” or “inorder” or “postorder” etc traversal. The temporary variables are all cleared if its the recursion occurs preorder which it often is with arrays, meaning the big-O space complexity could be as low as linear; such occurs as a limitation of a computer to only have one turing-esque pointer, but is not a factor in actual multicore computing i think

[@Hello-jz3em]

If we think about what Alvin wrote here, simply each stack call consumes O(n) space so it should be O(N^2).

[@Dipenparmar12]

I love the way of explaining.

[@chrisjarvis509]

Really great videos!!! Thank you

[@deyvidpopov2778]

You can set a default value to the *idx* and skip passing the 0 by the first call of *_sum* function.

[@qwertyguy1556]

wow your videos are super amazing! Tnx I really needed them

[@souravskr]

Linear Time Solution def sum_array(nums): size = len(nums) if not size: return 0 print(nums) num = nums.pop(size - 1) time.sleep(2) return num + sum_array(nums)

[@TheJakehalsted]

divide into two halfs...divive each half into two halfs....its log2(N) much better than linear time

[@MrFsjay]

all of your videos are amazing

[@burszuras1674]

Great tutorial however I'm having issues understanding space complexity used here. How is that possible that Space: O(n) in sum algorithm from 09:30. We are doing n recursive calls and each of them keeps local variable 'rest' on the stack (which is roughly of size n). According to my understanding the space complexity should be O(n^2). Am I missing something?

[@SLPKNTs]

True. Each recursive call will have new array to work with and the size of it will decrease by 1 on each recursive call, meaning the space used by all those arrays is an integral of n, which results into 1/2 * n^2 and simplifies by big-O rules to just n^2

[@kirillzlobin7135]

Great video

[@davidfernandezbajo]

I came up with >> return arr.shift() + sum(arr), anything wrong with that?

[@ritsk4338]

First like. Superb Video. Awesome explanation

[@CoderbyteDevelopers]

Thanks for watching our videos!

[@stanleyagwu4818]

Great work!

[@usmanmunir1559]

Awesome 🤍

[@yohannistelila8879]

Thank you so much!!!

[@iiimiiim]

Thank yoooooou!

[@cmdv42]

💎

[@BabekNagiyev]

Unsbscribe? I'd rather leave development

[@TheJakehalsted]

Divide and conquer. O Log2(N) Now I'll write it, then I'll watch the video. Then I'll roll me eyes and write in in ARmV8 Assembler just to be a chode

[@Eddie4k]

For the sum recursion problem, I implemented it using .pop() instead of slicing. def sum(arr): if len(arr) == 0: return 0 return arr.pop() + sum(arr)