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.

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.