Watch me build an AVL tree step by step with linear data that would normally create a terrible unbalanced BST. See insertions, balance factor calculations, and rotations in action.

Perfect follow-up to my BST and AVL intro videos.

00:00 Introduction to AVL Tree with Bad Data
00:14 Previous Videos on BST and AVL Trees
00:28 Practice Example Building Step by Step
00:50 Adding First Node 12
01:11 Adding Node 21
02:10 Adding Node 30 and First Rotation
04:03 Recomputing Balance Factors
05:08 Adding Node 38
08:03 Adding Node 42 and Second Rotation
12:51 Recomputing Balance After Rotation
14:09 Adding Node 55 and Third Rotation
18:55 Placing Unaccounted Nodes
19:21 Final Tree and Balance Factors
20:07 Conclusion and Thanks

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

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

Hey there! Let’s build an AVL self-balancing binary search tree with some really bad data.

It’s all going to work out, trust me.

Okay, so hopefully by now you’ve seen my other videos where we talked about how to define binary

search trees, how to build them, search through them, add, delete, all that stuff. And also AVL

trees. What are rotations? Why do we rotate? How does the AVL tree maintain itself? And so forth.

just going to be a practice example. In the previous video that I that I

recorded regarding AVL trees, I started off with a really long and gnarly linear

tree and then I suddenly turned on AVLness and we rotated the crap out of

it for about 30 minutes until it was really really good. So now I’m just

going to build a tree one step at a time. Suppose for the sake of argument that

you have some really bad data. You know a long time ago, I love telling this story.

time ago you know my grandma before she passed on she was kind of bitter and she had some enemies in

the neighborhood she used to call the cops on her neighbors for gossip um she had a neighbor who

kind of feuded with her and at one point according to my grandma anyway uh my neighbor like didn’t

like my grandma’s tree and so one day when my grandma was looking out into the backyard

through the back window because she likes to yell at ducks who are swimming in her pool

notice that the other little old lady’s arm just kind of went over my grandma’s fence

with a spray bottle and then sprayed her tree. And then my grandma’s tree died. So this kind of

thing I like to call, you know, tree poisoning or data poisoning or bad data, it can affect a binary

search tree and make it really, really, really slow. But in AVL trees, if we have bad data,

it should actually end up being fine. So I’m just going to say we’re poisoning our grandma’s tree

grandma’s tree with some bad data. I’ll just do maybe maybe five pieces of data. We could go

further than that but it’s it’s going to be a super long video if we do. So we’re going to add

these pieces of data one by one. So that means the first thing I’m going to do remember we are kind

of just regularly you know building a regular binary search tree. It’s just that the differences

after we modify the topology in some way we’ll just check to see that it satisfies the rules of

then we’re going to start performing rotations to make sure that it’s self-balancing.

So we’ll add the 12 first.

So let me see if I can draw a little arrow just indicating,

yeah, we’re going to add this number right now.

I’m going to do an ellipse for a node.

And you know, like for binary, what is that?

Flying saucer for binary search trees.

It’s like, well, if there is no data already, if the tree is empty,

first piece of data you add is going to end up being the root node. So that’s it. We have our

root node here. See my other videos if you want more practice on building trees. So we’re just

going to call that the root node. And then we’re going to compute its balance factor, which is

obviously just going to be a zero. So that was super easy. Now we’re going to move on to adding

the next piece of data. Things are getting a little bit worse. This is going to be a linear tree.

tree if it weren’t for our trusty I guess AVL functionality so the 21 I’m

gonna maybe just duplicate this node right now and set that to a 21 and then

we’ll figure out where does the 21 go well it can’t be the root because the

root is already occupied 21 is larger than 12 so it’s got to be on the right

side so the 21 is going to be the right child of the root node so I’m just going

Connecting line right here.

And then we have to recompute balance factors.

So the 21 is the thing we just added.

We have to compute that.

Then we have to work our way up the tree until we hit root.

So we see the root node.

It now has a balance factor of 1.

So it got a little bit worse.

But we don’t see 2 or worse.

So that means this is currently a valid AVL tree.

And we don’t have to do any rotations.

So now it’s time to add the 30.

just realized I could just upload like a hundred videos like this and I think you’d all be pretty

happy or some people would be pretty happy um I don’t know if I want to do that to myself maybe

I will so we’re going to add the 30 node uh so first I’m just going to duplicate some node

and I’m going to call it 30 then we have to figure out where the 30 node belongs uh it’s not going

to be the root node that’s already occupied 30 belongs on the right side of 12 but we can’t use

of 12 but we can’t use that right child it’s occupied 30 belongs on the right side of 21

so you know it makes sense we called this linear data that would make a linear tree so everything

ended up being on the right side so far it’s just getting worse and worse but now the ablness is

going to kind of come to the rescue we have to recompute the balance factors so the 30 has a 0

the 21 ends up having a 1 again if you want practice computing balance factors see my other

The 12 has a balance factor of 2 and now we know right away this is not a valid ABL tree anymore

because we have a balance factor that is bad. It’s too bad.

So we have to now select an XYZ trinode subtree so we can perform a rotation.

I’m sure you can imagine it’s just going to end up being three nodes that are perfectly balanced like that.

But let’s do it one step at a time.

So the Z node is going to be the 12.

That was the first node that we noticed that was out of whack or like I guess the highest node.

or like I guess the highest node of the lowest nodes.

And then we have to find Y by taking a child of Z.

There’s only one possible child we could choose, so that’s going to be Y.

And then we find X by taking a child of Y.

There’s only one choice again, so it’s just going to be there.

Now we have X, Y, and Z, and I’m going to write it down real fast.

Let me just put this in black ink.

So X is 30, and Y is 21, and Z is 12.

12. Then we’re going to do A and B and C, which are going to be just in order representations of

XYZ. So again, think in your code, you would be doing pointers, you’d probably want to make three

more pointers, call them ABC. If you had a rotation function, the rotation function,

after you selected three nodes to rotate, it would receive XYZ. And then you say, let’s reorder,

you know, XYZ and call them ABC. So A is going to be 12, and B is going to be 21,

it should you know ascend from left to right if we’re not supporting duplicates in our tree

and then i’m going to um just you know make some make some nodes for our target pattern here

our output pattern so i’m going to like make some nodes here kind of place them uh in the perfect

avl tree output pattern a perfectly balanced trinode subtree i’m just going to reconnect this

The output pattern is always the same.

You know, it always starts this way because this is better

than the linear pattern that we have above.

And then I just have to update the numbers.

So the left child is going to be 12.

The right child is going to be 21.

Sorry, the center is going to be 21, the new parent.

And the right child is going to be 30.

Okay, now we look for any nodes that are children of the input nodes

that have been unaccounted for.

You can tell easily that all nodes are being used.

So we don’t even have to worry about that step.

So now that we have our trinode subtree which is perfectly balanced, we are ready to just sort of override it into the diagram.

And since the diagram only has the three nodes to begin with, I could pretty much just like erase everything, call it a day, and say this is the new tree, the new rotated tree.

So I’m just going to maybe put this in the middle I guess.

I’m going to delete this over here and recompute the balance factors.

a zero, get zeros, and this 21 also gets a zero because it’s perfectly balanced.

Next thing is let’s move on to adding the number 38. So we’ll add the 38 here and

same thing that we do before. Let’s make a copy of one of the nodes for our diagram.

Let’s call it the 38 and then let’s figure out where it belongs. It’s not going to be the new

root node because that’s occupied. It belongs on the right side. It’s not going to be the right

It’s not going to be the right child because that’s occupied.

It belongs on the right side of the 30.

It couldn’t go on the left.

That would be an invalid binary search tree.

So I’m just going to stick it right there and do a connection.

And then we’re going to update the balance factors.

So the 38 is a leaf.

It gets 0.

The 30 gets a 1.

And the 21 also gets a 1 because its left subtree is a 1 and its right subtree is 2,

or height, and the difference is just 1.

is just one. Remember we don’t really need to update the 12 or any nodes that are not

directly above the node that we just added or removed. So if you look at this tree there’s

a little bit of imbalance but nothing is two or worse so we don’t actually need to perform a

rotation. This is already a valid AVL tree. So I’m going to move on to adding the next number.

Let’s add a 42. Same thing we’re going to duplicate a node for our diagram and we’re going to call it

going to call it the 42 where does it belong well we start by looking at root that’s occupied 42

belongs on the right side of 21 the right child is occupied 42 belongs on the right side belongs on

the right side i mean it’s always going to be on the very right of the of the diagram because that’s

the poison data that we received uh so i’m going to put it over there and then connect um the child

child relationship and then let’s update the the balance factor so 42 gets a 0

38 gets a 1 and 30 gets a 2 now because it’s got 2 height of subtree on its

right side and no subtree on its left side the 21 we should update left subtree

is a 1 right subtree is a 3 oh it’s still gonna it’s actually gonna be 2 so

we have two instances of the number 2 and again which one do we actually want

by the way here’s here’s how I like to eyeball it you can kind of see oh there’s two levels of

difference in terms of the root node which one do we rotate first well as low as possible because

if we rotate the 30 it might end up fixing the 21 so we don’t want to do any more more work than we

have to so I’m just going to maybe move this over here a little bit and select our xyz um hang on

a second I think I just like didn’t do a snap to grid when I was doing that okay hang on

doing that okay hang on okay so we got to choose our x y and z uh we’re going to say that the 30

is z the lowest node possible that is out of whack and then we hop down to a child of z to find y

we hop down to a child of y to find x and so now we have our xyz i’m just going to write them down

I’m going to change the ink real fast and then we have to get ABC so A is the least value B is the

one that belongs in the middle and C is 42 now we have our ABC we’re ready to draw our output pattern

or target pattern so I’m just going to put like some nodes up here duplicate that a couple times

all right not the prettiest but I’ll take it I’m gonna do my connecting lines

and then I have to update the numbers so a is 30 and then b is 38 and c is 42 still so we’ll just

leave that as is now we have to look for children of any of the output pattern nodes that are

for so we’ll first look at the z node here the 30 it had a right child of 38 that’s already handled

as the y node so we don’t need to worry about the 38 okay next we look at the uh y node it had a

right child of 42 that’s also handled in the output pattern so we don’t have to worry about that uh

then the 42 had no children so we don’t need to really do anything this is going to be super easy

Just as a reminder, the Z could have had a left child, the Y could have had a left child,

and the X could have had two children, at least in this particular pattern.

Oh, I think in my previous video, I didn’t name off all the rotation types.

Whoops.

Okay.

So now I’m ready to just kind of like move this into the diagram.

So the 30 and 38 and 42, we can just kind of get rid of that

move the rotated output pattern into the diagram like this.

We’ll make the 38 the right child of 21.

I want to make it go a little bit more to the right

so that we have a nicely drawn diagram

so that all the nodes have space so it’s easy to debug visually.

It’s easy to just kind of eyeball it.

Then I’m going to update the balance factors.

So the 42 has 0, the 30 has 0, the 38 has 0.

Nice.

The 21, hopefully that improved.

The left subtree has a height of 1, the right subtree has a height of 2.

of one the right subtree has a height of two so actually the balance factor of the 21 node improved

to one we are now done uh rotating and we have a valid avl tree and uh we could have had you know

a tree that was just totally linear all the way down to the right it could have worked out that

way if we weren’t using avl trees uh and we would have had a really slow binary search tree but with

avl trees this is like you know a lot a lot faster reasonably and you can imagine if i added some

And you can imagine if I added some more data, let’s see, how long is this video?

Oh, it’s this video.

It’s already 15 minutes.

Let’s add one more piece of data just for fun, Zars.

I’m going to add 55.

Anybody remember that old song, I Can’t Drive, 55?

So we’re going to add the 55.

I’m going to say, here it is.

And then I’m going to do just like a new node duplicate.

node duplicate. I’m going to stick a 55 in there. And then where does the 55 belong? Well,

it’s not going to go with the root node belongs on the right side. Not going to go there belongs

on the right side, not going to go there belongs on the right side, we just end up going all the

way to the right. Pretty much. Okay, so I’m going to say it belongs there. And I’m going to connect

it. And then we update the balance factors. So zero here, and then the 42 becomes a one and the

42 becomes a 1 and the 38 becomes a 1 and the 21 becomes a 1 on the left and 3 on the right

which means we have a balance factor of 2 so now the 21 node is imbalanced this is no longer a

valid abl tree we got to rotate to make it better so once again we look at the first node that’s out

of whack or the lowest node that’s out of whack it’s going to be the 21 we call it our z and then

we find a child of z with the tallest subtree so it you know is it going to be the 12 or the 38

the 12 or the 38 it’s definitely going to be the 38 because 38 is the taller subtree same thing to

find x it’s got to be a child of y should we go left or should we go right we have to go right

because that’s the taller subtree so now we have our x y and z um i think i’ve been forgetting to

is 38, Z is 21, X, Y, and Z, and then we do A and B and C. So A is the least value, 21, B is the one

that belongs in the middle, C is the one that belongs on the right side. Now we’re ready to

draw our target output pattern. So I’m going to do this, a little duplication.

Do you like when I say, oh, we’re going to do this, we’re going to do this, we’re going to do this?

Because sometimes I just go, I don’t like it.

And I don’t think people like it when I say that.

Okay.

I’m going to connect these real fast and then change the numbers to match.

I think I made that one.

I think it’s okay.

I can never tell if it’s perfectly symmetrical.

I can’t do it.

It’s perfectly symmetric.

All right.

So A is going to be on the left.

Alright, so A is going to be on the left, that’s 21.

B is in the middle, that’s 38.

C is on the right, that’s 42.

Then we have to look for children of the output pattern that are unaccounted for.

So we’re going to do, look at the Z node.

The Z node had 12, which is unaccounted for as a left child.

So I’m going to copy the 12 somewhere.

We’ll deal with it in a second.

Then we look for the right child of 21, that’s a 38.

that’s a 38 that’s already in the output pattern so we don’t have to worry about that anymore

and then we look at the y node so y had left child was 30 that’s not accounted for so i’m

going to copy that put it somewhere else and then its right child was 42 that’s already

handled in the output pattern so we’re done there i’m going to duplicate this and then we look at

the uh we look at the x node the 42 it had a right child of 55 that also was not accounted for so i’m

for so I’m gonna just copy it over here and we’ll do something with it okay we’re done looking for

unaccounted for children again if you are just rearranging pointers you don’t really have to

worry about this in your code but since we’re doing a diagram we have to double check that

none of these nodes at the bottom here the unaccounted for children have children of their

own if they did the children would have to come with them so 55 uh no children 12 no children 30

So those are fine. If there were any children underneath, they would just stay on those nodes.

So now we have to figure out who goes where. So the 12 is the least value. That means it’s going

to go probably in the leftmost position compared to the other ones. But if we figure out like,

where does this belong in the binary search tree? It belongs right here as the left child of 21.

The 30 node, same thing. Where does it belong? It belongs between the 21 and 38. That’s the only

And then the 55, it belongs on the right side of 42 for the same reason.

Okay, I’m going to do my connecting lines real fast.

If I don’t do my connecting lines, then I don’t like it.

So now we have how many nodes in the output pattern?

We have one, two, three, four, five, six.

there’s also just six which means the final tree after rotation is just everything that we’ve

written on the right side so i’m just going to erase all of this stuff get rid of that too

and then move all these nodes over to the left call that the tree this is now the tree and then

i just have to recompute the balance factors to make sure that everything is okay so the leaves

0, 0, the 42 gets a 1, the 21 is perfectly balanced so that gets a 0.

The 38 is also perfectly balanced.

Again, it’s not about weight or mass even though there are more nodes on the left subtree,

it’s all about the height.

The height of the left subtree is 2, the height of the right subtree is 2, so 38 is actually

perfectly balanced.

Because there are no nodes that have a balance factor of 2 or worse, we are done rotating

this tree.

This is a valid AVL tree and it’s pretty fast.

So I think that’s pretty much it.

That’s all I wanted to go through today for this video.

Thank you so much for following along.

I hope you learned a little bit of stuff and had a little bit of fun.

And I will see you in the next video.

Have a great night and or day and or week and or weekend.

Hey everybody.

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

I really appreciate it.

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

do me a kindness and uh 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 i’ll just wake up i promise that’s what will happen also uh if

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

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 uh 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

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.

