Learn how to represent a directed and weighted graph using an edge list.

We start from a directed unweighted example, add weights to every edge, then store the graph as a tuple of a vertex list and an edge list. Each edge is a tuple of start node, end node, and weight. Order matters because the graph is directed.

Then we convert node values to indexes so you can jump straight to a vertex in constant time instead of scanning the vertex list. That keeps edge scans closer to O(E) instead of O(E + V).

This is part of a series covering all four combinations: directed vs undirected and weighted vs unweighted. Watch the earlier videos for basic graph terms and the other representations.

Leave a comment if you want a topic covered next.

00:00 Intro to directed weighted edge lists
01:05 Starting from the directed unweighted graph
01:35 Adding a weight to every edge
02:48 Graph as a vertex list plus edge list
03:35 Writing the vertex list
04:18 Node classes versus raw values
05:18 Writing directed weighted edges
05:45 Order matters on directed edges
06:38 Walking remaining outgoing edges
09:08 Why value-based edges scan slowly
10:29 Replacing node values with indexes
12:36 Constant-time jumps after an edge scan
14:13 Series wrap-up
14:45 Subscribe 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 representing a directed and weighted

graph inside your machine using an edge list representation.

That’s a lot of words, a lot of words. Okay, so I hope you watched my previous videos. You didn’t

necessarily need to watch the previous three where we talked about edge list

representation.

where we talked about edgeless representation on the other types of graphs we’re doing a directed

versus uh undirected and weighted versus unweighted and all four combinations of those

so uh you don’t need to watch those others if you’re just only interested in this but it’s

probably a good idea if you watch my other graph videos because we talk about basic graph

terminology and like you know what is a graph and stuff like that but for now we’re just going to

continue um the screenshot you’re looking at right now was the last part of the last video where we

Thank you.

the last part of the last video where we did a directed unweighted graph so I’m

gonna duplicate this real fast and I’m gonna start modifying it so we can

basically just move on with our lives so this is gonna be directed and also

weighted then I’m gonna erase a whole bunch of other stuff because it’s fun to

draw again I don’t know why but it is I like to do my drawings get that and then

And I’m going to get rid of that stuff.

Okay.

that stuff okay and i’ll get rid of this because i’d like to draw it okay i probably should have

gotten rid of it first so i guess the real first thing that i’m going to do after erasing all that

stuff is add weights to all the edges remember this has to be a weighted graph so this particular

graph you’re looking at right now is directed and unweighted so we have to add weights to all of

the edges in my previous videos we talked about what is the meaning of weights you know these

could be a cost these could be like some property like in a video game

property like in a video game uh whatever you want them to mean uh these could even be classes

with like complicated values um but for now i’m going to say i don’t know maybe this is an airport

map and the weights are how much gas it takes to fly from one city to another maybe a node is a

city number six and city number 12 you want to fly between them it’s like five million jillion

gallons of gas so let me just take a look real fast and make sure that i’m not forgetting

I mean, any edge.

getting any edge every single edge should have a weight i think there were nine edges here one two

three four five six seven eight nine so i should see nine weights one two three four five six seven

eight nine okay we’re now ready to start representing this and what’s going on with

this computer okay the first thing uh that we talk about in all of these you know recent related

videos is that in an edge list representation we’ll say

edge list representation, we’ll say that our graph is a tuple, meaning just like a collection of some

things. A tuple where the first item in the tuple is a vertex list or a node list, and the second

item is an edge list. Again, in previous videos, we talked about representing paths using nodes or

using edges. So the edge list path is going to come back to haunt us where we do our edge list

graph representation, which is different than an edge list path.

path. So how do we do our vertex list? That’s going to be pretty easy for this diagram.

I’m going to say that V is equal to, oh, it’s pink. Let me change the color to be more serious.

Okay. The vertex list is going to be a collection of just all the nodes, just naming all the nodes

or having all the nodes. I’m going to say it’s a vertex list or a node list, but really you

probably want this to be a vector I’ve been saying that recently because it’s faster to

because it’s faster to jump to a particular index in a vector

than it is in an actual linked list or some other list-like data structure.

So we’ve got a vertex list.

I’m just going to name all the nodes.

So for me particularly, I like to go from left to right.

You can sort them, you can do whatever you want.

They just need to all be in there.

So I’m just going to say every node that we see in the graph

is going to end up in this vertex list.

So we’ve got 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6.

So we’ve got all the nodes in there.

another point that I’ve been making in the in these recent videos is that in real life in your

code in your in your computer you don’t really want to just have this value three here you don’t

want to have this 12 value here that the 12 value that’s just the value that the node holds I mean

if you want everything to be really fast maybe you know keep it bare bones but for me I like to

have a full node class a full vertex class and make an instance of it so I can add a whole bunch

of custom properties and function

bunch of custom properties and functionality and other stuff onto my node so that that means i

couldn’t really put an integer there i would have to put a full node so keep in mind for yourself

you probably want to try it both ways but um you probably want to want an instance of a node class

and maybe stick the instance right there in the vector or maybe make a smart pointer and so like

you allocate you know a new pointer of an instance of the class or it’s a raw pointer it’s a smart

point or whatever so just keep in mind this diagram is

So just keep in mind, this diagram is more simple than your code, but we’re just diagramming

today.

Anyway, so we put all the nodes in there.

The next thing I need to do is represent the edges.

So I’m going to put E is equal to another list.

And this probably does need to be a linked list or a list like data structure and not

a vector.

There’s not much point in jumping to an index.

I don’t know.

You could probably come up with one.

But anyway, so the edge list is going to be a list of tuples that describe one edge at

a time.

at a time so every little parenthesis that i put here that’s going to represent one edge so again

for me i like to go from left to right i’m going to start on the left node and i’m going to say

that the start node is three and remember this is a directed graph which means the order if you

looked at my previous videos the hang on the order of the nodes actually matters a lot like i can put

3 and 13 but i cannot put 13 comma 3 because the first item in the tuple is supposed to be the

The first item in the tuple is supposed to be the starting node.

And if you see, I only have like an edge going from 3 to 13.

I don’t have one going from 13 to 3.

So 13 comma 3 would be invalid.

It would be totally bad.

So I’m going to say the 3 goes out to the 13.

So the 3 comes first and the 13 is second.

And then I have to describe how much it costs.

So that’s the third item in that one particular tuple.

It’s going to be a 1 because the cost of that one particular edge is 1.

one gasoline one

one millisecond delay one time whatever so then the next item is going to be where else does the

three go to the three doesn’t go anywhere else so we’re done representing the three at least as a

start node so next up uh i’m going to look at the 13 where does the 13 go to it goes to the six it

doesn’t go to the three the three goes to 13 but this the 13 doesn’t go to the three so 13 goes to

six and it costs six because that’s the cost of the edge there’s two sixes here

the edge. There’s two 6s here, a little confusing, but that’s because one is a node and one is a

weight. The 13 does not go out anywhere else, so we’re done with the 13. I like to make, you know,

different rows for every single start node. You don’t have to do that. Next up, I’m going to look

at the 6. The 6 does not go out to the 13. The 6 does not go out to the 18. There is a connection

there, but it’s going in the other direction. The 6 goes to the 12 and also to the 15. So the 6 goes

to the 12, and that cost us $5,000.

to the 12 and that cost us five because that was the weight we assigned and the six also goes to

the 15 with a cost of i think i just wrote seven in a weird way um so we go from six to fifteen it

costs us seven and then we’re done looking at the outgoing edges of these six let me just double

check out out yes now we’re ready to move on to the uh the 12 node the 12 node has one outgoing

connection it goes out to the three did i get that wrong in the last video leave a comment

Did I get that wrong in the last video?

Leave a comment.

I don’t know.

And then we’re done with the 12 node.

Now we look at the 15 node.

Oh, that’s why I had that feeling,

because the 15 didn’t go anywhere.

15 has incoming connections, but no outgoing connections,

so we actually can’t write it down here.

There’s no need.

Then we look at the 18 node.

The 18 has outgoing connections to four other nodes.

To the three, with a cost of three.

Am I mind-tripping myself when I’m doing these duplicates?

18 also goes out to the 6 with the cost of 8.

Didn’t trick myself that time.

The 18 also goes out to the 12 with the cost of 2.

And then the 18 also goes out to 15 with the cost of 9.

I just realized recently it’s a good idea to make faces at the camera for emotional thumbnails.

I don’t know if you’ve picked up on that yet, but yeah.

if you’ve picked up on that yet but yeah so let me just double check that i’ve got like nine edges

and nine entries one two three four five six seven eight nine so i think i probably did it all right

now there’s a problem um i’ve been talking about this in in the recent videos there’s a problem

with this type of representation what if you are scanning through the edge list and you’re like

well i’m scanning this edge and that edge and that edge and that edge and that edge and then i come

to the 18-6 edge

and I think, well now I found

and i think well now i found some edge that was interesting for whatever reason

maybe if i was scanning or doing some kind of like a operation that might have costed linear time so

you don’t have to know about this uh this is in other videos but basically it’s not incredibly

scalable it’s not incredibly fast it is technically scalable just not incredible

linear time based on the number of edges so that kind of sucks because if i wanted to do something

with those nodes with the 18 and

with those nodes with the 18 and the six node i would then have to do another linear scan

to find each node i’d have to go into my vertex list and i’d have to say well where the heck are

those things where’s 18 nope nope nope nope nope uh found the 18 and then there’s another scan

to find the six so really this is going to end up being um linear time based on the number of edges

and also the number of vertices so that’s a little bit slower not

a little bit slower not too great the upgrade that we’re going to do which we’ve been doing

in all the other videos of of these recent edge list representations is i’m going to

