coding interview Archives - NeuralLantern.com

AVL Tree Rotations Practice: Balancing a Huge Linear Tree Step by Step

mike — Tue, 16 Jun 2026 04:49:15 +0000

In this hands-on AVL tree tutorial, we take a massive unbalanced linear binary search tree and perform multiple rotations to turn it into a properly balanced AVL tree. Watch as we identify imbalance, label X Y Z nodes, determine A B C, handle outstanding children, and reattach subtrees step by step.

Perfect for computer science students learning data structures, self-balancing trees, and AVL rotations. We go through several rotations on the same tree to show the full process from start to finish.

If you’ve seen the basics, this is the practice video you’ve been looking for. Timestamps and clear diagrams included.

Like and subscribe for more data structures content!

00:00 Introduction to AVL Rotations Practice
00:22 Previous Videos Overview
00:56 Understanding the Linear Tree Problem
01:24 Why Balance This Tree
02:20 Computing Balance Factors
03:16 First Rotation Setup XYZ
04:04 In-Order ABC Pattern
05:50 Reattaching Subtree
07:17 Recompute Balance Factors
08:06 Second Rotation Setup
09:20 XYZ and ABC for Second Rotation
10:08 Drawing Output Pattern
11:40 Placing Outstanding Children
13:32 Third Rotation Setup
14:28 XYZ for Third Rotation
15:02 Output Pattern and Children
18:28 Recompute Balance Factors
19:28 Fourth Rotation Setup
20:04 XYZ for Final Rotation
20:32 Handling All Outstanding Children
23:20 Reattaching Final Subtree
24:50 Last Rotation Setup
25:48 XYZ and ABC Final
26:38 Output Pattern and Children Placement
30:16 Final Balance Factors Check
30:52 Valid AVL Tree Achieved
31: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

Hello there! Let’s practice AVL rotations with a big ugly gross linear tree that for some reason hasn’t been rotating up to this point.

But we’re going to rotate it all at once to make it nice and balanced per the rules of AVL trees, just for practice.

Okay, so first off, you should have hopefully seen my previous videos.

search trees how to define them how to build them search through them add remove stuff all that

stuff and then we talked about abl trees which are really just self-balancing binary search

trees with some extra special rules on top we talked about the types of rotations how to do

the rotations when to rotate when to how to detect whether a tree is actually a valid abl tree and

all that stuff so if you don’t know what i’m talking about see my previous videos otherwise

we’re just going to practice on this one tree right now we’re just going to do a practice run

run. Okay so you would never I mean you would hopefully never see an AVL tree

that looks like this. This is way too imbalanced for an AVL tree. An AVL tree

would have started rebalancing itself a long time ago but let’s just pretend for

the sake of argument that you disabled the balancing feature of your AVL tree.

You maybe like have a boolean inside of your class that you’ve written in your

program called am I behaving like an AVL tree true or false and you set it to

for a while then you started throwing nodes at the tree after you ended up with this giant linear

tree then we’re going to suddenly turn on the avlness bool and start rotating this tree sucks

this is a valid binary search tree but like if you notice it follows all the rules of a binary

search tree and the data is in order but this is definitely not a valid avl tree the time

complexity of searching through this tree would be o of h and since o of h is actually the number

h is actually the number of nodes in the entire tree the time complexity of

searching through this particular tree is o of n so this is a linear tree it’s

no faster to search through than a linked list at least in terms of

scalability so this is bad we need to fix this so now let’s turn on the AVL

ness we’ll say okay now you’re no longer pretending to be a regular binary search

tree you’re an AVL tree let’s do some rotations the first thing we should do

do if you’re presented with a tree like this all at once is just compute the balance factors for

every single node. So I’m going to say the 55 is a leaf it has a balance factor of 0, the 42 has a

balance factor of 1, and really the balance factors just increase by 1 for every level up we go. So