It should all work out according to plan, trust me.

Anyway, um, so…

The post AVL Trees: Adding Linear Data and Performing Rotations appeared first on NeuralLantern.com.

In this video we walk through a real example of maintaining an AVL tree by performing a rotation. We start with an unbalanced tree, compute balance factors, identify the Z Y and X nodes, and apply a double right rotation to restore balance. Perfect follow-up if you’ve seen the basics of binary search trees and AVL trees.

Watch as we turn an invalid AVL tree into a perfectly balanced one with clear step-by-step instructions.

If you’re learning data structures and algorithms, this practical example will help you understand when and how to rotate.

00:00 Introduction to AVL Tree Rotation
00:14 Prerequisites and Previous Videos
00:36 AVL Trees Overview
00:40 Types of Rotations and Balance Factors
01:01 Examining the Example Tree
01:24 Confirming Binary Search Tree Properties
01:27 Computing Balance Factors
01:39 Identifying Imbalance at Node 65
02:01 Locating the Z Node
02:54 Finding Y and X Nodes
04:08 Assigning X Y Z Values
04:33 Creating ABC In-Order Representation
04:58 Drawing the Target Rotation Pattern
05:34 Updating Node Values in Pattern
06:04 Checking Unaccounted Children
07:00 Reattaching Nodes and Performing Rotation
07:56 Recomputing Balance Factors
08:24 Updating Root Balance Factor
08:41 Resulting Perfectly Balanced Tree
08:48 Identifying Double Right Rotation
09:06 Explaining the Rotation Process
10:16 Conclusion and Next Video Teaser
11:56 Channel Promotion and Outro
15:48 Final Hello and Recap

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

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

Hey there! Let’s maintain and rotate an AVL tree which is a self-balancing binary search tree.

Okay. Alright, so hopefully by now you’ve seen my other videos. If you haven’t,

you probably won’t understand this unless you’ve seen other videos elsewhere.

But in my previous videos we talked about what is a binary search tree, how to make one, how to

binary search tree, how to make one, how to define one, how to know you’re looking at one, how to build one, search,

insert, remove all the operations and time complexities.

And then we talked about AVL trees, which are a self-balancing binary search tree.

And we talked about what are the different types of rotations you can do? Why would you rotate?

How do you compute balance factors? How do you know when it’s time to rotate?

How do you do the rotation? Stuff like that. So this is just going to be one

example tree, and we’re just going to try to burn through it. If you want to learn more about

see my previous videos. Okay, so supposing now that you have a tree that looks like this, let’s

confirm that this is a valid AVL tree. This seems to be a tree. It’s a connected graph. It’s got no

cycles. It’s a rooted tree. It’s a binary tree. There are no more than two children per every

single node. And the data is in order. So 14, 22, 36, 41, 48, 55, 65. So this is a valid binary search

Now to determine if it’s a valid AVL tree, we just have to compute balance factors.

So in my previous videos, we talked about doing this.

So I’m just going to try to burn through this quickly.

I want to put zeros on all the leaves because that’s pretty easy.

This 48 gets a 1.

The 65 actually gets a 2.

So at this point already, we know there’s something wrong with our tree.

We need to rotate it.

This is not a valid AVL tree because we see a balance factor that is worse than, you know,

plus or minus 1.

61 is going to have a balance factor of, let’s see, just a 1.

And so really the only thing that we need to rotate is going to be this 65 node.

This is the node that’s out of whack.

Sometimes you see, you know, the bad balance factor in other areas of the tree,

maybe like a little bit higher and also a little bit lower.

You want to rotate as low as possible first because sometimes when you rotate low,

it fixes stuff that’s higher.

This is actually only true if the thing that you’re rotating is a direct descendant,

Not necessarily a direct child, but just a descendant of the thing that you see that is higher if you have two different nodes that are

unrelated in terms of

You know, they’re not direct descendants or ancestors of one another. They’re sort of like siblings or cousins

Then it doesn’t really matter so much which one you rotate first because they’re not really going to affect each other

but

In this case if we rotate, you know starting with the 65 there’s a chance that the 41 will get fixed up a little bit

I haven’t tried this yet, so I don’t know for sure, but I have a feeling it might.

Let’s see what happens.

So we know that the first node that is out of balance we’ll call the Z node.

So I’m just going to put a Z here.

Let me just duplicate this and we’ll say Z.

Hang on a second.

I got some dashes in my pen.

There we go.

We’ll make this the Z node.

And then we have to find X and Y.

We’ll do that backwards.

We’ll find the Y first and then the X.

them by going down one level at a time so the Y node will be a child of Z and

we’ll have to find the child that has the taller subtree in this case there’s

no choice because there’s no subtree on the right side of 65 so we can only go

left but just keep in mind if there was a subtree let’s say like that then we

would still go to the left and select that 48 as the Y node let me just write

down Y node here because it would have a taller subtree notice the left subtree

in this little example has a height of 2 and the right subtree has a height of 1

That subtree has a height of one.

So let’s just get rid of that little extra thing.

Same thing for the X.

We want to find a child of Y and we’ll always take the taller subtree.

So you know, if there was a subtree over here and maybe like another like node down there,

then we would still go to the right to get the 55 because it would have the taller subtree.

In this case, there’s only one choice.

So the X node is just going to be this 55 and that’s it.

So let me just put an X right here.

are x and y and z i’m just going to write that down real fast x equals 55 i’m going to probably

change the color here y is equal to 48 uh z is equal to 65 um and then we want to make an in

order representation of xyz and just call it abc so i’m going to say a is equal to something

and so is c so a is going to be the least value the value that belongs on the left because again

these are supposed to have ordered data like binary search trees so i’m going to put 48 here

and 55 there and then 65 here now abc is the in order representation of xyz now that we’ve done

that i’m going to draw our target pattern here so let’s see i’m going to do i’m going to do a

to connect with some blue lines because that’s just like such a cool connection.

Hang on a second.

I put that a little bit too far down.

Okay.

So we’ll do that.

And then I’m going to do another connected in line.

Okay.

I had to make a little edit there.

So I’m going to just continue making this blue line.

So I’m going to do this.

And I have to update the values now.

the values now. So this 14 on the left, that should be the A node. So we’re going to see 48,

and then the new parent is going to be 55, and then the right child is going to be 65.

Always after you fill in these values, ask yourself, have I actually drawn a valid binary

search tree? If you haven’t, meaning if the data is out of order in some way, then you haven’t

drawn a valid binary search tree, and you probably need to try again. So we’ve got 48 and 55 and 60.

is are there any children that are unaccounted for in terms of the input nodes to the pattern

that we’ve just drawn down here, the output pattern.

So let me just kind of remind you that there could have been, you know, potentially some

nodes, right?

Like we could have had a right child of 65, we could have had a left child of 48, and

we could have had two children of 55.

So there’s always a potential for four nodes that are unaccounted for.

We’ll just check them one by one real fast here.

Look at the 48 first. The 48 had a right child of 55, but that’s already taken care of in the output pattern, so we don’t have to worry about that.

Now we look at the 55. We could go XYZ if we wanted to, but I like looking at the output pattern.

55 had no children, so that’s fine. And then we look at the 65. The 65 had a left child of 48, but that’s already in the output pattern.

So at this point, all children are accounted for. We don’t really need to do that much.

that were unaccounted for they would need to be attached under the 48 and 65 somewhere and each

child would only go in one place without an there’s only one place that the child could go

without invalidating the binary search tree but that’ll be i’m going to make a harder example in

the next video so now that we’ve done this we’re ready to reattach all the nodes are accounted for

that we’re about to remove from the diagram we’re not actually going to be deleting nodes or creating

creating nodes or anything like that in the code we’re really just disconnecting

pointers and reattaching them so I’m gonna just erase this from the diagram

but keeping in mind that the nodes are not really being recreated and I’ll just

put the 55 over here where the old trinode subtree was and then I’m gonna

recompute the balance factors for all of the nodes involved so you know I just

the output pattern someone put a 0 48 also 0 because their leaves the 55 it’s a 0 it’s perfectly

balanced that’s pretty sweet and now that we’re done with the nodes that we touched we have to

work our way up to the root node we don’t have to worry about anything over here on the left

because those nodes couldn’t possibly be affected by uh by the rotation we just did because only

nodes that are above the rotation will be affected so uh the last one we you know looked at was this

basically going to say all right 55 let’s look up one more parent it’s going to be the root node

the 41 so what’s the new balance factor of the 41 node it’s actually going to be better it’s going

to be a zero so with that in mind we’ve actually created a perfectly balanced binary search tree

this is definitely a log time tree super super fast and super super cool and what type of rotation

So we had XYZ. If you don’t have the rotations memorized, keep in mind my previous videos explain all of that with some fun ways to help you remember, hopefully. Maybe some unfun ways.

So I’ll just kind of like reiterate real fast here. There are two nodes that need to be moved into position. Notice how 55 is supposed to be the new parent node, which means the 65 needs to be rotated under the 55, and so does the 48.

And so does the 48. So the 48 and the 65 both are going to be rotated into position.

That means two nodes are rotated, which means it’s a double rotation, not a single rotation.

Which node was rotated first? I always rotate the Z node first, you know, the node on the very top.

And so I’ll just use the rotation direction of that Z node.

So that’s a regular clockwise rotation.

And that’s a right rotation, so this is a double right rotation.

you can do to remember is if you go from y to z you’re going up into the right so that’s a right

rotation you could also imagine that there is some negative space kind of sitting here on the right

side a little right pocket so that’s a right rotation and i’m sure there were some other ways

that i added in the other video but i can no longer remember them so i’ll just move on we’ll

say we did a double right rotation in order to get this uh this perfectly balanced binary search tree

research tree so I’m gonna cut the video here in the next video we’re going to I

think probably rotate a linear tree you can kind of see I’ve already started to

draw one here in the next video we’re gonna look at this like giant gnarly

linear tree and we’re gonna pretend that we have the ABL rotating disabled for a

while while we built this tree and then all at once we’re gonna turn it on and

do like a whole bunch of rotations and see what the tree is gonna end up

looking like it’s gonna be pretty ugly and fun anyway thank you so much for

Anyway, thank you so much for watching this video.

I hope you learned a little bit of stuff and you had a little bit of fun.

I’ll see you in a moment, hopefully.

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

as 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 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

And I just subscribe and then I’ll just wake up. I promise that’s what will happen

Also, uh, 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

and uh if you have a suggestion for uh uh 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

Enjoy the cool music as I fade into the darkness which is coming for us all.

Thank you.

Hello there.

Hi there.

Hi there. Let’s maintain a self-balancing AVL tree,

which is recursive. Hello there. Let’s,

The post How to Perform AVL Tree Rotations – Step By Step Example appeared first on NeuralLantern.com.

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,

leave a comment.

leave a comment if i get enough comments maybe i’ll do it um otherwise thanks for watching this

video i’ll see you in the next one i hope you learned a little bit of stuff and had a little

bit of fun i’m outie i’m just simply outie 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

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 uh and subscribe you know sometimes i’m

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 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.

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 I’m like this

It would really mean the world to me.

I would really appreciate it.

So again, thank you so much for watching this video.

And enjoy the cool music as I fade into the darkness, which is coming for us all.

Thank you.

Hey there, let’s uh…

Bart on ourselves.

Hello there, let’s rotate an AVL tree because it’s frickin invalid.

No.

Hey there, let’s uh maintain an AVL tree.

and eh.

The post AVL Tree Rotations Tutorial: Fixing Imbalance After Adding a Node appeared first on NeuralLantern.com.

Hey everyone, in this video we break down the four types of rotations you need to know for AVL trees – self-balancing binary search trees.

We cover single right rotations, single left rotations, double right rotations, and double left rotations with clear diagrams and explanations of the input patterns and how they become the balanced output pattern.

If you’ve been learning about binary search trees and want to understand how AVL trees maintain their balance through rotations, this is the perfect next step. We look at the trinode subtrees, balance factors, and exactly how to rearrange the pointers for each case.

Great for computer science students, coding interviews, or anyone building their data structures knowledge.

Watch the full series on binary search trees and AVL trees for more.

00:00 Introduction to AVL Tree Rotations
00:14 Previous Videos Overview
00:28 Balance Factors and Trinode Subtrees
00:50 Identifying Imbalance
01:56 When to Rotate
02:20 Four Input Patterns
02:41 Target Balanced Pattern
04:18 Single Right Rotation
04:33 Single Left Rotation
08:44 Double Rotations
11:51 Remembering Rotation Types
13:04 Wrapping Up Rotations
13:27 Thanks 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

Hey there, let’s talk about rotation types in an AVL tree, which is a self-balancing binary search tree.

Okay, so hopefully you’ve watched my previous videos. If you have not, you probably want to check them out first,

where we talk about what is a binary search tree, how to build one, how to define one,

terminology, searching through it, all that stuff. And then we talked about an introduction to AVL trees,

trees which are self-balancing binary search trees this video is going to be

about the types of rotations that you can perform in an AVL tree what do I

mean by rotation well the basic idea that we talked about in the last video

was that throughout your tree you’ll notice that different nodes have

different balance factors which means how imbalanced or balanced they are when

we identify a node that has a balance factor that’s too bad then we consider

AVL tree and we have to stop and rotate a couple of nodes you know kind of rearrange them to make

them better before we have a valid AVL tree so we have four different input patterns that we can

have so imagine you know this little trinode subtree up on the top left that could be you know

three nodes that we found somewhere in our tree that had a bad balance if you just quickly compute

the balance factor for this trinode subtree you’ll notice actually let me just do it real fast for fun

that the 65 node has a balance factor of 2 because its left subtree has a height of 2

and there is no right subtree. The 55 has a balance factor of 1 and 48 being a leaf, at

least in terms of this trinode subtree, has a balance factor of 0. All of these trinode

subtrees are going to have the same situation. The one on top is going to be 2 and so forth.

So you can imagine that you were going through the whole tree, computing balance factors like

And you found a two, which remember we said in our last video, two or worse, meaning two or higher,

if we’re using balance factors that are absolute or negative two and also positive two or worse,

if we’re not using absolute balance factors, means you got to stop and try to rebalance that trinode subtree.

So we found a node that had a balance factor of two and we realized we have to stop and rotate.

The pattern of the trino subtree before we perform the rotation could be one of these four things.

It could be the thing on the left on top, the thing on the right on top, the thing on the bottom left, and the thing on the bottom right.

And all four of these patterns should end up becoming, after we do our rotation, they should end up becoming the pattern in the middle.

So this is always going to be the target pattern.

Let me draw some arrows real fast.

pattern is going to end up looking like the output pattern in the middle.

Why is that?

How is that possible?

Well, we only have three nodes.

If you look at all the input patterns, they’re all the same numbers.

What we’re really doing is disconnecting all the pointers, disconnecting the parent child

relationships and then reconnecting them in the best possible way to make, you know,

the most balanced trinode subtree.

Notice how the height of all of these input trees is always three, right?

because it’s a trinode subtree that’s really really bad and out of whack so we’ll you know

like one two three one two three right height of three we’ll do a rotation rearrange the pointers

rearrange the parent-child relationships so that the final height ends up being actually just two

and if you think about reducing the height we’re making the tree better we’re making it more

balanced we’re making it faster to search through and add and remove things from so we’re making a

So we’re making a better tree by reducing the height a little bit.

If you had a really, really, really bad tree and you just went around to all the bad nodes

and just started rotating them all, you’re reducing the height by one for each rotation.

Eventually, when you get up to the top of the tree, you’ll have an overall AVL tree,

which is pretty fast.

We should say now that AVL trees are always going to be log time trees because the imbalance

factor is limited by a constant number.

We’ll say that again in a future video.

in a in a future video so anyway i’m going to label these trees now

i’m going to say that the one on the top left is a single right rotation

and the uh the tree on the top right you can probably imagine is a single left rotation

let me just duplicate this real fast so i can come on man can i duplicate this yeah so i can

edit the text real fast. This is going to be a single left rotation. And then the trees at the

bottom, those are going to be double rotations. Let me just write over here, maybe next to that

one, double right rotation. And then I’ll duplicate this. And this one over here is going to be a

these on different sides than I usually do because I was trying to make it look a little more tricky

but it’s really not that bad. So how do we know that the top pattern is a single right rotation