first i’m going to duplicate the vertex list like this

and then i’m going to show you that each node each vertex has an index so i’m going to say

one this is index two it’s index three when i type too hard i think my hand shakes the table

that kind of sucks i need shock absorbers for my galumpiness oh so we have uh an index for every

single vertex what if we uh what if we copy pasted the edge list over here on the left

um what’s going on it’s not oh there it is dumb okay what if we copy pasted it and then we

converted all of the values.

at all of the values uh or um i guess you maybe on the left side if you if you’re doing this in

the code you might put pointers instead of values so we’ll just say that we’ll convert the pointers

or these values into indexes so this first tuple we’re describing the edge that goes between 3 and

13 with the cost of 1 3 is sitting at index 0 in the vertex list so i’m going to change it to a 0

13 is sitting at index 1 I’m going to leave the weight alone and

I’m going to leave the weight alone, and then I’m just going to convert every other tuple

to indexes. So the 13 node, that’s sitting at index 1. The 6 node is sitting at index 2,

leave the weight alone. The 6 node is at index 2, the 12 node is at index 3.

The 6 node again is at index 2. The 15 node is at index 4, again leave the weights alone.

The 12 node is sitting at index 3, the 3 node is sitting at index 0, leave the weight alone.

The 18 node is sitting at index 5.

The 3 node is sitting at index 0.

I think I’m going too fast.

I’m probably going to screw something up.

We’ve got index 5 there for the 18, and then 6 is index 2.

18 is index 5.

12 is index 3.

18 is index 5.

15 is index 4.

So all I did was just convert every node value or pointer, if it’s in your code, to an index that references the vertex list.

the vertex list why would I want to do this okay so like last time we said we

would do O of E it would be linear time based on the number of edges if we’re

performing some sort of a search or examination of all the edges so we have

to like scan all the edges and then eventually we come to something we’re

interested in maybe we realize oh that’s that’s a special edge we want to see

what’s going on there maybe we want to grab those nodes and extract more

information from them or modify them or do something to them this representation

tells us

this representation tells us exactly where to go,

because this 5 is an index, it’s not a node value.

Same thing for the 2.

So index 5 gives us the 18,

and index 2 gives us the 6.

Notice how we still actually were looking for the 18 and 6 nodes,

like we were in the previous, I guess, representation.

So now, instead of scanning the vertex list,

we can just jump directly to an index,

jump directly to an index and you know remember like if you’re using an array or a vector it’s

going to be constant time to jump to an index it’s like very very fast it’s the holy grail

of time complexities so it’s really going to be something like o of e plus c or one or whatever

you want to call it but it’s going to reduce to just o of e so it’s going to be a little bit

faster notice how you know this one is going to take more time than that one maybe i’ll put it in

red to make the

it in red to make the the more than the greater than operator feel feel bad and evil but anyway

this is how you do edgeless representation if you’re interested in the in all four uh types

of graphs being represented with an edgeless representation check out all my other videos

please leave a comment with ideas for stuff you want me to go over but i think i’m finished with

this video it’s been 15 minutes already i don’t remember what i forgot to say but i guess we’re

done now thank you so much for watching

we’re done now thank you so much for watching i hope you learned a little bit of stuff and had a

little bit of fun i’ll see you in the next video i’m gonna get my gear i’m just kidding i’m gonna

eat a bunch of cookies i’m just kidding i shouldn’t do that but i probably will

hey everybody thanks for watching this video again from the bottom of my heart i really

appreciate it i do hope you did learn something and have some fun uh if you could do me a please

a small little favor could you please subscribe and follow

subscribe and follow this channel or these videos or whatever it is you do on

the current social media website that you’re looking at right now it would

really mean the world to me and it’ll help make more videos and grow this

community so we’ll be able to do more videos longer videos better videos or

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

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

I just wake up because I know somebody subscribed or followed it just wakes me

up and I could feel

followed it just wakes me up and i get filled with joy that’s exactly what happens every single time

so you could do it as a nice favor to me or you could you could troll me if you want to just wake

me up in the middle of the night just subscribe and then i’ll i’ll just wake up i promise that’s

what will happen also uh if you look at the middle of the screen right now you should see a qr code

which you can scan in order to go to the 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

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

If you have a suggestion for

Clarifications or errata or just future videos that you want to see please leave a comment or if you just want to say hey

What’s up? What’s going on? You know, just send me a comment, whatever

I also wake up for those in the middle of the night. I get I wake up in a cold sweat. I’m like this

It would really it really mean the world to me. I would really appreciate it. So again, thank you

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.

ご視聴ありがとうございました

Teksting av Nicolai Winther

Hey there!

The post Directed Weighted Graph Edge List Representation appeared first on NeuralLantern.com.

We start from the previous diagram and add weight costs on every single edge. The graph is a tuple consisting of a vertex list and an edge list. Vertices are listed from left to right. Edges are stored as triples with starting node, ending node, and weight.

We build the edge list by scanning nodes left to right so each undirected edge appears only once. Then we convert the representation to use indexes instead of node values. This lets you jump to any node in constant time when using a vector or array for the vertex list.

This makes operations on edges and nodes much faster than linear scans for both. Next up: directed graphs, both unweighted and weighted.

0:00 Introduction to Weighted Graphs
1:00 Adding Edge Weights
3:16 Creating the Vertex List
5:19 Building the Edge List
10:34 Completing the Value-Based List
10:44 Why Value-Based Is Slow
13:04 Converting to Index-Based
15:29 Benefits of Index Lookups
17:49 Wrap-Up and Next Videos
18:22 Thank You 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! Hello there. Hey there. In the last video we talked about representing

an unweighted and undirected graph using the edge list representation inside your

machine. Now let’s talk about how to do that exact same thing with undirected

weighted graphs.

seeing on the screen right now is basically the last diagram that I drew on my previous video

where we talked about how to represent unweighted undirected graphs in the machine. You don’t

necessarily need to watch that video to understand this video but you probably want to watch a few

of my other previous graph videos to know the basics of graphs and edge lists and edge-based

paths and node-based paths and all that stuff. So for now I’m just going to continue from this

document. So let’s see, I’m going to duplicate

I’m going to duplicate this real fast I am going to just kind of modify the captions here because

we’re not going to do unweighted anywhere we’re going to say a weighted undirected graph did I

get that backwards I think sometimes people say undirected and then the weighted part after so

I’m just going to I’m just going to change it so it’s still undirected which means the edges don’t

have arrows so that’s fine but it’s going to be weighted now which means I have to assign a cost

of traveling along every single edge.

So I am going to just

so i am going to just sort of like erase a bunch of this stuff real fast erase these notations

uh you know what i’m going to erase all of this because i want you to you know see it

from start to finish okay so now i’m going to add weight costs on every single edge

um in the last video what i mentioned is that the the edge list representation of a graph in

the machine uh is basically your graph is a tuple that’s the orange you know marking

a tuple that’s the orange you know markings up here your graph is a tuple where the tuple consists

of a vertex list and also an edge list so we’ll do that from scratch together again but um let

me get the weights on there first what color do you want i don’t know i’m going to put arbitrary

numbers on all the edges just to say that every edge has a cost remember in a graph when you

travel along an edge if the edge has a weight then you consider that weight to be part of the cost

usually of traveling there so like if this was a network diagram

traveling there so like if this was a network diagram maybe these weights represent pings or

lags or bandwidth cost or something like that if this is like an airport diagram maybe the weights

represent gasoline or time or something like that so i’m going to do like four there we can repeat

weights if we really want to i’m going to line this up a little bit better that 12 looks gross

okay i think we’re okay now i have 14 all right did i forget anything raise your hand if i forgot

something

raise your hand if i forgot something oh i forgot okay did you raise your hand okay

i’m going to do the 13 and 6 uh let’s just put a 2 weight there you could put ones everywhere

if you wanted to i mean any any number is fine um also in an unweighted graph you kind of can

consider the number of hops to be a path cost which means you can kind of consider every uh

edge to just have a weight of one but for now we’re just gonna say this is the weighted graph

Okay, so the first…

okay so the first thing we need to do uh after that is make a vertex list so our vertex list

is just going to be a list of all of our vertices all of our nodes in the graph

how do we list them so for starters like we usually say vertex list but for me personally

this this particular data structure just that we’re going to type up on the bottom

i usually like to consider that a vector or an array at least because you can jump into a

Thank you.

uh because you can jump into a specific index in constant time which is really really fast if you

don’t know uh big o and time complexities check out my other videos but um it’s just really really

fast to jump to an index when you’re using an array or a vector but it’s kind of slow when

you’re using an actual linked list or some other data structure that makes you scan through it so

i’m going to say that my vertex list is actually a vector but i’ll keep calling it a list anyway

so we got the vertices uh we have to start naming them okay so the first thing is i’m going to do

we got the three there and we got the 13 and we got the 6 and the 12 and the 15 i’m just naming

all of the nodes in my graph i like to go from left to right because that makes it easier for

me to debug what i’m doing um you probably in your code i said this in the last video you probably

don’t want to store the actual value in your vertex list you probably actually want to create

an object of type node or of type vertex and give it the template data

and give it the template data type of in this case integer and then set the 13 inside of the class

it’s not as fast and memory efficient as just putting a number there but uh you know for me

i like more flexibility and i like to be able to do more powerful things with my stuff so i’m going

to say that 13 and all of the other nodes really that represents to me i made a brand new instance

of a class called node or vertex and then i set it up however i wanted and one of the things i did

set it up, we’ll stick to number 30.

things i did to set it up we’ll stick the number 13 inside of the class but for the for the diagram

it’s fine like this okay so we have our vertex list that’s the v if you’re looking at the uh