the balance factor of the 15 node is horrible, it’s really really really bad. Now that we’ve done

this we could rotate anywhere we wanted to. I mean it’s valid to rotate starting with the 34 or the

or the 27 or 22 or 15 you wouldn’t want to rotate the 42 because that’s not

imbalanced enough for an AVL tree but really the smartest thing to do is

rotate as low as possible because when you rotate stuff that’s lower it tends

to fix stuff that’s higher so then you’ll end up doing less work and

probably end up with a tree that matches what someone else expected okay so we’re

going to rotate as low as possible that means I’m going to find the lowest node

and I’m going to say it’s the 34 node and I’ll label that as Z.

That’s bad. Let me try again.

34 is Z.

Okay, then we find the A child of the Z node

and we have to find the child that has a taller subtree,

but there’s only one choice.

We can only go to the right.

There’s nothing on the left.

So that means Y is the 42 node.

Same thing for the X node.

We’re labeling for X and we have to find a child of Y.

We have to look at the taller subtree,

We have to look at the taller subtree, but there is no other choice.

We can only go down and to the right.

So now we know our XYZ.

I’m just going to place these labels up here at the top.

I’m going to say X is 55, Y is 42, and Z is 34.

And maybe I’m going to change that text color real fast.

Then we want to produce an in-order representation of XYZ.

This step, I think it helps people with diagrams, but it also helps you a lot when it comes time to code.

when it comes time to code,

because coding for these rotations is way easier

than diagramming these rotations.

You pretty much just have to come up with three new pointers,

A and B and C,

and all they are is the ordered version of XYZ.

So, you know, which node belongs on the very left,

that’s gonna be 34,

which node would belong in the middle,

that’s gonna be 42,

which node would belong on the right side,

that’s gonna be 55.

And so now we’re ready to come up with our output pattern.

So I’m just gonna take one of these nodes

So I’m just going to take one of these nodes and copy it.

Maybe get rid of that little stem there.

And then I’m going to just, you know, copy paste this a couple of times as quickly as I can.

It doesn’t need to be perfect.

But if it’s not, they’ll laugh at you.

Okay.

So we’ll do this.

And we’ll draw some connecting lines.

So we’ve got like three nodes here.

A perfect little tri-node subtree because we picked X and Y and Z.

because we picked X and Y and Z and that became A and B and C.

Can’t get that line right, I’m going to give up.

So then we, I’m going to fix the labels here. So what is A belonging on the left?

That’s 34. What is B which belongs in the middle? That’s 42.

What is C which belongs on the right? That’s 55. So now we have

a perfectly balanced trinode subtree. Notice how this is a valid binary search tree.

If the numbers were in a different order, this wouldn’t be

a valid binary search tree and you’d have to try again with your ordering and also this has to be

a perfectly balanced trinode subtree otherwise this probably wouldn’t actually help if we if

we did a different output pattern it wouldn’t help the tree so then the next thing we need to do is

just double check that we don’t have any nodes that are unaccounted for from the input pattern

the xyz nodes so if we look at the uh the 34 node let’s look at z first i guess we’ll look at the 34

had 42 as a child but 42 is already handled so that’s actually okay then we look at the y node

that’s 42 it had 34 and 55 as children the 34 was handled uh here and the 55 is handled here so we

actually are fine we don’t need to worry about that now we’ll look at the x node the x node had

no children so we’re pretty much done again like i said in previous videos there could have been up

You know, each of these XYZ nodes could have had its own children.

Notice how 34 could have had one, 42 could have had one, 55 could have had two.

So there would be four outstanding children.

So we’re actually done at this point with the outstanding children.

There are none.

So I’m ready to reattach this tree, I guess the rotated subtree, into the regular tree.

So these three nodes can just go away from our diagram.

In code, you’re not actually removing these nodes.

You’re just sort of, you know, reattaching pointers.

reattaching pointers but I’m going to redraw this in a way that looks kind of nice and I’ll just