and not a double right rotation or it’s a single right rotation and not a single left rotation?

The first thing to try to understand is what’s going to happen between the input pattern and

the output pattern. So if you look at the input pattern here we’ve got like a straight line and

And the output pattern is like a perfectly balanced trinode subtree.

Notice how the 55 is the new parent.

And it’s also in the middle for the output pattern.

And then for the input pattern, the 55 is also in the middle, but it’s not the new parent.

But it is the parent already of the 48 node.

Notice how it’s the parent already of one node, the 48 node.

So that means its relationship to the 48 node, the left child, doesn’t actually change.

bit more you’ll realize that only one node actually needs to be moved into position so we’ll call this

a rotation try to imagine visualize maybe like your point your left pointer finger being placed

on the 55 node and your right pointer finger being placed on the 65 node and then just rotate

the 65 node downward we rotate that clockwise and the physics people out there love to say that

are right rotations.

At least as far as I remember.

Not totally sure about that,

but I’m just going to say it anyway.

So notice how the 65 needs to be rotated

to the right or clockwise.

And only one node actually needs to be rotated

to produce that final output pattern.

That’s why we call this a single right rotation

because there’s only one node to rotate.

The next thing I’ll do is just try to give you

a few extra ways of being able to remember

being able to remember whether it’s a left or a right so for starters one node needs to be rotated

so it’s a single rotation and we’re rotating clockwise so it’s a right rotation but you can

also do this you can think of it like can i get rid of that real fast you can think of it like

well there is a bunch of empty space kind of sitting here on the right side so that could be

another way to remember that this is a right rotation also if you were to start at the node

and work your way to the node at the top,

you know, the Z node,

then we’re kind of going up and to the right.

So that’s another way to remember

that this is a right rotation.

Single, you can remember that also

by just the fact that this is a straight line.

Like notice how the nodes are kind of in a straight line.

They don’t do a zigzag or a bounce.

So single rotations are rotations that look straight at first,

or I guess input patterns that look straight

and only one node actually needs to be rotated.

um right versus left is there’s a pocket of empty space on the right side and you go up and to the

right for the right rotations similarly you can probably already figure out by now that

the left rotation just means well we’re going let’s see we’re going up and to the left to get

to that top node or the only node that has to be rotated is that 48 node and it’s going to be

rotated counterclockwise which is left so again only one node needs to be rotated and we’re going

to be rotated and we’re going to rotate it counterclockwise which is a left rotation so

one node rotated single counterclockwise left or just like a pocket of empty space sitting on the

left side okay so then for the double rotations the first thing you can look at is the idea that

there’s a little bit of a bounce you know there’s like a angle bounce there if you see a bounce or

sick a couple weeks ago then that’s a double rotation another way you can try to remember it

as two nodes need to be moved into position so if I maybe I should copy this to another slide real

fast let me copy this and we’ll do another slide okay so you know which nodes need to be moved into

position let me copy also the output pattern just as a quick reminder if we wanted to make that

If we wanted to make that output pattern, let me put it up here maybe,

then obviously the 55 still has to be in the middle

because it was already in the middle before we rotated.

That means both the 48 and the 65 need to be rotated underneath the 55.

So that means we’re going to do the 65, we’re going to rotate it clockwise underneath the 55.

So I’m going to do like a little circle here, a connector, and then I’ll do like 65 there.

65 there and then after we do that rotation we have to rotate the 48

underneath the 55 so that’s going to be a rotation that is counterclockwise so

I’m going to do this circle that there and then do a 48 notice how when we’re

done doing the rotations we have a valid binary search tree you should always

check your rotated pattern your output pattern to make sure it’s actually in

binary search tree because if it’s not let’s say the numbers are out of order for some reason from

left to right then you have rotated incorrectly and you have to double check yourself so two nodes

need to be rotated into position therefore it’s a double rotation or you see a diagonal input pattern

double rotation how do you remember the difference between left and right well um if you start at the

node in the middle just like we did in the last slides we start at the node in the middle and go

and go to the node at the top, the Z node,

we’re going up and to the right.

And so this is a right rotation.

So it’s a double right rotation.

Another way to remember it is you should probably try to rotate the Z node first.

The node that’s on very top is the 65.

Rotate that first and then call that the direction of the rotation.

So, you know, we rotate the 65 first.

That’s a clockwise.

So that’s why it’s a right rotation.

Then just ignore the direction of the other node that you rotated.

you can also kind of imagine taking the original node if you don’t if you don’t

want to think of like actually rotating let me just kind of erase this real fast

you can kind of imagine that you are you’re sort of taking the new parent

that’s supposed to be the new parent and just sort of pulling it up

I draw a picture of Batman and he shoots a batarang at it and he sounds like Christian

Bale and he’s like, where is the rotation?

I’m not going to do that.

Maybe if there are enough comments, I’ll do a special video just for my really, really

bad drawing.

But imagine the 55 is getting pulled up and it’s getting pulled up past two other nodes.

So that’s why it’s a double rotation.

Another way to remember.

The 55 would be the mob boss that’s hanging by his ankle.

anyway so uh we we kind of know how we can remember the difference between uh single and

double rotations uh we’ve got a single right rotation a single left a double right a double

left there’s only going to be four possible input patterns and they’re all going to look like this

one output pattern because really what we’re doing is we’re just we’re not you know creating

any nodes or removing any nodes we’re just disconnecting pointers we’re disconnecting

just get this over here we’re saying okay input pattern I disconnect the pointers I’m saying the

65 no longer has a left child the 48 no longer has a parent the 55 no longer has a parent and

the 48 no longer has a right child and then when we’re done with that we just kind of like reconnect

the relationships we’re like okay you know what just kidding you all have parents and children

again we’re just rearranging them okay let me check out my thing real fast here

I’m going to cut the video here because this is the basic idea for the different types of rotations that you could use.

In the next videos, we’re going to actually start rotating bad trees to make them work.

So thanks for watching this video.

I hope you learned a little bit of stuff and had a little bit of fun.

I’ll see you in the next video.

Okay.

Hey, everybody.

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

I really appreciate it.

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

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

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 uh 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

the night I get I wake up in a cold sweat 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 rotation types in an AVL self-balancing binary search tree.

The post AVL Tree Rotation Types Explained for Self-Balancing Binary Search Trees appeared first on NeuralLantern.com.

Learn AVL trees in this beginner-friendly introduction. We cover balance factors, why regular BSTs get slow, and how AVL trees stay balanced with rotations. Great for coding interviews and data structure understanding.

00:00 AVL Trees Introduction
00:00:28 Problems with Regular BSTs
00:00:56 AVL Tree Balance Rule
00:02:10 Balance Factor Explained
00:02:48 Computing Balance Factors
00:03:11 Example Tree Analysis
00:04:40 Imbalance at 65 Node
00:05:08 Invalid AVL Tree
00:06:18 Linear Tree Problem
00:06:50 Trinode Subtree
00:07:40 Selecting Z Y X Nodes
00:09:20 Rotation Overview
00:10:03 Next Videos Preview
00:11:09 Thank You and Subscribe

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

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 a type of self-balancing binary search tree called an AVL tree.

Okay, so by now I hope you’ve seen my other videos that I’ve posted

previously where we talked about binary search trees, how to define them,

terminology, how to know you’re actually looking at one, how to build them, insert,

If you finish those videos already with me, then you know that binary search trees can actually get slow sometimes because if we have bad data, regular binary search trees don’t really know how to rearrange themselves.

They just might become slow depending on how good or bad the data is.

The data is totally random.

Then on average, it’ll, you know, the trees will be log time, but that’s not always the case.

Maybe sometimes you have bad data, sorted data, poison data, whatever kind of data.

The secret to AVL trees is we’re going to start with the binary search tree.

And so first it has to satisfy all the rules of the binary search tree.

And then we add on another rule.

The rule is going to be that we don’t have a valid AVL tree.

If the balance factor for any of the nodes, we’ll talk about balance factors in a second.

If the balance factor for any node is two or worse.

Meaning if we think the tree is too imbalanced at any node, it’s not a valid AVL tree.

and therefore we must rebalance the tree with something called a rotation.

After we do enough rotations and we see that the tree is balanced again, then it’ll be valid.

And so AVL trees sometimes are invalid in some intermediate state.

Like if you have an AVL tree and you add some data into it,

for a moment it might be an invalid AVL tree and then internally it’s sort of just like rotating itself and rebalancing itself.

Then when the tree is done, you’ll have a valid AVL tree again, if that makes sense.

AVL tree again if that makes sense. So suppose this tree here we can tell this is a valid binary

search tree because it follows all the rules that we talked about before. So let’s start implementing

the first rule of an AVL tree which is let’s compute the balance factors for every single node.

How do we compute balance factors? The basic idea is I want to say BF for balance factor

the left subtree height minus the right subtree height.

If you don’t know what a subtree or height is,

you should probably check out my other videos right now.

But basically, we’re just going to take the absolute value

just to get the difference in the height of the left

and the height of the right.

So if you know binary search trees already,

then you know that the leaves, they don’t have any subtrees.

So their balance factor is going to be pretty easy to compute.

It’s just going to be a zero.

I should also point out that some other tutorials out there use positive and negative numbers

for the balance factor.

That’s okay.

I’m just going to use absolute values here because it’s a little bit more simple.

So all the leaves get a balance factor of zero, which is fine.

We’re looking to see if we can find a balance factor of two or worse to indicate to us that

we have an invalid AVL tree.

So far, so good.

Let’s look at the 22 node.

we’ll compute the height of the left subtree versus the height of the right subtree.

So, you know, I’m going to highlight its left subtree.

That’s just the 14 node that has a height of 1.

And then its right subtree is just the 36 node that also has a height of 1,

which means the balance factor for the 22 node is the absolute value of 1 minus 1 is 0.

So actually the 22 node is perfectly balanced.

If you think about it, that makes sense.

Left and right subtrees have the same height.

No problem.

have the same height no problem so I’m going to move on let’s compute the balance factor for the

48 node this is a little trickier notice how the right subtree has a height of one and there is no

left subtree which means its height is zero so for the 48 node it’s actually going to be

the absolute value of zero minus one or just one so we find our first node that’s a little bit out

imbalance here but avl trees tolerate imbalances of one they don’t really care we sort of try to

make a trade-off between constantly always rotating every single time anything happens

which would perhaps burn a little too much cpu versus letting the tree just be imbalanced to a

reasonable amount so we could still call this a log tree in the end so we consider this to be okay

65 node and compute the balance factor so 65 node has no right subtree so the height is zero there

and its left subtree is those two nodes on the left so that has a height of two which means the

balance factor for the 65 node is going to be the absolute value of two minus zero is two at this

point we are already certain that this is not a valid avl tree and it would need to be rebalanced

you know, consider it a valid AVL tree in the future.

So invalid AVL tree, still a valid binary search tree.

Something has to be done.

Normally what I would say is if you find some nodes

way down lower in the tree that are imbalanced,

then just go ahead and perform a rebalancing

or a rotation immediately,

because sometimes when you rotate lower in the tree,

you’ll end up fixing nodes that are a little higher.

But since we started with this tree

and we’re not kind of, you know,

building a tree step-by-step,

I just want to compute the balance factor for all of the nodes at the same time.

So we’ll do the same thing for the 41 node, the root node.

Its left subtree has a height of two and its right subtree has a height of three.

So its balance factor is the absolute value of two minus three is one.

So actually the root node is okay.

If it was only up to the root node, we would say this is a valid AVL tree

and we don’t really need to do anything.

need to do anything however we’ve already seen that the 65 node is invalid so again uh we we

need to do something here’s another quick example before we move on to actually identifying which

nodes to to modify and rotate just real fast i want to show you you know that a binary search

tree could actually end up being a linear tree if you had really really really bad data the binary

This is slow because this is a linear tree.

The time complexity of searching through this tree is linear time.

It scales linearly with the number of nodes in your data set.

That’s really far away from log time, which is supposed to be lightning fast.

So an AVL tree will fix this kind of bad data.

Let’s take a step back here and focus your attention for a second on these three nodes.

We noticed that there is one node that’s actually out of whack.

It’s the 65 node, right?

What we’re going to do is we’re going to find a trinode subtree that starts with the first node or the lowest node we can find that’s out of whack.

It’s the 65 node.

And you can tell that if we just kind of go down a level and down another level to select the other two nodes,

it’s just going to be this little, you know, subtree of three nodes or otherwise known as a trinode subtree.

So here’s kind of a diagram for that.

Whoops, forgot to delete that earlier.

Let me get rid of that.

So this is the trinode subtree that we selected, right?

So we’ve got the 65 and the 48 and the 55.

How did we actually select this?

So what you kind of want to do is the first node that is out of whack,

you want to call that Z.

So I’m going to write a Z here.

What we’re looking for is a trinode subtree,

which we’ll first call X and Y and Z.

And then we’ll end up reordering the nodes

and then rearranging all the pointers to the nodes

so that the trinode subtree is a little bit more in balance.

more in balance. So we see the Z node. We have to find the Y node next. To find the Y node,

what’s going on with my computer? Oh, there we go. We have the Z node. To find the Y node,

really, we’re just going to take the child of the 65 node that has the taller subtree. So

there’s only one subtree, you know, on the left, there’s no subtree on the right of the 65 node.

So the choice is obvious. But just so you know, if there was, you know, another, you know, child

another you know child hanging off of the right for some reason we would still choose the number

48 node as the y node because it has the taller subtree notice how the subtree on the left is two

and the subtree on the right has a height of one so always take the taller subtree when you’re

looking for uh y and then x so then we do the same thing we go down to the grandchild of the z node

and if we had a choice to go left or right again we would always choose the taller subtree in this

taller subtree in this case there’s only one choice so that x node is going to be the 55

now in this next slide i’ve kind of redrawn this in a little bit different of a way

notice the trinode subtree that we just selected here the 65 48 55 subtree it has a height of three

i mean that should be obvious right it’s just got a height of three

or height. Notice on the left, these are the same three nodes. Exactly. 48, 55, and 65. That’s the

same three nodes that we originally had. But notice how the height is too. So the basic idea for ABL

trees is, you know, compute the balance factors. And as soon as you identify a node that’s out of

whack, you grab a tri-node sub-tree starting at the node that’s out of whack, the Z node.

And then we’ll perform, quote unquote, a rotation where we just kind of smoosh it to be a little

be a little bit more balanced and a little bit more a little bit shorter so the height goes from

three to two once we do that the rest of the tree it’s going to get a little bit better you’ll notice

that this will end up sometimes completely but sometimes partially fixing bad balance factors

in the tree so um this is the end of the intro i only wanted to spend a little time just kind of

like warming you up to the idea in the next videos uh we’re going to actually look at performing

identifying the four different types of rotations that you could see and like how to do them.

We’ll talk more about the idea that we’re really just rearranging pointers here.

If you’re thinking about code, you’re thinking about, oh, I’ve got some pointers between these

nodes. We’re not going to delete any nodes or add any nodes. We’re just going to like

rearrange who is a parent of who, who is a child of who. And then eventually we’ll deal with some

really bad trees and we’ll become experts at just like maintaining ABL trees.

talk about ways to visualize the rotations, which makes it a little bit easier to remember these

patterns and stuff. Okay, so thank you for watching this video. I hope you learned a little bit of

stuff and had a little bit of fun. In the next one, we’re going to get started. We’re going to

go deep. I’m going to get my gear. Sorry.

Hey, everybody. Thanks for watching this video again from the bottom of my heart. I really

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,

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 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.

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 uh 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

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 enjoy the cool music as I fade into the darkness

which is coming for us all.

Thank you.

The post AVL Tree Tutorial: Balance Factors and Why They Fix Slow BSTs appeared first on NeuralLantern.com.

In this video we walk through how to perform searches in a Binary Search Tree. Starting with a perfectly balanced BST, we cover the search process step by step, including finding existing nodes like 73 and determining that numbers like 44 do not exist in the tree.

We discuss time complexity for searches in BSTs – O(log n) on average for balanced trees and O(n) in the worst case when the tree becomes skewed like a linked list due to sorted or bad data. Learn why each comparison eliminates half the remaining data and how height affects performance.

Perfect for students learning data structures and algorithms. If you’re studying BSTs, this clear explanation will help you understand searching, insertion paths, and why self-balancing trees matter.

