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

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

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

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

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hello there! Let’s practice constructing a binary search tree from scratch.

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

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

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

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

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

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

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

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

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

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

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

according to the rules of building a binary search tree.

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

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

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

So it’s going to be the 88 first.

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

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

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

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

And that’s it.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

left of 21 because it’s less than 21 we go down to the left then we look at the three that’s also

occupied does the six belong on the left or right of three it belongs on the right side of three

because it’s greater than three so that means the sixth node is going to be the right child

of three again try to split the difference these diagrams get ugly fast i really

i don’t i don’t want to rearrange the topology but i’m probably gonna have to

I think I’m like crashing out here.

Oh, no.

Okay.

Nope.

Okay.

Let me try one more time.

These lines are killing me.

Okay.

I’m just going to update the three to a six and leave a little gap on that line.

It’s fine.

Now we’re ready to try to add the 72 node.

We have a little relief here because this is not like a smaller and smaller number that we’re dealing with.

So, well, we just look at the root node.

72 belongs on the left side so I’m going to hop to the left here we then look at

the 21 72 belongs on the right side because it’s greater than 21 so that

means 72 is going to be the right child of 21 so I’m just going to select this

make a duplicate try to keep the three and the six at the same you know y

coordinate because they’re on the same descendancy rank they’re at the same

you know generation whatever you want to call it so I’m going to put the 72 on

And then I’m going to do our connecting line, indicating that both nodes now have pointers that refer to each other.

Okay, we’re done adding the 72.

I’m going to move this to the right a little bit.

And then, oops, get rid of that little dot.

Now we’re ready to add the 34.

So the 34, we look at the 88 node occupied.

We go left.

We look at the 21 node.

34 belongs on the right side of 21.

of 21 so then we look at the 72 34 belongs on the left side of 72 so that means 34 is going to be

the left child of 72 so I’m going to select one of these nodes and duplicate it and say that

you have a left child of 72 now and it’s going to be the 34 node do my pointer connection real fast

I haven’t been duplicating the pages. Okay. So, uh, I guess that’s just for me.

We’ll move on to adding the 11 node.

So we add the 11 node by looking at the root node first.

11 belongs on the left side. We then look at the 21,

11 belongs on the left of 21. Go to the left here. We look at the three,

11 belongs on the right of the three. We go to the right,

11 belongs on the right of the six node.

This is definitely a gross graph at this point.

at this point. So I’m going to duplicate this node here and try to split the difference between

the six and the 21 in terms of like the free space. So I’m just going to drag this down a

little bit there and say that 11 goes as the new right child of the six node. So

just do that. This is a gross diagram. I might want to redraw this later.

Now we’re ready to try to add the one node.

the one again we look at the root node of the tree and it’s occupied so we can’t put it there

we go to the left we go to the left again and the one belongs on the left of the three nodes so we

have a little bit more room there so that’s good i’m gonna copy this node and make it the new left

child of the three i’m gonna like say that our one is right there and then i’m gonna do the connecting line

okay all right we’re done adding the one now I’m gonna add the 90 node oh this is

gonna be nice and easy because the 90 definitely belongs on the right side of

the 80 node whoops what happened okay sorry for making that noise I’m gonna

duplicate this node here and make it the right child of the 88 node so let’s see

kind of even there. So we’re going to put 90 right there. And then I’m going to do a connecting line

in blue. Now we’re done adding the 90.

So then we’re going to add the 65. 65 belongs on the left of the 88 node.

So we’re kind of in left territory now. It’s kind of sucky again.

And bounce down to the left. 66 belongs on the right side of the 21 node. So we look at the 72.

look at the 72 it belongs on the left of the 72 we go there it belongs on the right of the 34 so we

go right here as the new right child and the diagram kind of sucks at this point it’s a little

cramped but i’m going to try my best to split the difference between the 34 and the 32 visually to

make a nice easy to debug graph so maybe like somewhere around there put 66 then i’m going to

So the 66 is now the right child of 34.

Okay, next number that we’re going to add is my computer’s crashing.

Hello?

What happened?

There we go.

Okay.

So we’re ready to add the 55.

Oh, God.

Okay, let me see what’s going to happen here.

This is awful.

is awful i usually say you have to space these out enough so that none of these overlap but

they’re about to overlap okay we’ll do go to the left because 55 is less than 88 go to the right

because 55 is greater than 21 go to the left because it’s less than 72 go to the right because

