data structures tutorial Archives - NeuralLantern.com

AVL Tree Rotations Tutorial: Fixing Imbalance After Adding a Node

mike — Mon, 01 Jun 2026 05:46:56 +0000

In this video we walk through a complete example of maintaining an AVL tree. Starting with a valid AVL tree, we insert a new node that breaks the balance rules, then recompute balance factors up the tree until we find the imbalance.

Watch as we identify the X, Y, and Z nodes and perform a double right rotation to restore the AVL property while keeping it a valid binary search tree.

Perfect for students learning data structures, computer science fundamentals, or anyone preparing for coding interviews.

Previous videos cover binary search trees, AVL basics, rotations, and balance factors.

00:00 Intro to AVL Tree Rotation
00:20 Prerequisites and Previous Videos
01:06 Initial AVL Tree Example
01:18 Computing Balance Factors
03:44 Adding Node 54
04:31 Recomputing Balance Factors
06:08 Detecting Imbalance at Node 78
07:20 Identifying X Y Z Nodes
08:36 Labeling X Y Z and Trinode Pattern
10:09 Output Pattern and BST Ordering
11:03 Handling Extra Children Nodes
14:50 Reattaching Rotated Subtree
15:24 Recalculating Balance Factors
17:05 Double Right Rotation Explained
19:18 Final Verification and Outro

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

https://www.NeuralLantern.com/social
Twitter / X: https://x.com/NeuralLantern
Rumble: https://rumble.com/c/c-3696939
BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
Daily Motion: https://www.dailymotion.com/neurallantern
Minds: https://www.minds.com/neurallantern/
Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

Buy me a coffee: https://ko-fi.com/neurallantern
Subscribe + Sharing on Social Media
Leave a comment or suggestion
Subscribe to the Blog: https://www.NeuralLantern.com
Watch the main “pinned” video of this channel for offers and extras

Hello there! Let’s maintain an AVL tree by rotating some nodes after we add a new node that messes up the whole tree.

Okay, I hope that before you watch this video you’ve seen my other videos where we talk about what is a binary search tree, how to define it, terminology, how to build a tree, search through the tree, all the stuff for the tree.

the tree all the stuff for the tree the binary search tree and then my other videos where we

talked about what is an avl tree what is a rotation what are the different types of rotations why would

you want to rotate how do you do the balance factors all that stuff happens in previous videos

so uh search the video history anyway so for now i’m going to assume that you know all that because

you watch the videos and now we’re looking at an a we’re looking at an avl tree maybe first we’re

a valid AVL tree and then we will add a new node which will probably mess the whole thing up

and force us to do a rotation to get the tree back in balance.

Okay so the first thing I’m going to do is just this is an example tree, it’s got some nodes

and I’m going to compute the balance factors for every single node just to double check.

Remember the rule that we’re using is if an AVL tree has a balance factor of two

for any node, then it’s considered invalid.

The tree itself is just a binary search tree,

not an AVL tree, until we fix the imbalance.

So the 44 node, wait, hang on, that’s actually wrong.

I don’t know why I even typed that number there.

Oh, because I was saying two.

First thing I want to do is do the balance factors

for the leaves, because they’re the easiest.

All the leaves have a balance factor of zero,

because they have no difference in left subtree

versus right subtree height.

The 50 node is also kind of easy,

because it’s left subtree and right subtree

left subtree and right subtree have the same height so that’s just a zero 17 is a little bit

more tricky it’s got one node hanging off the right side so its right subtree height is one

its left subtree height is zero so absolute value of zero minus one is just going to be one

so that’s not perfect but at the same time that’s acceptable we can just sort of move on remember

only two or worse is going to make us stop we look at the 78 again let me just uh or for the first

or for the first time we look at the 78 let me just do this the hard way to make sure everybody’s

on the same page uh for the for the balance factor of the 78 node we look at the height of the left

subtree uh which is two and then we look at the height of the right subtree which is one

and so if you take the absolute value of two minus one that’s going to be one

so actually the balance factor of the 78 node is okay this is maybe a good time to point out the

We don’t care that there are more nodes on the left. We just care about the height of the left subtree

So I’m going to duplicate this slide to continue so far so good every node seems to be okay

We’ll look at the 44 node. You can probably eyeball it because

Well, I mean for me when I want to eyeball a balance factors

I just look at the left subtree versus the right subtree notice how there’s like one level of difference

in height we could do it the hard way if we wanted to and

do it the hard way if we wanted to um so like the left subtree has a height of two right subtree has

a height of three so two minus three absolute value that’s going to be one or just that one

line that i drew before which was the the difference so that means this whole tree is

actually okay it is a valid avl tree nice video over i’m just kidding uh let’s add a node that

So I’m going to add the number 54.

Let me just try to select an existing node here, duplicate it.

I’ll change this to a 54.

Then we’ll figure out where the 54 node actually belongs.

Hopefully you’ve already become an expert at binary search trees.

So I’m just going to do it real quick.

We show up top here, 54 belongs on the right.

We look at the 78, it belongs on the left.

We look at the 50, it belongs on the right.

We look at the 62, it belongs on the left.

right there as the left child of the 62 node. So I’m going to go ahead and do my little connecting

line indicating that the nodes are now pointing to each other. The 54 thinks its parent is 62.

The 62 thinks its left child is 54. And now we have to recompute the balance factors.

So obviously the node we just added, it doesn’t have a balance factor, so we have to recompute

way up the tree until we hit the root node, recomputing all balance factors along the way.

We don’t actually, I’m going to do marks here to make sure that I don’t forget.

We don’t actually have to recompute, you know, the 17 or the 32 or the 88 because those nodes

are not possibly going to, or actually even the 48, because those nodes are not possibly going

to be affected by the 54 node because balance factors are only affected by nodes that are

or even nodes below wouldn’t be affected. So we’re only going to compute the 62, the 50,

the 78, and the 44, working our way up to the root node. Soon as we hit root, then we’re done

recomputing. So the balance factor for the 62, I’m going to eyeball that. That’s going to be a one

because left subtree height is one, right subtree height is zero. So far, so good. As soon as we

away. Again as I said in a previous video we probably will see that the root

nodes balance factor is bad but if we if we compute the whole tree and then just

decide I don’t know like the root node is going to be rotated we’ll probably

rotate incorrectly you want to rotate as low as possible first because rotating

lower in a tree is probably going to fix nodes that are higher. So recomputing the

balance factor for the 50 that’s going to be a 1 because left subtree height of

right subtree height of 2, take the absolute value of the difference there.

We go up to the 78 node and this one is going to be bad because you can see that the left subtree

has a height of 3 and the right subtree has a height of 1 so the bounce factor is going to be

a 2. It’s at this point since we just started by inserting the 54 and worked our way up that I

would stop and do a rotation but just for the purposes of this tutorial I’m going to compute

just to show you what’s going on.

The height of the left subtree off the root node is two,

the height of the right subtree is one, two, three, four.

So that means the balance factor of the 44 node

also has a two.

So at this point, it might be a little confusing

if you don’t remember that you kind of have to stop

as you’re working your way up

or at least rotate the lowest possible node first.

You might be confused, you know, which one do I rotate?

Do I rotate the 78 first or do they rotate the 44?

If we were to rotate the 44 first, the root node, you know, we could do it.

But at the same time, there’s a chance that it won’t actually fix the 78 node.

And there will be other stuff underneath that is bad.

And so it’ll cost us more work to do it that way.

So instead, we’re going to stop at the 78 and do our rotation.

So remember we said in a previous video that we’ll choose the first node that is out of whack as the Z node.

We’re looking for X, Y, and Z.

I’m going to write X, Y, and Z here.

X, Y, and Z.

Now, how do we choose Y?

We go down to a child of Z,

and it has to be the child that has the taller subtree.

Notice how the left subtree of the Z node has a height of 3,

and the right subtree has a height of 1,

which means we definitely need to go left to find the Y node.

So I’m going to put Y right here.

If the left and the right subtree had the same height,

then it doesn’t really matter which one you choose.

matter which one you choose. Maybe try to be consistent, but definitely we have to go left

this time because that’s the taller subtree. Again, look how tall it is. Okay, now we need to look for

the X node. Again, we have to take the left or the right child of the Y node, or just like a grand

child of the Z node. That is definitely a child of the Y node. We have to choose the taller subtree,

so we could not put X as 48. We can’t do that because that’s not the taller subtree. Instead,

Instead, the X is going to be the 62 node because that’s the taller subtree.

Now we have chosen our X, Y, and Z node,

which means I’m going to just type some stuff up here real fast.

I’m going to do X is equal to 62, Y is equal to 50,

and Z is equal to 78, just as a reminder.

And this is kind of similar to what you would do in the code.

I mean, on these diagrams, us humans,

we have to like rearrange things and name the types of rotations and so forth in the code it’s

actually really easy uh in comparison because all you have to do is produce an in-order representation

of the three node pointers that you received x y and z let’s say we have a function called rotate

we don’t even have to remember the types of rotations you just grab xyz and then you order

them and call them a b and c let’s do a equals something b equals something c equals something

So A is going to be the least value because again, this has to be a binary search tree

before it can be an AVL tree.

So 50 is going to go on the left.

That’s the only place that it could go.

And then 62 in the middle and then 78 on the right side.

And then I’m going to just, maybe I’ll copy and paste this here.

This little trinode subtree.

Was that, will that work?

Yeah.

So I don’t have to draw this again.

I’m going to erase some of this stuff.

Oh, come on, man.

I’m going to erase some of this stuff just to make it a little more neat.

just to make it a little more neat.

Then I’m going to replace the values in these nodes with just X, Y, and Z.

So, sorry, ABC.

So A is going to be 50.

That’s the leftmost node or the least value.

And then B is going to be 62.

And then C is 78.

Before you continue, make sure you’ve actually drawn a valid binary search tree,

because if you haven’t, then your AVL tree is not going to end up being valid either.