Thanks for watching!

00:00 Introduction to BST Search
00:31 BST Not Self-Balancing
00:40 Average Case Log Time
00:53 Linear Time in Worst Case
01:13 How BST Search Works
01:18 Search Path Example
02:08 Searching for Existing Node
02:35 Searching for Non-Existent Node
03:19 Tree Size and Height
03:30 Time Complexity O(h)
05:40 Bad Data Example
08:23 Skewed Tree Like Linked List
09:53 Linear Time in Worst Case
11:58 Why Log Time
12:36 Halving the Search Space
14:14 O(log n) Summary
14:28 Conclusion

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

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

hey there let’s perform searches in a binary search tree

okay if you watch my previous videos you know how to define a binary search tree by now

you know some terminology you know how to construct a tree and so now let’s just take

a tree that’s already been constructed and let’s search through it first thing i want to say is

first thing I want to say is this is a binary search tree this is not a self

balancing tree so in the future this tree could get lopsided and messed up

depending on what kind of data we add we can always expect that binary search

trees have a search time or an insert time or removal time of log log base 2

of n on average assuming that the data is random or in the worst possible case

scenario linear time so these could get slower right now you can see this tree

Right now you can see this tree is perfectly balanced.

So if we say that our tree is currently perfectly balanced and it’s always going to be perfectly balanced,

which is a fantasy, but let’s just say that it is,

then we could just say it’s a log tree.

It’s going to take log time to search through.

So how do we perform searches?

Again, if you saw my previous videos, you should know that it’s really easy to find out where a node belongs.

Like for example, if I was going to add the number 14,

I would first look at the root node and I’d say, okay, the root node is occupied.

and I’d say, okay, the root node is occupied.

And so where would 14 belong?

Well, it would belong on the left of 37

because it’s less than 37.

It would belong on the left of 16

because it’s less than 16.

It would belong on the right of 9

because it’s greater than 9.

It would belong on the right of 11

because it’s greater than 11.

And so the 14 node that we just wanted to add,

is that what I just said, 14?

Would end up going there.

So when you’re searching through a binary search tree,

you really just have to go find

have to go find where the node would belong as if you’re performing insert or you could think of it

the other way around like insert is really thinking of a search first but basically we’re just going

to start by saying you know pick a number and we’ll see if it exists so uh let’s pick the number

67 or actually let’s pick the number 73 just to see if it exists in the tree so 73 i’m going to

do like you know seven three with like a question mark we check the root node 73 belongs on the

side we look at the 59 it belongs on the right side and we found our 73 so 73 exists in the tree

and it only took us three examinations only three examinations let’s look for a number that doesn’t

actually exist in the tree so maybe oh my thing is freezing what’s going on okay so maybe uh let’s

The 37 here, 44 belongs on the right of 37.

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

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

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

The 44 would have been there, but it’s not because that right child pointer off the 43

is null.

So we only had to really examine one, two, three, four nodes in order to determine that

our number 44 didn’t exist in the tree.

Notice how we’re not doing a lot of examinations compared to the total size of the tree.

compared to the total size of the tree.

So let me just write this up here.

How many nodes do we have?

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

We got 15 nodes up here.

Someone say N is equal to 15.

And what’s the height of the tree?

Remember, the height of the tree is the number of nodes you must touch

as you make your way down towards the deepest node.

Or if you’ve already found the deepest node,

you take its depth and you just add 1, assuming that depths start at 0.

start at zero. So I’ll just say that the depth of the root node is zero and the 59 and the 16 are

one. And then that third row is two. And that last row is three. And then I just add one to the

deepest node that I can find, which is just going to have a depth of three. All of these on the

bottom row have a depth of three. So the height of this tree is actually four, because we would

so like 37 59 48 43 that’s four touches um or the or the depth of the deepest node plus one okay um

all trees all binary search trees whether they’re actually avl trees or regular binary search trees

or whether they’re balanced or imbalanced they’re always going to have a time complexity to search

through of o of h meaning in the worst case scenario you’ll have to touch h number of nodes

order to find a node by search query or to add a new node or even to delete a new node.

So how does that compare to this tree in reality?

Let me just open up a little calculator real fast.

I just want to show you.

So if we do log base two, because we have a binary search tree, not a trinary search

nodes 15 it tells us that it should take us no more than four examinations to find the node that

we’re looking for if the tree was perfectly balanced and if you if you if you notice that’s

exactly what the height is telling us here if the tree was more imbalanced the height would get

really bad compared to the number of nodes and it would no longer be considered a log tree it would

just be you know somewhere in between linear time and log time um let’s see what else can i show you

let’s do well we did that computation let’s do a search through the tree that

through a tree that’s actually really really bad let’s pretend that we have a

bunch of nodes here and you know I’ve got an old story that I love to tell

about this when like when my grandma was alive she was kind of bitter towards the

end you know I loved her but she used to call the cops on her neighbors for

gossip and at some point in time she got into a feud with her neighbor who was

with her neighbor who was also a bitter old lady.

You know, towards the end, it kind of happens sometimes.

It sucks, but it happened.

And I guess the neighbor didn’t like my grandma’s tree

that she had in her backyard.

So they fought over it, they argued over it,

and then one day my grandma said

she was looking out the backyard window

to yell at ducks who were jumping into her pool

because she just hated when the ducks went into her pool.

She was waiting for them to show up.

She wasn’t even looking at ducks.

even looking at ducks she was just waiting and she saw the other little old lady reach her arm over

the fence and spray my grandma’s tree with some sort of poison then my grandma’s tree died and uh

i guess you know my grandma never never got over it i always thought it was like a funny story it

was a little sad but um she poisoned my grandma’s tree so we can kind of do the same thing with the

binary search tree we can give bad data let me show you what happens here if i use this data set

search tree. So we’re going to add this node right here. It’s going to be the 14.

And then when we add the 19 node, I’m just going to duplicate it. The 19 is supposed to be on the

right side of 14 because it’s greater than 14. So I’m just going to like, you know, draw a 19 right

here and a little connecting line. Okay. Then when we add the 24, I’m going to duplicate this node

the 24 go belongs on the right side of the 14 and also belongs on the right side of the 19

because it’s greater than 19 so again we have a node that shows up on the right side let me

remember to actually fix the 19 so it looks like 24. then when we add the uh 29 it’s gonna end up

being the same thing right the 29 is gonna end up showing on the right the right the right it’s

If we have bad data, we can end up with a tree that kind of looks like a straight line.

And if you are watching this video from the future,

after I’ve posted all of my data structures videos that I have,

you might notice that this looks like another data structure.

If you’re watching this right away, I haven’t posted those videos just yet.

But just tilt your head to the right a little bit

and tell me if that looks like something that you recognize.

It looks like a linked list.

looks like a linked list just like a straight line or even i guess you could kind of say maybe an array

um just like a straight line of data there’s no uh you know there’s no splitting of the data

so we have the 29 and then the 35 and then uh maybe i’ll just do one more node only and i’ll

get rid of that 54 because that’s too many nodes so what happens is if you have you know bad data

tree doesn’t actually search or add insert or remove or anything like that in log time anymore

instead it operates in linear time just like a linked list would meaning we would have to scan

through every single node in the entire tree to be sure that some value did not exist well

not exactly but in the worst case scenario we’d have to scan through the whole entire tree

for example let’s just look at the the number of nodes real fast we’ll say the

number of nodes here is one two three four oh I put two 24s in there oh dearie

let me get that says 14 19 24 29 and then I guess I got to make that a 35 oh

okay and then there’s a 49 I guess I did add every single node okay so we added

so there’s like seven uh items in the tree so i’m going to say n is equal to seven the height also

is seven though so the height is seven notice how if we say that it’s always true that a binary

search tree has a time complexity in the worst case of o of h meaning you’d have to go down

in the worst case the number of levels that is equal to the whole entire height of the entire

tree that’s also the number of nodes in the tree which means uh if i wanted to add let’s say the

I don’t know, if you wanted to add the number 60,

60 would end up going down here.

And in order to find where 60 would go,

we’d have to look at the 14, that’s 1, 19, 24.

We’d have to look at all these nodes.

That is seven nodes.

We’d have to examine seven nodes

just to figure out where the 60 would go.

Or if we were searching for 60,

then we’d have to go down that far

to find out that 60 didn’t exist.

So this is nowhere near a log tree.

This is a linear tree, a linear time tree.

year time tree and just to drive the point further if we did log base two of the number of nodes in

this case seven notice how it’s telling us that we should if it was a log tree if it was perfectly

balanced or a self-balancing tree we should have to touch no more than three nodes in order to find

what we’re looking for to search through the tree or to insert a new node or even to delete a node

but that’s not the case here because the tree is really really slow compared to a perfectly balanced

slow compared to a perfectly balanced tree.

So we call this a linear tree.

It sucks.

You want to try to avoid that.

You don’t want your data to be poisoned.

On average, your trees won’t really look like this if you just have totally

random data, but if you think there’s a chance that your data might be skewed

in some way, it’s probably a good idea to upgrade to a self-balancing tree,

which we’re going to talk about later.

Okay.

What else can I tell you real fast?

So we talked about searching.

why are these trees considered log time? I mean, they’re really, really fast, but why?

Let’s just duplicate this slide here and I’ll move it down one level. I just want to kind of

show you why this ends up being a log time tree. Okay. So why, why is this a log time tree?

Suppose for the sake of argument, we’re searching for the number 52. So if we’re searching for the

node the root node and decide where would the 52 belong let me actually write that down so i don’t

forget 52 question mark where would the 52 belong it would belong on the right side of the 37 because

it’s greater than 37 right which means it’s actually impossible that the 52 would be in any

of these other nodes on the left side there’s no need to check them we’re not going to scan the

whole tree we’re just going to go left or right and ignore the whole other side of the tree

we just did is with one examination we eliminated half of the remaining data set or i guess of the

initial data set if we’re looking at the root node so then the next thing that we do is we just kind

of say okay it belongs on the right side so we look at the 59 node and we do the same thing we

say where would 52 be would it be on the left side or the right side of the 59 node it would be on

the left side which means we’re going to eliminate from consideration the entire right subtree of the

So again, we’re eliminating half of the remaining data set.

Then we kind of go down here and we look at the 48.

We do the same thing.

52 belongs on the right side.

So we eliminate half of the remaining data set, you know, and then eventually we do find

the 52 and then that’s it.

So if we’re eliminating half of the data set with every single, just one examination at

a time, that’s why it ends up being log base two.

getting twice as close to your destination at every step you took if you’re like in a car like

running maybe you’re on the moon or something then it would be a log time you know uh progress

towards your goal or eliminating half of the data set at every single step sometimes people see

for loops on exams and stuff when we talk about this um like for i equals zero uh i is less than

it would be like i times equals two.

So i’s jumping twice as far each time.

That’s the sort of thing that makes it log.

So I’m just going to write down log here real fast

to drive the point home a little bit more.

O of log base two of n.

Yeah, so I guess that’s all I wanted to tell you in this video.

Hopefully you feel like an expert in searching now.

If you want to see more searching videos,

leave a comment or something like that.

leave a comment or something like that. But yeah, thank you for watching. And I hope you

learned a little bit of stuff and had a little bit of fun. I’ll see you in the next video.

I’m going to go find a blueberry muffin.

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,

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 uh and subscribe you know sometimes i’m sleeping in the middle of the night and i just

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

And I 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

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. I’m like this

It would really it really mean the world to me. I would really appreciate it. So

So again, thank you so much for watching this video and enjoy the cool music as I fade into the darkness, which is coming for us all.

Thank you.

The post How to Search in a Binary Search Tree (BST) – Step by Step Explanation with Examples appeared first on NeuralLantern.com.

In this hands-on tutorial, we build a binary search tree (BST) from scratch by inserting numbers one by one: 88, 21, 3, 6, 72, 34, 11, 1, 90, 65, 55, 17, 23, and 9. Watch as each node finds its correct position following BST rules, with clear explanations of left and right child decisions, parent pointers, and why the tree ends up looking a bit wonky but is still valid.

We cover the full insertion process, verify the tree is a proper BST by checking inorder traversal (sorted order), confirm it’s a connected acyclic rooted binary tree, and discuss tree height, time complexity (O(h) where h=6 for this tree), and why self-balancing trees matter for better performance.

Great practice for computer science students, programmers learning data structures, or anyone prepping for coding interviews. No fancy animations – just real step-by-step drawing and reasoning.

If you want more BST practice videos or specific insertion sequences, drop a comment below!

00:00 Introduction to BST Practice
00:35 Insertion Sequence Overview
00:59 Rules for Building BST
01:30 Insert 88 as Root
02:20 Continue building the tree from input data
13:04 Finish building the tree
14:56 Clean Up Diagram
15:24 Verify Inorder Traversal
16:48 Confirm Tree Properties
19:23 Tree Height and Time Complexity
22:01 Search Example for 55
23:09 Log Time vs Actual Height
24:21 Conclusion and Future Topics

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

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 practice constructing a binary search tree from scratch.

In my previous video, we actually did this already, and in other previous videos we defined

what is a binary search tree and some terminology and stuff like that, but I thought it would

be nice to have two practice videos up. I’m willing to put more up if people want to make

comments about more trees that they want to see inserted. For now, I’m just going to say

we will add the following sequence of numbers. So this is a little diagram from the last time we

did this. Let me just, oh, I’m supposed to make that full screen so it can be bigger. Whoops.

Let me go ahead and add a new slide here. And then I’m going to do,

Okay, so we’re going to try to add the following sequence of numbers.

Like I said in my other video, don’t try to make the tree prettier.

Don’t get mad if a number looks like it’s too far to the left or something.

Just follow the normal rules of letting a node drop wherever it is supposed to drop

according to the rules of building a binary search tree.

So the first thing that I’m going to do is maybe draw a little arrow here.

I’m going to do like a pink arrow to indicate, you know,

You know, well, maybe I’ll do like a red one to indicate which number we’re actually trying to add at the moment.

So it’s going to be the 88 first.

Let’s see, we’ll put that right there.

And then now let’s say that the 88 is going to drop into our tree somewhere.

First question we have to ask ourselves is do we have a root node?

We don’t have a root node, which means the number we’re trying to add should be the root node.

And that’s it.

So I’m going to draw like a little circle here, a little node.

and I’m going to stick the number 88 inside of it we’re using integer t types

if you recall the last videos these nodes are supposed to be able to hold

almost any data type that you want they don’t have to be numbers but I’m just

going to use numbers for the sake of this example because it’s easier so I’m

going to say this is our root node it’s at the very top of the tree and we’re

done adding 88 and that’s it next step we’re going to add the 21 so I’m just

forward a little bit here and the 21 same question do we have a root node we currently do so that

means we can’t actually put the 21 there so we have to make a decision does the 21 belong on the

left or the right of the 88 the 21 is less than 88 which means it belongs on the left side so i’m

just going to duplicate this and try to make a pretty diagram by sort of splitting the difference

in terms of the empty space on the left between the edge of the screen and the existing root node

and make sure that it goes down, you know, a full rank, you know, at least the full height of a node,

maybe a little bit more, but you want to keep all same depth nodes on the same Y coordinate.

It’s just easier to debug your diagrams that way.

This one’s actually probably going to get messy. I might have to readjust this a few times.

I think I recalled these were, these might’ve been bad numbers. I can’t remember.

Okay. So the 21 is going to be the left child of the 88 because it belongs on the left side.

So I’m just going to do my little connecting line here.

connecting line here now 21 has a parent of 88 and 88 has a left child of 21 and we’re done adding

the 21 so i’m going to move the arrow to the three we’re now trying to add the three node

again we look at the root node we say okay that’s occupied so we can’t use that does three belong on

the left or the right of the 88 well it’s less than 88 so it belongs on the left the left child

again, does the three belong on the left or the right of the 21? It belongs on the left

because it’s less than 21 and the left child of 21 is currently doesn’t exist. It’s null.

So that means the three is going to be the new left child of the 21 node. Maybe just put it

like right there, put the three there. And then I’m going to do the connecting line in your code.

You can imagine that the left child pointer of the 21 node has now been set. So it’s pointing

been set so it’s pointing to the brand new node we just made for the three and then inside of the

three node its parent pointer is pointing to the 21 node okay so we’re done adding the three we