you know the v comma e the v part now we need to do the edge list so i’m going to say here’s my

edge list and we’re going to use the edge list representation like i talked about in previous

videos, which is basically a tuple where one tuple describes one edge. So in our

So, in our graph that we have right now, we definitely need a starting point and an ending point.

So, let me just start by looking at the 3 node, and I want to describe one of the edges for the 3.

So, the 3 goes to the 18 and the 13 and the 12.

I’m going to scan my eyes from left to right to make it a little more simple.

So, the 3 node, it connects to the 13 node, so I’m going to put a 3, 13.

the nodes doesn’t matter in an undirected graph so i could have easily put 13 and 3 it’s fine

you don’t want to duplicate it by putting 13 comma 3 sorry you don’t want to put 3 comma 13 and then

later put 13 comma 3. you don’t want to double it up because that would be like representing two

separate edges i’m just going to sort it in my mind before so that i don’t have to sort it again

later when i’m reading the graph which makes it faster for read operations but so 3 goes to 13

And then we have to represent the weight, so the tuple gets a little more complicated.

so the tuple gets a little more complicated than the last video just by a little bit i’m going to

say 3 comma 13 comma the weight which is just a 1 here and i think i mentioned this in my other

videos like a while back but uh the weight doesn’t have to be integer it could be a float it could be

any data type you wanted really as long as your algorithms support it and you have you know your

operator overloads all done and all that could be a full class just for the weight if you wanted to

but for this video it’s just going to be the weight is an integer so that’s the cost of

traveling

is an integer so that’s the cost of traveling along that one edge so notice how all of our

tuples have three items each it’s a triple tuple so i’m going to continue trying to represent uh

what the three touches so the three uh it touches the 13 and it also touches the 12 so i’m going to

say 3 goes to 12. what does that edge cost it costs us six because that’s the little pink six

there we’re done with that tuple so what else does three touch uh touches the 13 and then it touches

the

touches the 13 and then it touches the uh 12 and then it touches the 18. so i’m going to put an 18

there what does that edge cost it costs a four because there’s a pink little four at the very

top of the graph surprise you didn’t know that okay so then uh i’m sorry we’re going to move on

to the next node so we did the three already so i’m done with that i’m going to look at the 13.

where does the 13 connect it connects to the three but that’s to the left

because i’m this is why i like to scan my eyes from left to right i already know stuff on the

left is handled i don’t have to do it again so forget about the three i already described it

up here in the very first tuple three comma thirteen comma one i don’t want to describe it

again so forget about the three now the thirteen connects to the six so thirteen comma six and what

does that cost it costed two for our arbitrary labeling thirteen doesn’t touch any other node

so we’re done with the thirteen row and by the way i’m doing a line new lines here you don’t have to

to do that, I just

here you don’t have to do that i just like to i like to do one you know row per per start node

to make it look cooler and nicer okay so the uh 13 is done now let’s do the six

six touches the 13 but remember in the previous row we just handled that so i’m not going to do

it again the six to the right touches three other nodes you can see there are three lines

protruding on the right side of the six so um i’m just going to take those from left to right

It’s.

I’m just going to take those from left to right.

It’s touching the 12 at a cost of 14.

The 6 is also touching the 15 at a cost of 12, I think.

And the 6, you know, if I make mistakes, just leave it in a comment.

I will leave the video up so you can always remember my humiliation.

But I’m going to try my best.

I did not practice this.

6 touches the 15, and then the 6 touches the 18.

So 6 touches 18, and then it costs 9.

So now we’re probably done with the 6.

we’re probably done with the six um moving on uh one node to the right now we’re going to look at

the 12 okay so the 12 it touches 3 and 13 and 6 but those are already handled so forget it

the 12 touches the 15 we did not handle that right yeah because we’re going from left to right

uh and and then it costs us from going from 12 what am i doing it doesn’t touch the 15 oh my god

so the 12 touches the

uh so the 12 touches the uh the three which is already handled and it touches the

six which is already handled and then it only goes to the right to the 18. okay

anyway you know when i make mistakes on camera and i say do over i always go i don’t know why

so the 12 and the 18 uh it’s going to cost us three so then we’re done with the 12th so i’m

I’m going to go to the next one. We’ll look at the 15. The 15. 6 is already handled. 8.

6 is already handled, 18 is not handled yet, so I’m going to put 18 there, and it cost us $88, and then the 18 is the last one.

There’s nothing to do, because every node is on the left of the 18.

If you carefully, if you pause the video and look at every single node, you’ll see it’s already represented in a previous node.

So we’re officially done with the basic edge list representation of this graph, this undirected but weighted graph.

We need to do something else, though.

we need to do something else though i mentioned in the last video i’m going to repeat it in case

you didn’t watch the last video but we need to make sure that uh oh i guess i forgot to separate

those two things that means i have to duplicate the vertex list over here on the right side too

okay um so on the left this is okay but it’s kind of slow because what if we’re trying to look at uh

you know one particular edge let’s say that we we want to see what’s going on with this uh this

edge right here. Let’s say the 3 and the 13 edge, for whatever reason.

13 edge for whatever reason um i don’t know green 3 and the 13 edge okay so we’re looking at that

edge maybe for some reason we had just finished scanning uh maybe that’s not a fun edge well

what’s going on hello uh oh i forgot to set up a thing where you can make your cursor really

visible okay um actually so so this is not the most fun edge let me let me see about the 15 and

and 18-inch.

18 edge excuse me i had to take a drink of water so we’re going to look at this edge connecting

the 15 and the 18 node that’s a little more interesting so you can imagine maybe you were

doing a little scan uh if you know big o complexity by now we had to check out every single edge in

this edge list until we found the one that connected the 15 and the 18 so this was a linear

time scan based on the number of edges so this is just it’s scalable but it’s not very fast right so

We ended up kind of looking at this one.

so we ended up kind of looking at this one right here not fast um but what if we want to examine

uh some properties of the nodes or the vertices uh involved like the 15 and the 18.

here in this representation on the left we have the values we have the 15 value and the 18 value

we don’t really have a pointer to a full node object if that’s what you’re doing in your code

so um how do we get those those node objects we’re gonna have to do another linear scan we’re gonna

I’m gonna have to look at this one right here.

to look at this one right here oh that doesn’t match the value of 15 look at this one look at

this one look at this one we’re gonna have to scan every single node until we realize that it’s those

two at the end this is true even if it’s a vector uh holding your vertices because if we don’t know

the index then we have to actually just sweep through the whole vector so that’s really slow

it’s still kind of scalable but uh it’s not the best instead let’s update the the representation

on the right to have index

on the right to have indexes we did this in the last video but basically if you just kind of look

at this three node here the three node well let me let me copy this one more time the three node

corresponds to index zero which i forgot to write down my bad let me write that down for you real

fast get rid of that get rid of that get rid of that okay so i’m just going to update this vertex

list to just show you that if we have a vector or in a

that if we have a vector or an array then every single item has an index here’s index one index

two index three and four and five and then i guess i’ll just copy paste that to the other one since

i was too dumb to make an extra separated graph there um separated item okay so the uh the 15

sorry no the 13 the 3 and the 13 i guess i got to get rid of that that’s distracting me

I guess I gotta get rid of that, that’s distracting me.

The three and the 13,

those correspond to indexes zero and one

in the vertex list, right?

So zero and one, that’s the three and the 13.

So I’m just gonna change the values,

the T-type values, to the raw indexes.

It’s gonna seem a little weird at first,

and I’m gonna leave the weight alone,

because that’s totally fine.

We’re not gonna jump to a weight,

unless maybe you had a weight list, a weight vector,

if you wanted to make instances of weights.

You could do that, I’m not gonna do it.

do that i’m not going to do it so then again the 3 is a 0 the 12 is index 3 the 3 is another 0

the 18 is index 5. i’ll just do this for every single row so the 13 here is index 1 and then

the 6 index 2 notice how i’m just looking up here at the indexes of the vertex list and i’m just

changing the node values to the indexes where the nodes actually are in the vertex list so that’s a

So two.

vertex list so that’s a 2 and then the 12 is going to be a 3 and then the 6 is also going to be a 2

and the 15 is going to be a 4 and then the 6 is going to be a 2 and 18 is going to be 5

on to the next row the 12 node is index 3 the 18 node is index 5 uh the 15 node is index 4 and the

18 node is index 5 so whoa whoa correct me if i made a typo in the comments please i’ll release

another video as a thank you.

i’ll release another video as a thank you but uh now i’ve converted the whole entire representation

on the right side to an index based uh uh you know edge list so i’m gonna do this one over

here is by value and the one on the right is by index why is the one on the right better now

remember at some point we might have been scanning to find an edge well what did i just do wrong oh i

clicked over there okay we might have been scanning to find you know some edge so we’re like

Like, subscribe, and hit the bell icon to be notified when I post a new video. Thanks for watching, and I’ll see you in the next one.

Bye-bye.

edge so we’re like scanning scanning scanning scanning and then maybe we decide we’re trying

to figure out what’s going on with the two and the not the two and the four the uh the six and

the fifteen node right so that’s uh the six and the fifteen node that’s basically you know this

right here uh so now what if we want to do something with the nodes we want to do something

with the six node do something with the 15 node we don’t want to scan through the vertex list again

we don’t want to go scan scan scan scan scan that’s linear time that’s not as fast as it could

Could be.

That’s linear time, that’s not as fast as it could be.

So instead, we’ve already converted here so that we have indexes.

So if I look at the 2 and the 4, the 2 and the 4 represent indexes, not node values.

So this 2 tells me that I can go to index 2 to get the 6 node,