not going to end up being valid either it always has to be a valid binary search tree so the order

has to be correct so if you were thinking about well how can we can’t put the 78 in the middle

or how come we can’t put the 62 on the left what would have happened well it would have been invalid

or you would have ended up with like a straight line or something that wasn’t the target pattern

for a rotation which is supposed to be a perfectly balanced trinode subtree okay so now we’ve got x y

here which is going to basically take away from these three nodes the next thing we need to do is

take into account any nodes that come underneath nodes from the output pattern so our xyz i guess

you could say input pattern too let’s look at uh you know x for example so like the 62. did it have

any children that are not accounted for in the output pattern actually yes it has a 54 node so

this 54 needs to go somewhere we can’t just like erase it from the tree so i’m going to move it

to move it down here just so I don’t forget it. Then we look at the Y node. What children did the

Y node have? It had a 48 as a child and a 62 as a child. The 62 is actually already handled in the

output pattern so we don’t need to worry about that but the 48 was not handled so we got to put

that somewhere too. So I’m going to move that down here. Now we look at the Z node. The Z node

had 50 as a child, as a left child. That’s already handled in the output pattern so we don’t need to

don’t need to worry about that it also had 88 and that is not in the output pattern so we have to

do something with 88 so i’m going to move that down here too i should also point out um i think

in a future video i’m going to do a more complicated example where some of these nodes that are

children of the uh the output pattern they might have children of their own or descendants of their

own if they do don’t rearrange any of the descendants so anything that was below 54 just

hanging exactly where it was already off of the 54.

Same thing for the 48.

If it had any children of its own,

just leave them in place.

Don’t touch them.

Don’t touch any descendants.

So now that we’ve done this, whoops, dang it.

Let me copy this in a good way instead of a bad way.

Okay, let me erase this real fast.

X, Y, and Z.

Nope, that’s going to screw me up.

I’m going to forget.

Okay, now we have to place these nodes

nodes of the output pattern in their appropriate position like where do they

actually belong well remember this is supposed to be a binary search tree so

there’s actually only one place that the 54 node could ever go and still give us

a valid binary search tree so I mean think about it for a second could it go

on the left of 50 no could it go on the right of 62 no it has to go in between

the 50 and the 62 otherwise we wouldn’t have a valid binary search tree so I’m

there maybe a little bit lower to make this a more beautiful diagram then I’m going to do my

connecting line real fast so I’m going to do this so it’s the right child of the 50 now notice how

before it was the left child of the 62 so then you know again we’re just really disconnecting

pointers and then rearranging them so this 48 it can’t be on the right side of 62 it has to be on

the left side it can’t be on the right side of the 50 it has to be on the left side so the 48 must be

side so the 48 must be the left child of the 50. again you must end up with a valid binary search

tree or you’ve done something wrong so i’m going to just kind of do this here

um and then same thing for the 88 node there’s only one place this could go it can’t go on the

left of 62 it has to go on the right of the 78 it couldn’t go on the left of the 78 that would be bad

news so i’m just going to place this here and then uh just make a little connecting line okay

Okay, now I’m going to double check to make sure that I didn’t forget any other nodes

because when you’re working with a diagram, you might forget a couple of nodes and just

sort of like erase too many nodes without putting them in the output pattern.

If you’re rearranging pointers, it’s fine.

You wouldn’t have to worry about any nodes that came underneath these nodes because they

would just remain attached in place.

But I just want to double check real fast.

So we got X, Y, and Z.

So that’s three nodes and then four, five, six.

So we’ve got six nodes total if we include the XYZ nodes and all nodes that are direct children of those and even underneath.

So how many do I have in the output pattern?

1, 2, 3, 4, 5, 6.

So I’ve got the same number of nodes.

I’m ready to erase all this stuff up top and reattach.

1, 2, 3, 4, 5, 6.

Yeah, reattach this into the diagram.

So I’m literally just going to erase all this stuff right here.

Then I’m going to select all the nodes in the output pattern.

the output pattern and i’m going to move them up to be the new right child of the 44 because that’s

where originally the z was so i’m just going to maybe move these up here real fast and then get

that 32 back down where it belongs dang you 32 uh actually it’s a little bit too low get that

So the last step is we have to recalculate the balance factors to make sure that we have a valid AVL tree.

Maybe we have to do another rotation, maybe not, I don’t know.

Kind of looks like maybe not, but I’m not going to take any chances.

So let’s do the leaves first.

Remember, we have to recompute the balance factors for every node that we just moved.

So all the nodes in the output pattern and their immediate children, not anything lower.

all the leaves are just going to have a balance factor of zero that’s pretty easy.

The 50 is perfectly balanced nice so it’s going to have a balance factor of zero.

The 78 has one node hanging off the right and nothing on the left so it’s got a one there.

The 62 again we’re not looking at mass we’re not looking at weight we’re looking at the height of

the left subtree versus the height of the right subtree so this is actually perfectly balanced

because the height of the left subtree is 2 and so is the height of the right subtree.

we’re done with all the nodes that we just moved we should recursively or just kind of like walk

our way up the tree and recompute all balance factors until we find the root node. Okay so

there’s the root node only one more thing left to do. The balance factor of the root node is let’s

see left subtree has a height of two right subtree has a height of three so the balance factor for

the root node is going to be a number one. Notice how the 44 the root node got fixed because we

we rotate it a little bit lower.

And this is not the fastest tree in the world,

but it is considered a log tree

because the imbalance is only scaling

with a constant factor because we’re limiting

the balance factors to just the number one basically

before we rotate.

So what type of rotation did we actually perform?

If you looked at my previous video,

you should know this already,

but maybe I’ll duplicate this here

sort of start to maybe annotate it. I’m going to do…

Okay, so what is the rotation we did? Well, if we look at the ZYX here, the XYZ,

there’s a little bit of a bounce. Actually, let me do orange. There’s a little bit of a bounce,

right? So that’s going to be a double rotation. Or you can imagine that we had to move two nodes

and the 50 on the left and the 78 on the right. Notice how the 78 had to be rotated first.

So it’s like under the 62. And then the 50 was rotated second underneath. I mean,

we snipped off that 54 elsewhere. But long story short, there are two nodes that need to be rotated

into position for output pattern. So that’s a double rotation. So diagonal bounce or two nodes

means a double rotation and then is it a left or a right rotation well if you

think about the first node that we rotated it was the 78 what’s going on my

computer the first node that we rotated was 78 the Z node so what direction did

we rotate that that was clockwise so that’s a right rotation so a double

right rotation another way of looking at it is if we only look at the input

look at the input pattern we just look at you know these nodes right here there was kind of a

pocket of empty space on the right side wasn’t there so that’s why it’s a double right rotation

another way to think of it is I’m running out of colors if we started at the y node and worked our

way up to the z node we went up into the right so that’s a double right rotation also either way you

cut it we performed a rotation and now we have a pretty good tree okay let me just double check

Okay, let me just double check.

This is a valid BST.

Doop, doop, doop, doop, doop, doop, doop, doop, doop.

And it’s a valid AVL tree

because all the balance factors are okay.

Yeah, and in future videos,

we’re going to do more rotations.

I’m probably going to do at least like,

you know, two or three more videos

where we just simply rotate, you know, some tree

and explain it and work our way through it.

If you have an idea for a really gross tree

that you want me to rotate in front of you,

Binary Search Tree Removals – Delete Nodes with 0, 1, or 2 Children

mike — Mon, 11 May 2026 01:54:41 +0000

Hello there. In this video we break down exactly how to delete nodes from a binary search tree. We cover all three cases step by step: deleting a leaf node with zero children, deleting a node with one child by promoting it, and the trickiest case – deleting a node with two children using the in-order successor method.

You’ll see clear diagram walkthroughs, pointer manipulation explanations, and time complexity discussion for each type of removal. Perfect for computer science students, coding interview prep, or anyone strengthening their data structures knowledge.

We search for the node, identify its children, and handle the reconnection properly to maintain the BST properties. Includes examples for each scenario and tips for implementing in code.

If you’re learning BST insert, search, and now removal, this completes the core operations.

00:00 Introduction to BST Deletions
00:10 BST Review and Setup
00:46 Three Types of Deletions
00:56 Deleting a Leaf Node (Zero Children)
03:21 Pointer Manipulation for Leaf Deletion
05:25 Deleting a Node with One Child
07:17 Pointer Updates for One Child Deletion
10:09 Deleting a Node with Two Children
12:08 In-Order Traversal and Successor Concept
13:18 Finding In-Order Successor
14:20 Copying Successor Value and Recursive Delete
18:28 Deleting the Root Node Example
22:56 Additional One Child Successor Example
25:12 Time Complexity Summary
26:08 Closing and Outro

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

https://www.NeuralLantern.com/social
Twitter / X: https://x.com/NeuralLantern
Rumble: https://rumble.com/c/c-3696939
BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
Daily Motion: https://www.dailymotion.com/neurallantern
Minds: https://www.minds.com/neurallantern/
Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

Buy me a coffee: https://ko-fi.com/neurallantern
Subscribe + Sharing on Social Media
Leave a comment or suggestion
Subscribe to the Blog: https://www.NeuralLantern.com
Watch the main “pinned” video of this channel for offers and extras

Hello there. Let’s talk about deletions in a binary search tree.

Okay, so hopefully at this point you already understand binary search trees

in all other aspects than just deleting. If you don’t, see my other videos. In my other videos,

we talk about how to identify a binary search tree, all the rules that define it,

search tree with the insert or add operation.

We talk about searching through a binary search tree and time complexities

and even drawing the diagram in a really nice and pretty way so that your trees

are easier to debug.

So for now, I’m just going to say it’s time to learn how to delete notes from

a binary search tree.

So there are three types of deletions.

Actually, let me just kind of like, for example,

suppose you want to delete to delete the number 48 from the tree.