it’s greater than 34 then go to the left again because it’s less than 66 i hate this i hate this

between 34 and 66, just to try to make it easier to debug.

This is almost, I’m almost stretched

to my mental limit right now.

So I’m gonna make the left child pointer here

and the new node we just added was 55.

Whoops, yeah, 55.

Okay, my God.

Let me just duplicate this one more time

and get rid of those pink arrows.

arrows let’s add the 17 next 17 right here um so once again we look at the root node it’s occupied

go to the left because it’s less than we look at the 21 we go left because it’s less than 21

we go to the right because it’s greater than three we look at the six we go to the right

because it’s greater than six we go to the right because it’s greater than 11.

So a super cramped diagram.

I’m in hell.

I’m just going to move this slightly to the right because this is just awful.

And I’m going to try to make sure again that same depth nodes are at the same Y coordinate.

Let me fix that number real fast before I forget.

And put it as a 17.

And then do my connecting line.

Like that.

Okay.

I’m losing it.

The, uh, whoops, the 23, where is this going to go?

Is it 23?

Um, Hmm.

Hmm.

Oh, well, it’s going to be like left child of the 34 probably.

Okay.

Let me just, uh, look at the root node.

Okay.

23 belongs on the left of that.

Look at the 21, 23 belongs on the right of that.

Cause it’s greater than 21.

Look at the 72.

It belongs on the left.

it belongs on the left look at the 34 belongs on the left and then that’s going to be the new left

child okay so I’m going to duplicate one of these nodes and it’s going to be the new left child of

the 34 node that is awful but I guess we barely have enough room let me change that to a 23 and

then I’ll add my connecting line okay and now we’re ready to add the final value in our tree

to be? It’s going to be like left child of 11 maybe. So we look at the root node. Whoops,

forgot to move that arrow. We look at the root node. We can’t put it there. Nine belongs on the

left side of the root. So we go like that. Nine belongs on the left side of the 21. Oh, did I just

guess something wrong? No, no, no. I think I’m okay. Go to the left side of that. We look at

right side of three we look at the six nine belongs on the right side of the six we look at

the eleven nine belongs on the left side of eleven because it’s less than eleven so I’m just going to

duplicate this and it’s going to end up being the left side whoops nope that’s wrong hang on a second

let me oh come on man let me get this down it’s going to be the left child of eleven not the left

there and the diagram is a little messed up maybe I should try to rearrange this in a second

it the topology is correct but it’s harder to debug because you can see that one of the right

descendants of the six node is actually physically on its left side and that just makes it extra hard

to debug but for now we’ll say that we’re done adding stuff into the tree so maybe I can kind

I’m not going to change the actual topology.

I’m just going to like, you know, redraw this in a slightly nicer way.

So I can probably take this whole subtree and move it over to the left a little bit to make it a little cleaner.

Which will give me some room to move this subtree a little bit over to the right.

Am I still wearing my microphone? Yeah.

And then it’s a little bit cleaner.

Then I just have to redraw this line.

Whoops.

oops yeah just have to redraw this line and now i think we’re following the rules that i talked

about before where a good diagram has all the left descendants physically on the left side of

a given node so let’s see the six has everything on the right and everything i think we’re okay

i’m going to duplicate this real fast and now let’s verify that our tree is actually correct

So I said this in the last video when we built a tree, but you basically want to take like the input data set here and sort it.

And whatever sorted list you end up with, that’s what you should see when you scan your eyes from left to right.

Again, this is another good argument for drawing the diagram in a really good way.

All left descendants are physically on the left. All right descendants are physically on the right.

So another way that I could do this, besides I don’t really want to sort this list right now,

Just scan from left to right and make sure that I see increasing numbers

Or if you’ve decided to make a tree that supports duplicates, make sure that you see non-decreasing numbers

But I’m looking for an ascending list

Okay, so I’m gonna just like do little hashes here

One is the lowest number. That’s good. Then if I go to the right just a little bit

I see a three go to the right a little bit. I see a six that’s still increasing then I see a nine and then I see an 11

still been increasing go to the right a little bit more it’s a 21 go to the right a little bit more

it’s a 23 then it’s a 34 then it’s a 55 then it’s a 66 then it’s a 72 so far everything’s been

increasing and then from 72 to 88 and from 88 to 90. so the ordering of the numbers are correct

let me just make sure i actually have a binary search tree by the definition of a bst first it