and the 4 tells me I can go to index 4 to get the 15 node.

Notice how I did not have to scan the vertex list to figure out where those nodes are.

And if you’re using a vector for your vertex list,

list then you can jump to every index in constant time so now if we were going to you know search

and do a bunch of stuff on edges we probably only had to spend linear time on the edge list but then

we only spent constant time uh to to manipulate each node whereas it would have been linear plus

linear uh in the past like on the left side that would have been uh you know if we’re going to do

stuff with with both the edges and the nodes it would have been o of linear time based on the

number of edges if we’re gonna do every

on the number of edges if we’re going to do every you know something to every single edge

plus linear time based on number of vertices but over here it’s going to be linear time of the

edges plus just constant time which basically means it’s going to be you know big o of just

the number of edges and i’m talking about a you know a fantasy scenario where we’re just going

to scan a bunch of stuff you can imagine there’s a whole bunch of different operations you could

do on a graph, and it would be very advantageous and fast.

very advantageous and fast if you could just jump to a node if you wanted to be able to manipulate

it directly um let’s see so i did i think 20 minutes already so i think this is going to be

it for for today’s video um and i’m going to do another video after this where we start working

with directed graphs so i’m going to do directed unweighted and then directed weighted so by the

time you watch all four of these videos

by the time you watch all four of these videos you’ll know how to represent all four types of

graphs in the machine okay anyway so thank you for watching this video i hope you learned a little

bit of stuff and had a little bit of fun i’ll see you next time tell your friends eat a chocolate

okay i’m outie hey everybody thanks for watching this video again from the bottom of my heart i

really appreciate it i do hope you did learn something and have some fun uh if you could do

me a please a small little favor could you please

please, a small little favor. Could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website that you’re looking at right now?

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

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making

videos in general. So please do me a kindness and subscribe. You know, sometimes I’m sleeping

in the middle of the night and I just wake up because I know somebody subscribed.

just wake up because i know somebody subscribed or followed it just wakes me up and i get filled

with joy that’s exactly what happens every single time so you could do it as a nice favor to me or

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

and then i’ll i’ll just wake up i promise that’s what will happen also uh if you look at the middle

of the screen right now you should see a qr code which you can scan in order to go to the 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

where you can just kind of like see all the videos i published and the services and tutorials and

things that i offer and all that good stuff and uh if you have a suggestion for uh uh clarifications

or errata or just future videos that you want to see please leave a comment or if you just want to

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

those in the 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 really mean the world to me i would really appreciate it so again thank you so much for

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

Teksting av Nicolai Winther

Thanks for watching!

Thank you.

The post How to Represent Undirected Weighted Graphs Using Edge Lists appeared first on NeuralLantern.com.

Hello there. Lets talk about graphs and whether they are connected or not or maybe whether they are strongly connected versus weakly connected. We look at undirected graphs first and show what makes a graph connected meaning every node can reach every other node by a path. We add edges and check the connections step by step while also noting subgraphs. Then we switch to directed graphs and explain strongly connected versus weakly connected. Strongly connected follows the edge directions for every path. Weakly connected ignores the directions and checks if the graph would still be connected. Examples show how adding edges changes the status of the graph.

00:00 Introduction to Graph Connectedness
00:01 Drawing Nodes and a Disconnected Graph
01:56 Defining a Connected Graph
03:21 Introducing Subgraphs
04:48 Adding Edges to Create a Connected Graph
06:32 Adding Directions to Create a Directed Graph
08:03 Strongly Connected Versus Weakly Connected
08:34 Removing an Edge to Show Disconnection
09:29 Checking and Achieving Weak Connectivity
11:18 Adding Edges to Create a Strongly Connected Graph
13:20 Confirming the Strongly Connected Graph
13:32 Conclusion
14:17 Outro and Subscribe Request

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

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 graphs and whether they’re connected or not or maybe whether they’re

strongly connected versus weakly connected versus not connected. You never know.

Okay, so hopefully you’ve seen my previous videos by now where we just talked about the basics of

paper here i’m just going to start drawing a graph remember graphs are nodes and edges where

the nodes are like little t-type data structures that can hold a specific type of value um so i’m

going to say our our nodes hold integers um i think i made that one too small that’s okay

and the edges uh could have weights or maybe not weights at all depending on if you have

a weighted or an unweighted graph so i’m just going to start duplicating my nodes a little bit

going to make a random graph. I need to probably change these values. Technically your graphs

should support duplicate values in the nodes and also the weights, but I don’t want to because

it’s easier to talk about the graph when all the values are distinct. So for starters, we have a

bunch of nodes and they’re not really connected to each other. Is this a valid graph? Yeah it is.

It’s just not a connected graph. So the terminology that we’re going to use for

undirected graphs meaning the edges don’t have direction is going to be connected or not you

know i usually just say a not connected graph or a disconnected graph so just basically like

connected or not connected okay so this is a not connected graph i’m going to say not connected

not cinnamon i’m thinking about food as usual

connected graph why is it not a connected graph well to define what does it mean to be a connected

graph it just means that every single node can find a path to every single other node

in an undirected graph so we can just double check this real fast we can say you know can

node number two find a path to uh you know let me put a question here let’s say we’re going to check

you should be checking all the nodes one by one by one to see if if the node in particular can

first node that can’t do it means the whole graph is not considered connected so you know two it

can’t reach one so that means it’s not a connected graph so this is not a connected graph because one

or more nodes violate the rule of you have to be able to reach every single other node okay so that

means if we want a connected graph we probably just have to start adding edges so I’m going to

go ahead and uh let me let me write the word connected here and then I can like either circle

cross it out. So right now we have no, this is not a connected graph. I’m going to start adding

edges. We’re going to stick with an undirected graph for now. So I’m going to connect two and one

and two and nine, maybe one and 13. Actually, you know what? I’m going to erase this edge

and maybe connect these over here. And the thing is, this is a valid graph that you’re looking at.

it’s just not a connected graph.

Some other terminology I didn’t mention in other videos

is that we can have subgraphs.

We have like a subgraph here and another subgraph here.

Those are basically just two different portions of the same graph

that appear to be connected within themselves.

So those are subgraphs.

You can probably tell right away that this is not a connected graph.

You can double check to be sure.

You know, it’s good to do things the hard way

so you don’t get the wrong answer

when you’re really trying to figure something out.

So let’s look at two.

So let’s look at two. Can two reach one? Yes. So that’s good. Can two reach nine? Yeah,

it just hops to one and then hops to nine. So two can reach one and also nine. That’s good.

Can two reach three? Nope. So this is still not a connected graph.

Okay, I’m going to add one more edge. And then we’ll just check again.

Where do you think I’m going to do it? Maybe if I add, I’ll add a funky edge going from 13 to like

to like nine or something just so it feels a little bit more awkward okay let’s check one by

one by one let me actually get rid of this edge on the previous slide so we can still say that’s

not connected let’s check one by one by one every node must be able to reach every single other

node so I’m gonna look at two and I’m gonna say all right two can it reach one yes can it reach

to nine. So that’s good. Can it reach three? Yeah, it can go from two to one to nine to 13

to three, and then it can reach three. And because we just saw that it went through 13 to reach three,

that means two can reach every single other node. This is going to be more important as a double

check when we have directed graphs in a second. So two is good. So the next thing you want to do is

the next thing you want to do is just move on to some other node and do the exact same process you

know can can nine reach a one yes okay it can reach a one can it reach a two yeah it goes through

the one can it reach the 13 yep can it reach the three yep okay so we just check every single

destination node starting at the node nine but here’s a little bit of a shortcut try to find a

node that is right next to a node that you know can reach everything and if the node in question

that previously connected node, vertex,

then we know that that node in particular is also connected.

So what I’m saying is the one,

instead of checking every single other node in the graph,

which might be really hard

if we have a whole bunch of nodes in our graph,

we’ll just ask, can the one reach the two?

Because if it can, the two can reach everything.

So that means the one actually can reach everything as well.

So the one can reach the two.

So the one is connected to everything.

the three, the three can reach the one and the one can reach everything. I’m doing things the

hard way on purpose just to prove a point. So the three can reach everything. The 13 can reach the

three in one hop. So the 13 can reach everything. The nine, it can reach the one and it can reach

the 13 in one hop. So the nine can also actually reach everything. So that means this is indeed a

the next thing that we’re going to do is add direction to our graph you know we could do like

more examples maybe leave a comment if you want me to do some super extra complicated examples for

just a undirected and connected graph i’m ignoring weight by the way because it doesn’t really matter

for these purposes so let’s upgrade our graph so uh maybe i should put a question mark here

that would have been a good idea we’re just asking you know is it connected or not

And I’m just going to start adding direction to every single edge.

Let’s see if I’m following my notes.

Single node, subgraphs, right?

Well, it wasn’t connected at first and then we started adding.

Okay, so that’s basically okay.

Let’s add direction to every single edge.

So every single edge has to have a direction

or every single edge has to have no direction.

You can’t really mix and match.

So I’m just going to go through every single edge and add a direction like this.

and you know to be fair I think I’ve said this in my other videos an undirected edge is kind of the

same thing as a directed edge going in or two directed edges going in both directions so this

3 and 13 what’s going on with my computer hello this 3 and 13 edge it would have kind of been the

same as just having two edges going in opposite directions so maybe I’ll just do that right now

for this huge weird edge I’m just going to put like an arrow over here instead of totally redrawing

Then I double check that every single edge has a direction so that I have a valid graph.

And now I can ask, is this connected or not?

Actually, when it comes to a directed graph, you don’t really have connected or not anymore.

You have strongly connected versus weakly connected.

Maybe I should just separate these words and then just kind of like move them.