48 from the tree. Okay. Well, first you’d have to go search for 48. So already, you know,

this is going to be an O of H operation or log time. If the tree was perfectly balanced

or linear, if the tree was really poorly balanced. So we’re going to search for,

what did I just say? 48. I should write it down. Let’s say we’re going to search for 48.

We have to go search for it first. So that’s going to be O of H. Once we find it, we then

How many children does it have?

Is it a leaf with zero children?

Is it a node with one child?

Or is it a node with two children?

Each type of node is deleted in a different way.

So let’s see, the first type we would delete

is a node with zero children,

also known as a leaf, also known as a, sorry, external node.

The second type of deletion is a node with one child.

with one child and the third type is going to be the hardest type we’ll do that at the end of the

video it’s going to be a node with two children uh numbers two and three are going to be internal

nodes but i hope you already know that because you watch the videos anyway so let’s start off

with the easiest possible node to delete first just a regular leaf so i’m going to delete this

stuff real quick um and then just kind of like erase that and down and down okay so let’s identify

so let’s identify a leaf well it could be anything that just doesn’t have any

children of its own let’s do let’s do the number 11 just to make things a

little bit easier so let’s delete the number 11 I’ll put 11 here we first

search for 11 so we look at the root node 11 belongs on the left we look down

here 11 belongs on the left we look down here 11 belongs on the right we find 11

you know if we reach the end of the tree and we couldn’t find it then it’s like I

don’t know maybe throw an exception at the user hey you tried to delete

tried to delete something that wasn’t there but the 11 is there and now we have to figure out how

to actually delete it so let me draw a couple of larger representations of these nodes real fast

i’m just going to draw like a big old circle here and maybe duplicate it and we’ll just pretend that

that’s the 9 and the 11 so i’ll put like a tiny little 9 there because i don’t want to change the

And when we draw our diagrams, we usually just kind of do one line.

But you should know that if you’re doing this in code,

actually what’s happening is the nine node,

it’s got a right child pointer that points down to the 11 node.

And then the 11 node has a, let me just redo this real fast to make it prettier.

And then the 11 node has a parent pointer that points up to the nine.

This is probably going to be true for almost every language,

at least that I can think of that you would code a tree in.

a tree in. And then of course the nine would have a parent pointer to you know the 16 but we won’t

consider that. So what are you really going to do? Well first you have to look at the 11 node and

travel up to its parent and let the parent know that it no longer has a right child. So long story

short we’re going to null the right child pointer. We’re going to say disconnect that right child by

setting it to null. Maybe I’ll just put like a little null symbol here. Then we don’t necessarily

null the pointer on the 11 node because we can just delete the 11 node if we’re

using dynamic memory if we’re using a smart pointer it should go away already

at this point because it has no one else pointing to it but long story short

once we kill the 11 node we also end up killing its pointer so we don’t really

need to tell its pointer to point to null it’s just going to end up going away

it’s not going to be a memory leak because it was only pointing to the 9

and the 9 is not going to leak memory because the 9 is still going to be inside

going to be inside of the tree so uh the time complexity once we find the the leaf the node

with zero children is just going to be constant time we’re just going to manipulate a couple

pointers maybe call delete on that node so it’s really all about log time to go find the node if

it was perfectly balanced or just o of h to find it and then plus constant is going to get cancelled

out so it’s like an o of h operation or log time if the tree is perfect so let me just uh

cross it out to let you know that this is what it’s going to be like.

We’re going to say the 11 is just gone,

and so is the pointer that the 9 has pointing down to the 11.

That’s how you delete a node with zero children.

So deleted a leaf.

All right, now the next thing, which is slightly harder, but not too hard,

is deleting a node that has one child.

Long story short for this, we’re pretty much just going to…

oh I forgot to full screen the annotator let me do that to get myself a little more room

we’re really just going to promote its one child to wherever that node was so let me erase this

real fast and we’ll say that let’s first let’s find a node with only one child it’s not the 35

it’s the 32 node okay I guess that’s why I drew that so let’s kill the number 32

You know, if there was just like one child, like let’s say the 23 was the only node that existed

and there were no nodes underneath the 23, then this would really be the same operation. We would

literally just promote the 23 up to where the 32 was. But I wanted to do this example because it’s

a little bit more difficult. So we want to kill the 32. What we’re going to do is first search

for it. So this is already going to be an O of H operation or a log time if the tree is perfectly

We do, we go down here, we go down there.

You know, where is the 32?

We’re just searching for it.

So we had to spend the time to search for the node.

We then look at the node.

Okay, we found the 32.

We identify how many children it has.

We see that this is a node with only one child.

And that means the one child, which in this case is 23, just needs to be promoted up to where the 32 is.

just you know remove the 32 from the diagram maybe get rid of get get rid of one of these uh

connecting lines and then just move the 23 up a level and that’s pretty much it if you’re thinking

about this in terms of code uh you you want to have let’s see let me duplicate this again in a

different way if you’re thinking about code what you want to do is have the 32 which is the node

you’re going to delete go to its child so determine if it’s the left child or the right

or the right child that exists once you find that child you tell it that its new parent is the

parent of the node you’re trying to delete so that means the parent of the 23 is no longer 32 the

parent of the 23 is actually 35 you know it’s its original grandparent or the the parent of the node

you’re trying to delete after you do that you tell the grandparent that it’s no longer pointing down

to the node you’re trying to delete but instead to its grandchild so again we’re just going to

So again, we’re just going to manipulate some pointers here.

We’re going to say, yep, your left child is now the 23 and not the 32.

Notice how we’re kind of, you know, drawing arrows around the original node.

We’re sort of cutting it out of the situation, just like in a linked list where you remove one node.

And this is going to be a constant time operation, at least after we search and find the 32 node.

Finally, of course, you want to like delete the 32.

you have in your tree you would call delete on it depending on your language and then uh if it was

a smart pointer uh as soon as no other nodes are pointing to the 32 it’s just going to go away so

you don’t really have to worry about it but yeah long story short uh notice how the 23 is actually

the new left child of the 35 so that’s why i say that the the uh the one child that was on the 32

is going to get promoted uh to wherever the 32 was wherever the node you wanted to delete was

this will be the same whether or not whether it’s the left child or the right child in terms of what

is the one child that the node had and also you know how do you decide how to tell the the

grandparent is its left child pointer going to be changing or is its right child pointer going to be

changing well you know when you originally looked at that 32 and you’re about to delete it you could

tell that it had that it had one child based on its left pointer and right pointer one of them

pointer one of them was null and one of them was not so whichever one of them was null that tells

you the direction that the grandparent should be pointing so in this case the 32 had a left child

pointer that was not null and a right child pointer that was null because there was no right child

so that’s why we told the grandparent that its left child pointer is now the 23.

and that’s it for deleting a node that has one child okay so uh i’m going to go ahead and delete

one more time and we’re going to do the deletion of a node let me let me write down you know deleted

a node one child yay we did it you guys um okay i’m gonna put that there too just for my notes

so this is going to be the hardest uh part we’re going to try to delete a node that has two

children maybe i’m first going to delete the uh the 35 nodes since that’s kind of where we’re

node since that’s kind of where we’re hanging out lately and then we’ll delete the hardest node of

all the 41 nodes so the first thing we need to know before we can get ready for deletion is

the in order traversal sequence of the data in this tree if you’re watching this video as soon

as i published it then i i don’t have videos up yet on traversal i’m going to upload those soon

then you can just check out one of my traversal videos.

But long story short,

in order traversal just means produce a sorted list,

an ascending list or a non-decreasing list

based off the data that’s inside of the tree.

So, you know, if I put this down here,

I can just say, you know, looking visually

from left to right, this is why I draw my trees in this way.

I see a six and then a nine and then an 11

and then a 16 and then a 19 and then a 23

and then a 29, no, no, no, a 26, and then a 29, and then a 32, 35, 38, 41, 43, 48, 52, 59, 67,

73, and 79. Let me just double check that I’ve done this correctly. The numbers seem to be

to be increasing or at least not decreasing.

Let me just double check.

Okay, how many do I have?

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19.

I already got lost.

I think it’s 19.

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19.

Okay, did it right.

list, an ascending list of the original data that was inside of the tree. And now we need to look

at a concept called in order successor. Successor comes after, predecessor comes before. Think of

like a king and a prince, right? The prince is the successor to the king. Eventually one day when

the king grows very old and becomes grandpa king and the prince grows up and becomes the regular

king, then you would look at the prince king and you would say, who was your predecessor? Well,

grandpa king right so whoever comes before his predecessor whoever comes after is the successor

so we want the in order successor of the node that we wish to delete so I can’t remember what

I said originally but let’s just say we’re going to delete the 35 node I should have written it

down let’s delete the 35 first we have to find the 35 itself to make sure it exists in the tree

so I’m going to look at the 41 I’m going to go left to the 16 I’m going to go right to the 35

We found it in O time in the worst case.

So this is obviously not going to be the fastest operation, but you know, all the ops are kind

of the same speed in a perfectly balanced binary search tree, not empirically, but in

terms of time complexity.

So we found the 35, we identified that it has two children.

So then what we have to do is find the in order successor.

What is the in order successor of the 35 node?

list 35 here and it appears to be 38 and that actually makes sense because since the data in

the tree is going to look sorted if you sweep your eyes from left to right assuming you drew

the diagram well you’re really just looking for the the node that is as close as possible

to the node you wish to delete but happens to be to the right of it there are some tutorials out

there that use the in order predecessor so that would mean the 32 would be the one you select

I like to do successor.

So first we find the 35,

then we find it’s in order successor.

We’ll do another delete maybe next of the 16 node

because that’ll be a little more difficult.

Once we find the in order successor,

we’re actually just gonna copy the data up into the tree.

So I’m gonna, sorry, up into the node we want to delete.

So that means I’m gonna take this 35

and it no longer has 35 as its value.