maybe redo this line real fast so I’m going to do a blue line here okay now we have to recompute the

balance factors so I’m going to say that the 34 is a leaf it’s got balance factor of zero same for

perfectly balanced and then we have to work our way up until we reach the root node. So

the 27 node, it’s got two nodes hanging off the right side and nothing on the left.

So its new balance factor is two. So it actually improved a little bit.

The 22 node, one, two, three, it’s got three nodes hanging off the right side and nothing

on the left. So it improved a little bit to three. And I’m guessing that the 15 also improved to four.

You can see the height on the left subtree of 15 is one, two, three, four, nothing on the left,

So we’re done with this particular rotation.

But because we see a node that has a balance factor of two or worse,

we’re not actually done rotating.

This is still an invalid AVL tree.

And under the hood, we would continually just, you know, rotate up and up and up the tree

until everything looked like it was fixed.

So again, the first node that’s out of whack, or I guess the lowest node that’s out of whack,

we’ll call that our Z node.

So we’re going to put a Z here.

piece of text and then we have to find a child of Z with the tallest subtree so there’s no child on

the left which means we have to go to the right to find our Y node okay then we have to go find X

through a child of Y and we have to find the child with the taller subtree actually the left child

and the right child have the same height of their trees of their subtrees so it doesn’t actually

know for fun let’s just go to the left because it’ll probably be harder we’ll say that the x

node is 34. be consistent if you always whenever you see like sub trees that are equal height

i don’t know maybe try to be consistent going left or right but in this case it doesn’t really matter

so we have xyz i’m going to type them up again right here we’re going to say x equals

Let me just double check that 34 42 27 and then we’ll produce ABC, which are the in order

representations of XYZ.

Again, imagine you’re using pointers if you’re doing this in code.

So we have like a is equal to the least value, the one that would belong on the left.

That’s the 27 B should be 34 and C should be 42.

And then, you know, just visually check.

way so that all the nodes have their own space. The one that’s furthest on the left is Z and that

ends up being A. The one in the middle is X, that’s B, and the one on the right is C, that’s 42, Y.

Right, yeah. Okay, so now that we’ve selected our ABC we can start drawing the output pattern. So

I’m going to like make a little copy of this and I’m just going to very quickly try to draw

balanced maybe a little bit lower they’ll laugh at you um they won’t they will i’m just kidding

let me finish this line

all right fix the numbers real fast uh so a is supposed to be on the left so that’s 27 that’s

already good uh b is 34 c is 42 so now we have to just worry about the unaccounted for children of

unaccounted for children of ABC or XYZ. So first I’m going to look at X. Whoops.

We look at X, it’s 34. It had no children of its own, so we don’t even have to worry about any of

its children. So we’re done. We look at Y, Y had two children. It had 34, but 34 was already handled

up here. And it had a right child of 55. Oh, so we have a child that is unaccounted for now. So I’m

duplicate it over here. We got to put it somewhere. I don’t know where just yet.

You can probably figure it out, but I’m just going to put it over there. Now we’re done looking for the Y.

And then next we’ll look at the Z node.

So I’m going to do

the Z node is 27. It had a 42 as a right child, but 42 was already handled in the output pattern.

So we’re done looking for outstanding children.

So the next thing I’m going to do is figure out where the heck does that 55 go?

does that 55 go? Remember, we’re trying to make valid binary search trees, which means there’s

only one place where this 55 node could actually go. If you stuck it on the left side, a greater

value on the left of 27, that’s invalid. That wouldn’t work. 55 is greater than 34, so it can’t

go on the left. It’s greater than 42. So actually 55 belongs all the way on the right side, because

again, that’s the only place it would actually work to allow us to still have a valid binary

search tree when we were done placing it so double check the subtree that you have written down after

you’re done doing all this stuff and make sure that the whole entire tree is a valid binary search