So let’s get rid of this.

to this save this over here move it down so what am i talking about um well first let me remove an

edge real quick i’ll remove this edge right here so now we have two sub graphs in this graph you

can tell for sure if this was an undirected graph it would not be connected but now that we’re

dealing with direction we have to ask is it strongly connected versus weakly so what does

can every node reach every other node if you obey the direction of the edges so that’s clearly not

true there’s no edge at all that even connects this one and nine so it’s definitely not strongly

connected weakly connected on the other hand means if you temporarily ignore the direction

of the edges then could you consider the graph connected so if we pretended that there were no

arrows here would we think that it’s a connected graph if the answer is yes then it’s at least a

So this is not weakly connected because if this was an undirected graph, it’s not even connected at all.

So that sucks.

I’m going to go ahead and add another edge here.

So I’m going to add an edge from 2 to 9.

So the first thing is, oh, sorry, I have to add another edge.

Let me do from 1 to 13 for fun.

So now the first thing is, let’s check to see if this is a strongly connected graph.

node is unreachable by any other node so this is definitely not strongly

connected because all the other nodes would be would have to be able to reach

too alright so first thing you could do just to very quickly check is just look

at every single node and ask is it reachable you know by anything and then

after that you can do things the hard way so it’s not strongly connected what

about weakly connected if we ignore the direction of the graph sorry if we

then yeah, we could reach every single node from every other node. Let’s just double check that

real fast. I’m going to say, you know, the two node, if we’re ignoring direction, can it reach

the one? Yes. Can it reach the 13? Yes. The three? Yes. Can it reach the nine? Yes. So that means the

two node is sort of like weakly connected to every other node in the graph. Do the same thing for the

one node. Previously, we just said, you know, check everything one by one or use a shortcut.

one by one or use a shortcut. So I’m going to use the shortcut. The one node, if we ignore direction

can reach the two nodes. So I’m going to say the one is weakly connected, at least everything else.

I’m not even going to check to see if it’s strongly connected to everything else. I think the answer

is no, but we do the same thing for the 13. The 13 can reach the one pretty fast. The three can

reach the 13. The nine can reach the two. So every single node can weakly reach. That’s not an

a weakly connected graph. Okay, cool. How can we make this a strongly connected graph? Well,

we just have to add a bunch of edges. So that’s what I’m going to do. I’m going to kind of like

look at what is missing here. So we’ll ask the two, can the two reach and let’s obey the direction

of the edges again. Can the two reach the one? Yes. Can the two reach the 13? Yes. Can it reach

Yes, so that means right now the two is strongly connected to everything else.

So we’re on track for a strongly connected graph.

We then look at the one node and we realize that the one node,

it can reach the 13 and the three and it can also reach the nine,

but it can’t reach the two.

That’s one thing that was blocking us last time from saying strongly connected.

So we just have to add another edge if we want this to be a strongly connected graph.

We have to figure out how can we get the one to reach the two.

the 2 we can go through something if we want to that’s fine we can also just

write an edge that just goes back to the 2 but that’s I don’t know that’s kind of

boring I’m gonna make an edge that goes from 1 to 9 and then I’m gonna make an

edge that goes from 9 to 2 so looking at the 1 node it can now reach the 2 if we

go through the 9 so that’s good can the 1 reach the 9 yes can the 1 reach the 13

three yes okay so the one node can now reach every single other node so now we’re a little bit more

on track for a strongly connected graph look at the 13 node can it reach the one node um actually

yes if we go from 13 to 9 and then 2 and then 1 we can reach the one node since we know the one

node is connected to everything else we can now say that the 13 node is connected to everything

13 so i’ll say three is connected to everything the nine node can reach the two node which is

connected to everything so that means the nine node is also connected to everything and at this

point we now have a strongly connected graph it’s not weakly connected it’s stronger than that

any questions um so let’s see we added a bunch of uh edges i think maybe this is actually all we

need to do for this particular video because we’re just going to talk about connectedness

going to talk about connectedness about 15 minutes not too bad all right so i think i’m

going to leave it here drop a comment if you want to do way more complicated examples if you want to

provide me a sample graph that’s awful and i could just i don’t know in the sometime in the future i

could record a video about it um or just let me know your thoughts thank you so much for watching

this video i hope you had a little bit of fun and i hope you learned a little bit of stuff i’m outie

Patowdy.

Alright, let’s see.

I’m going to do this.

Whoa. Can you see that guy in the background?

Oh, shoot.

I’m just kidding.

I set that as the screensaver.

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,

please subscribe and follow this channel or these videos or whatever it is you do on the current

social media website that you’re looking at right now. It would really mean the world to me and it’ll

help make more videos and grow this community. So we’ll be able to do more videos, longer videos,

better videos, or just I’ll be able to keep making videos in general. So please do me a kindness

and subscribe. You know, sometimes I’m sleeping in the middle of the night and I just wake up

or followed. It just wakes me up and I get filled with joy. That’s exactly what happens every single

time. So you could do it as a nice favor to me or you could you could troll me if you want to just

wake me up in the middle of the night. Just subscribe and then I’ll just wake up. I promise

that’s what will happen. Also if you look at the middle of the screen right now you should see a

QR code which you can scan in order to go to the website which I think is also named somewhere at

the bottom of this video and it’ll take you to my main website where you can just kind of like see

videos i published and the services and tutorials and things that i offer and all that good stuff

and uh if you have a suggestion for uh uh clarifications or errata or just future videos

that you want to see please leave a comment or if you just want to say hey what’s up what’s going on

you know just send me a comment whatever i also wake up for those in the middle of the night i get

i wake up in a cold sweat and i’m like it would really it really mean the world to me i would

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

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

Thank you.

so

I’m going to go ahead and get started.

so

Yeah, I think I’m good.

Hello there.

Let’s talk about whether a graph is connected or not,

or maybe whether it’s strongly connected or weakly connected or not connected at all.

You never know.

The post Graph Connectedness Explained: Connected Strongly Connected and Weakly Connected appeared first on NeuralLantern.com.

In this video we break down the four main types of graphs used in computer science: undirected unweighted, undirected weighted, directed unweighted, and directed weighted.

We start with the basic idea of graphs – collections of nodes (vertices) and edges – and then explore each type with clear examples. Learn how these graphs represent real-world relationships like computer networks, airport routes, road maps, and game maps.

Perfect for anyone learning data structures, algorithms, or preparing for coding interviews.

00:00 Introduction to Graphs
00:19 Basic Graph Definition
00:48 Nodes and Vertices
01:01 Empty Graph Example
01:17 Graph Implementation Concepts
02:02 Node Data and Templates
03:22 Adding Nodes
04:00 Adding Edges
04:44 What Graphs Represent
05:36 Graph Use Cases
06:56 Real-World Examples
08:35 Four Types of Graphs
08:52 Undirected Unweighted Graph
10:40 Unweighted as Unit Weights
11:40 Undirected Weighted Graph
13:32 Weighted Graph Benefits
15:52 Directed Weighted Graph
19:50 Directed Unweighted Graph
20:32 Summary of Four Graph Types
21:19 Closing and Future Videos

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

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 four different types of graphs that you can use and how they relate to computer science.

Okay, so you can see like I’ve got like a blank little graph paper up here.

I’m going to talk about graphs and just the very basic idea of graphs in general

and then show you the four different types of graphs that we have.

about how to implement graphs inside the machine, time complexities, maybe graph algorithms,

and a whole bunch of stuff, terminology, everything. Okay, so the first thing is, I guess I’m going to

assume probably most of you have sort of seen a graph before and you kind of understand a little

bit about it already, but I’ll say that a graph is basically a collection of nodes, also known as

vertices or vertexes, and edges, which are the lines that connect nodes to each other. This screen

See, this is a valid graph.

I’m not talking about the graphing paper.

It’s just an empty graph.

There’s nothing there.

So it’s still valid.

It’s just blank.

Okay, so then what I want to do is start drawing some nodes.

What are the nodes again?

Those are just vertices.

Those are just like little data structure objects you can imagine in the code.

I don’t want to get too far ahead of myself, but imagine that you have a class called graph.

This is just one way to imagine.

We have a class called graph and then a nested class inside of a graph called a node or a vertex

If you want to be more fancy

So the vertex class itself by the way

This is not always going to be the way that you actually do this in your code the other representations that we’ll talk about sooner a little bit easier, but

The vertex class itself needs to basically hold some data

Depending on your implementation it might know about who it’s connected to maybe the graph knows that instead

instead. In my implementations, the graph is going to know everything, but the vertex or the node

itself needs to hold one piece of data. That’s kind of the whole point. So I’m going to say that

the data type that these nodes hold are just integers. So I’m just going to put like a six in

here just to indicate we have one node and the templated data type that it holds is an integer.

And the specific integer for this specific node is just the number six. You can have any template

any template type if you really want to you can people put floats in there you could put a custom

custom class in there whatever you want but i just want to show you that we have a class called

vertex or node and inside of it’s got a template type maybe just to make this a little bit more

clear i’ll say you can imagine inside the vertex class uh there is a template type and we’ll call

it uh i don’t know node node value type or something and we’ll call it data and then up

I’m doing C++ up here.

We have to kind of define the whole graph class as a template class.

Now, of course, you could define the vertex class as the template class,

but if you define the graph class as a template, then it all kind of falls through.

So I’m just going to say class node value type.

And so if you’ve written template classes before in C++,

now you know that the user can instance the graph and at the same time,

specify what is the data type of the stuff that the nodes hold.

the stuff that the nodes hold.

We do the same thing for edges too,

but notice how there are no nodes that are connected to each other.

So we have no edges in this graph.

This is still a valid graph,