as its value. Instead, we’re going to steal the value of its in order successor. So 35, sorry,

38 up here. So now we have two 38s in the tree. That’s bad. We need to recursively delete the 38

node. It’s not really a recursive delete. It’s more like you’re inside the remove function or

the delete function or whatever you chose to call it. It’s usually remove. And after you’ve copied

of the in order successor to the node you actually wanted to delete then you call delete or remove

again on the the in order successor you probably want to use a pointer to that node or have some

sort of a way to reference that node without telling the tree to start deleting from the top

again because if we say if we just call tree.remove with the number 38 it’s going to actually find the

38 on top and that’s going to be no good because then if you’ve written your code correctly

uh at least after that point then it’s going to find the 38 and copy its value up

and then it’s going to happen all over again we’re going to just be stuck in an infinite loop

um so instead you want to have like a pointer to this node or a reference to this node

and then call a removal function or a delete function that can receive just like you know

a reference or pointer directly to that node and then if you notice the number 38 node

So there’s actually a guarantee that when you find the in-order successor, it will only have zero or one children.

It’s absolutely impossible, unless your tree is super messed up in some way, that the node would have two children.

Because if it did, then you have not gone far enough to the left towards the node you’re trying to delete.

Remember we said we need to find the node that is as close as possible to the node that we want to delete, but just like on the right side.

the 38 had a left child then we would actually want to follow the left child we wouldn’t stop at

the 38 node so it’s impossible for the node to have two children which means it’s going to end

up being an easy deletion so the first thing we do is we’re we’re saying let’s delete a node with

two children that’s the 35 we find it’s in order successor we copy its value up and then we call

delete again or remove again on this in order successor which is guaranteed to just be an easy

leaf removal or a node with one child removal where we just like you know promote its child up

and that’s it so let me uh let me duplicate this real fast and uh let me say also that everything

we just did was basically all it’s just going to be o of h because it’s going to be o of h to go

find the node in the worst case and then o of h to find its in order successor uh some fraction of

each you know o of h fraction o of h fraction but when you just combine them it’s just going to be

It’s just going to be O or log time if it’s a perfectly balanced tree.

And then once we find the in order successor and the node we want it to delete, it’s just

a matter of like just copying data and maybe doing the second delete.

So, you know, the second delete itself would just be like another O or log time.

So you probably know at this point that if you have two times log of N, it’s just going

to cancel out to log of N if we’re talking about big O time complexity.

time complexity. Anyway, so I’m going to duplicate this one more time and then revert everything

to scratch to scratch here or to the very beginning again. So we can delete something

that’s a little bit more difficult. Whoops, that’s bad. Can I get this? Nope. Can I get

that? Yes. Okay. So let’s delete that 16 node. So we can look at how you might find the in

order successor in a program because you don’t want to like traverse the whole entire tree and

produce a giant list and then scan the list and then like find the successor and then once you

know the number go search for the for the node that’s like going to be way too slow the tree

should be way faster than that so instead this is kind of how you do it let’s search for the 16 first

so we do like 41 16 belongs on the left side we found the 16 now we have to find the 16s in order

successor the one that comes after you can tell just by eyeballing it that it’s going to be the

eyeballing it that it’s going to be the number 19, right? But how do we find that number in the code

to make it a little bit faster? So again, 16 and 19, they’re just paired up right there.

Well, first you just take a hop to the right. So you look at the right child, if it exists.

If it doesn’t, then you have not tried to delete a node with two children. It was definitely a

node with the one child at most. So we take a hop to the right to find its right child.

as far down as you can possibly go until you reach a dead end.

So that means I’m taking a hop to the right and then I’m just going to go.

Maybe I’ll do like another color here.

I’ll go left child pointer, left child pointer, left child pointer,

as far down as I can possibly go. And that is the successor.

Notice how that’s the 19. Again,

if the 19 had a child on its left side,

we would have to follow it down further,

which means it’s guaranteed that you will stop at a node that has no left child.

no left child if it had a right child same situation it’s still going to be the in order

successor that just but that just means when we call a remove a second time on that node it’s

going to be a leaf that gets removed and not a node with one child so it’s just pretty easy let

me uh let me say that now that we’ve found the in order successor we’re just going to copy the value

so i’m going to do maybe i’ll put this in orange so this 16 is no longer in that particular node

no longer in that particular node we’re not even deleting that node we’re just stealing a value

from a different node we’re going to steal the 19 value from the node which is the in order successor

and now that we’ve done that we’ll use our reference to the 19 node to call remove on it

specifically so when we call remove or delete it’s basically going to say all right what sort

of node is this um it’s not even going to have to search for the node because you gave a point

you gave a point to the node or a reference to the node it’s going to go oh this is a leaf node

that’s easy i just tell the 23 that it has no left child anymore and then i just actually

deallocate the 19 node or if it’s a smart pointer let it die on its own anyway let’s do something a

little bit more difficult now so i’m going to duplicate this and try to revert all this stuff

Okay, okay.

Let’s delete the root node, the hardest node of all, the 41.

Okay, so if we want to delete the 41 node, I’m just going to put 41 here so I don’t forget.

First, we search for 41.

In the worst case, you know, it would have been O of H, but we were lucky.

We just found it right away.

Now we have to find the in-order successor for the 41.

So again, take a hop to the right and then follow left child pointers as far down as you can possibly go.

go so we’ll look at the 48 here and then we’ll look at the 43 now we’ve hit a

dead end and we know that the in-order successor for the 41 is 43 and that

makes sense because they’re paired up here in this sorted list at the bottom

so then the next thing that we do is we just copy the data you know we steal the

data from the 43 so I’m gonna cross out this 41 here and it’s gonna end up

and then we call delete a second time or remove a second time on the actual 43 which is another

easy removal because it could not possibly have two children it’s only going to have zero or one

children and well that’s pretty much it it’s just going to be just so fast and easy so that means

the 43 is gone when we’re finished here if you look at all the slides in this video you’ll notice

notice that the data is still ordered correctly so we do have a valid binary search tree even after

we kind of do this weird data stealing let me see if i can find something that would have had one

child so i want to look through the whole tree and see if i can find a node that has one child

that would make a good in order successor and if i can’t find one i’m just going to manufacture

one real fast let’s see um who has a right child only no one has a right child only that sucks

child only that sucks all right uh let’s say we want to delete the root node again

and i think last time we just said it was the 43 how about we uh that’s boring let’s delete the 59

okay so i’m going to uh write 59 up here so i don’t forget and then we’re going to add another

node real fast so that the 50 uh sorry the 67 has a right child why am i doing this because the 67

order successor of the 59 node. So I’m just going to draw like another line real fast like that.

And I’m going to update some number. Let me just say 70 is going to be the number in that node,

which is double check that it’s increasing 59, 67, 70. Okay. So we want to delete 79,

sorry, 59. The first thing we do is we go find the 59. So I’m going to

take off my line tool. Okay. So we’re going to go to the root 59 belongs on the right side.

59 belongs on the right side so we find the 59 there it is now we’re looking for the in-order

successor we go to the right side and then we follow all left child pointers until we hit a

dead end left child pointer dead end already because i mean there is a right child but we’re

supposed to be going down left child pointers there is no left child pointer so we’ve hit a

dead end so that means the 67 is the in-order successor of the 59 which means we’re going to

67 data and put it where the 59 data was. So again, we’re not really deleting the node that

had two children. We’re going to eventually delete the node that had one child, the successor.

But 67 is the number that’s going to be there. And then we call delete on this 67. And what’s

going to end up happening is our removal function identifies that that 67 had one child. And so what

one child which is the 70 node just one level higher where the 67 was so that means the uh

the 67 is just gone we do actually delete that and then the 70 node is going to be the new

left child of the 73 node notice how the data still makes sense okay i think that’s all i’ve

log time operation just one more time log time if the tree is perfectly balanced it’s a little bit

closer to linear time as the tree becomes more imbalanced if this was a self-balancing tree then

you know this would be like log time in terms of worst case scenario in general we’ll say that this

is still on average if we had just totally random data and totally random deletions on average this

would be you know a log time operation even if we do log down to find the node and then another

uh down to find the node and then another log to find the successor that’s still not going to be

you know worse than log or o of h in general okay that’s all i’ve got for you thank you so

much for watching this video i hope you learned a little bit of stuff and i hope you had a little

bit of fun i need to see if someone is selling pi at this hour going on a searching thing

Hey everybody!

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website

that you’re looking at right now.

It would really mean the world to me and it’ll help make more videos

and grow this community.

So we’ll be able to do more videos, longer videos, better videos,

videos or just I’ll be able to keep making videos in general so please do do

me a kindness and and subscribe you know sometimes I’m sleeping in the middle of

the night and I just wake up because I know somebody subscribed or followed it

just wakes me up and I get filled with joy that’s exactly what happens every

single time so you could do it as a nice favor to me or you could you control me

if you want to just wake me up in the middle of night just subscribe and then

I’ll just wake up I promise that’s what will happen also if you look at the

you look at the middle of the screen right now you should see a QR code which you can scan

in order to go to the website which I think is also named somewhere at the bottom of this video

and it’ll take you to my main website where you can just kind of like see all the videos I published

and the services and tutorials and things that I offer and all that good stuff and

if you have a suggestion for clarifications or errata or just future videos that you want to

just want to say hey what’s up what’s going on you know just send me a comment whatever i also

wake up for those in the middle of the night i get i wake up in a cold sweat and i’m like

it would really it really mean the world to me i would really appreciate it so

again thank you so much for watching this video and um enjoy the cool music

as as i fade into the darkness which is coming for us all

Thank you.

Hello there.

Let’s talk about.

The post Binary Search Tree Removals – Delete Nodes with 0, 1, or 2 Children appeared first on NeuralLantern.com.

BST Terminology: Root, Leaves, Subtrees, Depth, Height, Ancestors & More

mike — Mon, 06 Apr 2026 09:25:41 +0000