move on to the six same thing that we did before we look at the root node uh the six belongs on

the left so i’m gonna say go to the left the 21 node is it’s there it’s occupied so we have to

left of 21 because it’s less than 21 we go down to the left then we look at the three that’s also

occupied does the six belong on the left or right of three it belongs on the right side of three

because it’s greater than three so that means the sixth node is going to be the right child

of three again try to split the difference these diagrams get ugly fast i really

i don’t i don’t want to rearrange the topology but i’m probably gonna have to

I think I’m like crashing out here.

Oh, no.

Okay.

Nope.

Okay.

Let me try one more time.

These lines are killing me.

Okay.

I’m just going to update the three to a six and leave a little gap on that line.

It’s fine.

Now we’re ready to try to add the 72 node.

We have a little relief here because this is not like a smaller and smaller number that we’re dealing with.

So, well, we just look at the root node.

72 belongs on the left side so I’m going to hop to the left here we then look at

the 21 72 belongs on the right side because it’s greater than 21 so that

means 72 is going to be the right child of 21 so I’m just going to select this

make a duplicate try to keep the three and the six at the same you know y

coordinate because they’re on the same descendancy rank they’re at the same

you know generation whatever you want to call it so I’m going to put the 72 on

And then I’m going to do our connecting line, indicating that both nodes now have pointers that refer to each other.

Okay, we’re done adding the 72.

I’m going to move this to the right a little bit.

And then, oops, get rid of that little dot.

Now we’re ready to add the 34.

So the 34, we look at the 88 node occupied.

We go left.

We look at the 21 node.

34 belongs on the right side of 21.

of 21 so then we look at the 72 34 belongs on the left side of 72 so that means 34 is going to be

the left child of 72 so I’m going to select one of these nodes and duplicate it and say that

you have a left child of 72 now and it’s going to be the 34 node do my pointer connection real fast

I haven’t been duplicating the pages. Okay. So, uh, I guess that’s just for me.

We’ll move on to adding the 11 node.

So we add the 11 node by looking at the root node first.

11 belongs on the left side. We then look at the 21,

11 belongs on the left of 21. Go to the left here. We look at the three,

11 belongs on the right of the three. We go to the right,

11 belongs on the right of the six node.

This is definitely a gross graph at this point.

at this point. So I’m going to duplicate this node here and try to split the difference between

the six and the 21 in terms of like the free space. So I’m just going to drag this down a

little bit there and say that 11 goes as the new right child of the six node. So

just do that. This is a gross diagram. I might want to redraw this later.

Now we’re ready to try to add the one node.

the one again we look at the root node of the tree and it’s occupied so we can’t put it there

we go to the left we go to the left again and the one belongs on the left of the three nodes so we

have a little bit more room there so that’s good i’m gonna copy this node and make it the new left

child of the three i’m gonna like say that our one is right there and then i’m gonna do the connecting line

okay all right we’re done adding the one now I’m gonna add the 90 node oh this is

gonna be nice and easy because the 90 definitely belongs on the right side of

the 80 node whoops what happened okay sorry for making that noise I’m gonna

duplicate this node here and make it the right child of the 88 node so let’s see

kind of even there. So we’re going to put 90 right there. And then I’m going to do a connecting line

in blue. Now we’re done adding the 90.

So then we’re going to add the 65. 65 belongs on the left of the 88 node.

So we’re kind of in left territory now. It’s kind of sucky again.

And bounce down to the left. 66 belongs on the right side of the 21 node. So we look at the 72.

look at the 72 it belongs on the left of the 72 we go there it belongs on the right of the 34 so we

go right here as the new right child and the diagram kind of sucks at this point it’s a little

cramped but i’m going to try my best to split the difference between the 34 and the 32 visually to

make a nice easy to debug graph so maybe like somewhere around there put 66 then i’m going to

So the 66 is now the right child of 34.

Okay, next number that we’re going to add is my computer’s crashing.

Hello?

What happened?

There we go.

Okay.

So we’re ready to add the 55.

Oh, God.

Okay, let me see what’s going to happen here.

This is awful.

is awful i usually say you have to space these out enough so that none of these overlap but

they’re about to overlap okay we’ll do go to the left because 55 is less than 88 go to the right

because 55 is greater than 21 go to the left because it’s less than 72 go to the right because

it’s greater than 34 then go to the left again because it’s less than 66 i hate this i hate this

between 34 and 66, just to try to make it easier to debug.

This is almost, I’m almost stretched

to my mental limit right now.

So I’m gonna make the left child pointer here

and the new node we just added was 55.

Whoops, yeah, 55.

Okay, my God.

Let me just duplicate this one more time

and get rid of those pink arrows.

arrows let’s add the 17 next 17 right here um so once again we look at the root node it’s occupied

go to the left because it’s less than we look at the 21 we go left because it’s less than 21

we go to the right because it’s greater than three we look at the six we go to the right

because it’s greater than six we go to the right because it’s greater than 11.

So a super cramped diagram.

I’m in hell.

I’m just going to move this slightly to the right because this is just awful.

And I’m going to try to make sure again that same depth nodes are at the same Y coordinate.

Let me fix that number real fast before I forget.

And put it as a 17.

And then do my connecting line.

Like that.

Okay.

I’m losing it.

The, uh, whoops, the 23, where is this going to go?

Is it 23?

Um, Hmm.

Hmm.

Oh, well, it’s going to be like left child of the 34 probably.

Okay.

Let me just, uh, look at the root node.

Okay.

23 belongs on the left of that.

Look at the 21, 23 belongs on the right of that.

Cause it’s greater than 21.

Look at the 72.

It belongs on the left.

it belongs on the left look at the 34 belongs on the left and then that’s going to be the new left

child okay so I’m going to duplicate one of these nodes and it’s going to be the new left child of

the 34 node that is awful but I guess we barely have enough room let me change that to a 23 and

then I’ll add my connecting line okay and now we’re ready to add the final value in our tree

to be? It’s going to be like left child of 11 maybe. So we look at the root node. Whoops,

forgot to move that arrow. We look at the root node. We can’t put it there. Nine belongs on the

left side of the root. So we go like that. Nine belongs on the left side of the 21. Oh, did I just

guess something wrong? No, no, no. I think I’m okay. Go to the left side of that. We look at

right side of three we look at the six nine belongs on the right side of the six we look at

the eleven nine belongs on the left side of eleven because it’s less than eleven so I’m just going to

duplicate this and it’s going to end up being the left side whoops nope that’s wrong hang on a second

let me oh come on man let me get this down it’s going to be the left child of eleven not the left

there and the diagram is a little messed up maybe I should try to rearrange this in a second

it the topology is correct but it’s harder to debug because you can see that one of the right

descendants of the six node is actually physically on its left side and that just makes it extra hard

to debug but for now we’ll say that we’re done adding stuff into the tree so maybe I can kind

I’m not going to change the actual topology.

I’m just going to like, you know, redraw this in a slightly nicer way.

So I can probably take this whole subtree and move it over to the left a little bit to make it a little cleaner.

Which will give me some room to move this subtree a little bit over to the right.

Am I still wearing my microphone? Yeah.

And then it’s a little bit cleaner.

Then I just have to redraw this line.

Whoops.

oops yeah just have to redraw this line and now i think we’re following the rules that i talked

about before where a good diagram has all the left descendants physically on the left side of

a given node so let’s see the six has everything on the right and everything i think we’re okay

i’m going to duplicate this real fast and now let’s verify that our tree is actually correct

So I said this in the last video when we built a tree, but you basically want to take like the input data set here and sort it.

And whatever sorted list you end up with, that’s what you should see when you scan your eyes from left to right.

Again, this is another good argument for drawing the diagram in a really good way.

All left descendants are physically on the left. All right descendants are physically on the right.

So another way that I could do this, besides I don’t really want to sort this list right now,

Just scan from left to right and make sure that I see increasing numbers

Or if you’ve decided to make a tree that supports duplicates, make sure that you see non-decreasing numbers

But I’m looking for an ascending list

Okay, so I’m gonna just like do little hashes here

One is the lowest number. That’s good. Then if I go to the right just a little bit

I see a three go to the right a little bit. I see a six that’s still increasing then I see a nine and then I see an 11

still been increasing go to the right a little bit more it’s a 21 go to the right a little bit more

it’s a 23 then it’s a 34 then it’s a 55 then it’s a 66 then it’s a 72 so far everything’s been

increasing and then from 72 to 88 and from 88 to 90. so the ordering of the numbers are correct

let me just make sure i actually have a binary search tree by the definition of a bst first it

crazy lines going off in some direction or like different symbols this is a

connected graph meaning I could probably find well I definitely could find a path

from any node to any other node if I just you know trace the edges so can the

9 find its way to the 90 yeah if we just kind of like go you know up this way and

follow the edges up to the 88 and then back down to the 90 so every single node

could do that it could find every single other node on the graph which means this

every single other node on the graph which means this is a connected graph so that’s good the next

thing is now that we have a connected graph do we have a tree so check for cycles uh can any start

node find its way back to itself in a path that does not repeat edges i don’t see that anywhere

in the tree so i think we have a valid tree let me get rid of that real fast so for example uh

Could we find a path that goes away from the 9 node and then comes back without repeating any edges?

I cannot because as soon as we go out to the 11,

later on we would have to use that same edge to come back down to the 9 and that would be repeating an edge.

So we just kind of check that for every single node.

We can’t find a cycle anywhere in this entire graph.

So this is an acyclic graph.

Okay, that means it’s a tree.

Is this a rooted tree?

ancestor to all other nodes and it’s that 88 node that’s the root node of the

entire tree every single node in the tree can say that 88 is its greatest

ancestor there’s no you know same leveled nodes at the very very very top okay so

this is a rooted tree now is it a binary tree yeah we look at every single node

and we can see that none of the nodes have more than two children they’ve all

this is a binary tree. And then when we, you know, we verified the numbers a second ago,

that means this is a binary search tree. So it satisfies all the properties of a binary search

tree. It doesn’t look very good. It’s kind of wonky, but it is valid. Remember this,

you know, a binary search tree just by itself is not a self-balancing tree,

which means you, you, you need to like not inject your human feelings into the tree while you’re

building it and start rearranging it to make it prettier. It wouldn’t be a valid binary search

if you tried to add special rules when you were creating it.

I don’t know.

If you imagine that maybe you, the human,

were changing the input data,

then I guess that’s valid.

But don’t imagine that the tree

is changing the data as you add it.

Anyway, so how fast is this tree?

Remember we said in a previous video

that a perfect binary search tree,

meaning perfectly balanced on every single node,

would be a log time tree.

It would be really, really fast to add and search

to add and search and even remove but this tree is definitely lopsided so this

is not a log tree the time complexity of a binary search tree actually is not

really log because the tree could just grow in any direction so in the worst

case scenario if you add the worst possible data you’d end up with a linear

time tree self balancing trees will be log time trees because they always

rearrange themselves to make sure that they’re balanced to a certain extent but

But, you know, as a binary search tree scales, it could just get slower and slower and slower.

So we wouldn’t be able to say that BSTs, binary search trees in general are log time.

We could pull up a calculator though and we could say, well, you know, what’s the height of this particular tree?

Let me just look at the depths real fast here.

What’s the height of this tree?

So the root node has a depth of zero and then one and then two and then three and then four.

drawing your tree in a nice pretty way where all the ranks are the same physically.

We just take the deepest node and we add one to it and we say that’s the height.

So the height of this tree is six.

Another way of looking at it is if we wanted to touch one of the deepest nodes,

how many nodes would we have to touch as we travel down through the tree?

So how many nodes would we have to touch to find, you know, the nine or the 17 or the 55?

one node the 88 two and let’s go to the left three four five six we’d have to touch six nodes

to get to the deepest node so that’s why we’re saying that’s another way that we’re justifying

that we say the height is six so the height of this tree is six which means in the worst case

scenario if we needed to search this tree again we’ll talk about actually searching in another

video but for now i can just promise you that if we were going to search this tree we could do it

going to search this tree we could do it in at most six uh examinations so even though we have

a lot of nodes here how many nodes do we actually have let me just double check this we have n

is equal to one two three four five six seven eight nine ten eleven twelve thirteen fourteen

we have fourteen nodes but at most we’d have to examine six nodes because this is a binary search

tree so it’s a lot faster than scanning the whole tree in linear time but it could be a lot faster

It could be a lot faster if the tree was better balanced.

That’s a topic for another day.

So for example, if we wanted to search for the number 55, let’s say we were just going

to search for 55, you know, we’d look at the 88.

Basically searching is pretty much the same as adding a node.

You just kind of go find where the node would belong.

And then if it’s there, then you found it.

And if not, then it’s not in there.

55 belongs on the left of 88, belongs on the right of 21, it belongs on the left of 72.

belongs on the left of 72, belongs on the right of 34, belongs on the left of 66, and there we

found it. Notice how we only did one, two, three, four, five, six examinations. So I’m going to talk

about big O and time complexities in another video, but long story short, the time complexity

of this particular tree, or actually any binary search tree, is always going to be O of H, no

imbalanced or perfectly balanced O of H so in the worst case scenario since H is 6 we’re going to have to touch H or 6 nodes

To search or add something or whatever if the tree was perfect. It would look more like log time. Let’s pull up that calculator real fast

Where the heck is my calculator? I think I like got sidetracked

so if I pull up a calculator here

and I typed in

log base 2 it’s base 2 because we only allow two children per node at most log

base 2 of the number of nodes in the tree so log base 2 of 14 if we get the

answer to that it says 3.8 which means the calculator is telling us that in a

log time tree we should not have to examine more than four nodes in order to

search the tree or add a brand new node but this is not a log tree because it is

totally imbalanced it’s kind of wonky it’s not it’s not perfect so it’s telling us in a perfect

tree we’d have to touch four nodes only but we clearly know we might have to touch six nodes in

the worst case so that i’m just trying to bring to your attention that the more imbalanced the tree is

the further its uh performance drifts away from log time which is a great argument

I think this is pretty much everything I wanted to talk about today.

I’m going to take a break and like, you know, eat some cookies and stuff.

But in a future video, we’re going to talk about inserting.

No, we already just did that literally right now.

We’re going to talk about searching through the tree.

We’re going to talk about removing nodes from the tree.

We’re going to talk about linear trees.

We’re going to talk about all the time complexities.

And then eventually we’ll move on to self-balancing trees.

on to self-balancing trees. So I hope you had fun watching this video. I hope you learned a little

bit of stuff and I’ll see you at a later date in time. I’m outie. Patowdy. Note to self, edit out

Patowdy. Hey everybody, thanks for watching this video again from the bottom of my heart. I really

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

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, I’ll just wake up. I promise that’s what will happen. Also, uh, 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

we’re 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 uh 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

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 Binary Search Tree Insertion Tutorial: Building a BST from Scratch Step by Step appeared first on NeuralLantern.com.

Clear step-by-step explanation of what defines a Binary Search Tree (BST). We build the definition rule-by-rule starting from graphs all the way to the BST ordering property (all left descendants, node, all right descendants). Great first video before learning insert, delete, search, and Big-O.

What is a Binary Search Tree? 00:00
Intro to Graphs and Nodes 00:42
Connected Graph Requirement 03:16
Acyclic Graph – Removing Cycles 04:54
Turning Graph into Tree 07:05
Establishing a Root 07:09
Adding Hierarchy and Levels 09:05
Single Common Ancestor 11:18
Binary Tree Definition 17:30
BST Ordering Property 17:39
Left Subtree Less Than Node 18:29
Fixing Invalid BST Example 20:26
Valid BST Final Check 21:24
In-Order Ascending Order 24:11
Video Summary and Next Steps 25:02
Thanks and Call to Action 25:30

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

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

hey there let’s talk about binary search trees specifically in this video I want to help you

define and identify what is a binary search tree all the rules that go into determining whether

or not something is a binary search tree so you can you can tell that you’re looking at one or

whether you’re not looking at one we’ll talk about some terminology but keep in mind I’m

going to save searching and sorting and like you know deleting and adding items and a whole bunch

extra stuff, especially the hard stuff for videos that’ll come right after this one.

For now, we’re just going to talk about what is a binary search tree.

So you can see on the screen right here, I hope that we have a binary search tree.

Let’s see.

