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.