Quick but thorough run-through of binary search tree terminology: root, leaves, internal nodes, subtrees, depth, height, ancestors, descendants, siblings, left/right child – everything clearly labeled on a working example.

Great for beginners, interview prep, or reviewing foundational BST concepts before coding insert/search/delete.

00:00 Introduction to BST Terminology
00:28 Root Node
01:10 Ancestors and Descendants
01:58 Children, Grandchildren, and Siblings
04:07 Internal Nodes vs External Nodes (Leaves)
05:34 Understanding Subtrees
06:09 Left Subtree and Right Subtree Examples
08:34 Depth of a Node
11:02 Height of the Tree
12:48 Height of Subtrees
17:32 Node Structure and Pointers Overview
18:12 Closing Remarks and Call to Action

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

https://www.NeuralLantern.com/social
Twitter / X: https://x.com/NeuralLantern
Rumble: https://rumble.com/c/c-3696939
BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
Daily Motion: https://www.dailymotion.com/neurallantern
Minds: https://www.minds.com/neurallantern/
Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

Buy me a coffee: https://ko-fi.com/neurallantern
Subscribe + Sharing on Social Media
Leave a comment or suggestion
Subscribe to the Blog: https://www.NeuralLantern.com
Watch the main “pinned” video of this channel for offers and extras

Hello there! Let’s talk about binary search tree terminology. If you saw my

previous video we talked about how to define a binary search tree meaning a

whole bunch of rules so that if the thing you’re looking at follows all the

rules then you know you’re actually looking at a binary search tree if not

then not. So see my previous video if you want to know for sure whether you’re

looking at a binary search tree. For now we’re just going to talk about some

Okay, so the first thing we should probably obviously talk about is the root node over here.

So I mean, well, in my previous video, we talked about nodes, right?

So this is kind of a graph with a whole bunch of rules on top of it.

That means we have nodes and edges.

So if you look at the very top node here, sometimes also referred to as a vertex,

I think in binary search tree terminology, we usually say nodes.

We usually say nodes. I can’t actually remember. But so look at the 42 there

That node is the root node of all other nodes. It’s the highest common ancestor in the entire tree. So this is the root node

First bit of terminology. Also, I tried to sneak past you ancestor

So these trees are supposed to be written in a way that kind of looks like they have a family hierarchy with one parent per

like not two children per parent, but just like one parent and then either zero or one or two

children. So we’ll say that ancestors are higher on the tree. So that means 42 is actually an

ancestor of 33. And it’s also an ancestor of 12. It’s also an ancestor of 19. Just anything that’s

higher is an ancestor of anything that’s lower. We could also say that 33 is an ancestor of 39

and 19 and so forth. You can probably also imagine that we have children and grandchildren. Yeah,

we do go that far in binary search trees. So the 42 node, it has two children. It has a left child

and a right child. The 33 is the left child. I’ll put LC for left child. And the 67 is its right

child. I’ll put an RC there. The 67 in turn has two children. The 56 has no children of its own.

the 33 has two children the 12 only has one child it was you know playing it safe i guess

you never know if these children are going to come out and just like run amok

and and engage in constant shenanigans so the 12 has a right child but no left child that’s okay

um in terms of going higher on the tree anything that is higher is an ancestor sorry i should have

said lower anything that’s higher is an ancestor anything that’s lower is a descendant so if we’re

If we’re looking at the 33 node, the 33 is a descendant of 42 because it’s the left child of 42.

It’s also an ancestor of anything that comes below it.

So it’s an ancestor of 12 and 39 and 19, right?

So if we’re looking at 33, we’ve got a left child over here and we’ve got a right child over here.

And then we have a grandchild, which is the 19 node.

We don’t really have left and right grandchildren.

You could say a grandchild in the left subtree or the right subtree.

subtree talk about sub trees in a second the 33 has a parent node which is just the 42 node

which is also the root node of course it’s got a sibling the 67 is the sibling you can tell

something’s a sibling because it’s got the same parent as you it’s the people that you’re usually

fighting with right anyway so if we’re looking at any node in particular it might have a whole bunch

of ancestors above the tree it might have a whole bunch of descendants below the tree

It has siblings or it usually has zero or one sibling because in a binary search tree,

we can only have up to two children per node.

It’s got sometimes, you know, grandparents and great grandparents and children and great

grandchildren.

So just think about the hierarchy like a family tree would have.

Okay, moving on to some more terminology.

Next thing is we have internal nodes and also external nodes.

So what do I mean by internal? Internal means a node has more than zero children. It has one or two children.

So I’m going to put internal on the 33 because the 33 node has children.

The 12 also has children, so it’s internal. The 39 does not have children, so it’s not internal.

67 has children, so it’s internal. And the root node, 42, also has children, so it’s considered internal.

That 42 has a lot of different names.

It’s the root node, it’s the greatest common ancestor,

it’s an internal node and so forth.

Notice how the other nodes that I have not highlighted,

they have zero children.

So when a node has zero children,

it’s known as an external node.

It’s also known as a leaf

because we’re talking about trees

and I guess it’s kind of like a nice synonym.

So the 19, the node with no children of its own is a leaf.

So is the 39.

So is the 56.

So is the 76.

I just want to point out also, if you were with me on my last video,

then the numbers need to be ordered from left to right.

But don’t worry, we’re going to do another video where we build a complete tree from scratch.

There’s some more terminology we should talk about.

So I’m going to get rid of all these externals and internals real fast.

Or the labels.

We should talk about the left subtree versus the right subtree.

left subtree versus the right subtree i mean what is a subtree anyway the subtree is basically

a subtree is basically just pick any node you want in the entire tree let’s pick

the 76 and then we’ll just pretend that it’s the root node of a separate tree starting with 76 so

if there was anything below it then all those nodes would be included so this 76 right here it

really has nothing underneath it it’s a leaf which means well it can be the root node of its own

the subtree is just going to be a tree of one node.

So kind of boring, right?

You’re boring.

If instead we decided to look at the 33,

which is a little bit more interesting,

and we called the 33 the root node of its own subtree,

then really what we’re saying is all these nodes here

are included in that subtree.

So if I told you, give me the subtree starting with node 33,

then you would say, oh, it’s 33, 12, 39, 19.

descendants of the subtree root node that we picked out. So subtree just means, you know,

like a little fragment or a portion of the original tree. You could also say that the

entire tree is a subtree of itself. If you chose the subtree root to be the real root node, I mean,

that’s not super useful, but you can do it. Anyway, so if we decide to say that the 67 is the root of

with 67 and below in terms of descendancy is going to be considered part of the subtree.

I’ve highlighted the left subtree and the right subtree of the root node because that’s usually

what we say. We’ll say this is the left subtree over here and then over here we’re going to say

this is the right subtree. Meaning if you look at any node at all, if it has a left child,

then that left child is the root node of the left subtree of the node in question. Same thing for

same thing for the right so if I say all right let me duplicate this real fast

let me get rid of actually this real fast too if I say okay give me the left subtree of the 33 node

well then you would know to include the 12 and the 19 because the left subtree of the 30 node

has to the 33 node has to start with the left child of the 33 node which would be the 12 and

And we’ll just say, okay, the 12 is now the root node of its own subtree.

And then anything that goes below it in descendancy is going to be considered part of that subtree.

So that highlighted subtree is the left subtree of the 33 node.

The 39 is the right subtree of the 33 node.

I think I just did the wrong color.

Let me do that in gray.

Right, so we can do left subtree and right subtree for any node in the entire tree.

if a node has no children, then there are no subtrees, but we can still look and check.

And if there are children, then we’ve got subtrees or left and right subtrees.

Okay, so now that we’re done talking about subtrees real fast, let’s talk about the depth of a node.

So for me, I like to say that the depth of the root node is zero.

And so I’ll just, I guess we could start off by putting a zero on the 42 indicating it has zero depth.

It has zero depth.

Imagine maybe it’s a buoy in the water and it’s just like sitting, floating like directly

on the water.

So it has no depth.

It’s just like kind of on the surface.

But if you draw your binary search trees in this nice pretty way where every single time

you go down a generation from parent to child, from parent to child, you maintain, I guess,

like the same Y coordinate for same leveled nodes, then it’s really easy to calculate

the depth of every single node.

of every single note let me show you what show you what i mean real fast you saw my video uh

previously then you already know this but the 42 it’s got two children so if i go down to get one

of its children i’m going down to the 33 and then i’m going down to the 67 right since those two

children are on the same i guess level as if we were looking at a family tree they should be

physically on the same level they should be on the same y coordinate or the same horizontal plane

plane if we go down one more level which means any child of 33 or any child of 67 then those all

should be lined up also so notice how these are all lined up on the same y coordinate then if we

go down another level then this 19 here is just kind of by itself because the tree is not very big

so if we draw the tree like this which is a really smart way because uh it’s easier to debug

whether it’s a valid binary search tree and all sorts of other things,

then we can easily write down the depth kind of on the side of the graph.

We can say, all right, here’s depth zero, and here’s depth one,

and here’s depth two, and here’s depth three.

Just every time you go down one level, you just increase the depth.

And now you know the depths of all the nodes in the entire tree pretty quickly.

The 19, I’m just going to maybe do this in red.

the 56 and the 76 have a depth of 2, the 33 has a depth of 1, and the 42 has a depth of 0.

So all these trees, sorry, all these nodes in the tree have their own depth,

which are very easy to calculate if you draw the tree well. The next thing after depth is the height

of the tree. So what is the height of the tree? Well, that’s basically the depth of the deepest

to the very deepest node what is the minimum number of nodes that you must touch when you

start at the root node and then find your way to the deepest possible node in the entire tree so

um if you if you notice the 19 node is definitely the deepest node in the entire tree

it’s got a depth of three which means the height of the entire tree is four heights

equals four and maybe i’ll change that to like just black or something okay

So, let’s do it the other way real fast.