Can you see that?

Yeah, I think you probably can.

Yeah, I think you can.

This is not drawn quite as well as I would like to draw ours.

I’ll tell you how to do that in a little while.

to do that in a little while but when you draw a tree in a really really nice pretty aligned way

it’s way easier to debug it’s way easier to tell that you’re looking at something that is sorted

and so forth anyway okay so first let’s start off with a graph so this is not a video about graphs

uh i guess i can probably expect that you already kind of know what a graph is at this point in time

and edges. So what do I mean by nodes? Well just imagine there’s like a little circle here

that contains some sort of data. If you know data structures already then

there would be a t-type sitting inside the node. We’ll just call the t-type an integer

and so for our nodes, for our trees, we’re just going to say that they hold integers even though

you know technically speaking in a binary search tree or a graph you could have all sorts of

Okay. So I’m just going to, you know, grab this and sort of like duplicate it and just duplicate it again.

I’m just going to make a bunch of duplicates. Something is definitely wonky about my setup right now.

I think I just upgraded the camera and the CPU is maxed out. I just upgraded the CPU on this computer too.

Oh well. Okay. So we aren’t going to support duplicate values in our binary search tree,

I’m going to say it doesn’t really matter for the graph. Later on, we’ll start making sure there’s

no duplicate data. For now, I think I can probably do that somewhat quickly. Let’s see. So a graph,

you know, for the for our purposes right now, a graph is just basically a collection of nodes and

edges. It could be empty. It could be just nodes. It couldn’t just be edges, it would have an edge

always has to have a node or two connected to it. So we just have like a bunch of nodes inside of

data values this is a valid graph but I’m going to draw some edges randomly here so we’re going

to do this it doesn’t really matter I’m just randomly drawing edges okay actually I should

probably do maybe like one that’s kind of separated okay so this is a graph this is not a binary search

tree so let’s add a bunch of rules let me just pull up my rules real fast here okay so what is

First we’ll start off with the graph like we have here and then we’ll say that the graph must be connected.

What is a connected graph? A connected graph is basically a graph where every single node can find every single other node

or find a path to every single other node only following along edges and only by respecting the direction of edges.

You can see this particular graph is undirected meaning the edges don’t really have a direction to them.

So that means we could travel along in any direction from node to node.

So just as a real quick, you know, I guess like tutorial, I’m going to say is 8 connected to every single other node?

Well, it can find a path to 12 and it can find a path to 33 and it can find a path to 76 and 45.

But it cannot find a path to 99, which means this is not a connected graph.

So that’s the first rule that we have to implement here.

We’re going to say this graph needs to be upgraded or modified so that it will be a connected graph.

start randomly adding edges until this is a connected graph I’m gonna do maybe

like an edge from 99 to 12 there and then now I think this is a connected

graph but let’s double check real fast so connected graph you know what I’m

gonna put graph connectedness in another video to keep this one short for now

check out my other videos if you would like to see whether or not a graph is

but long story short as I just said if every single node can find a path to

every single other node without you know skipping where there is no edge then

it’s connected okay so that’s the first thing the next thing that we need let me

just put the words connected up here we need a connected graph the next thing

that we need is we need an acyclic graph which basically means a graph with no

A cycle is, can you find a path in this graph that starts at one node and ends at the same node without repeating any edges?

So for example, if I was asking, you know, is 76 involved in any cycles?

Well, we could go from 76 to 33 and then 12.

And, you know, we could kind of take 8, 45, 12 again.

But by the time we turn around and try to get back to the 33, we’ve already crossed this edge twice.

so that means the 76 is not involved in any cycles because we cannot find our way back to 76

without repeating an edge so 76 is okay i’m just going to maybe put like a little check box here

and uh you can also tell that the 33 is not involved in any cycles because we go down to

the 76 and then come back up to 33 we already repeated an edge so that’s not valid same thing

again. Same thing for the 34, same thing for the 99. But if you look at the 12 here, we could

actually find a cycle. We could go from the 12 to the 8, and then from the 8 to the 45, and from the

45 to the 12. Now we’re back where we started. We’re at the 12 node again, and we did not repeat

any edges. So this is not a cyclic. This is a cyclic graph. It’s got a cycle. So that’s the

we want to make sure that our graph has no cycles. So, uh, the next rule I’m just going to say is,

is going to be satisfied by me removing some edges at random. So I don’t know, let’s get rid of, uh,

the eight to the 45 connection. See if that works. Um, let’s see. Well, wait a minute. What did I

just do? Something happened here. I just accidentally, oh, I erased too many edges

from the last slide. Okay. Let me add that one back in 33 to 76. That was supposed to be there.

33 to 76 that was supposed to be there.

So now we have an acyclic graph

and we can consider this graph a tree.

The next thing we need to do is add a hierarchy to this tree.

So this is gonna make more sense in a little bit

but for now I’m gonna say,

we’ll imagine a family tree kind of,

it’s not really exactly a family tree

but you know imagine there are parents

and children and grandchildren

and we’ll just try to like,

we’ll try to rank children according to

according to you know when they were born or or how many parents or children

they have you know their descendancy their lineage whatever you want to call

it so I think I’m just gonna maybe move the eight up a little bit so that it’s

on the same rank with the 12 and the 33 so I’m just gonna move these up a little

bit and then redo their connecting lines so I’m gonna do this and that and then

and then we’ll say that the 76 is still a child of the 33.

So I’ll just kind of move it over here.

Or sorry, we never said it was a child.

Now we’re saying it’s a child

because when you go from top to bottom,

imagine like a family tree,

we’ll say we have parents and children.

The children or the descendants are lower.

The ancestors or the parents or the grandparents are higher.

Maybe I want to put this 45 over on the left

so that it’s a child of the 8 node.

And maybe I’ll say that the 99 node

the 99 node is a child of the 12 node. Okay, so eventually this is going to look not exactly like

a family tree because usually in the family tree we have two parents that go to one or more children.

In this type of tree, in eventually our binary tree, we’re going to have one parent that has,

you know, children just by itself, like asexual reproduction. We’re pretending to be bacteria

What was that comedy skit a long time ago, Tiny Elvis?

And he was like, hey, see that protozoa over there?

The thing is huge.

Anyone?

No?

Okay.

So the next rule we need is we must have a rooted tree.

What is a rooted tree?

Actually, let me clean up the lineage real fast, the heritage.

I want to make nodes that have the same level with respect to their ancestors

respect to their ancestors to have the same physical y coordinate the same

physical level so notice how the 99 I just moved it down a little bit because

I wanted it to look like it’s the same you know number of generations lower

than the top row so like with aid it had a child 45 so that’s one level down 33

had a child that’s one level down that’s a 76 and the 12 also one level down

would have been 99 but the 99 was kind of too physically high this will help

will help you debug your binary trees in the future anyway so i’m just going to clean this up right now

and uh now that we have you know parent child relationships we need to look at the most common

ancestor in the whole entire tree or if there is one so notice how uh i guess i’m just kind of using

the word ancestor without explaining it so your ancestors are the people that you’re disappointing

or whatever it is, ancestors came before us, right?

Like my parents are my ancestors.

My grandparents are also my ancestors.

My great-grandparents are also my ancestors.

Going down in the family tree are your descendants.

You know, my children are my descendants.

My grandchildren are my descendants.

My great-grandchildren are my descendants and so forth.

So if you look at the number 34 here,

what is the greatest ancestor that it has?

Well, if you just go up and up and up

until you can’t go up anymore,

up until you can’t go up anymore it’s the 12th so that means the greatest ancestor of at least in

this tree of the 34 is the 12th the 45 the highest you can go is the 8 notice how 8 and 12 and 33 are

siblings there’s not really like a parent-child relationship they’re connected sideways we’ll

eventually get rid of the sideways connections for our binary search trees but for now we have

some siblings and so we actually have three different greatest ancestors in this tree we’ve

tree we’ve got 8 and 12 and 33 and that’s no good so the next rule that we need is we need

one common ancestor for every single other node in the entire tree so I’m going to duplicate this

slide right here and I’m going to say we need to clean this up so we got to choose 8 or 12 or 33

I don’t know I’m just going to maybe say that 8 and it’s 45 are children of the 12 so I’m just

line here arbitrarily so i’m gonna go like that notice how i’m trying to keep the 8 the 99 and

the 76 on the same y coordinate the same level now we have two uh you know greatest ancestors

we need to have only one so i think i’m probably going to say that the 33 and the 76 are going to

become children of the 12 node just for simplicity so i’m going to put this over here i’m going to

i’m gonna like move this over here this is a gross tree but we’ll fix it soon we’ll do that all right

okay okay

okay and then i have to get rid of that little sibling line and then i have to add another line

to say that 33 is a child of 12. okay so now we have a rooted tree what we had before was an

unrooted tree or just like not a rooted tree because there was no root there was no greatest

greatest common ancestor to the entire rest of the tree. But now we can say that 12 is the root

of the tree because it’s the ancestor for all other nodes. I guess even if 12 was by itself,

we could call it a root of tree. It just wouldn’t be a very good example. So I’m going to actually

get rid of the word acyclic here since we already handled that. And I’m going to do,

I’m going to say that 34’s greatest ancestor is 12, 99’s greatest ancestor is 12, 33’s greatest

all the nodes in the tree their greatest ancestor is 12 and it’s common to all of them so now we

have a rooted tree maybe I should type in my doomed I really hope the screen I really hope

the screen cast doesn’t freeze it probably will upgraded the CPU it’s 33 faster than it was before

board so i am still using an old cpu even though it’s new to me dang it i’m gonna have to spend

like 500 okay uh so the next rule is so we have a rooted tree and now let’s rearrange everything

hierarchically which we already kind of did so uh there’s not really much to do here except

we did hierarchical organization

we probably just need to move on to our next rule which is to say that

if our rooted tree is to become a binary tree

then each node in the entire tree

cannot have more than two children

every single node in the entire tree

can have zero or one or two children

if there are three or more anywhere in the entire tree

then it’s not a binary tree

so okay that means you know the 45 is okay

because it has no children

because it has no children. All the rows, all the leaves at the bottom are okay. All these nodes

over here are okay because they just have one child. But the 12 node, the root of the tree,

it’s got three children and that violates the rule. So now we need to rearrange this.

So I think I’m going to just move these numbers down here maybe. Whoops. Maybe move these nodes

descendants of the 33 node. So I’m going to do this.

Okay. So cool. Now we have a binary tree and now we need to rearrange the drawing a little bit.

This is not part of the definition, but this will make it easier to debug your trees. So what I want

to do is make it so that every left descendant of a node appears physically on that node’s left

every right descendant of a node should appear on its right side

or like further to the right on the x-coordinate

so sort of similar to you know like the y-coordinate ranking

but notice how the 12 its left child is 8 and its right child is 33

so that means all the nodes here on the left side you know that come underneath the 8

are left descendants or you could say that they are in the left subtree of the 12.

So, they’re okay because 8 is to the left of 12 and 45 is to the left of 12.

But notice how 33 is a right child of 12 and it’s part of the right subtree.

It’s part of the right descendancy, but it’s physically on the left of 12.

That’s going to be really bad because it’ll be harder to debug our trees later.

So, I’m just going to slide it over without rearranging the tree.

And I usually try to split the difference here.

and then their parent is kind of like physically in the middle that will also help you debug in

the future so i’m going to do this wrong let me get the blue i’m going to do this make sure that

my ranking is still okay not the best most neatest tree and so now i’m going to look at the eight

it’s left subtree or it’s left uh descendancy uh all of those nodes which is just the 45 are

it’s left child 76 is the only thing that’s on the left side in the left subtree so that’s all

right probably the 33 I think it’s still a little lopsided I probably could have you know dragged

it a little bit more to the right but I’m going to leave it so the 33 and the 76 are okay and then

the 99 is a right descendant or it’s part of the right subtree of the 33 so it should be on the

right side it is that’s good the 34 should be on the right side of the 33 because it’s it’s a it’s

It’s part of the right subtree of 33.

It’s part of the right descendancy.

And it should also be on the left side of the 99

because it’s part of the left subtree of the 99.

So, so far, this is okay.

This is not the best drawing.

So now we have a binary tree

and we have kind of drawn it in a slightly good way.

Not super great.

The last rule that we’re going to add here is,

whoops, what happened there?

I’m supposed to do that, yeah.

The last rule we’re going to add is

we must have ordering to our nodes, to the numbers in our nodes. So what do I mean by ordering? Well,

the whole reason that we want a binary search tree, at least usually, is because it’s really,

really fast to search through. This is going to be a tree that we can search through in log time,

which we’ll talk more about in another video. We’ll do time complexities and searching and stuff. But

in order for this to be a super fast tree to search through, we need to be able to

very quickly make a decision. Do we go down and to the left? Do we go down and to the right?

left do we go down into the right and every decision we make should help us eliminate half

of the remaining data set half of the tree at a time every time we go down a level and that’s only

possible if the nodes themselves are ordered so what i’m going to do is say every node that’s on

the left side or let’s say every descendant that’s on the left side of a node should be of a lesser

value than that particular node every node that is on the right side of a node meaning it’s a right

descendant of that node or part of the right subtree of the node should be greater than that

node. Please note that this would not allow us to support duplicate values in our tree.

You could use something like less than or equal to versus greater than if you wanted to support

duplicate values in your tree. You could also change the T type, you know, the template type

to a node from the data you want it to store to a list. So every single node has a list inside of it

and the items in the list are just, you know, the regular values that you wanted. There’s a whole

values that you wanted there’s a whole bunch of different ways you could actually do that

but for now we’re going to see our trees don’t support duplicate values

so okay we don’t support duplicate values but we need you know from left to right

the order needs to look sane and this is kind of why we’re drawing the tree in this special way

we’re trying to make our tree really easy to debug visually so check this out the way we’ve

drawn this every single node has its own x coordinate basically notice how the 12 there’s

nothing underneath it at least not directly underneath it the 33 the 34 all the nodes you

know you can draw a straight line down from the node and it shouldn’t cross over with any other

nodes or edges so that means now that we’ve drawn it this way and we’ve made sure that all the left

descendants are on the left and all the right descendants are on the right we could actually

just scan our eyes from left to right and be sure that we are seeing an increasing order or

Since duplicates aren’t allowed in this tree, we’ll say an increasing order or an ascending order.

So if we start at 45 and then we go to the right, we should see a higher number.

So if we look at 8, 8 is a lower number.

So this violates the ordering rule.

This is not a valid binary search tree.

It’s only a valid binary tree.

So sad.

Okay, so I could, you know, swap the 45 and the 8 or I could just increase the value of the 8 itself.

of the 8 itself, I think it’ll be faster for me to just increase the 8 value. So I’m going to make

it 52 now. So we’ve got 45, 52. Then we go to the right a little bit more. It should also increase.

So 52 should increase. I’m just going to randomly increase it to, you know, 59, let’s say. Then as

we go to the right, we see another number here. It is 76. That already is increased from 59.

So we don’t need, we don’t need to alter that number. Then we go to the right one more time

that because it’s lower than 76 so I’m going to put 87 then when we go to the right one more time

that’s the 34 down here that’s definitely a decrease so we have to increase it now so I’m

going to say 99 how about if I just do 92 yeah so now we have a 92 down here and then if we go

to the right a little bit more there’s the 99 and now we actually have a binary search tree let’s

just double check all the rules first off is this a graph yeah there’s nodes and edges there’s nothing

There’s nodes and edges.

There’s nothing weird happening.

There’s not like a edge floating in the middle of nowhere.

Is this a connected graph?

Yeah, it is.

Because every single node, if you followed, you know, the edges, you know, could find

every single other node.

Like the 45, it could find, you know, the 92 node if it just followed all these edges.

Notice again that these edges have no direction.

There’s no arrows on them.

So we could go up or down in any direction we want.

So that means the 76 can find everything else.

else and so this is a connected graph for sure okay now that we have a

connected graph is this an acyclic graph I don’t know about you but I can’t find

any cycles in the graph right like the 92 it goes out but it doesn’t come back in

same thing for the 76 if we went from the 76 up to the 87 and then took a

right turn we wouldn’t be able to come back towards it without repeating that

same edge so this is definitely an acyclic graph all of the nodes follow

they’re not involved in cycles is this a rooted tree yeah there’s only one common ancestor to the