crazy lines going off in some direction or like different symbols this is a

connected graph meaning I could probably find well I definitely could find a path

from any node to any other node if I just you know trace the edges so can the

9 find its way to the 90 yeah if we just kind of like go you know up this way and

follow the edges up to the 88 and then back down to the 90 so every single node

could do that it could find every single other node on the graph which means this

every single other node on the graph which means this is a connected graph so that’s good the next

thing is now that we have a connected graph do we have a tree so check for cycles uh can any start

node find its way back to itself in a path that does not repeat edges i don’t see that anywhere

in the tree so i think we have a valid tree let me get rid of that real fast so for example uh

Could we find a path that goes away from the 9 node and then comes back without repeating any edges?

I cannot because as soon as we go out to the 11,

later on we would have to use that same edge to come back down to the 9 and that would be repeating an edge.

So we just kind of check that for every single node.

We can’t find a cycle anywhere in this entire graph.

So this is an acyclic graph.

Okay, that means it’s a tree.

Is this a rooted tree?

ancestor to all other nodes and it’s that 88 node that’s the root node of the

entire tree every single node in the tree can say that 88 is its greatest

ancestor there’s no you know same leveled nodes at the very very very top okay so

this is a rooted tree now is it a binary tree yeah we look at every single node

and we can see that none of the nodes have more than two children they’ve all

this is a binary tree. And then when we, you know, we verified the numbers a second ago,

that means this is a binary search tree. So it satisfies all the properties of a binary search

tree. It doesn’t look very good. It’s kind of wonky, but it is valid. Remember this,

you know, a binary search tree just by itself is not a self-balancing tree,

which means you, you, you need to like not inject your human feelings into the tree while you’re

building it and start rearranging it to make it prettier. It wouldn’t be a valid binary search

if you tried to add special rules when you were creating it.

I don’t know.

If you imagine that maybe you, the human,

were changing the input data,

then I guess that’s valid.

But don’t imagine that the tree

is changing the data as you add it.

Anyway, so how fast is this tree?

Remember we said in a previous video

that a perfect binary search tree,

meaning perfectly balanced on every single node,

would be a log time tree.

It would be really, really fast to add and search

to add and search and even remove but this tree is definitely lopsided so this

is not a log tree the time complexity of a binary search tree actually is not

really log because the tree could just grow in any direction so in the worst

case scenario if you add the worst possible data you’d end up with a linear

time tree self balancing trees will be log time trees because they always

rearrange themselves to make sure that they’re balanced to a certain extent but

But, you know, as a binary search tree scales, it could just get slower and slower and slower.

So we wouldn’t be able to say that BSTs, binary search trees in general are log time.

We could pull up a calculator though and we could say, well, you know, what’s the height of this particular tree?

Let me just look at the depths real fast here.

What’s the height of this tree?

So the root node has a depth of zero and then one and then two and then three and then four.

drawing your tree in a nice pretty way where all the ranks are the same physically.

We just take the deepest node and we add one to it and we say that’s the height.

So the height of this tree is six.

Another way of looking at it is if we wanted to touch one of the deepest nodes,

how many nodes would we have to touch as we travel down through the tree?

So how many nodes would we have to touch to find, you know, the nine or the 17 or the 55?

one node the 88 two and let’s go to the left three four five six we’d have to touch six nodes

to get to the deepest node so that’s why we’re saying that’s another way that we’re justifying

that we say the height is six so the height of this tree is six which means in the worst case

scenario if we needed to search this tree again we’ll talk about actually searching in another

video but for now i can just promise you that if we were going to search this tree we could do it

going to search this tree we could do it in at most six uh examinations so even though we have

a lot of nodes here how many nodes do we actually have let me just double check this we have n

is equal to one two three four five six seven eight nine ten eleven twelve thirteen fourteen

we have fourteen nodes but at most we’d have to examine six nodes because this is a binary search

tree so it’s a lot faster than scanning the whole tree in linear time but it could be a lot faster

It could be a lot faster if the tree was better balanced.

That’s a topic for another day.

So for example, if we wanted to search for the number 55, let’s say we were just going

to search for 55, you know, we’d look at the 88.

Basically searching is pretty much the same as adding a node.

You just kind of go find where the node would belong.

And then if it’s there, then you found it.

And if not, then it’s not in there.

55 belongs on the left of 88, belongs on the right of 21, it belongs on the left of 72.