If we’re kind of just walking down the tree, let’s start at the 42 and then we go down

to the 33, we’ve touched two nodes so far.

We go down to the 12, we’ve touched three nodes.

We go down to the 19, we’ve touched four nodes.

So the height of the tree is four or the number of nodes that you need to touch as you make

your way down towards the deepest node or just a shortcut is the deepest nodes depth

plus one.

And that’s the height of the tree.

you can also have a height of a left subtree and a height of a right subtree so let me just

what’s going on here i think my thing is crashing hello oh i was definitely crashing i think my cpu

is burning right now all right i’m going to be complaining about my new cpu for a long time

i sprung only a few bucks for the best cpu that this motherboard could hold but it’s an old

something percent um i’m eventually going to have to like build a brand new computer

anyway so uh suppose we’re looking at the 67 node and the question is you know what is the height

of the left subtree of the 67 node versus the right subtree of the 67 node well if you recall

the left subtree is just all the nodes that are included uh beginning with the root node of the

subtree of the 67 node well that’s just the 56 node totally by itself what’s the right subtree

of the 67 it’s just that 76 node all by itself what’s the depth of 56 and 76 they’re both depth

zero if we’re talking about relative depths per their subtrees that means what is the height of

the left subtree and the right subtree they’re just one because the depth is zero the maximum

depth is zero and if we want to get to the deepest node in one of those subtrees we’re just

end up touching the one node that’s in the in the subtree at all so that means uh

uh i don’t want to write down uh left subtree height right now so left subtree height of 67

is one right subtree height of 67 is also one so we can do this with any node we want you know what

is the uh what is the situation with the 33 node let’s do uh the 33 node yeah uh it has a left

It has a left subtree height of 2 and you can tell because, well, the left subtree starts with the left child and the left child is going to be the root node of its own subtree.

Notice how the maximum depth we can find here is 1, right?

Like if we start at depth 0 for the 12, considering like it’s a relative depth, that means we take the deepest node, which is the 19 node, which has a depth of 1.

We add 1 to that.

So that means the height of that subtree is 2.

if you wanted to find the deepest node in that whole subtree, how many nodes would you have to

touch to get there? We’d have to touch the 12 and then touch the 19. We touch two nodes, so the height

of that subtree is two. Maybe I’ll just put H equals two here. So now for the right subtree of

the 33 node, it’s kind of easier. We just basically only have one node to really look at.

that means that 39 has a depth of 0 and the right subtree has a height of 1.

Whoops, 8 equals 1.

I didn’t put two equal signs. I like to do two.

I like to do the comparison operator.

We could also do the same thing with the 42 node, right?

We can say, let’s get rid of all this stuff real fast.

We can do the 42.

Its left subtree starts with that 33 node.

33 node so I’m just going to highlight that real fast the 42 nodes left subtree has a height of

one two three and you can tell because the 33 has a depth of zero a relative depth of zero and

the 12 and the 39 have one and the 19 has two so the deepest node has a depth of two

so that means the height of that subtree is is three so I’m just going to like do this real fast

and then the right subtree of the 42 node, the root node of the entire tree, is going to be this.

So the root node has a depth of zero, depth of zero, and then these other leaves over here have

depth of ones, which means the height of this subtree is going to be two, or the deepest node

plus one, or the number of nodes you need to touch to find the deepest node. And 56 and 76,

those are both equally the deepest node in those trees okay so we talked about a bunch of

terminology here let me just double check my notes in case I forgot to to tell you anything

I think I’m all right well maybe okay maybe I should real fast just briefly mention that these

nodes I mean this is not really part of the video exactly but let’s let me just mention that these

whoops that’s dumb let me do a blue circle they would have you know there’s

like some sort of an object you would call it a node and then they would have

pointers they would have each of these nodes would have a pointer to its

parents and it would have a left child pointer that goes down into the left and

a right child pointer that goes down to the right and also a little slot in that

object for the data so I’m just going to put t type data and C++ I usually say

I usually say that the templated data type for a node or data structure is just the T type.

That just means you could put anything you want.

You could have your nodes hold integers, letters, strings, custom objects, whatever you want to do.

And we’ll talk about this more in future videos.

But long story short, I want you to just imagine that every node actually has three pointers inside of it pointing to something else, to other nodes,

graph because in a graph you could have like a whole bunch of different connections and that’s

usually managed by the actual graph object itself so anyway we’re done with terminology i hope you

learned a little bit of stuff and had a little bit of fun thanks for watching this video

tell your friends eat a donut and a chocolate and then be really happy and stuff okay i gotta go

Hey everybody!

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website

that you’re looking at right now.

It would really mean the world to me and it’ll help make more videos

and grow this community.

So we’ll be able to do more videos, longer videos, better videos,

or just I’ll be able to keep making videos in general so please do do me a

kindness and and subscribe you know sometimes I’m sleeping in the middle of

the night and I just wake up because I know somebody subscribed or followed it

just wakes me up and I get filled with joy that’s exactly what happens every

single time so you could do it as a nice favor to me or you could you control me

if you want to just wake me up in the middle of the night just subscribe and

then I’ll just wake up I promise that’s what will happen also if you look at the

at the middle of the screen right now you should see a qr code which you can scan in order to go

to the website which i think is also named somewhere at the bottom of this video and it’ll

take you to my main website where you can just kind of like see all the videos i published and

the services and tutorials and things that i offer and all that good stuff and uh

if you have a suggestion for uh clarifications or errata or just future videos that you want to see

say hey what’s up what’s going on you know just send me a comment whatever i also wake up for

those in the middle of the night i get i wake up in a cold sweat and i’m like it would really it

really mean the world to me i would really appreciate it so again thank you so much for

watching this video and um enjoy the cool music as as i fade into the darkness which is coming for us

Thank you.

The post BST Terminology: Root, Leaves, Subtrees, Depth, Height, Ancestors & More appeared first on NeuralLantern.com.

Master Stacks: Fun Guide to Data Structures, LIFO & Real-World Uses

mike — Sun, 20 Jul 2025 09:15:59 +0000

Want to nail down stacks? This beginner-friendly video breaks down the stack data structure with clear diagrams and a laid-back vibe. We’ll walk you through how stacks work, why they reverse data (hello, LIFO – Last In, First Out), and how they’re used in real-world stuff like browser history, undo features in editors, and even the call stack in your code. Whether you’re just starting out or brushing up on data structures, we keep it simple with hands-on demos of pushing, popping, and checking stack size—no boring jargon here! Subscribe for more coding tutorials to level up your skills, and let us know in the comments what you want to learn next. Check out our site via the QR code in the video for more coding goodness!

Introduction to Stack 00:00:00
Explaining Stack Concept 00:00:06
Drawing Stack Diagram 00:00:30
Adding Elements to Stack 00:00:53
Stack Rules and Operations 00:01:16
Pop Operation and Interface 00:06:09
Stack Size and Empty Check 00:07:59
Tracing Stack Operations 00:11:46
Stack as Data Reverser 00:17:44
LIFO/FILO Explanation 00:21:13
Stack Use Cases 00:24:10
Call Stack Mention 00:26:18
Conclusion and Subscribe Request 00:27:21
Outro and Website Promotion 00:28:34

Thanks for watching!

Find us on other social media here:

https://www.NeuralLantern.com/social

Please help support us!

Subscribing + Sharing on Social Media
Leaving a comment or suggestion
Subscribing to our Blog
Watching the main “pinned” video of this channel for offers and extras

Hello there.

In this video, I’m going to show you a data structure called a stack.

We’re going to make a diagram of it.

We’re going to explain how it works.

We’re going to look at its typical interface,

and we’re just going to kind of work through the concept

of what is a stack and what does it do and all that stuff.

Where’s your daddy and what does he do?

So for starters, what am I talking about?

What am I talking about?

Let me open up a little notepad here.

And I’m going to start drawing.

A stack is pretty simple when you first think about it.

It just takes a little bit more work to really get all the details down.

Imagine I have a data structure and maybe like at the bottom here,

there’s like some grass.

And so we can say that the data structure is empty when we first start.

Okay, so there’s kind of a stack here, but it’s empty.

So there’s nothing really on screen.

Imagine then I wanted to add integers into this stack.

So I’m going to say let’s add the integers eight and then two and then three and then four for some reason.

Okay, so how do we do this?

The first thing we do is we take the eight and we just put it on top of the stack.

You can imagine this as a stack of boxes or a stack of books or a stack of whatever.

When we add items, we’re always going to add to the top of the stack.

When the stack is empty, we’re obviously just going to add like at the very bottom, you know, at the ground floor.

But that’s sort of the top.

when we add the two here the next thing that happens is we just put the two on top of the eight

and the next thing that we do is we uh put the three on top of the two and so forth right so

it’s important to understand a few a few rules about stacks let me add that four real fast

in stacks you’re only allowed to add to the top or remove from the top you’re not allowed to add

or remove from anywhere else let me put a t for top right here so basically you’re allowed to add

So basically you’re allowed to add and remove from the top.

So if I wanted to add, let’s say a 12, the 12 would have to go on top of the four.

It couldn’t go anywhere else in this data structure.

And if I wanted to remove data from this stack, I could only remove the four.

I could not remove the three or two or the eight or anything.

You’re also not allowed to look at the middle of the stack.

You’re not allowed to look anywhere but the top.

So if I wanted to look at the three, the two or the eight, I wouldn’t be allowed to do it.

I can only look at the four.

look at the four and if I want to see that three I have to pop the four off

first in order to just see what’s under it and technically unless you have the

data you added memorized somewhere else you probably shouldn’t know what’s under

the four until you actually remove it okay so we can add and remove from the

top we can’t look in the middle we can’t look at the bottom or anything like that

and let’s do a little let’s do a little sequence of pops let me show you what

So first off, you can imagine a stack is sort of like a vector or a list with less functionality or more restrictions.