entire tree it’s the 59 it’s the highest node in the entire tree and it’s common to all other of

all of its descendants um so let’s see i’m going to duplicate this real fast the next thing is

we arranged it hierarchically and we added the terminology of like i think i kind of just like

tried to sneak this one past you but we added the terminology of a left child and a right child

and a right child.

Right? We also added the terminology of a right subtree and a left subtree.

Just to clarify what I mean, what do I mean by a right subtree and a left subtree.

So imagine we’re considering the 59.

If we consider the 59, then the 52 is the root node of the left subtree of the 59 node.

If we consider the 59, then the 87 is the root node of the right subtree of the 59 node.

so the right child is basically the root of the subtree uh in in you know the right child is the

root of a subtree of the right subtree uh i think i’m getting muddled my words here okay

anyway so we have a little bit of terminology uh the 59 is the root node that’s like the

the only node in the entire tree without uh an ancestor or a parent so okay uh then we have a

Note, and the entire tree doesn’t have more than two children.

Notice how the 59 has two children.

That’s fine.

If it was three, that’s way too much.

52 has one.

87 has one.

No, 87 has two children.

99 has one child.

92 has zero children.

So, okay, we’re not violating that rule.

So, we definitely have a binary tree.

And then we, you know, kind of read from left to right.

Let me write down the numbers this time for fun.

physically without kind of like following edges or anything we just scan

our eyes from left to right we can see that we have an ascending list if we

supported duplicates it would be okay to just see a non decreasing list but we

see an increasing list or an ascended list ascending list okay whoops this is

left to right so this is actually a binary search tree and um i don’t know about you but i think i

need to like you know get a snickers or something right now because uh this video has been going on

for longer than i wanted it to go on so we’ve defined a binary search tree in future videos

we’ll talk about how to add nodes into a binary search tree how to build the tree what’s the time

complexity of the tree in various operations deleting nodes from a tree terminology like

terminology like what are these nodes called things like that so anyway thank you so much

for for watching i hope you learned a little bit of stuff and had a little bit of fun

i’ll see you at a later date in time

just kidding

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 uh if you could do me a please

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?

It’s a 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 uh and subscribe

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 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 would really, it

it would really mean the world to me.

I would really appreciate it.

So again, thank you so much for watching this video

and enjoy the cool music

as I fade into the darkness,

which is coming for us all.

Thank you.

The post Binary Search Tree Definition Explained Step by Step appeared first on NeuralLantern.com.

Ready to master x86-64 assembly? This video breaks down system services, showing you how to use syscalls to print messages, handle file descriptors, and exit programs cleanly. We’ll walk through a real assembly program, explain key concepts like standard output and file handles, and share tips from a top book on the subject. Whether you’re new to assembly or sharpening your skills, this tutorial is packed with clear examples and practical advice. Subscribe for more coding deep dives, and check out our upcoming file I/O video! #AssemblyProgramming #SystemCalls #x86_64 #CodingTutorials

Introduction to System Services 00:00:00
System Services in x86-64 Assembly 00:00:04
Recommended Book on Assembly 00:00:35
What is a System Service? 00:01:01
Example Assembly Program 00:01:21
Syscall Instruction Explanation 00:02:52
Standard Output and File Descriptors 00:04:01
Printing a String with Syscall 00:05:16
Exiting a Program with Syscall 00:07:21
Exit Codes and Program Success 00:08:02
Book Reference for System Services 00:09:51
Detailed System Write Service 00:11:01
Checking System Call Return Values 00:12:08
File Operations with System Calls 00:14:35
Closing Files and Best Practices 00:15:50
Other System Call Codes 00:16:43
File Permissions and Modes 00:17:20
Handling System Call Results 00:19:03
Future Video Plans and Wrap-Up 00:20:40
Call to Subscribe and Outro 00:21:28

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

Hey everybody in this video we’re going to talk a little bit about system services

in an x86-64 machine while programming in assembly

this video is going to focus on yasm assembly but this should also work for any other assembly

language that you program as long as you have the right kind of cpu x86-64 is also known as

that in mind okay so for starters let’s see here’s a wonderful book i love pushing this book i did

not write it the person who wrote it is a genius it’s called x86 64 assembly language programming

with the boot to it’s a free and open source book so anybody can go get it find his website

and here’s the version i’m using and honestly a really old version of this book is still really

good he just keeps you know making little improvements but it was it was good even a

even a long time ago. Anyway, so what is a system service? For starters, before I go into this book

a little bit more, what is the system service? Suppose for the sake of argument that I’ve

already written an assembly program, a pure assembly program, not a hybrid module program

or anything. If you want to learn assembly, see my other videos, but for now I’m just going to

assume you kind of already know how, so I’m just going to open up a pre-made program here.

I’m going to do nano so I can edit the assembly file just so you can see what’s inside of here.

just so you can see what’s inside of here.

Okay, so I hope the red is not too hard to see.

Oh, the tabs got ruined on Nano.

Hang on, let me see if I can just open this up in Genie.

Should have done that to begin with, okay.

Yeah, okay, I wrote it in Genie

and I guess I don’t have the tabs set up in Nano very well.

Okay, so here’s like my assembly program.

You know, I just have a little string here

string length and CRLF for like a line feed and some file descriptors and stuff

that I talk about in other videos here’s the entry point of the program just like

a little start entry point because it’s pure assembly and all I’m gonna do is

I’m gonna print a message right I’m just gonna print a little hello message and

then call on CRLF all CRLF does is just it just prints a new line so the program

if i run it right now you’ll just see what happens if i say let’s see clear and make run

then you can see there’s some stuff happening up here in the make file which i forgot to update

the title ignore that basically the real action is this line right here hello i’m printing using

a system service if you already know assembly then you have probably already seen this before

and it seems a little boring that’s good but i just want you to know that we’re using a system

system service to actually do the printing.

Kind of take it for granted here.

This little instruction called syscall.

What is a syscall?

Well, it’s just basically you set up some variables, some,

some codes, some data, whatever in, in some special registers.

One of the registers lets the system know what you want it to do.

One of the registers is like, or I guess all the following registers

if they’re needed, are just input to the system call that you’re trying to do.

do so in this case rax is letting the system know i want you to do this this code i want you to do

this certain thing i have a defined set up here called system right but if you look up in my

little defines area it’s just a number one so that means if i set the number one in rax i’m letting

the system know that i want it to write to some pipe to some file then you know depending on what

code you’re using rdi rsi rdx and other things may be needed or maybe not be needed at all

in this case when i’m writing somewhere it wants three arguments so i have to use rdi rsi and rdx

because those are the three arguments the first argument that it wants is where to print

see my other videos for a more in-depth explanation of file descriptors and pipes but just long story

pipes standard input standard output and standard error standard out is a pipe

number one let’s see where’s that yeah it’s just assigned a number one so

every program has its own number one pipe which is just standard output and I

guess I should say that it gets piped to file descriptor one it’s kind of like an

ambiguous term sort of but the system right call will write data to a file

file and if i give it a file handle of just one that lets the system know oh actually i want to

write to this standard output for the one particular process that we’re inside of but

you could open any file that you want and get like a file handle to it and the operating system will

realize oh you know i i associate that file handle i gave you with this certain open file that you

created or opened for reading or whatever um and so when you give the handle back it knows where

knows where to write. So in this case,

it’s treating the standard output just like a file,

just a file with a special handle of just one.

I’ll talk about that more in another video.

Then the next two arguments it wants is just the,

a pointer to the first character of the message that you want to print.

And then just an integer representing the length of the message that you want

to print. And if we just look up here again at my little hello,

my hello symbol points to an array of bytes, just characters.

bytes just characters there is no null terminator on there it’s just bytes only

and so when I give it you know message hello by itself what I’m really giving

it is a pointer to that H letter just a pointer to the memory look you know I’m

pointing to the memory location of the very first character in that string and

then for the length I’m just using a special token little shortcut thing

where you just put a dollar sign minus and then the name of another string and

and then the name of another string,

and then the assembler will compute the length of that string.

So this right here is the same thing as me

just typing the exact length of the string.

I don’t even know what it is.

I don’t feel like counting it.

You can at home if you want.

One, two, three, four, I’m not gonna do it.

Anyway, so we basically just say,

you know, I would like to write somewhere.

I would like to write to the standard output file,

file handle, I would like to, you know, to that pipe.

I would like to write, you know, this string,

you know this string and then i would like to tell you that this is how long that string is

and then after you set all that stuff up you just say system call and the system will go ahead and

do all of the hard work for you it’ll go figure out how to actually write data to the file and

you know figure out how to do everything that it’s supposed to do and all you have to do is

a little system call here right after this you can see that i have a call crlf that’s just a function

call i talked about functions in other videos but basically you know i’m just calling a function here

you know i’m just calling a function here and it does the same thing it makes a system call but

instead of printing the hello string it’s printing my crlf string and if you just kind of look at what

my crlf is it’s just these two characters 13 and 10 so like you know slash r slash n for carriage

return line feed that’s why i call it crlf so all this program does just print a message and then a

new line and then at the very end it does another system call to properly exit the program if this

hybrid program and I had like the entry point of main, you know, that the GCC libraries give you,

then I would probably just want to return at the end of this function. But since this is pure

assembly, I can actually just exit the program and be fine. So exit with success is a different

system call code. Notice how I have the symbol system exit loaded into RAX. And if you look up

here, system exit is just the code 60. So if I send a code of one into RAX, that means I want to write

a code of 60 somewhere that means i want to exit the program the only argument that takes is rdi

which is just what is the exit code that you want to return to the operating system so um

if you recall from some of my other videos let’s see if we do echo hello echo always succeeds at

least as far as i know there’s like it’s like really hard to make it fail if i echo hello then

the program echo launches and it will succeed by just printing the word hello like see how it just

like see how it just does that so that means after that command i could echo the special

variable dollar sign question mark just to see what the echo command exited with right it should

be a zero because it succeeded so you can see now a zero under the hello on the other hand

if i concatenate um let’s say a file that exists i should also get you know an error code that is a

So it’s a zero at the very end.

But if I try to concatenate a file that doesn’t actually exist,

I’ll put a OS release two because that doesn’t exist.

Notice how the cat command fails because it couldn’t find the file and the exit

code is a one.

So all you’re doing when setting RDI here is just controlling what exit code you

want your program to exit with.

This isn’t very convenient for a human running a program.

Maybe if you want to look at the exit code for some reason, but this is really,

really convenient for programs that want to automate other programs.

programs just keep in mind if you have a program that is executing another

program and it wants to see if that program succeeded the exit code is one

of the easiest ways to find out if the program succeeded so this is the whole

idea of this entire program we’re just using two system calls to print

something and then to exit the program hopefully this makes sense and now I

want to go show you this wonderful wonderful book if I didn’t already say

If I didn’t already say this before, sorry if I already did.

This book is written by a genius.

It’s called this.

Here’s the guy who wrote the book.

And here’s the version that I’m using, but old versions are good.

You can get this book for free on his website if you go find it.

So I’m just going to go to this assembly book, which deals with a lot of Yasm assembly tips

and tricks and tutorials and explanations and things.

And I’m going to go to the section labeled after system services.

So for me, this is a chapter 13 system services, just to give you a little explanation of what

this is.

You know, this is basically what I said.

It gives you, you know, a chance for your application to ask the operating system to

do something for you that you don’t want to program from scratch in assembly or that you

can’t program.

But here’s the real juicy details here.

If we go to, yeah, yeah.

Okay.

C, which is section 23.0 system services.

There’s a whole bunch of system services in here that you can, uh, that you can read about.

So for starters, if we go down a little bit, notice how it says basic system services.

If we go down a little bit, you can see right here, the system write service that we’ve

been using in the sample assembly program.

You know, when we’re just printing, we say code one is to write something.

And so this is what the table says.

you place inside of RAX before syscall.

Call code 1 is going to be to write characters and then it tells you what arguments it needs.

So like RDI is the file descriptor where do you want to write to.

Just like I said before you could give it a file handle that you already received from

opening a file or creating a file.

Or you could give it 0 or 1 or 2 if you want to try to write to one of the pipes although

actually file descriptor 0 is standard input I don’t think that would actually work.

zero to reading if you wanted to read the user’s input or or you know any input that that program

was given through its standard input rsi is just the address of the characters to write like we

talked about before and then rdx is the count of the characters to write notice how there are no

more arguments and that’s why i only gave it three arguments besides rex notice how it says here if

unsuccessful it returns a negative value if successful it returns the count of characters

count of characters actually written this is a really really good idea if you think about it

um a lot of new programmers they don’t really look at return codes when they call system services

or built-in c functions or built-in c++ functions they just kind of call it and hope for the best

but imagine if you uh if you try to write a huge long string in uh using system write call code one

and maybe some of the characters did write but the system decided to only write i don’t know half for

reason maybe it ran out of buffer maybe you know it interrupted you know your right or something

like that so it could happen what that would mean is that the return value it would be greater than

zero indicating that some characters were written but it’ll tell you exactly how many characters

were written so you’ll know that you got to keep calling the sys call until all the characters were

successfully written why would you do this i don’t know maybe you have a gigantic string like maybe

like a several gigabyte file and you wanted to copy it to another file so you’ll be calling

system write over and over again and system write it’s only going to write so many bytes at the same

time so you use the return value to figure out how far forward in the read buffer you need to advance

or you know whatever so that you can well write the entire complete file or the entire complete

string or whatever it is without any gaps without it being truncated and so forth and then of course

And then of course, if it returns a negative value, then it totally failed.

Like you tried to write to a bad file handle, like standard input or a file handle that

was closed or a file handle that was open for reading only, something like that.

And then you can use some if else, you know, branching logic.

I mean, not if else in assembly, it’s just going to be comparison and conditional jumping

or branching.

But you can have more control over your program, right?

Because you want your program to be able to respond to errors.

Let me just quickly cruise through all of the other options and let you know that

and let you know that in another video I’m gonna do a full tutorial for how to

copy one file to another by opening one file for reading and then like using

system calls to read from it and then open another file for writing and then

you know use system calls to write to it and I’m gonna do that looping buffer

stuff that I talked about before anyway so but for now I’m just gonna go through

the rest of these system call codes let’s see so first off we got open well

Well, if you want to open a file, then you just give it call code 2 and you pass in the

address here, you know, RDI, you say, here’s the address of a null terminated file name.

So that means somewhere in memory, you have to have the file name that you want to open

with a null terminator, like a zero at the end of the string, either the full path or

relative path to wherever the program is currently running.

And then RSI is going to be file status flags.

And what does that mean?

And what does that mean? We can actually just search for that.

I’m going to say control C to copy,

and then I’m going to do control F to search for that.

And let’s see what page of mine right now, 340.

If I go down to the search results for that,

it just explains what the file modes are. So if you put value zero,

that means read only you’re opening the file and read only mode value one.

That means a write only a value to allows reading and writing to the file.

So if you don’t know what that means, well, there it was.

What was I just on before?

40?

Oh, gosh.

Completely lost my…

Oh, yeah, 40.

Okay, so opening pretty easy, right?

Like if you didn’t know this before, you didn’t necessarily read me.

You could just look at this table and go, what do I want to do?

I want to open.

So here’s the code.

Here’s the address that it needs.

When you’re done opening a file, when you’re done working with a file,

you want to close that file unless the whole program is going to terminate.

unless the whole program is going to terminate at that point you i mean maybe you have a function

that gets called somewhat often and you kind of always have to open a file and sort of look at

something or write something and maybe you want to close it when the function is over right you

don’t want to have a file handle just open forever that’s a waste of memory and it might introduce

bad behavior to your program if you just have a bunch of file handles floating around that you

forgot about so it’s proper to close a file when you’re finished with it that’s just going to be

and it only wants one argument.

It just wants the file descriptor of the file that you wanted to close.

So if you open a file for a reading or to create it,

you get a file descriptor back.

You should probably hang on to it somewhere on the stack

or like in a global variable or like, you know, in a register or whatever.

Then when you’re done doing something to that file

and you’re sure that it’s time to close it,

just give that handle right back when you call code three to close it.

Then you can sort of like seek, you know,

forward and backwards to the file if you want to.

You can fork the current process.

You can fork the current process that’s kind of advanced for this video.

You can exit.