but we could just sort of copy a node just for fun and say,

all right, we’ve got two nodes now, two vertices.

They could have the same value if you want.

Graphs are supposed to, you know, support duplicate values in the nodes,

but I’m just going to change the value here.

This is also a valid graph.

You don’t really need edges to have a valid graph.

edges to have a valid graph. This is just something called a something called a graph that is not

connected. We’ll talk about all that terminology and how to detect it in a future video. For now,

I’m just going to say we have like a little graph here, which is kind of boring, but I’m going to

add an edge. An edge is basically just, you know, a little mini data structure that connects two

nodes. Depending on the way you represent this in the machine, which we’ll talk about in future

well, a whole bunch of different ways.

You could imagine this as a full-fledged class,

although that’s not always going to be the way that we represent an actual edge.

So imagine that we have a nested class called edge.

And inside the edge class, we’ve got, you know, some stuff.

We could have a weight, which means the cost of traveling against the edge.

We could have many other properties.

For now, I’ll just try to keep it simple.

is pretty much a collection of vertices and edges and some sort of connection.

What is a graph really for?

Some people at first think that a graph is another way to represent a database.

I’m going to erase this thing over here.

Graphs, you could sort of use them as databases,

but they’re not very good as databases because

it would be really, really slow to search through the graph

to find some piece of data that you’re looking for.

It could be like a linear time database.

better would be to take this graph and add a bunch of rules as you probably have found

in my other videos by now and turn it into a binary search tree.

A binary search tree is lightning fast.

It runs in log time.

Hash tables are faster than binary search trees, but basically a graph is always going

to be way slower than a binary search tree unless the binary search tree is severely

imbalanced.

But that’s something for another video.

Anyway, so we have a graph and it’s not a good database.

What would a graph be good for?

would a graph be good for? Well, graphs are usually pretty good to help you represent

relationships between things. For example, the six and the one, imagine the six is something,

maybe it’s a computer, maybe it’s a city, maybe it’s, I don’t know, like a train station,

and the edges could represent connections. So I’m just going to start changing these values

have some nodes just kind of hanging out off to the side, not really connected to anything.

Maybe not great for your particular use case, but like it’s a valid graph. So I’m just going to,

I’m just going to connect this and try to make this into a better graph.

That’s a little bit more interesting. So we’ve got graphs that do a whole bunch of different

things. Let me change these values real fast. I’ll maybe turn that into a 13 and turn that

So imagine that we have like a little connection here, a little connection here, maybe another

connection here and another one there.

And you know, you are allowed to have connections that sort of look weird, like going from this

six all the way around to this 13.

That’s totally valid also.

So I’ve basically just drawn a random graph, random nodes and random edges.

Imagine that every single node here is a computer in a computer network and imagine every edge

every edge which connects the nodes is just some sort of a connection let’s say a network cable

or a wi-fi signal or something like that so if you imagine it that way then this graph could

represent a network topology a bunch of computers connected together if these were cities and this

is like actually maybe these are airports in cities you could imagine a graph could represent

the relationship between different airports in which planes will fly notice on this graph just

that the uh you know the uh the city number one uh there are no flights connecting it directly to

city 44 but you could probably imagine well if we take a flight to uh from city one to city 10 and

then from city 10 to 44 then we can get from one to 44 we just have to be clever about our connecting

flights um let’s see so we could do like road maps airport maps the worldwide web is basically a graph

at least from a certain perspective electrical circuits that are connected to each other

are connected to each other even game maps what if your character is allowed to stand here in

in space number three on some map and the character is only allowed to travel to space 13 or

space 6 but not directly to space 1 well it could be a map that helps you understand where your

character can go in a game okay so that’s like the basic idea of of what a graph is and uh how it

actual four types of graphs that I’m going to go over in more detail in future videos. Let’s see,

what time is it right now? We got like 10 minutes. Okay, so I can still kind of make this fast.

So the first type of graph that we’re looking at right now is actually something called an

undirected, unweighted graph. Why is it, let’s see, let me write this down first. It’s an undirected,

undirected, unweighted graph. So why is this undirected? Because the edges don’t have direction.

If I was standing in, you know, city six and I wanted to like drive or fly or whatever

from city six to city three, then I should be able to do it because this edge that connects

them doesn’t really say that I have to go in one direction or the other. I could also go to city

three and then just walk right back or fly right back to city six. There’s no direction. So there’s

no direction. So there’s an this that’s that’s why this is an undirected graph. This is an

unweighted graph because we haven’t specified a cost for traveling along an edge. For example,

if you know, if you’re at city three here, and you want to fly to city 13, how much jet fuel

does it cost? How much time does it cost? If three is a computer and 13 is a computer,

and the edges like a network cable, like how much money does it cost to transmit the data?

transmit the data or what is the lag in milliseconds.

You know, you can represent all sorts of things with these edges,

but there’s no value on these edges,

which means there are no weights to these edges.

So that’s why this is an undirected and also unweighted graph.

Uh, the first upgrade that I want to do is just kind of show you what you can

sort of assume about an unweighted graph. This is not always true.

It just depends on who you talk to and what your application implementations are.

So imagine the node that goes from six, sorry, the edge that goes from six to one.

If it’s an unweighted graph, you could just probably imagine that every weight is just a one.

The point being that it always costs the same amount to travel along every edge,

because in an unweighted graph, we don’t differentiate between the different edges

in terms of their costs.

We could just put a bunch of ones on all these edges.

And it would still, you know, basically be considered an unweighted graph.

It depends on who you talk to.

maybe all the weights are zero, maybe all the weights are 10 or whatever.

But, you know, usually I put a one there because I’d like to imagine the cost could just be the number of hops.

So, for example, if I wanted to go from city six to city 10,

I could probably, you know, start at city six and then go to city one and then hop to city 10.

How many actual hops did I do? I did two.

I could also come up with that number by just looking at the sum of all the weights of all the edges.

all the edges. So notice how when I go from six to one, that costs me one weight or one hop. And

then when I go from one to 10, that’s another one. So if you put ones on all the edges in an

unweighted graph, then you’re kind of saying the total cost of some path is really just the number

of hops. So it’s up to you. Anyway, that’s unweighted and undirected. Let’s upgrade this

see we have an undirected and unweighted and i’m just going to duplicate this real fast and change

this to a weighted graph so undirected but also weighted and the thing is as soon as you start

putting numbers on a graph on the edges of a graph well then it’s considered weighted so even even a

graph that has all ones on all the edges you could also call that weighted but now you have the

freedom since it is considered a weighted graph to just assign different values to all the edges

to all the edges. Again, these edges are a class sometimes, or you can think of them that way

inside the graph. And the edge weights themselves are definitely considered a T type, a templated

type, which means, you know, right now I’m clearly typing integers, but you could type some other

data type. You could type floats. You could type some weird data type, like a string.

Whether or not that’s going to be useful depends on your program, you know, what you’re trying to

you know, what you’re trying to do with the graph. But let’s see, I think I’ve added custom numbers

to every single edge. So now this is definitely an undirected, but weighted graph. That’s the

second type of graph that we’re talking about. Okay, what’s what’s cool about a weighted graph?

Well, imagine again, that this is an airport map, where we’re representing relationships between,

you know, cities, like where can we fly and stuff. We’re basically saying at this point,

it’s going to cost you 44 of something.

Maybe this is a graph representing jet fuel or time or frequent flyer points or something like that.

If you consider your edges to be custom classes,

you could even put a whole bunch of different types of values in your graph at the same time

to make it a little bit more flexible.

But for now, we’ll just say there’s one templated type,

which means if we go back up to this code real fast, where was that code at?

Where was that code at?

And we had, you know, our rough idea of, you know, what the, what the graph holds, you

know, it holds like vertices and edges.

We could upgrade this just a little bit to say that there is a, an edge value type.

So I’m going to say class edge value, edge weight type, something like that.

for the edge so that I can save characters. And then here, I’ll change this to a type for the

node. This is why we call it T type. There’s like, we put the keyword template here in C++.

And then sometimes people just use T’s here for these tokens. So I’m just going to say

the type of data that a node can hold is going to be the T node. And then the type of data that

the edge could hold would be the T edge. We’ll call that data. Or we could call that weight,

because usually that data comes into play when you’re traveling along an edge, right? So there’s

traveling along an edge, right? So there’s like two different types here. Anyway, so we got an

undirected and unweighted graph. If we traveled from city six to city one, that costs us 44. But

if you look at the graph a little bit more closely, we could take the longer way around. We could say

go from six to three, and then go from three to 13. And then actually, let me change the color

to orange so that you can see there’s different paths, six to three, and then three to 13,

and then 13 to one, even though we took more hops,

and that might have been considered more expensive

in an unweighted graph,

you can see that the cost of the first path

from six to one, that’s 44.

And the cost of the second path is seven plus three,

that’s 10, and then plus nine, so that’s 19.

So if we take the long way,

it actually costs us less

of whatever we’ve determined this unit is.

You know, less jet fuel, less time, less whatever.

less whatever these graphs in the machine are not necessarily going to be to scale because the

machine in your computer your computer doesn’t really keep track of like the physical positioning

of all these nodes and edges it just can keeps track of the relationship between the nodes and

the edges and the weights and all that stuff so two different paths that we could take to get

from six to one one of the paths is less expensive um or less time costly or just whatever and a graph

data structure can kind of help us figure that out if we’re using an algorithm that understands

weights okay so undirected and unweighted let’s add direction so um i’m going to erase this stuff

right here real quick and in an undirected graph remember you can just kind of go in either

direction along any edge but in a directed graph every single edge needs to have a direction so as

I change one of the edges to have direction, then I must change all of the edges to have direction

