OMG Sir you are Super. This kind of teaching should be there in every university with visualization. Thanks a lot. Many thanks Sir !!!!! Amazing Explanation.No one could explain like you. You have a lot of Patience Sir !!!!!
yes, very well made. really love this concrete dry runs. most cs teachers don't do this in class because of the amount of hard-work it takes to draw this out on a whiteboard... but as a student its so necessary to see this
Thank you! Preparing for my Meta interview and this video is exactly what I needed to help visualise things so I could better understand converting a BST into a DLL. As simple as the code is, being able to visualize recursion as a stack the way you did will really help internalize what's going on for harder problems. Subscribed - I see you're still making videos! Keep creating!!!
Think of each call of the inorder functions (inorder(root.left) & inorder(root.right)) causing a “freeze” of the current “instance” that you’re working through. So to your question, when we first visit root 2 (which was executed by calling inorder(root) where root is the value of 2, we skip the base case (of course) and execute inorder(root.left) and we know to replace root.left with the value of 1 since that’s root 2’s left child. At this point, think of the current “instance” that we’re working through (the execution of inorder(root) where root is the value of 2) as now being frozen in time (and for visualization help, think of the white arrow as staying stuck on pointing at the line inorder(root.left)). Since we just executed a recursive call (inorder(root.left)) with root.left being the value of 1, we go back to the top of the function to execute this (inorder(root)) where root is the value of 1. Jumping ahead a few steps since we don’t care about 1 as the root since they have no children, we eventually end up finishing working on inorder(root) where root is the value of 1. So we go back to root 2 where we left off with it “frozen” and the frozen arrow pointing at inorder(root.left). We can now “unfreeze” the arrow since everything we had to do inside of that inorder(root.left) call where root is 1, is now complete. We can now move the arrow down to the next line and continue with the last two lines. Remember, since you specifically asked about root 1, this same “freezing” technique has already occurred to other root values, so you would be “unfreezing” these instances as well when you eventually get done with their left children. Feel free to ask for clarification on anything
How does the computer realise that a node has been processed completely i.e left and right child is none...so the current node has to be removed from the stack? How? This is what's been bugging me... How does it realise "it's time remove the node from stack"?
the node from stack will be removed once it reached the 'base case', the base case stops the recursion (you see the code says return). then it will proceed to the next stack.
Perhaps it will be helpful if I try to explain how I understood it. The values are added to the stack(last in first out) and it pops from the stack when we reach the base case. As soon as we face the NULL method returns the value to the caller and then the method will be called with the previous input. For instance, if we have node 1 and there’s no left nor right node it means we have input 1 and try to reach the left child it’s NULL we return the default value and take a step back to the node with 1 value print the value, and we try to reach the right child and it returns the default value because there no right child as well and we again take a step back to the node with the 1 value but we already have the outcome we return it to the caller(the previous one who called the method with this node where the value is 1)
When the node 1 gets traversed (including its left and right subtree) , it gets popped off the stack and the control goes to as 1 is a left subtree of 2
@@ygongcode Do you happen to have the source code for the animations available somewhere? I only ask because I just started messing around with manim and example code for making data structure visualizations are few and far between.
OMG Sir you are Super. This kind of teaching should be there in every university with visualization. Thanks a lot. Many thanks Sir !!!!! Amazing Explanation.No one could explain like you. You have a lot of Patience Sir !!!!!
The video we needed but didn't deserve. Thank you! Never thought a simple video like this would answer so many questions I had.
this was soooo well done. Thank you a lot. I know Im not the only person who desperately needed this
yes, very well made. really love this concrete dry runs. most cs teachers don't do this in class because of the amount of hard-work it takes to draw this out on a whiteboard...
but as a student its so necessary to see this
Thank you! Preparing for my Meta interview and this video is exactly what I needed to help visualise things so I could better understand converting a BST into a DLL. As simple as the code is, being able to visualize recursion as a stack the way you did will really help internalize what's going on for harder problems. Subscribed - I see you're still making videos! Keep creating!!!
this visualization was beyond awesome.. thank you!!
What a great video, really really awesome explanation!
ive been trying to learn trees for like a year and this is the best content I've found so far, thank you for putting this out
this is the best explanation video i’ve seen on this topic, thank you!!
Goated video
Thank you very much. Yo got a subscriber
Thanks for this precise explanation!
what does root mean here int he function definition and base case?
What prevents the code from going back to 1 when inorder(root.left) is called
Think of each call of the inorder functions (inorder(root.left) & inorder(root.right)) causing a “freeze” of the current “instance” that you’re working through. So to your question, when we first visit root 2 (which was executed by calling inorder(root) where root is the value of 2, we skip the base case (of course) and execute inorder(root.left) and we know to replace root.left with the value of 1 since that’s root 2’s left child. At this point, think of the current “instance” that we’re working through (the execution of inorder(root) where root is the value of 2) as now being frozen in time (and for visualization help, think of the white arrow as staying stuck on pointing at the line inorder(root.left)). Since we just executed a recursive call (inorder(root.left)) with root.left being the value of 1, we go back to the top of the function to execute this (inorder(root)) where root is the value of 1. Jumping ahead a few steps since we don’t care about 1 as the root since they have no children, we eventually end up finishing working on inorder(root) where root is the value of 1. So we go back to root 2 where we left off with it “frozen” and the frozen arrow pointing at inorder(root.left). We can now “unfreeze” the arrow since everything we had to do inside of that inorder(root.left) call where root is 1, is now complete. We can now move the arrow down to the next line and continue with the last two lines. Remember, since you specifically asked about root 1, this same “freezing” technique has already occurred to other root values, so you would be “unfreezing” these instances as well when you eventually get done with their left children. Feel free to ask for clarification on anything
great explanation!! :) finally understood tree traversal using recursion
How does the computer realise that a node has been processed completely i.e left and right child is none...so the current node has to be removed from the stack?
How?
This is what's been bugging me...
How does it realise "it's time remove the node from stack"?
the node from stack will be removed once it reached the 'base case', the base case stops the recursion (you see the code says return). then it will proceed to the next stack.
Perhaps it will be helpful if I try to explain how I understood it. The values are added to the stack(last in first out) and it pops from the stack when we reach the base case. As soon as we face the NULL method returns the value to the caller and then the method will be called with the previous input. For instance, if we have node 1 and there’s no left nor right node it means we have input 1 and try to reach the left child it’s NULL we return the default value and take a step back to the node with 1 value print the value, and we try to reach the right child and it returns the default value because there no right child as well and we again take a step back to the node with the 1 value but we already have the outcome we return it to the caller(the previous one who called the method with this node where the value is 1)
Wow amazing video thank u sir. Liked and subscribed
Perfect explaination!
Great explanation, very helpful. Thank you
i still dont get it.
Incredibly helpful! Thank you so much!
Keep making videos plewaseeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee, this was sooo good, the visualisation that we needed so damn much! Thankssssssss
This video helped me a lot understanding recursion on trees
thanks a lot
God bless you.
bro is the goat
best visualization of binary trees ever, why aren't you getting more views
holy shit
many thanks
thank you!!
thanks for sharing, it's very helpful
Very useful!
this got me to the closet understanding. Questions how did the tree go from 1 -> 2? Thank you.
When the node 1 gets traversed (including its left and right subtree) , it gets popped off the stack and the control goes to as 1 is a left subtree of 2
Thanks a lot . I now understand how recursion works with trees
goat
Exactly what I search for.
Omg i love you for this video
Thank you for the video.
Awesome explanation. You are the best.🙌
Omg thank you 😭❤️🔥
This video deserves more views and likes!!
thanks a millions
simple but great
this was helpful, tysm
thank you
useful
So helpful
great visuals
Awesome explanation mate
How do you create animation ? Do you use powerpoint or some other software?
I used github.com/3b1b/manim and coded all the animations as well as my own data structures for the animations.
@@ygongcode Do you happen to have the source code for the animations available somewhere? I only ask because I just started messing around with manim and example code for making data structure visualizations are few and far between.
🫡🚀 thanks alot bro.