It’s useful to add restrictions on top of more robust data structures for the purposes of, I don’t know, kindling your imagination or allowing yourself to use easier implementations or whatever.

If you’re a musician or artist, probably at some point you’ve been stumped and you’ve had writer’s block and you can’t figure out what to create.

can’t figure out what to create so uh you know i know sometimes musicians when they get writer’s

block they’ll they’ll go to the swap meet and they’ll buy like an old dusty dirty uh casio

keyboard from 1985 and then they’ll write a full song just with that one piece of equipment and it

really stirs their creativity or it sparks their creativity and then when they’re done then they’ll

probably upgrade to better equipment but anyway so there’s there’s a bunch of different reasons to

use you know lesser data structures although this is not really lesser it’s very useful

It’s very useful in its own right.

So let’s see the interface.

So what can we do in a stack?

I’m going to put S for stack.

Actually, I’m just going to type this up as code.

No need to use the pen the whole entire time.

Let’s see.

So I’m going to put S for stack.

Maybe I’ll say, you know, stack that holds integers.

And I’ll just put an S here.

If you don’t know how to code right now, at this point in your career, just bear with

me.

variable of type stack and in C++ these stacks you know stacks are a template of data structure

which means the integers that we are holding inside of the stack they could be any other data

type that we wanted to including custom classes so in C++ we would use these angle brackets to

say I want my stack to hold integers and then I’m going to say s is the variable that I’ll use for

the stack so but this is not really a programming video this is just about stacks so if I wanted to

stack to push something like onto the top of the stack i would use the the method push the method

push usually has this prototype let’s see i’ll do stack push and it usually takes in a t type element

and again the t type it’s a templated data type which means right now if i just declared a stack

that was of type integer it holds integers then the t would actually expand under the hood in c

hood in C++ anyway at compile time to be an integer. So it would be like typing int e, right?

So whenever I type t, just understand that that means one instance of a thing that you could put

into the stack. So we’ve got a push here and usually the return type is void and it takes in

one element to push. And that means if I’m going to actually call, let me put some comments here.

If I’m going to actually call push on the stack, I’ve got to give it something to push and the

type of the thing that I’m pushing has to match what the stack was declared to hold. So in this

case, it’s integers. So I’m going to put an eight to match the diagram up above. And then after that,

maybe I wanted to push another number. So it’s going to be a two. And I’m just going to match

what the diagram has up above. So eight, two, three, four. So that’s the interface for pushing

usually in C++. And other languages should be similar. The other thing you can do with stacks

We haven’t done that yet, but let me show it to you first.

POP usually comes in two forms,

depending on what implementation you’re looking at.

So sometimes POP returns nothing.

It simply removes an item from the top of the stack.

And sometimes it returns a copy of the item

that you’re actually removing.

So I’m going to put like stack here and then like stack

just to show you that it’s inside of the namespace.

Oh, I don’t know.

Maybe that’s too C++y.

I’ll get rid of that stuff.

Hold on.

hold on so we’ll maybe do this just to show you that we have three separate

parts to this little code snip so sometimes pop doesn’t give you a copy of

the thing it removes sometimes it gives you a copy of the thing it removes in

cases where pop does not give you a copy of the thing it removes then you would

probably want to call top right before you popped and top will return a copy of

Just to clarify, if I wanted to remove something and get a copy of it and I had this line 13

form of pop from whatever implementation I was using, then well, I would just call pop

and I would do something like this, you know, auto element equals, you know, the stack dot

pop.

And what would happen is under the hood, it removes the item and then it also returns

a copy to me.

Sorry for being too C++ in this video.

On the other hand, if I have the form that has void for pop,

then I would have to do something like this.

I’d have to say auto element equals stack.top just to get a copy first,

get a copy of that for before I remove it.

And then when I’m finished, then I can say s.pop just to grab a copy of it and then remove it.

So for now, we’re just going to use the form that gives you a copy of the data

at the same time that you’re removing it.

thing to keep in mind let’s see there are two other functions i wanted to mention mention real

fast so for now i’m going to say that we only have the t pop type you can also check to see if a stack

is uh is empty and you can also check its size uh usually those are functions that have those names

but i’m going to do let’s see boolean empty and then i’m going to say size type size again sorry

an unsigned 64-bit integer so just like a count or a size something that’s just

going to be a whole number and never negative so we have this little

interface that this data structure has and we have been calling push so far so

let’s go ahead and do some pops I’m gonna say auto auto elements equals s

dot pop maybe I’ll do two of those in a row maybe instead of calling that

just so that we can have different variables to put our pops in.

And then maybe after that, I’ll do some more pushes.

I’ll say, let’s push like a 15 and let’s push like a 25.

And then I think that means it’s probably time to erase that,

the top part of the diagram with the 8, 2, 3, 4

in favor of just whatever pushes and pops we’re doing.

So let me just do this real fast.

Okay, so we did our pushes.

two three four and then I’m going to try to grab a couple pieces of data with these pops

and for pop all you have to do is just to well I should have mentioned this before but first

check to make sure that there is something to pop for example if I had a blank stack let’s say I had

a blank stack right here there’s just like nothing on it and this green line is non-standard I’m just

drawing it for fun but imagine I had a blank stack with no items and I decided to call pop on it

well you’re not allowed to pop them an empty stack there’s nothing there to pop which means that’s a

stack there’s nothing there to pop which means that’s a really really naughty thing in c++ and

other languages we would say that something exceptionally bad has happened the user tried

to pop something that wasn’t there and so then we would do something called throwing an exception

at the user again this is not really a code video but if you know a little code hopefully you

understand try catch blocks and throwing exceptions when bad things happen so we would just throw an

exception at the user if you don’t know how to code at this point then just keep in mind we would

mind we would refuse to do it we would say something bad has happened we can’t do that

and then when you’re doing your pushes sometimes depending on what what you’re using to implement

the stack under the hood inside of your code you might decide that you’re using let’s say you’re

using an array under the hood which has a fixed capacity if you run out of capacity and you can’t

then you would throw if the user tried to push something into a full stack we would call that a

stack overflow and then when we tried to pop from an empty stack we would call that stack underflow

but for the purposes of this video just assume that the stack is just a diagram and it has no

capacity so we can just add as many things as we want on it or maybe we’re using a linked list

under the hood which would have an unlimited capacity or limited only by the machine’s

But anyway, so let’s go ahead and try to do this pop.

So let’s do a pop here.

Well, in the pop, we just look at the top only, right?

So we say, well, you know what?

Let’s make this more interesting.

Hang on a second.

Let’s make this more interesting.

Let’s do this.

I’m going to do auto a equals s dot top.

So I’m going to grab a value without actually removing it.

Okay.

So more interesting.

So we push the 8 and we push the 2.

So at that point in time, actually let’s trace this from scratch.

So we have like an empty stack here.

There’s nothing there.

And we’re going to push the 8.

So the 8 goes on the very top, just like we did last time.

I’m going to put an 8 there.

And then we’re going to push the 2 next.

So the 2 just kind of goes on top.

And then the next line, line 12, we’re just checking the top.

we’re allowed to actually look at the top if we want to. So since two is at the top, that means

a is equal to two. I’m going to put a two here to remind ourselves that a is now equal to two.

Then we’re going to do a push three. So I’m just going to stick a three on top of the stack.

And then we’re going to push a four, four is on top of the stack. Now, again, we’re not allowed

to look at anything in the middle, anything, anything, but the top. So for example, when the

it and remove it but now that we have a four on top we can no longer even see the three it’s not

available to us anymore so then we’re going to pop and put that value into b so um you know what’s

at the very top it’s a four so that means we’re going to actually remove the four and stick that

into b so i’m going to put four right here to remind ourselves that b is now equal to four

and uh for the purposes of this video you can just imagine that this you know the top of the stack is

of the stack is just totally gone deallocated depending on what implementation you use you

might want to think about crossing it out maybe there’s like some junk data there now but for the

purposes of this video in this diagram we’re just saying it’s gone so it’s just totally gone

okay then let’s do another pop so we’re going to pop and that’s going to become c so obviously the

top is uh is now the three so that means the three is going to go into the c variable so here’s a

c variable so here’s a three right there then the three gets deallocated

and now the top is the two so then we’ll push a 15 and we’ll push a 25 so again we just put those

new items on top of the stack even if there was stuff uh there before it’s gone now so we’re just

be a 15 and a 25 on top of the stack so we got this and then 25 and then we’re done adding our

stuff so uh the other functions that we talked about are empty and size uh at the very beginning

when we had just an empty stack like that if we were to call on the empty function it would tell

us true the stack is empty and then every step after that where we had some data in the stack

data in the stack like as soon as we even added that eight at the very beginning from that point

forward then empty would have returned false to us saying no the stack is uh it’s not empty

the size would have changed uh during every step of the way so you know at line 10 the size would

have been one after we’re finished with line 10 after line 11 the size would have been 2. 12

wouldn’t have changed the size so it still would have been 2. 13 would have upgraded the size to

have upgraded the size to four once we popped after that pop was finished it would have been

three again then the second pop would have brought it back down to two and then those two pushes

would have put it back up to three and then four and so then the final size whoops that was horrible

the final size of the stack is four and you can tell that there’s just four items

another way to double check yourself if you’re kind of trying to trace this on your own is just

count the number of pushes and subtract the number of pops so how many pushes do we have one two three

2, 3, 4, 5, 6.

So that’s like 6 minus however many pops we saw.

We see 2 pops.

So 6 minus 2 is equal to 4.

So, you know, when you’re writing this sort of thing down on,

like as a diagram to practice,

then you know it’s a 4 just by looking.

But what if you did something wrong?

It’s a great idea to double check yourself at all times.

So 6 minus 2 is 4.

So we know that the size of the stack is 4.

Looks pretty good.

Looks pretty good and we know the values of A, B, and C and you know one of those was

top two of those were pops.

And yeah, okay.