tree if not you probably have to try again okay so i’m going to duplicate this slide right here

and we’re going to say that we’ve got four nodes ready to be inserted in place of these four nodes

over here one two three four so i’m going to just select all four of these nodes and just delete them

and reinsert the rotated, you know, the rotated nodes, which are the same nodes, but they’re just,

you know, they’re drawn differently with, you know, different connections. And then I’m going

to fix this connection over here. So that’s 34 is now the right child of 22. Then I have to do

the balance factors for all of the nodes that we rearranged. So the leaves are easy. As usual,

This 42 has a balance factor of 1, and this 34 has a balance factor of also 1.

It’s not perfect, but it’s okay.

Then we work our way up the tree until we find the root node.

So now we’re going to recompute the balance factor for the 22.

Actually, it doesn’t improve.

If you notice, the right subtree has a height of 1, 2, 3.

There is no left subtree, so the balance factor is 3.

Same thing for this 15 node.

So we made a little progress.

Not much.

We have to keep going.

So, you know, once again, I’m going to select the lowest node that’s out of whack.

Or I guess as I work my way up the subtree, I can see that three node is still out of whack.

So I’m going to call that Z.

Nope.

Somebody remind me to do what types of rotations to talk about the rotation types.

Somebody send me an email or a comment.

I’m going to do it at the end of this video, but send me a comment anyway.

So the Z node is the 22 node.

22 node to find the y node we have to take a child of z with the tallest subtree but that’s obviously going to be 34

There’s no other choice

And now we actually do have an interesting choice to find the x node

It has to be a child of y, but it’s got to be the child with the tallest subtree

So for the first time we can kind of see

That we you know, we might have wanted to put x on the left or right, but it has to be on the right

We’re not allowed to put it on on the left at least for this method

So there we go. We have our XYZ. I’m going to go ahead and do X is equal to 42, and Y is equal to 34, and Z is equal to 22, and then A, B, and C are going to be the in-order representations.

the middle 42 goes on the right so now i’m ready to draw my output pattern so i’m going to like

select this real fast duplicate it up here make some copies making copies anyone no okay just

just wondering okay i’m going to do this do some connecting lines

So A is supposed to be on the left, that’s 22, and then B is going to be 34, and C is

going to be on the right, that’s going to be 42.

So we have a perfectly balanced trinode subtree.

Now we’ve got to double check for outstanding children.

So we start by looking at the Z node.

Oh my god.

Not as skilled as I think I am.

We look at the Z node.

which is already handled over here so we’re fine that way then we’ll look at the y node the y node

was 34 it had a left child of 27 that is not accounted for in the output pattern so i’m going

to grab it and then also you know when you’re grabbing these unaccounted for children double

check that they might also have children of their own if they do we have to take them with the node

that we’re moving so if 27 had any children we would not be you know removing or rearranging

children and just kind of you know let them stay in their position underneath 27. You know we would

not rearrange pointers that are further down but in this case what have I done in this case 27

doesn’t have any children I’ll have to do a copy that’s why make a copy put it somewhere so now

we’re done with the 27 on the right side of 34 it had a child of 42 but that’s already handled

42 and then I’ll just put like an arrow here. Now we’re ready to look at the X nodes children.

So the X is 42. It had a right child of 55 which is also not accounted for in the output pattern.

So I’m going to just move that over here.

Okay now we have to place these children in their appropriate positions.

So the 55 if you think about it there’s only one position that the 55 could ever go

go to produce a valid binary search tree so it can’t go there it’s got to go all the way on the

right side so that’s where we’ll put it same thing for the 27 there’s only one place it could go it

can’t go here because it’s less than 34 so it can’t be on the right side of 34 it’s going to

be on the left side of 34 and if you look at where is it going to go with respect to 22 it can’t go

on the left it has to go on the right because again we need a valid binary search tree

So I’m just going to connect this line right here.

And now we’re done making our little output tree, subtree.