belongs on the left of 72, belongs on the right of 34, belongs on the left of 66, and there we

found it. Notice how we only did one, two, three, four, five, six examinations. So I’m going to talk

about big O and time complexities in another video, but long story short, the time complexity

of this particular tree, or actually any binary search tree, is always going to be O of H, no

imbalanced or perfectly balanced O of H so in the worst case scenario since H is 6 we’re going to have to touch H or 6 nodes

To search or add something or whatever if the tree was perfect. It would look more like log time. Let’s pull up that calculator real fast

Where the heck is my calculator? I think I like got sidetracked

so if I pull up a calculator here

and I typed in

log base 2 it’s base 2 because we only allow two children per node at most log

base 2 of the number of nodes in the tree so log base 2 of 14 if we get the

answer to that it says 3.8 which means the calculator is telling us that in a

log time tree we should not have to examine more than four nodes in order to

search the tree or add a brand new node but this is not a log tree because it is

totally imbalanced it’s kind of wonky it’s not it’s not perfect so it’s telling us in a perfect

tree we’d have to touch four nodes only but we clearly know we might have to touch six nodes in

the worst case so that i’m just trying to bring to your attention that the more imbalanced the tree is

the further its uh performance drifts away from log time which is a great argument

I think this is pretty much everything I wanted to talk about today.

I’m going to take a break and like, you know, eat some cookies and stuff.

But in a future video, we’re going to talk about inserting.

No, we already just did that literally right now.

We’re going to talk about searching through the tree.

We’re going to talk about removing nodes from the tree.

We’re going to talk about linear trees.

We’re going to talk about all the time complexities.

And then eventually we’ll move on to self-balancing trees.

on to self-balancing trees. So I hope you had fun watching this video. I hope you learned a little

bit of stuff and I’ll see you at a later date in time. I’m outie. Patowdy. Note to self, edit out

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

hope you did learn something and have some fun if you could do me a please a small little favor

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

current social media website that you’re looking at right now it would really mean the world to me

and it’ll help make more videos and grow this community so we’ll be able to do more videos

longer videos better videos or just i’ll be able to keep making videos in general so please

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

because I know somebody subscribed or followed. It just wakes me up and I get filled with joy.

That’s exactly what happens every single time. So you could do it as a nice favor to me or you

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

and then I’ll, I’ll just wake up. I promise that’s what will happen. Also, uh, if you look at the

middle of the screen right now, you should see a QR code, which you can scan in order to go to the

we’re at the bottom of this video and it’ll take you to my main website where you can just kind of

like see all the videos i published and the services and tutorials and things that i offer

and all that good stuff and uh if you have a suggestion for uh uh clarifications or errata

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

what’s up what’s going on you know just send me a comment whatever i also wake up for those in the

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

really appreciate it so again thank you so much for watching this video and um enjoy the cool music

as as i fade into the darkness which is coming for us all

Thank you.

The post Binary Search Tree Insertion Tutorial: Building a BST from Scratch Step by Step appeared first on NeuralLantern.com.

Quick but thorough run-through of binary search tree terminology: root, leaves, internal nodes, subtrees, depth, height, ancestors, descendants, siblings, left/right child – everything clearly labeled on a working example.

Great for beginners, interview prep, or reviewing foundational BST concepts before coding insert/search/delete.

00:00 Introduction to BST Terminology
00:28 Root Node
01:10 Ancestors and Descendants
01:58 Children, Grandchildren, and Siblings
04:07 Internal Nodes vs External Nodes (Leaves)
05:34 Understanding Subtrees
06:09 Left Subtree and Right Subtree Examples
08:34 Depth of a Node
11:02 Height of the Tree
12:48 Height of Subtrees
17:32 Node Structure and Pointers Overview
18:12 Closing Remarks and Call to Action

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

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 binary search tree terminology. If you saw my

previous video we talked about how to define a binary search tree meaning a

whole bunch of rules so that if the thing you’re looking at follows all the

rules then you know you’re actually looking at a binary search tree if not

then not. So see my previous video if you want to know for sure whether you’re

looking at a binary search tree. For now we’re just going to talk about some

Okay, so the first thing we should probably obviously talk about is the root node over here.

So I mean, well, in my previous video, we talked about nodes, right?

So this is kind of a graph with a whole bunch of rules on top of it.

That means we have nodes and edges.

So if you look at the very top node here, sometimes also referred to as a vertex,

I think in binary search tree terminology, we usually say nodes.