as well. So I’m just saying, okay, as soon as I did that, now this is an invalid graph

because some of the edges don’t have direction. So now I need to fix everything. So I just,

I’m going to arbitrarily and randomly choose a direction for every single edge like this.

And then as soon as I’m done, I’m going to deal, I guess, with that giant edge

that giant edge. So I’m going to go like that. So let’s see, all the edges seem to have direction.

Now I’m just going to hand draw an arrow on one side of this giant edge. Okay. So this is directed

and also weighted. What can we do with the directed graph? Well, it just basically tells

you which direction you’re allowed to travel in. What if you have an airport where city six can

only fly to city one, but city one, for some reason, never flies to city six. You got to take

take like the long way you got to go from city one to 13 to three to six that’s something that

a graph could help you represent what if your character in your game can only go in one direction

but not the other direction okay no problem i mean that’s pretty much it you’re only allowed

to travel in the same direction as the edge points but now we have a graph that is a lot less

flexible because for example before we used to be able to go from city uh 10 to city 44 and then

then come back again later if we wanted in the opposite direction. We can no longer do that

because this edge only goes to 10. It doesn’t even go to 44. We can’t even ever actually get to 44.

How do you sort of solve that? Well, just add another edge in the opposite direction.

In graphs, you are allowed to do something called a parallel edge,

which just basically means, you know, two edges between the same pair of nodes that just point

in the same direction. You’re also allowed to do, you know, opposite facing edges. So

edges so i just added a second edge there going from 10 to 44 and now if i was you know hanging

out in city 10 i could just go back and forth between city 10 and 44 as much as i wanted to

oh i forgot to add an edge weight for that new edge which means i wrote down an invalid graph

so i’m just going to say two so uh maybe the wind is blowing in in your favor when you’re going from

city 10 to city 44 maybe it’s blowing against you if you’re talking about city 44 to city 10 you

you know whatever but you just have to have edge uh edge weight on every single edge

okay so uh that’s directed and also weighted um and you can probably imagine previously when we

had an undirected um graph when there was just like you know one edge going between uh two nodes

and there was no direction on it like you know 44 to 10 if we just had like one edge with no

have two edges each going in the opposite direction so we have directed and weighted i think the last

thing that we didn’t do was directed and unweighted right so we have let me just double check real

fast here we have undirected and unweighted and then we had undirected and weighted and then

directed and weighted okay so now let’s do um i’m getting lost already oh my gosh i can’t believe i

I saw undirected and unweighted so we did undirected twice already undirected so we’re

going to do directed and unweighted next okay so the next graph a little bit less useful than

what we’re looking at this this type of graph is a little bit more useful we’re going to do

directed and unweighted oh my god okay directed and unweighted so directed and unweighted you

Directed and unweighted, you can imagine, just means we get rid of all these weights.

And then we keep the direction on all the edges.

So this means we can keep track of where we’re allowed to go, if we’re pathfinding or just whatever.

But we don’t really know what it costs to travel between the different graphs.

So that’s directed and unweighted.

Let’s see here.

I’m going to just duplicate this or just make a new blank slide.

Okay, undirected, oh gosh, I’ve got pink letters.

Let’s see, undirected plus unweighted.

And we’ve got undirected plus weighted.

And then we’ve got directed plus unweighted.

I don’t think I’m writing these down in the same order,

but that’s okay.

And then we’ve got directed plus weighted.

So basically, you know, four types of graphs

that we can talk about.

In future videos, we’re going to go over graphs

in more detail.

We’ll talk about graph terminology,

maybe some pathfinding algorithms.

And yeah, so this is just a basic intro.

How much time do we spend already?

Oh God, we spent so much time.

Spent like 22 minutes.

Dang, man, even the smallest thing takes time.

So I’ll see you in a future video

when we talk more and more and more about graphs

and other data structures concepts.

Thanks for watching this video.

I hope you learned a little bit of stuff

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

I’m out of here.

Go.

Hey, everybody.

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

I really appreciate it.

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

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

could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website that you’re looking at right now,

it would really mean the world to me.

And it’ll help make more videos and grow this community.

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

or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night

and I just wake up because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could you control me if you want to just wake me up in the middle

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

Also, if you look at the middle of the screen right now

You should see a QR code which you can scan in order to go to the website

which I think is also named somewhere at the bottom of this video and

It’ll take you to my main website where you can just kind of like see all the videos

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

and if you have a suggestion for clarifications or errata or just future

videos that you want to see please leave a comment or if you just want to say hey

what’s up what’s going on you know just send me a comment whatever I also wake

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

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

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

Thank you.

I’m going to go ahead and get started.

Thank you.

Hello there.

Let’s talk about the four types of…

Hello there.

The post 4 Graph Types: Undirected vs Directed, Weighted vs Unweighted appeared first on NeuralLantern.com.

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

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

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So we’ll add the 12 first.

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

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

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

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

Flying saucer for binary search trees.

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

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

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

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

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

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

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

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

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

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

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

Connecting line right here.

And then we have to recompute balance factors.

So the 21 is the thing we just added.

We have to compute that.

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

So we see the root node.

It now has a balance factor of 1.

So it got a little bit worse.

But we don’t see 2 or worse.

So that means this is currently a valid AVL tree.

And we don’t have to do any rotations.

So now it’s time to add the 30.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So the Z node is going to be the 12.

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

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

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

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

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

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

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

Let me just put this in black ink.

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

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

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

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

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

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

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

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

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

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

The output pattern is always the same.

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

than the linear pattern that we have above.

And then I just have to update the numbers.

So the left child is going to be 12.

The right child is going to be 21.

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

And the right child is going to be 30.

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

that have been unaccounted for.

You can tell easily that all nodes are being used.

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

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

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

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

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

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

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

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

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

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

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

It belongs on the right side of the 30.

It couldn’t go on the left.

That would be an invalid binary search tree.

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

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

So the 38 is a leaf.

It gets 0.

The 30 gets a 1.

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

or height, and the difference is just 1.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Whoops.

Okay.

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

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

move the rotated output pattern into the diagram like this.

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

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

so that we have a nicely drawn diagram

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

It’s easy to just kind of eyeball it.

Then I’m going to update the balance factors.

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

Nice.

The 21, hopefully that improved.

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

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

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

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

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

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

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

Oh, it’s this video.

It’s already 15 minutes.

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

I’m going to add 55.

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

So we’re going to add the 55.

I’m going to say, here it is.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Okay.

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

I think I made that one.

I think it’s okay.

I can never tell if it’s perfectly symmetrical.

I can’t do it.

It’s perfectly symmetric.

All right.

So A is going to be on the left.

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

B is in the middle, that’s 38.

C is on the right, that’s 42.

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

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

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

So I’m going to copy the 12 somewhere.

We’ll deal with it in a second.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The 38 is also perfectly balanced.

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

it’s all about the height.

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

perfectly balanced.

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

this tree.

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

So I think that’s pretty much it.

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

Thank you so much for following along.

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

And I will see you in the next video.

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

Hey everybody.

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

I really appreciate it.

of my heart I really appreciate it I do hope you did learn something and have

some fun if you could do me a please a small little favor could you please

subscribe and follow this channel or these videos or whatever it is you do on

the current social media website that you’re looking at right now it would

really mean the world to me and it’ll help make more videos and grow this

community so we’ll be able to do more videos longer videos better videos or

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

do me a kindness and uh and subscribe you know sometimes i’m sleeping in the middle of the night

and i just wake up because i know somebody subscribed or followed it just wakes me up and

i get filled with joy that’s exactly what happens every single time so you could do it as a nice

favor to me or you could you could troll me if you want to just wake me up in the middle of the

night just subscribe and then i’ll i’ll just wake up i promise that’s what will happen also uh if

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

to go to the website which i think is also named somewhere at the bottom of this video

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

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

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

see please leave a comment or if you just want to say hey what’s up what’s going on you know just

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

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

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

coming for us all

Thank you.

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

Anyway, um, so…

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

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

so

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.

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

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

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

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

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

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

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

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

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

insert, remove all the operations and time complexities.

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

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

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

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

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

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

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

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

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

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

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

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

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

This 48 gets a 1.

The 65 actually gets a 2.

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

We need to rotate it.

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

plus or minus 1.

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

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

This is the node that’s out of whack.

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

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

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

it fixes stuff that’s higher.

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

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

unrelated in terms of

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

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

but

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

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

Let’s see what happens.

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

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

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

Hang on a second.

I got some dashes in my pen.

There we go.

We’ll make this the Z node.

And then we have to find X and Y.

We’ll do that backwards.

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

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

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

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

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

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

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

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

That subtree has a height of one.

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

Same thing for the X.

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

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

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

In this case, there’s only one choice.

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

So let me just put an X right here.

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

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

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

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

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

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

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

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

Hang on a second.

I put that a little bit too far down.

Okay.

So we’ll do that.

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

Okay.

I had to make a little edit there.

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

So I’m going to do this.

And I have to update the values now.

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

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

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

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

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

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

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

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

nodes, right?

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

we could have had two children of 55.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So that’s a regular clockwise rotation.

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

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

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

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

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

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

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

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

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

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

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

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

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

Anyway, thank you so much for watching this video.

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

I’ll see you in a moment, hopefully.

Hey everybody, thanks for watching this video again from the bottom of my heart.

I really appreciate it.

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

If you could do me a please, a small little favor, could you please subscribe and follow

as you do on the current social media website that you’re looking at right now.

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

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

to keep making videos in general.

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night and I just wake up because I

know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could you could troll me if you want to just wake me up in the middle

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

Also, uh, if you look at the middle of the screen right now