So how many nodes did we have in the input tree?

It was 22, 34, 42, and 55, so like five nodes.

And if you look at the output pattern here, there’s also five nodes.

So we’re pretty much ready to just kind of remove all of these nodes

all the way up to that 15.

and make it the right child of 15. So I’m going to select all of this stuff, make it the right child

of 15, and then I guess I’ll just redo that line real fast. So this is a nicely formatted diagram.

So we’ll do what’s going on with my computer. Okay, sometimes it lags. I’m gonna, well,

balance factors now so I’m going to do balance factors for the leaves pretty easy the 22 and the

42 have a balance factor of one again if this is confusing see my previous videos we practiced a

lot of that the balance factor for the 34 is going to be a zero remember it’s about the height of the

left subtree versus the right subtree which there’s no difference actually they both have a height of

two it’s you know just just because there’s a little diagonal bounce there on one side doesn’t

awesome. Not perfect, but it’s pretty good. We look at the 15. What’s the new balance factor of

the 15? It’s actually three now because the height of its right subtree is three and the height of

its left subtree is zero. So its balance factor improved to three. So we are making, you know,

a little bit of progress. Now we know that the only node that’s out of whack in the whole tree

is the 15. So we’re just going to call that our Z node for another rotation. So I’m going to put Z

of z which would be y and there’s no other choice and then once again we have to find a child of y

to find x and we have to take the child that has the taller subtree but both of these subtrees

are equal so i’m just going to go to the right for fun i don’t know i’m going to do x over here

on the on the right side well hang on have i been doing this the easy way oh yeah let’s let’s go to

Okay, so now we have XYZ. I don’t know why I say these things. We’ll do XYZ. X equals 22. Y is equal to 34. I say them for fun. Z is equal to 15. And then we’re going to do A and B and C. So A is going to be the least value. So that’s 15. B is going to be 22. C is going to be 34.

tree so i’m going to copy this over here a couple more times this tree is probably going to be huge

i’m probably gonna have to rearrange this a few times just do this over here make another copy

over here there’s a lot of nodes that are going to be unaccounted for here um i think this was

the example where we ended up just replacing the entire tree let’s see all right i guess that’s

And then I’m going to update the numbers. So A is 15, and B is 22, and C is 34.

So now one by one we have to look for any outstanding children of the nodes in the output pattern.

So we look at, let’s say, the Z first.

The Z had a right child of 34, but that’s already taken care of in the output pattern, so we don’t have to do anything.

now we look at the y the y had a left child of 22 but that’s already taken care of in the output

pattern so we don’t have to worry about that it also had a right child of 42

um so we don’t have to worry about that sorry we do have to worry about that so i’m going to copy

the 42 over here and we’re going to have to do something with it eventually now we’re ready to

If we’re looking at the X node, X node is 22.

It had a right child of 27 that is not in the output pattern.

So that’s something that’s unaccounted for.

I’m going to place it over here.

Okay, now we’re ready to attach the nodes in the output pattern.

Let me just bring something to your attention real fast.

Notice how the 42 node, which was an outstanding child of one of the output pattern nodes,

it had a child of its own, right?

on the bottom here, you know, below the output pattern, if they had any children of their

own, we would not like change their topology. We would not assign them to different parents.

They would just stay exactly where they are, which means just for the purposes of this diagram,

I should probably also bring the 55 down as the right child of the 42. So I can remember,

you know, that it was there and not totally forget it and ruin the tree.

27 had no children, so it’s fine. The 27 should be a left child of 34 because it’s greater than

of 34 because it’s greater than 22 and it’s less than 34 so I’m going to stick it right there and

then where would the 42 go well it would it would be a right child of 34 because it’s greater than

34 so maybe I should make the 27 like just a little bit more to the left okay then I’m going

to reconnect so the 34’s left child is 27 its right child is 42 and then you know this is easy

like I make mistakes all the time too so I just want to double check that this is a valid binary