We usually say nodes. I can’t actually remember. But so look at the 42 there

That node is the root node of all other nodes. It’s the highest common ancestor in the entire tree. So this is the root node

First bit of terminology. Also, I tried to sneak past you ancestor

So these trees are supposed to be written in a way that kind of looks like they have a family hierarchy with one parent per

like not two children per parent, but just like one parent and then either zero or one or two

children. So we’ll say that ancestors are higher on the tree. So that means 42 is actually an

ancestor of 33. And it’s also an ancestor of 12. It’s also an ancestor of 19. Just anything that’s

higher is an ancestor of anything that’s lower. We could also say that 33 is an ancestor of 39

and 19 and so forth. You can probably also imagine that we have children and grandchildren. Yeah,

we do go that far in binary search trees. So the 42 node, it has two children. It has a left child

and a right child. The 33 is the left child. I’ll put LC for left child. And the 67 is its right

child. I’ll put an RC there. The 67 in turn has two children. The 56 has no children of its own.

the 33 has two children the 12 only has one child it was you know playing it safe i guess

you never know if these children are going to come out and just like run amok

and and engage in constant shenanigans so the 12 has a right child but no left child that’s okay

um in terms of going higher on the tree anything that is higher is an ancestor sorry i should have

said lower anything that’s higher is an ancestor anything that’s lower is a descendant so if we’re

If we’re looking at the 33 node, the 33 is a descendant of 42 because it’s the left child of 42.

It’s also an ancestor of anything that comes below it.

So it’s an ancestor of 12 and 39 and 19, right?

So if we’re looking at 33, we’ve got a left child over here and we’ve got a right child over here.

And then we have a grandchild, which is the 19 node.

We don’t really have left and right grandchildren.

You could say a grandchild in the left subtree or the right subtree.

subtree talk about sub trees in a second the 33 has a parent node which is just the 42 node

which is also the root node of course it’s got a sibling the 67 is the sibling you can tell

something’s a sibling because it’s got the same parent as you it’s the people that you’re usually

fighting with right anyway so if we’re looking at any node in particular it might have a whole bunch

of ancestors above the tree it might have a whole bunch of descendants below the tree

It has siblings or it usually has zero or one sibling because in a binary search tree,

we can only have up to two children per node.

It’s got sometimes, you know, grandparents and great grandparents and children and great

grandchildren.

So just think about the hierarchy like a family tree would have.

Okay, moving on to some more terminology.

Next thing is we have internal nodes and also external nodes.

So what do I mean by internal? Internal means a node has more than zero children. It has one or two children.

So I’m going to put internal on the 33 because the 33 node has children.

The 12 also has children, so it’s internal. The 39 does not have children, so it’s not internal.

67 has children, so it’s internal. And the root node, 42, also has children, so it’s considered internal.

That 42 has a lot of different names.

It’s the root node, it’s the greatest common ancestor,

it’s an internal node and so forth.

Notice how the other nodes that I have not highlighted,

they have zero children.

So when a node has zero children,

it’s known as an external node.

It’s also known as a leaf

because we’re talking about trees

and I guess it’s kind of like a nice synonym.

So the 19, the node with no children of its own is a leaf.

So is the 39.

So is the 56.

So is the 76.

I just want to point out also, if you were with me on my last video,

then the numbers need to be ordered from left to right.

But don’t worry, we’re going to do another video where we build a complete tree from scratch.

There’s some more terminology we should talk about.

So I’m going to get rid of all these externals and internals real fast.

Or the labels.

We should talk about the left subtree versus the right subtree.

left subtree versus the right subtree i mean what is a subtree anyway the subtree is basically

a subtree is basically just pick any node you want in the entire tree let’s pick

the 76 and then we’ll just pretend that it’s the root node of a separate tree starting with 76 so

if there was anything below it then all those nodes would be included so this 76 right here it

really has nothing underneath it it’s a leaf which means well it can be the root node of its own

the subtree is just going to be a tree of one node.

So kind of boring, right?

You’re boring.

If instead we decided to look at the 33,

which is a little bit more interesting,

and we called the 33 the root node of its own subtree,

then really what we’re saying is all these nodes here

are included in that subtree.

So if I told you, give me the subtree starting with node 33,

then you would say, oh, it’s 33, 12, 39, 19.

descendants of the subtree root node that we picked out. So subtree just means, you know,

like a little fragment or a portion of the original tree. You could also say that the