You should see a QR code which you can scan in order to go to the website

Which I think is also named somewhere at the bottom of this video

And it’ll take you to my main website where you can just kind of like see

All the videos I published and the services and tutorials and things that I offer and all that good stuff and

and uh if you have a suggestion for uh uh clarifications or errata or just future videos

that you want to see please leave a comment or if you just want to say hey what’s up what’s going on

you know just send me a comment whatever i also wake up for those in the middle of the night i

get i wake up in a cold sweat and i’m like it would really it really mean the world to me i

would really appreciate it so again thank you so much for watching this video and um enjoy the cool

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

Thank you.

Hello there.

Hi there.

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

which is recursive. Hello there. Let’s,

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

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

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

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

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

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

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So this is always going to be the target pattern.

Let me draw some arrows real fast.

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

Why is that?

How is that possible?

Well, we only have three nodes.

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

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

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

the most balanced trinode subtree.

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

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

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

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

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

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

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

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

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

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

which is pretty fast.

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

factor is limited by a constant number.

We’ll say that again in a future video.

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

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

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

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

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

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

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

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

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

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

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

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

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

Notice how the 55 is the new parent.

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

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

But it is the parent already of the 48 node.

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

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

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

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

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

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

are right rotations.

At least as far as I remember.

Not totally sure about that,

but I’m just going to say it anyway.

So notice how the 65 needs to be rotated

to the right or clockwise.

And only one node actually needs to be rotated

to produce that final output pattern.

That’s why we call this a single right rotation

because there’s only one node to rotate.

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

a few extra ways of being able to remember

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

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

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

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

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

and work your way to the node at the top,

you know, the Z node,

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

So that’s another way to remember

that this is a right rotation.

Single, you can remember that also

by just the fact that this is a straight line.

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

They don’t do a zigzag or a bounce.

So single rotations are rotations that look straight at first,

or I guess input patterns that look straight

and only one node actually needs to be rotated.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

then obviously the 55 still has to be in the middle

because it was already in the middle before we rotated.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

we’re going up and to the right.

And so this is a right rotation.

So it’s a double right rotation.

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

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

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

So, you know, we rotate the 65 first.

That’s a clockwise.

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

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

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

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

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

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

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

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

I’m not going to do that.

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

bad drawing.

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

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

Another way to remember.

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

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

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

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

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

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

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

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

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

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

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

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

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

So thanks for watching this video.

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

I’ll see you in the next video.

Okay.

Hey, everybody.

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

I really appreciate it.

it. I do hope you did learn something and have some fun. If you could do me a please, a small

little favor, could you please subscribe and follow this channel or these videos or whatever

it is you do on the current social media website that you’re looking at right now. It would really

mean the world to me and it’ll help make more videos and grow this community. So we’ll be able

to do more videos, longer videos, better videos, or just I’ll be able to keep making videos in

and subscribe. You know sometimes I’m sleeping in the middle of the night and

I just wake up because I know somebody subscribed or followed. It just wakes me

up and I get filled with joy. That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could you could troll me if you

want to just wake me up in the middle of the night just subscribe and then I’ll

just wake up. I promise that’s what will happen. Also if you look at the middle of

the screen right now you should see a QR code which you can scan in order to go

to the website which I think is also named somewhere at the bottom of this

is also named somewhere at the bottom of this video and it’ll take you to my main website where

you can just kind of like see all the videos i published and the services and tutorials and

things that i offer and all that good stuff and uh if you have a suggestion for uh uh clarifications

or errata or just future videos that you want to see please leave a comment or if you just want to

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

the night I get I wake up in a cold sweat I’m like it would really it really mean the world to

me I would really appreciate it so again thank you so much for watching this video and um enjoy

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

Thank you.

Hello there.

Let’s talk about rotation types in an AVL self-balancing binary search tree.

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

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

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hello there. Let’s talk about a type of self-balancing binary search tree called an AVL tree.

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

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

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

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

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

The data is totally random.

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

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

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

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

And then we add on another rule.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

the left subtree height minus the right subtree height.

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

you should probably check out my other videos right now.

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

just to get the difference in the height of the left

and the height of the right.

So if you know binary search trees already,

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

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

It’s just going to be a zero.

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

for the balance factor.

That’s okay.

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

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

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

we have an invalid AVL tree.

So far, so good.

Let’s look at the 22 node.

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

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

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

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

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

So actually the 22 node is perfectly balanced.

If you think about it, that makes sense.

Left and right subtrees have the same height.

No problem.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Something has to be done.

Normally what I would say is if you find some nodes

way down lower in the tree that are imbalanced,

then just go ahead and perform a rebalancing

or a rotation immediately,

because sometimes when you rotate lower in the tree,

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

But since we started with this tree

and we’re not kind of, you know,

building a tree step-by-step,

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

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

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

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

So actually the root node is okay.

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

and we don’t really need to do anything.

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

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

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

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

This is slow because this is a linear tree.

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

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

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

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

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

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

It’s the 65 node, right?

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

It’s the 65 node.

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

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

So here’s kind of a diagram for that.

Whoops, forgot to delete that earlier.

Let me get rid of that.

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

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

How did we actually select this?

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

you want to call that Z.

So I’m going to write a Z here.

What we’re looking for is a trinode subtree,

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

And then we’ll end up reordering the nodes

and then rearranging all the pointers to the nodes

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

from the bottom of my heart. I really appreciate it. I do hope you did learn something and have

some fun. If you could do me a please, a small little favor, could you please subscribe and

follow this channel or these videos or whatever it is you do on the current social media website

that you’re looking at right now? It would really mean the world to me and it’ll help make more

videos and grow this community. So we’ll be able to do more videos, longer videos, better videos,

Do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe and then I’ll just wake up.

I promise that’s what will happen.

Also, if you look at the middle of the screen right now, you should see a QR code which you can scan in order to go to the website.

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

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

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

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

see please leave a comment or if you just want to say hey what’s up what’s going on you know

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

it would really it really mean the world to me. I would really appreciate it. So again thank you

so much for watching this video and enjoy the cool music as I fade into the darkness

which is coming for us all.

Thank you.

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

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

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

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

Thanks for watching!

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

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

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

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

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

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

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

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

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

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

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

Right now you can see this tree is perfectly balanced.

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

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

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

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

So how do we perform searches?

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

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

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

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

And so where would 14 belong?

Well, it would belong on the left of 37

because it’s less than 37.

It would belong on the left of 16

because it’s less than 16.

It would belong on the right of 9

because it’s greater than 9.

It would belong on the right of 11

because it’s greater than 11.

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

is that what I just said, 14?

Would end up going there.

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

you really just have to go find

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

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

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

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

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

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

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

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

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

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

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

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

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

is null.

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

our number 44 didn’t exist in the tree.

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

compared to the total size of the tree.

So let me just write this up here.

How many nodes do we have?

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

We got 15 nodes up here.

Someone say N is equal to 15.

And what’s the height of the tree?

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

as you make your way down towards the deepest node.

Or if you’ve already found the deepest node,

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

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

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

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

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

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

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

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

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

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

So how does that compare to this tree in reality?

Let me just open up a little calculator real fast.

I just want to show you.

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

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

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

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

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

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

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

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

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

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

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

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

with her neighbor who was also a bitter old lady.

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

It sucks, but it happened.

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

that she had in her backyard.

So they fought over it, they argued over it,

and then one day my grandma said

she was looking out the backyard window

to yell at ducks who were jumping into her pool

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

She was waiting for them to show up.

She wasn’t even looking at ducks.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

And if you are watching this video from the future,

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

you might notice that this looks like another data structure.

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

But just tilt your head to the right a little bit

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

It looks like a linked list.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

60 would end up going down here.

And in order to find where 60 would go,

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

We’d have to look at all these nodes.

That is seven nodes.

We’d have to examine seven nodes

just to figure out where the 60 would go.

Or if we were searching for 60,

then we’d have to go down that far

to find out that 60 didn’t exist.

So this is nowhere near a log tree.

This is a linear tree, a linear time tree.

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

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

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

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

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

slow compared to a perfectly balanced tree.

So we call this a linear tree.

It sucks.

You want to try to avoid that.

You don’t want your data to be poisoned.

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

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

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

which we’re going to talk about later.

Okay.

What else can I tell you real fast?

So we talked about searching.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

We do the same thing.

52 belongs on the right side.

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

the 52 and then that’s it.

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

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

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

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

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

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

it would be like i times equals two.

So i’s jumping twice as far each time.

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

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

to drive the point home a little bit more.

O of log base two of n.

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

Hopefully you feel like an expert in searching now.

If you want to see more searching videos,

leave a comment or something like that.

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

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

I’m going to go find a blueberry muffin.

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

appreciate it. I do hope you did learn something and have some fun. If you could do me a please,

subscribe and follow this channel or these videos or whatever it is you do on the current social

media website that you’re looking at right now it would really mean the world to me and it’ll

help make more videos and grow this community so we’ll be able to do more videos longer videos

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

and uh and subscribe you know sometimes i’m sleeping in the middle of the night and i just

It just wakes me up and I get filled with joy. That’s exactly what happens every single time

So you could do it as a nice favor to me or you could you control me if you want to just wake me up in the middle

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

Also, if you look at the middle of the screen right now

You should see a QR code which you can scan in order to go to the website

Which I think is also named somewhere at the bottom of this video and it’ll take you to my main website where you can just kind of like

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

if you have a suggestion for

Clarifications or errata or just future videos that you want to see please leave a comment or if you just want to say hey

What’s up? What’s going on? You know, just send me a comment, whatever

I also wake up for those in the middle of the night. I get I wake up in a cold sweat. I’m like this

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

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

Thank you.

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