search tree because I could have you know done the numbers incorrectly so we have 15 22 27 34 42 55

it all increases it is a binary tree so it’s also a binary search tree and then it’s like

it satisfies all the other properties so now how many nodes did I actually remove four five six and

there were only six nodes in the entire tree before we did this rotation you know z is kind of the

know z is kind of the culprit of why this happened so that means the rotated pattern is actually the

final binary search tree so i’m just going to erase the whole entire tree and put the rotated

pattern in the middle here then we just have to recompute all the balance factors to make sure

that we’re done or that we’re not done so the leaves get zero and then the 42 gets a one and

then the 34 gets a one because it’s got a height of one on its left subtree and a height of two on

and a height of 2 on its right subtree, take the absolute value.

The 22 node, I don’t think that’s quite finished yet.

It’s got a balance factor of 2 because it’s here.

Let’s just clarify to make sure everybody’s on the same page.

Anytime I feel that I had to think even a little bit,

I’ll sometimes just kind of take a little step back and make sure everybody’s okay.

So the left subtree has a height of 1.

You can see that I highlighted the left subtree.

The right subtree has a height of 1, 2, 3.

So 1 minus 3, take the absolute value.

That’s going to be 2.

value that’s going to be two so the balance factor of the 22 node is two meaning we’re not done

rotating our tree it could be a little bit better a little bit faster so maybe i’m going to move this

whole thing over to the left a little bit and then we’ll call the 22 node the z node because it’s the

first node that’s out of whack then we have some more interesting choices right remember before

if we’re going to go down into the left or down into the right it always seemed obvious but now

seemed obvious but now to find our y we could go left or right but we have to go to the right

because 34 has the taller subtree 15 it’s it’s a tree of just one it’s a height of one and 34 it’s

a tree of height three so we go to the right to find y to find x again we need to look at a child

of y with the tallest subtree so that’s not going to be 27 that’s a height of one it’s going to be

42 with the height of two so the x node is this over here and now we’re ready to talk about

ready to talk about what is XYZ and ABC. So X is, I always forget to change the color before I type

this. Okay. X is 42. Y is 34. Z is 22. And then we get A and B and C. Okay, so A is the least value,

the one that would belong on the left. I mean, you can just look visually on the diagram again.

on the left right so that would have to be a because anything that starts leftmost should end

up left leftmost in terms of a well-drawn diagram so b is going to be in the middle that’s the 34

and then c is going to be the greatest value which is 42 again c 42 is the rightmost value both

before and after we decided what is a xyz and abc so we’ve got that i’m going to go ahead and start

for another new diagram.

We’re going to say,

we got that.

Give it a little copy.

Give it another little copy.

Give it a copy.

Then I’m going to draw my connections.

Dang, how long is this video?

Man, I knew this was going to be a gnarly example.

That’s why I like doing it.

Okay.

Fix the numbers real fast.

So the 27 is A, it’s 22.

And then this is going to be B, which is 34.

And then 27, or the rightmost node, is going to be the 42.

Then we start looking at children that might be unaccounted for in our target pattern.

So I’m going to duplicate this.

And we’ll say, start by looking at Z.

It had a left child of 15, which is unaccounted for in the output pattern.

So I’m going to move 15 over here somewhere.

And then we look at the 34.

That’s already accounted for in the output pattern.

So we’re done looking at Z’s children.

So I’m just going to do this.

Now we’re ready to look at Y.

Y had a left child of 27.

That’s actually unaccounted for.

So I’m going to move the 20.

I’m going to copy the 27 over here.

And then we look at the 42.

The 42 is already handled in the output pattern.

So we don’t have to worry about it.

worry about it okay now we’re ready to look at the x nodes children so we look at x it had a right

child of 55 that’s also that’s also not accounted for in the output pattern so i’m going to make a

copy so we have like three nodes to worry about and then you know just for diagram purposes in