Remember before we exited from that program with code 60.

So that’s it. Call code 60.

If you didn’t watch this video, you could have gone through this table and just said,

Oh, you know, I want to terminate the executing process.

I do a system call with code 60 and I’ll give the exit status to RDI,

which is typically zero for success.

Bunch of other stuffs create, get the time of day,

and then the file modes that we talked about before.

we talked about before and then file permissions. Let’s see, where’s the permission. I think it’s

when you want to create a file. Yeah, right here. If we wanted to create a file, that’s code 85.

RDI is the name of the file, you know, like a pointer to the string. RSI is the file mode flags.

And then you’re thinking like, what are the file mode flags? Just go down here and then here you

go. All the file modes that you could ever want. You just look at it and go, well, I guess I can

I guess I can just copy paste this number right here and it’ll end up being, you know,

whatever is described on the left and the right.

Like the group has read, write and execute permissions and so forth.

I mean, really, if you look at this long enough, you’ll kind of realize that this is a quad

word because it has a Q on the end of it.

And the rest is just an octal file permissions notation where this first number here, notice

how the first two are zeros, but this first actual number here is something that applies

to the user and then the next one applies to the group the next one applies to others who are not

part of the user or group and this video is not about file permissions I’ll probably make one

later if I think people will actually watch it but yeah you can just kind of like look it up here if

you want to and just copy paste that into a define somewhere let’s see what else I just want to show

you a little code snip just to illustrate a little bit more what I was talking about before

for. People usually make this mistake, they’ll do see this is what people will usually do like new

programmers. Suppose this is a function pretend we’re in C or C++. For the time being, you call

some sort of a system function or an API of some other library. And you just you just hope that it

works, you just call it and then your program continues underneath, right? It’s a bad idea,

because maybe that failed, maybe there’s some action you need to take. So instead, it’s a really

really good idea to check the return result or i should say an even better idea is check the

documentation usually these types of you know c system calls or function calls or api calls or

whatever they’ll return something indicating success or failure sometimes the documentation

will tell you oh you’ve got to put like a pointer to some other data structure in the arguments

and then the result comes there of course just read the documentation but usually it’s just

So you want to grab the result and then check the result.

In this case I’m assuming this is sort of a standard function that will return zero

or greater on success like the system write call or the system read call and return less

than zero if it fails.

So here I’m just responding, you know, if it’s like if the result was greater than zero

then it’s like, yay we can proceed.

Maybe I’ll continue with my program in some way and if it’s not then I’ll print a complaint

then I’ll print a complaint to the user and then I’ll take some sort of an action

like I’ll write to a log file, send an email somewhere, you know,

do something to try and recover from the error and alert admins to the error.

And in this case, I’m just throwing an exception.

This video is not about exceptions, but so I just want you to know,

this is a good design pattern to not just discard the result of a call to

something. You should check the result and see what you’re supposed to do.

Let’s see, what else did I want to tip?

system services, file handles.

Yeah, okay, I think that’s everything that I wanted to tell you.

In future videos, I’m going to talk about, you know, some of this stuff much more in-depth,

like with my file.io video that I’m going to publish pretty soon, which is, you know,

it lets you read and write to files, and it uses a loop to read a little bit at a time.

Okay, thank you so much for watching this video.

I hope you learned a little bit of stuff and had a little bit of fun.

I’m outie.

Or something.

Goodbye.

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

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 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

if you have a suggestion for uh uh 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 I fade into the darkness which is coming for us all.

Thank you.

The post Mastering System Services in x86-64 Assembly Programming appeared first on NeuralLantern.com.

Get a clear, beginner-friendly dive into how your CPU works! This video explains the fetch-decode-execute cycle, the role of the clock, instruction pointer (RIP), and units like the ALU and cache. Learn why timing matters and how your CPU handles instructions step-by-step. Perfect for gamers, coders, or anyone curious about what makes computers tick. Inspired by Kip Irvine’s Assembly Language for x86 Processors, this is your gateway to understanding computer architecture. Subscribe for more tech insights and hit that QR code to explore more tutorials! #CPU #ComputerScience #TechTutorials

Introduction to CPU Operations 00:00:00
CPU Clock Explanation 00:00:17
Clock Cycle and Stability 00:01:07
Instruction Fetch from RAM 00:03:24
Instruction Pointer (RIP) Role 00:03:48
Sequential and Conditional Execution 00:04:49
Code Cache Functionality 00:06:24
Instruction Decoding Process 00:07:51
Control Unit Operations 00:08:33
Arithmetic Logic Unit (ALU) 00:08:52
Floating Point Unit 00:11:03
Data Cache Usage 00:12:08
Summary of CPU Process 00:14:36
Closing and Subscription Call 00:15:07

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

CPU #ComputerScience #TechTutorials #ComputerArchitecture #AssemblyLanguage #TechExplained #CPUBasics #LearnTech #x86Processors #Coding

Hello there. Let’s talk about how your CPU fetches, decodes and executes instructions.

We’re going to just do a quick surface level overview, but I hope you like it.

Okay. So for starters, your CPU has something called the clock.

keep my pen onto one monitor here let me just double check that real fast

okay is it working yeah okay so

okay so notice how we have this line that goes up and down and up and down it kind of looks like a

little binary line uh it actually is uh sometimes your cpu is outputting a zero to this special

and it just oscillates between zero and one constantly it goes zero one zero one zero one

it does so very very very very fast and the reason it does that is because something needs to control

the timing of your cpu imagine this we kind of take this for granted but when you apply electricity

somewhere as a human you kind of feel like the electricity goes to the other place like on the

other side of your house or your room or whatever you kind of feel like it goes there instantaneously

really fast but in reality electricity doesn’t go faster than the speed of light so there is a limit

which means if you have a cpu that is executing instructions really really really really fast

you know fetching instructions from your system ram really really fast

there’s there’s there’s the problem of trying to um to know for sure that the electricity actually

made it uh to the other place in time uh so like what if we said let’s load some instructions from

load some instructions from memory, they come down the wire to your CPU.

How do we know when it actually finished coming down the wire to the CPU?

We just take it for granted.

But in reality, physics has a limit.

And so the electricity needs time to get there and it needs time to stabilize.

So the clock cycle helps us with that timing.

So, you know, if we make the clock go too fast, your CPU becomes unstable.

Your gamers, you gamers probably know that.

If we make it too slow, then it’ll work.

it’ll work, but, um, you know, we’re not getting the fastest, you know, CPU, uh, that, that

we, that we can, we’re not getting all the performance out of it that we can.

So we make it, we make the clock cycle go as fast as we can, uh, without making the

CPU, uh, instable.

And so just keep that in mind.

That’s one component of the CPU.

Okay.

So then the next thing I wanted to show you, oh, and by the way, let me give credit to

the authors of this book.

I’m just looking at a diagram, but, um, this book is written by someone named Kip

This book is written by someone named Kip Irvine

and it’s titled Assembly Language for X86 Processors.

It’s written by Pearson or it’s published by Pearson

and the year is 2014.

So get a copy of this book.

Anyway, so this is a simplified CPU block diagram.

Let me get my notes here real fast

so I don’t forget what I was supposed to say.

Clock ticks and alu.

Okay, so I guess that’s pretty much it.

Imagine now that we have a little RAM stick or some place where we can get instructions for the CPU.

So this is like system RAM, we’ll say.

And we’ll just pretend for the sake of argument that we already have existing circuitry

that will easily transfer data back and forth from the RAM stick to the CPU.

So anytime the CPU wants to grab some kind of data or like an instruction or something off the RAM stick,

it can just do it. And that’s the arrow right there.

keep in mind after that is that there is a special register in the CPU called the instruction pointer

RIP in x86-64 assembly the RIP register and the RIP register it basically just holds a memory

location telling the CPU where is the next where’s the address of the next instruction that we want

to execute so you know imagine you have like some kind of memory address 0x I don’t know 55 and then

an instruction on the very next actually let’s do five zero so I can increase this by eight without

doing hex in my head we’ll say this is like the address five zero in hexadecimal so that means

that the next time the CPU wants to execute an instruction it’s just going to ask system ram

for that address system ram is going to give it whatever ones and zeros it has and then it can be

decoded and executed after that and then of course we have to execute a program you know step by step

you know step by step we have to execute more instructions and we can’t just do one instruction

so typically in a program you execute instructions one by one by one by one by one

and then every once in a while there might be some decision logic like you have an if else

branch like let’s say uh you know for the for the high level people i’ll put a question mark here

you have like an if statement and you say like if that’s true then execute this i’ll put maybe i’ll

then we’ll just execute this other logic down here. So you know very often we execute instructions

sequentially but every once in a while we have to jump right because if if you executed this

if statement and you realized that this condition was not true then you could not execute the body

that came right after the comparison instructions you would have to jump down to wherever the else

block is so there is circuitry inside of the CPU that allows you to either increase the instruction

instruction pointer by 8 bytes, 8 bytes because 64 bits per instruction because that’s your CPU.

So you just kind of go sequentially or to jump somewhere because you made a decision or you’re

like making a function call or whatever. So just keep in mind that under the hood, under this

diagram, there is a lot more logic even than the more detailed diagrams that you can find elsewhere.

There’s just like a lot more detail. So anyway, the RIP register just kind of increases by 8

every time we execute an instruction,

sometimes it’ll drastically change its address

so we can jump execution somewhere else

in order to make a decision.

So just keep that in mind.

So suppose that we just fetched an instruction from memory.

You know, it comes in here

and we kind of send it down the line.

We first give it to the code cache unit.

Your CPU is just not a solid block of stuff.

It’s got subunits inside of it.

And one of these units is the code cache unit.

it’s a lot more complicated than what you’re seeing here but basically

system ram is very slow dealing with the cpu internally is very very very fast in comparison

so if we have like a register or some unit that we’re accessing that’s inside of the cpu it’s

lightning fast compared to accessing the memory so that means cpus have caches which just i’m not

going to go too much into caches for this video but basically every time we get a new instruction

we might put it into the cache, which is like incredibly fast because it’s hardware that’s part

of the CPU. Then maybe sometime in the future, we might want to execute the same exact instruction

at the same exact address. Again, that’s possible. Remember we have loops. We can execute the same

instructions a bunch of times in a row. So if we come across an instruction that we have executed

in the past and it’s already in the code cache, then we don’t actually need to wait for memory

to fetch the instruction for us, we can just go directly to the code cache and it’s a dramatic

speed up.

Remember, when you access memory, execution has to stall for quite a long time usually

or sometimes.

Okay, so that’s what the code cache does.

Once the memory and the code cache have figured out, okay, we got the instruction and everything’s

good, then we just sort of decode the instruction.

We decide, you know, what is in the instruction?

it all like data or is it all like like is it half and half and part instruction

part data part whatever there’s lots of different formats for instructions so

the instruction decoder just sort of like you know decides how to separate

it and it sends data into the control unit notice how there’s a little arrow

pointing from the instruction decoder to the instruction pointer so we could use

that information to decide how to modify the RIP register like if we’re gonna go

or if we’re going to jump somewhere.

And then the, let’s see,

when we send the instruction to the control unit,

the control unit is not necessarily the brain

because the whole CPU is the brain of the computer,

but the control unit is kind of like the decider of the CPU.

At least that’s the way I see it.

It decides what to do.

There’s a lot of other subunits in the CPU.

Notice how down here we have, you know, CPU registers

and we also have the all you.

the all you the all you is basically the arithmetic logical unit so it’s it’s a little subunit that

will execute mathematical instructions or logical instructions like it’ll take some bits and it’ll

it’ll move them to the left or the right or it’ll flip the bits or whatever or it’ll add two numbers

together the registers you know they’re very very very fast they’re like you know the variables of

the cpu um so the control unit will examine uh whatever it’s getting and it’ll decide all right

want us to do it wants us to add two integers together or it wants us to

write something to memory or it wants us to do whatever right so when

the control unit receives input remember this is all just like ones and zeros

right so imagine if we had like a bunch of ones and zeros coming in and they’re

just wired directly into the control unit right so then the control unit has

its own internal circuitry that that makes it so well if I receive this

going to tell everybody else to add numbers together and if I see some other number I’m

going to tell everybody else to multiply numbers together so the control unit is really responsible

for deciding what the other units need to do in order to accomplish the current instruction

so gosh I really need to fix this I just reconfigured this thing and now it’s just like

drawing even when I don’t want it to draw so the control unit let’s say that we do that we have

that we have like an addition instruction we want to add two registers together the control unit will

send this down the wire to let the all you unit know that it needs to perform addition the all

you unit also has inputs and based on what it receives it will decide to do something it’ll

decide to add or subtract or multiply or just whatever so the control unit sends the right

input into the all you unit so that it knows to add or do whatever we wanted it to do

operands like it might receive data that just came from memory it might receive registers it might

receive just like a raw immediate number that’s embedded into the instruction on the other hand

we might also send something into the floating point unit so the control unit it’s always sending

all of these signals to all of its you know connected units these wires it’s not like we

can remove these wires so there’s always something even if it’s a zero going down the line

so the control unit will basically send the right signals down to the all you to tell it you’re

going to add and it’ll send the right signals down to the floating point unit to say you’re

not going to do anything or just we’re not we’re going to ignore the result there’s like all these

logical gates that we’re not showing on this diagram where we can just like ignore the output

result of some unit that we’re not going to use so it’s sending all these signals to these units

Just like a quick note here, the all you only deals with integer math and, you know, bitwise

logical operations.

Floating point numbers in the machine are stored totally differently than integers.

So we need a totally different unit in order to process them.

So that’s why there are two units there.

Well, I mean, I guess depending on, you know, what CPU we’re talking about, but like as

far as the ones that I’m aware of and that I use.

So then, you know, the data cache, kind of the same thing.

kind of the same thing um you know there’s like a code cache up here and a data cache down there

so sometimes we might want to fetch data that we’ve already fetched before and we don’t want

to hit system ram so you know we don’t want that slow down so we’ll just take it from the cache

and um we will also populate the cache when we have a result so when this like all you is done

adding whatever it’s going to add it’ll send its result data to the data cache and then um

two or three or whatever then we can reuse the result in another instruction or send it back to

memory or do whatever we want to so this is like a basic idea right like you you start off by you

know grabbing something from memory possibly if it’s already in the cache then you wouldn’t

actually grab it and then the instruction decoder decides you know are we gonna we’re gonna jump

are we gonna go to the next instruction after this is over so it’ll have the next address

notice how there’s kind of like a little cycle that goes here between code cache instruction

decoder and instruction pointer and so you know we’re always kind of deciding what’s the next

instruction that we’re going to execute and then we like you know send the decoded instruction to

the control unit the control unit decides you know are you going to do some addition are we

going to use registers or not and then you know like are you not going to do anything or are maybe

you are going to do something in this case I’m just saying the floating point won’t do anything

integers. And then once that is all processed, you know, it comes to the data cache and, um,

well, we can, we can basically just, uh, you know, write it back to memory. I think this

diagram is not showing an arrow that will write it, write it back to memory. Um,

yeah, the code cache is definitely not going to feed directly into memory. That’s just a cache,

but you know, so, so imagine like there’s a, there’s like another wire here that goes

so when we have a result we can just write it into system ram

let me see if i forgot to say anything rip

yeah that’s basically all i wanted to say okay so now you have a fairly good idea of at least

one level deeper of what’s going on inside of your computer how the cpu in a general way loads

and all these little subunits getting told what to do

and the results getting piped back to the instruction pointer

and also to system RAM and so forth.

And it just keeps going like this again and again and again.

And also just remember that at certain points

during even one cycle, we wait for a clock tick.

I’m not gonna say exactly when we wait

because it’s kind of specific to what’s going on

to be on the scope of this video.

But yeah, the clock speed controls

how fast these cycles go.

And there’s much more advanced stuff

And there’s much more advanced stuff that you could learn later,

like pipelining and such to increase efficiency.

But this is a basic idea of how your computer works.

I hope you enjoyed this video.

I hope you learned a little bit of stuff and had a little bit of fun.

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 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

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 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

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 uh 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

really appreciate it. So again, thank you so much for watching this video and enjoy the cool music

as I fade into the darkness, which is coming for us all.

Thank you.

The post How Your CPU Works: Fetch, Decode, Execute Explained appeared first on NeuralLantern.com.