entire tree is a subtree of itself. If you chose the subtree root to be the real root node, I mean,

that’s not super useful, but you can do it. Anyway, so if we decide to say that the 67 is the root of

with 67 and below in terms of descendancy is going to be considered part of the subtree.

I’ve highlighted the left subtree and the right subtree of the root node because that’s usually

what we say. We’ll say this is the left subtree over here and then over here we’re going to say

this is the right subtree. Meaning if you look at any node at all, if it has a left child,

then that left child is the root node of the left subtree of the node in question. Same thing for

same thing for the right so if I say all right let me duplicate this real fast

let me get rid of actually this real fast too if I say okay give me the left subtree of the 33 node

well then you would know to include the 12 and the 19 because the left subtree of the 30 node

has to the 33 node has to start with the left child of the 33 node which would be the 12 and

And we’ll just say, okay, the 12 is now the root node of its own subtree.

And then anything that goes below it in descendancy is going to be considered part of that subtree.

So that highlighted subtree is the left subtree of the 33 node.

The 39 is the right subtree of the 33 node.

I think I just did the wrong color.

Let me do that in gray.

Right, so we can do left subtree and right subtree for any node in the entire tree.

if a node has no children, then there are no subtrees, but we can still look and check.

And if there are children, then we’ve got subtrees or left and right subtrees.

Okay, so now that we’re done talking about subtrees real fast, let’s talk about the depth of a node.

So for me, I like to say that the depth of the root node is zero.

And so I’ll just, I guess we could start off by putting a zero on the 42 indicating it has zero depth.

It has zero depth.

Imagine maybe it’s a buoy in the water and it’s just like sitting, floating like directly

on the water.

So it has no depth.

It’s just like kind of on the surface.

But if you draw your binary search trees in this nice pretty way where every single time

you go down a generation from parent to child, from parent to child, you maintain, I guess,

like the same Y coordinate for same leveled nodes, then it’s really easy to calculate

the depth of every single node.

of every single note let me show you what show you what i mean real fast you saw my video uh

previously then you already know this but the 42 it’s got two children so if i go down to get one

of its children i’m going down to the 33 and then i’m going down to the 67 right since those two

children are on the same i guess level as if we were looking at a family tree they should be

physically on the same level they should be on the same y coordinate or the same horizontal plane

plane if we go down one more level which means any child of 33 or any child of 67 then those all

should be lined up also so notice how these are all lined up on the same y coordinate then if we

go down another level then this 19 here is just kind of by itself because the tree is not very big

so if we draw the tree like this which is a really smart way because uh it’s easier to debug

whether it’s a valid binary search tree and all sorts of other things,

then we can easily write down the depth kind of on the side of the graph.

We can say, all right, here’s depth zero, and here’s depth one,

and here’s depth two, and here’s depth three.

Just every time you go down one level, you just increase the depth.

And now you know the depths of all the nodes in the entire tree pretty quickly.

The 19, I’m just going to maybe do this in red.

the 56 and the 76 have a depth of 2, the 33 has a depth of 1, and the 42 has a depth of 0.

So all these trees, sorry, all these nodes in the tree have their own depth,

which are very easy to calculate if you draw the tree well. The next thing after depth is the height

of the tree. So what is the height of the tree? Well, that’s basically the depth of the deepest

to the very deepest node what is the minimum number of nodes that you must touch when you

start at the root node and then find your way to the deepest possible node in the entire tree so

um if you if you notice the 19 node is definitely the deepest node in the entire tree

it’s got a depth of three which means the height of the entire tree is four heights

equals four and maybe i’ll change that to like just black or something okay

So, let’s do it the other way real fast.

If we’re kind of just walking down the tree, let’s start at the 42 and then we go down

to the 33, we’ve touched two nodes so far.

We go down to the 12, we’ve touched three nodes.

We go down to the 19, we’ve touched four nodes.

So the height of the tree is four or the number of nodes that you need to touch as you make

your way down towards the deepest node or just a shortcut is the deepest nodes depth

plus one.

And that’s the height of the tree.

you can also have a height of a left subtree and a height of a right subtree so let me just

what’s going on here i think my thing is crashing hello oh i was definitely crashing i think my cpu

is burning right now all right i’m going to be complaining about my new cpu for a long time

i sprung only a few bucks for the best cpu that this motherboard could hold but it’s an old

something percent um i’m eventually going to have to like build a brand new computer