the code this would be easy to do but for the diagram we have to make sure are we dragging any

of these unaccounted for children away from their other children that they might have so 55 it has

children 27 it has no children 15 also has no children so these are pretty easy so just visually

I’m going to rearrange I lost my camera what happened test test test whoa I’m tripping so I

had a technical issue with my camera I had to edit out I guess a little portion where I was super

confused and screaming and now I think we’re okay so we can continue the video so we’ve just looked

children that are unaccounted for and accounted for them that’s so nice of us

and we’re going to have to place them somewhere so this 15 again it can’t go

anywhere over here on the right side that would be an invalid binary search

tree it’s actually got to go on the left of the 22

it’s the only place it could possibly go same thing for the 55 where is that

going to go I don’t know maybe like all the way to the right because that’s the

only numerically valid you know place that it could go to have a valid binary

27 can’t go on the right of 34 it’s too small it ends up going on the right of 22.

So now we’ve placed the children to account for them and I’m going to just like draw my

connecting lines real fast and then how many nodes do we have here let’s see the 22

1 2 3 4 5 6 1 2 3 4 5 6 oh actually that’s every single node in the tree just like last time we

again guess that that would have happened because it might be likely to happen because the z node

here was actually the root node of the tree. So I’m just going to you know replace the entire tree

and say that we’re done rotating now. So we’ll just do this put this in the middle and then

recompute all the balance factors just to check to see if we’re done. You can probably tell already

this is a pretty decent tree so we might not have to rotate but I’m going to go ahead and

have to rotate but I’m going to go ahead and just double check anyway. So the leaves get zeros

and the 22 gets a zero because it’s got left and right subtrees of equal height. The 42 has a one

and the 34 also has a zero because it’s left and right subtrees are equal height. This is maybe

another good opportunity for me to point out that it’s not about weight or mass on the left versus

right subtrees. It’s just about height only. So even though there are less nodes in the right

The fact remains that the heights are the same. So actually that’s a zero for the root node

This is now finally a valid AVL tree. We have rotated it enough. It is now considered

Log time again, it’s going to be fast to search and insert and remove and all that stuff. So this is pretty great

We are now officially done with this example tree. So thank you so much for watching this video

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

and I hope you enjoyed doing this tree with me it’s always a little stressful because it’s like

a half hour tree and I always wonder like did I make a mistake five hours ago I don’t even know

so I guess I’ll see you in the next video thanks for hanging in there with me

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

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

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,

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 rotate an AVL tree…

Hmm…

Test test test! Whoa, I’m trippin’!

The post AVL Tree Rotations Practice: Balancing a Huge Linear Tree Step by Step appeared first on NeuralLantern.com.

AVL Tree Rotations Tutorial: Fixing Imbalance After Adding a Node

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

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

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

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

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

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

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

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

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

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

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

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

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

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

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

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

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

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

for any node, then it’s considered invalid.

The tree itself is just a binary search tree,

not an AVL tree, until we fix the imbalance.

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

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

Oh, because I was saying two.

First thing I want to do is do the balance factors

for the leaves, because they’re the easiest.

All the leaves have a balance factor of zero,

because they have no difference in left subtree

versus right subtree height.

The 50 node is also kind of easy,

because it’s left subtree and right subtree

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So I’m going to add the number 54.

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

I’ll change this to a 54.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

just to show you what’s going on.

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

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

So that means the balance factor of the 44 node

also has a two.

So at this point, it might be a little confusing

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

as you’re working your way up

or at least rotate the lowest possible node first.

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

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

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

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

And there will be other stuff underneath that is bad.

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

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

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

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

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

X, Y, and Z.

Now, how do we choose Y?

We go down to a child of Z,

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

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

and the right subtree has a height of 1,

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

So I’m going to put Y right here.

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

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

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

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

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

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

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

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

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

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

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

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

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