So notice something though that’s kind of peculiar about the data that came out.

If we added the data, like I guess while we were adding the data, we added first an eight

and then a two and then a three and then a four.

I’m just looking at the pushes right now and then a 15 and then a 25, right?

So we added the data in that order.

order. But then when we grab the data out, let me put this in, but maybe like a red bracket

or something. When we grab data out of it, the pops and the tops gave us two and then

a, okay, nevermind. That was not a pop. It gave us a four and then a three if we’re just

look at the, look at the first two items. Sorry, sorry, sorry. Look at the last two items right

before, and I didn’t draw this very well. Imagine that we had just pushed the eight and the two and

the three and the four only forget about these other pieces of data. So at this point, when we

start calling our pops, we have only an eight, two, three, four stack, right? So the data that

has a four and then a three if we’re removing data from the stack.

So notice how the four and the three are backwards.

Notice also like if we kept popping out data, you know, we got the four and then we got

the three, the next, what’s the next thing that would come out?

It would be the 25, right?

And then it would be the 15.

And then it would be the two.

And then it would be the eight.

So if you really think about it, the stack is reversing our input data.

We added a three and then a four, but we received a four and then a three.

And of course, it’s a little bit muddled because we have some pushes in between some tops and pops and stuff.

But just looking at what goes into the stack, it’s backwards, right?

Eight, two, 15, 25.

Let me finish this push sequence up here.

So we added three and four, and then we added a 15.

And then, oh, my penmanship, dude.

shit dude 15 and then we added a 25 so if you look at the data that comes out this is like a 15 and a

25 backwards and then the three and the four are backwards and then the two and the eight are also

backwards and so one thing that a stack does is it reverses data let me give you a cleaner example

with no pops in between the pushes just to show you what we’re talking about a little bit more

bit more clearly okay so i’m going to do maybe like another code page here whoops do that and

then i’m going to say got our stack and we’re just going to push in some data

and then we’ll just say s.pop and maybe i’ll just do that however many times

six two three four five six so now just a very quick trace because this is basically the same

intermixed. So I’m going to do like the bottom of the stack here. And then, well, I mean like an

empty stack. That’s not really a bottom of a stack. So we’re going to push an eight.

And then we’re going to push a two. And then we’re going to push a three. And then we’re

going to push a four. Then a 15. Got to work on my fives, dude. Okay. And then 25.

Okay, one more time.

Oh yeah, I guess I got to slow down.

So what’s going to come out?

Remember the top is the only place that will give us data.

So if we start popping all these one by one, we’re going to end up with a 25 for that first

pop.

Maybe I should write it down over here.

Do like a 25 and maybe I’ll add some line breaks in the code here so that it’s easier

for me to write with a pen.

Do this and that.

Okay, so the 25, I’m just going to do a red line through it to designate or to denote

deallocation or just like gone-ness.

Then the top is at the 15.

We do another pop.

It’s going to be 15.

Oh, I did my first perfect five today.

And then the top of the stack is now at the four.

So then the four is going to pop out next.

And then the three is going to pop out next.

The top is now at the three.

the three so the three is coming out for that pop we deallocate the three the top goes down one and

then we pop it becomes the two that’s deallocated now and then we grab the eight because that’s

where the top is so now we’ve grabbed all of our data out and I just want you to look at this one

more time notice the data is eight that the data that went in was eight two three four fifteen twenty

The data that came out was backwards 25, 15, 4, 3, 2, 8 or 8, 2, 3, 4, 15, 25.

If you kind of like look up.

So a stack is a data reverser.

A stack is also known as something called a, let’s see,

last in first out data structure, LIFO,

or first in last out, phylo data structure.

What that basically means is just it’s reversing the data or priority goes to the item that is the youngest.

So if you looked at the stack at the point where we were about to remove the 25,

25 was the most recently added or the youngest item or the item with, I guess, the timestamp, the furthest in the future,

however you want to look at it.

And that’s the item that came out.

So if you think about it, it was the last item in.

And therefore, when we did another pop, it was the first item out.

So LIFO or PHILO.

and uh you know this eight down here that was obviously the last item that we were able to grab

out of it so when we said you know hop our final pop before the stack became empty uh the eight was

definitely the first item in so first in was the last out if you really want to you can kind of like

jumble these uh these acronyms uh i think most like people just use lipo or phylo

life if you say something to me that I understand I think it’s probably fine

but it’s it’s non-standard I like to say you know foley first out last in that

definitely makes sense it’s just not very common another thing that I like to

do for fun is also I’ll mix up the phylo and I’ll say lo-fi because last out is

first in and now I’m cooler than other computer people because I use the word

lo-fi I’ve now got like a giant mustache and like a little like swap meet shirt

like swap meat shirt and I have craft beers and I have work boots on and I’d

roll up my jeans and my, my, my, my, my sleeves are rolled up and all that stuff.

You know what I’m saying?

I’m cooler than everybody else now because I used loaf pie anyway.

So we used integers.

It’s just important to understand that in modern coding,

I think I might’ve mentioned this before with the T’s,

these stacks are templated data structures,

we can hold another data type besides integers as long as we declare what the stack will hold in

advance. So instead of integers, you could imagine there’s like a custom class, like my class,

every single, you know, item in the stack is actually a full instance of a my class object,

or, you know, floats or strings or just, you know, any data structure you want,

you could put another data structure inside of a stack. People do that sometimes just for fun,

sometimes just for fun you could take a vector and stick it inside of a stack a list put it inside

of a stack you know whatever you want to do just to show that you understand everything

um so again by the way the stack is empty if we tried to pop from it at this point

this would be called a stack underflow we would probably want to throw an exception at the user

or just say we’re not allowed to do it let’s see um so i guess now i should tell you some

common uses for stacks i’m looking at my notes right here uh obviously our stack has reversed

has reversed the data. So stacks are kind of good for data reversing. Imagine if you had like a word

and you wanted to detect if the word was a palindrome or not, you would just like put all

the letters of the word into your stack and then grab them back out and see if the word was still

in the same order. If it was, then your word was probably a palindrome. If you don’t remember what

a palindrome is, I’m going to write down the word radar in reverse from backwards, from back to

front, right? It’s the same word. So that’s a palindrome. You could also use stacks kind of

as a trail of breadcrumbs. Like you could imagine that early implementations of browsers

had your browsing history in a stack somewhere so that every time you visited a webpage, then

some kind of block of information, maybe like a custom class instance was put onto a stack

somewhere and it contained information about like when you visited the webpage, what the URL was,

it is that the browser wants to remember and then later when you hit the back button then you can

imagine the browser is popping from the stack in order to go backwards in your history or your

spotify playlist or whatever it is you’re doing honestly you know these systems are much more

advanced than just using you know vanilla stacks now but you could imagine doing something on your

own for fun or just what it might have been like in the very beginning i’m going to erase fully

because that’s just that’s just that’s just cringe lo-fi i think is way cooler um so trail of bread

So a trail of breadcrumbs, like browser history, you could also imagine undo history, like

if you had a, I don’t know, like a text editor of some sort or like a image editor of some

sort, every major change that you did to it, maybe the program under the hood is adding

your change to the stack.

And that makes it easier to sort of reverse your changes as those changes are popped.

And there’s like a sort of mathematical uses like balancing parentheses and things, but

balancing parentheses and things, but I’m not going to talk about that too much.

And one of the most important uses for stacks inside of your computer is actually the call

stack. I’m going to talk about that in a future video. But again, remember each, you know, little

item on the stack, it could be a different data structure on its own. It doesn’t have to be an

integer. So imagine that I bundled up a bunch of information about a function call, and I called it

I just stuck a call frame on the stack.

That’s basically the call stack.

But that’s for another video.

Anyway, so let’s see.

Is there anything else that I wanted to show you?

I think we’re actually done just talking about the basics of stacks.

I’m not talking about time complexities or anything like that in this video.

Check a future video if you’re interested in time complexities per certain implementations

and so forth.

But for now, this is how a stack works.

or LIFO or LOFI data structure.

Nobody’s going to say LOFI but me, just FYI.

But maybe everybody will start doing it now.

I don’t know.

If it becomes a trend, okay?

You heard it here first.

Give everybody this link.

All right, I hope you feel like an expert on stacks

at this point.

I hope you had a little bit of fun

and learned a little bit of something, some stuffs.

I’ll see you in the next video.

hey everybody thanks for watching this video again from the bottom of my heart I really

appreciate it I do hope you did learn something and have some fun if you could do me a please a

small little favor could you please subscribe and follow this channel or these videos or whatever it

is you do on the current social media website that you’re looking at right now it would really mean

the world to me and it’ll help make more videos and grow this community so we’ll be able to do

videos, longer videos, better videos, or just I’ll be able to keep making videos in general. So please

do me a kindness and subscribe. You know, sometimes I’m sleeping in the middle of the night

and I just wake up because I know somebody subscribed or followed. It just wakes me up

and I get filled with joy. That’s exactly what happens every single time. So you could do it as

a nice favor to me or you could you could troll me if you want to just wake me up in the middle

of the night, just subscribe and then I’ll just wake up. I promise that’s what will happen.

Also, if you look at the middle of the screen right now, you should see a QR code which you can scan in order to go to the website

which I think is also named somewhere at the bottom of this video and

It’ll take you to my main website where you can just kind of like see all the videos

I published and the services and tutorials and things that I offer and all that good stuff and

If you have a suggestion for

Clarifications or errata or just future videos that you want to see

please leave a comment or if you just want to say hey what’s up what’s going on you know just send

me a comment whatever i also wake up for those in the middle of the night i get i wake up in a cold

sweat and i’m like it would really it really mean the world to me i would really appreciate it so

again thank you so much for watching this video and um enjoy the cool music

as as i fade into the darkness which is coming for us all

Thank you.

The post Master Stacks: Fun Guide to Data Structures, LIFO & Real-World Uses appeared first on NeuralLantern.com.