anyway so uh suppose we’re looking at the 67 node and the question is you know what is the height

of the left subtree of the 67 node versus the right subtree of the 67 node well if you recall

the left subtree is just all the nodes that are included uh beginning with the root node of the

subtree of the 67 node well that’s just the 56 node totally by itself what’s the right subtree

of the 67 it’s just that 76 node all by itself what’s the depth of 56 and 76 they’re both depth

zero if we’re talking about relative depths per their subtrees that means what is the height of

the left subtree and the right subtree they’re just one because the depth is zero the maximum

depth is zero and if we want to get to the deepest node in one of those subtrees we’re just

end up touching the one node that’s in the in the subtree at all so that means uh

uh i don’t want to write down uh left subtree height right now so left subtree height of 67

is one right subtree height of 67 is also one so we can do this with any node we want you know what

is the uh what is the situation with the 33 node let’s do uh the 33 node yeah uh it has a left

It has a left subtree height of 2 and you can tell because, well, the left subtree starts with the left child and the left child is going to be the root node of its own subtree.

Notice how the maximum depth we can find here is 1, right?

Like if we start at depth 0 for the 12, considering like it’s a relative depth, that means we take the deepest node, which is the 19 node, which has a depth of 1.

We add 1 to that.

So that means the height of that subtree is 2.

if you wanted to find the deepest node in that whole subtree, how many nodes would you have to

touch to get there? We’d have to touch the 12 and then touch the 19. We touch two nodes, so the height

of that subtree is two. Maybe I’ll just put H equals two here. So now for the right subtree of

the 33 node, it’s kind of easier. We just basically only have one node to really look at.

that means that 39 has a depth of 0 and the right subtree has a height of 1.

Whoops, 8 equals 1.

I didn’t put two equal signs. I like to do two.

I like to do the comparison operator.

We could also do the same thing with the 42 node, right?

We can say, let’s get rid of all this stuff real fast.

We can do the 42.

Its left subtree starts with that 33 node.

33 node so I’m just going to highlight that real fast the 42 nodes left subtree has a height of

one two three and you can tell because the 33 has a depth of zero a relative depth of zero and

the 12 and the 39 have one and the 19 has two so the deepest node has a depth of two

so that means the height of that subtree is is three so I’m just going to like do this real fast

and then the right subtree of the 42 node, the root node of the entire tree, is going to be this.

So the root node has a depth of zero, depth of zero, and then these other leaves over here have

depth of ones, which means the height of this subtree is going to be two, or the deepest node

plus one, or the number of nodes you need to touch to find the deepest node. And 56 and 76,

those are both equally the deepest node in those trees okay so we talked about a bunch of

terminology here let me just double check my notes in case I forgot to to tell you anything

I think I’m all right well maybe okay maybe I should real fast just briefly mention that these

nodes I mean this is not really part of the video exactly but let’s let me just mention that these

whoops that’s dumb let me do a blue circle they would have you know there’s

like some sort of an object you would call it a node and then they would have

pointers they would have each of these nodes would have a pointer to its

parents and it would have a left child pointer that goes down into the left and

a right child pointer that goes down to the right and also a little slot in that

object for the data so I’m just going to put t type data and C++ I usually say

I usually say that the templated data type for a node or data structure is just the T type.

That just means you could put anything you want.

You could have your nodes hold integers, letters, strings, custom objects, whatever you want to do.

And we’ll talk about this more in future videos.

But long story short, I want you to just imagine that every node actually has three pointers inside of it pointing to something else, to other nodes,

graph because in a graph you could have like a whole bunch of different connections and that’s

usually managed by the actual graph object itself so anyway we’re done with terminology i hope you

learned a little bit of stuff and had a little bit of fun thanks for watching this video

tell your friends eat a donut and a chocolate and then be really happy and stuff okay i gotta 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 do me a

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

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

just wakes me up and I get filled with joy that’s exactly what happens every

single time so you could do it as a nice favor to me or you could you control me

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

then I’ll just wake up I promise that’s what will happen also if you look at the

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 uh

if you have a suggestion for uh clarifications or errata or just future videos that you want to see

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

those in the middle of the night i get i wake up in a cold sweat and i’m like it would really it

really mean the world to me i would really appreciate it so again thank you so much for

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

Thank you.

The post BST Terminology: Root, Leaves, Subtrees, Depth, Height, Ancestors & More appeared first on NeuralLantern.com.