I mean, on these diagrams, us humans,

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

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

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

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

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

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

before it can be an AVL tree.

So 50 is going to go on the left.

That’s the only place that it could go.

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

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

This little trinode subtree.

Was that, will that work?

Yeah.

So I don’t have to draw this again.

I’m going to erase some of this stuff.

Oh, come on, man.

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

just to make it a little more neat.

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

So, sorry, ABC.

So A is going to be 50.

That’s the leftmost node or the least value.

And then B is going to be 62.

And then C is 78.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hanging exactly where it was already off of the 54.

Same thing for the 48.

If it had any children of its own,

just leave them in place.

Don’t touch them.

Don’t touch any descendants.

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

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

Okay, let me erase this real fast.

X, Y, and Z.

Nope, that’s going to screw me up.

I’m going to forget.

Okay, now we have to place these nodes

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

would just remain attached in place.

But I just want to double check real fast.

So we got X, Y, and Z.

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

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

So how many do I have in the output pattern?

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

So I’ve got the same number of nodes.

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

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

Yeah, reattach this into the diagram.

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

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

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

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

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

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

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

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

So let’s do the leaves first.

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

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

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

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

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

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

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

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

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

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

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

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

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

we rotate it a little bit lower.

And this is not the fastest tree in the world,

but it is considered a log tree

because the imbalance is only scaling

with a constant factor because we’re limiting

the balance factors to just the number one basically

before we rotate.

So what type of rotation did we actually perform?

If you looked at my previous video,

you should know this already,

but maybe I’ll duplicate this here

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Okay, let me just double check.

This is a valid BST.

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

And it’s a valid AVL tree

because all the balance factors are okay.

Yeah, and in future videos,

we’re going to do more rotations.

I’m probably going to do at least like,

you know, two or three more videos

where we just simply rotate, you know, some tree

and explain it and work our way through it.

If you have an idea for a really gross tree

that you want me to rotate in front of you,

AVL Tree Rotation Types Explained for Self-Balancing Binary Search Trees

mike — Mon, 25 May 2026 20:03:52 +0000

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.

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

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

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

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

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

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

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

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

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

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

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

search tree with the insert or add operation.

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

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

are easier to debug.

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

a binary search tree.

So there are three types of deletions.

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

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

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

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

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

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

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

How many children does it have?

Is it a leaf with zero children?

Is it a node with one child?

Or is it a node with two children?

Each type of node is deleted in a different way.

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

is a node with zero children,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

actually what’s happening is the nine node,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So deleted a leaf.

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

is deleting a node that has one child.

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

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

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

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

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

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

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

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

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

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

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

You know, where is the 32?

We’re just searching for it.

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

We then look at the node.

Okay, we found the 32.

We identify how many children it has.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

But long story short,

in order traversal just means produce a sorted list,

an ascending list or a non-decreasing list

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

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

I can just say, you know, looking visually

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

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

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

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

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

to be increasing or at least not decreasing.

Let me just double check.

Okay, how many do I have?

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

I already got lost.

I think it’s 19.

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

Okay, did it right.

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

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

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

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

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

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

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

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

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

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

We found it in O time in the worst case.

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

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

terms of time complexity.

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

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

What is the in order successor of the 35 node?

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

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

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

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

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

I like to do successor.

So first we find the 35,

then we find it’s in order successor.

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

because that’ll be a little more difficult.

Once we find the in order successor,

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

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

So that means I’m gonna take this 35

and it no longer has 35 as its value.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Maybe I’ll do like another color here.

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

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

Notice how that’s the 19. Again,

if the 19 had a child on its left side,

we would have to follow it down further,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Okay, okay.

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

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

First, we search for 41.

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

We just found it right away.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Hey everybody!

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

I really appreciate it.

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

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

could you please subscribe and follow this channel or these videos

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

that you’re looking at right now.

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

and grow this community.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Thank you.

Hello there.

Let’s talk about.

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