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

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

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

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

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

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

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

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

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

search tree with the insert or add operation.

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

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

are easier to debug.

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

a binary search tree.

So there are three types of deletions.

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

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

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

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

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

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

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

How many children does it have?

Is it a leaf with zero children?

Is it a node with one child?

Or is it a node with two children?

Each type of node is deleted in a different way.

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

is a node with zero children,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

actually what’s happening is the nine node,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So deleted a leaf.

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

is deleting a node that has one child.

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

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

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

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

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

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

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

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

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

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

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

You know, where is the 32?

We’re just searching for it.

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

We then look at the node.

Okay, we found the 32.

We identify how many children it has.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

But long story short,

in order traversal just means produce a sorted list,

an ascending list or a non-decreasing list

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

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

I can just say, you know, looking visually

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

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

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

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

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

to be increasing or at least not decreasing.

Let me just double check.

Okay, how many do I have?

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

I already got lost.

I think it’s 19.

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

Okay, did it right.

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

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

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

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

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

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

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

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

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

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

We found it in O time in the worst case.

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

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

terms of time complexity.

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

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

What is the in order successor of the 35 node?

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

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

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

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

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

I like to do successor.

So first we find the 35,

then we find it’s in order successor.

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

because that’ll be a little more difficult.

Once we find the in order successor,

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

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

So that means I’m gonna take this 35

and it no longer has 35 as its value.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Maybe I’ll do like another color here.

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

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

Notice how that’s the 19. Again,

if the 19 had a child on its left side,

we would have to follow it down further,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Okay, okay.

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

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

First, we search for 41.

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

We just found it right away.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Hey everybody!

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

I really appreciate it.

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

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

could you please subscribe and follow this channel or these videos

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

that you’re looking at right now.

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

and grow this community.

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

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

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

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

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

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

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

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

you look at the middle of the screen right now you should see a QR code which you can scan

in order to go to the website which I think is also named somewhere at the bottom of this video

and it’ll take you to my main website where you can just kind of like see all the videos I published

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

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

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

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

it would really it really mean the world to me i would really appreciate it so

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

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

Thank you.

Hello there.

Let’s talk about.

The post Binary Search Tree Removals – Delete Nodes with 0, 1, or 2 Children appeared first on NeuralLantern.com.

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.

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.

In this hands-on video we build a binary search tree by inserting numbers one by one: 73, 98, 12, 45, 67, 10, 43, 11, 99, and 32. Watch exactly how each node finds its place following BST rules with no rearranging allowed.

We discuss why the tree becomes lopsided, calculate its height, and verify the in-order traversal is sorted. Great practice for anyone learning binary search trees.

Next videos will cover searching and deleting nodes.

If you’re studying data structures, build along with me!

00:00 Introduction to Building a Binary Search Tree
00:14 Plan for Inserting Numbers
00:30 First Node Becomes Root
02:26 Begin inserting from data set
12:29 Final insertion from data set
13:26 Final Tree Overview
13:29 Tree is Lopsided
14:00 Drawing Depths and Levels
14:50 Calculating Tree Height
15:08 Verifying Sorted Order
16:00 Confirming BST Properties
16:48 Time Complexity and Height
18:59 No Self-Balancing
19:07 End of Video 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 a binary search tree together if you’ve seen my previous videos

you understand now how to define a binary search tree meaning what are the rules

that you have to like adhere to if you want your thing to be a binary search tree

also terminology we’re in previous videos so in this video we’re just going to take a bunch of

random numbers and we’re just going to start dropping them into our tree and see how the

tree builds itself out we have to build our tree in a specific way if it’s going to be valid we’re

uh valid we’re not going to rearrange our tree and try to make it super pretty this is going to be

like a real binary search tree it might not be pretty but it’ll be real let’s see if i can find

those numbers that i was going to set up okay so for this particular video i think i’m going to do

two videos i want to build a binary search tree using the following numbers they’re not special

not not perfect but what I mean to say when I say inserting these numbers is one by one we’ll look

at each number and we’ll drop it in the tree and we’ll see where it falls according to binary

search tree rules of insertion then we’ll just go to the next number and then the next and the next

when we’re done we should have a tree and if you follow along at home and you use the right rules

to build your tree then if we use the same sequence of numbers to build the tree we should

they won’t suddenly be different they’re deterministic okay so the first thing that

we should try to understand is uh when we want to insert a node the 73 node right here the first

thing we should ask ourselves is do we actually have a root node for our binary search tree yet

right now the answer is no this is just a blank tree there’s nothing in it which means that first

number is going to be the root node you might be tempted to say no that’s a sucky root node let’s

do something else well i don’t know i mean you just have to let the numbers fall where they’re

going to fall just because a number seems to suck as a root node doesn’t mean it’s not going to be

the root node if it’s the first thing you added it’s going to be the root node don’t try to change

it or you’re going to mess you’re going to end up with topology that doesn’t match whatever system

or person is trying to grade your work or evaluate your work so we have no root node that means the

node of the entire tree we’re now done with 73 i’m going to duplicate this slide real fast

and we’ll say now it’s time to try to add the 98 you know what i can i think i can do better than

that arrow i can make a nice cute arrow with this program i’m going to do this can i like yeah

hang on one more one more try nice okay so now let’s add the 98 node

the first thing we have to ask is do we have a root node uh yes we can’t actually put the 98 there

we now have to make a decision uh if you recall in my previous videos the lesser values go on the

left and the greater values go on the right uh in in these trees which we’re not going to support

duplicate values with if you wanted to support duplicate values you could do something like

less than or equal to would be on the left and greater than on the right there’s a bunch of

other ways you can do it but i’m just going to say no duplicate values in our trees so we look at the

So we look at the 73 node and we ask, you know, is that where our 98 is going to go?

It can’t go there because 73 exists.

Now we have to ask the question, does 98 belong on the left side or the right side of the 73?

Well, because 98 is greater than 73, it belongs on the right side, which means I’m going to duplicate this node over here.

And I’m going to try to draw this well, which means basically splitting the difference in terms of the empty space.

empty space and trying to keep the same rank as we go down one level of

descendancy or like one generation down at a time.

So the next time I go down a level,

let’s say I do a left child in the future,

it should be at the same level as the new node I just added.

So I did a duplicate and I forgot to change the number.

And then I’m going to do a line to connect the 73 and the 98.

98 so now the 73 has a right child which is 98 the 98 has a parent which is 73 and we’re done

adding the 98 we have to just move on to the next number okay so i’m going to move on to the 12

again we look at the root node it’s occupied we cannot put the 12 right there on the 73 we have

to make a decision do we go to the left or the right of the 73 12 is less than 73 so it belongs

is to jump to the left side. Notice how the left side there’s no child on the left that means that’s

where the new node is going to go so I’m just going to like select this duplicate it real fast

maybe stick it on the same vertical coordinate and then also try to split the difference on

the screen just to make it look pretty. I’m going to update that 98 so that it is now the 12.

child 12 and then we’re done adding the 12. Okay, no problem so far. We then are ready to try to

add the 45. Maybe I should squish this a little bit. Nope, that looks gross. No, it’s okay.

We’ll do that. We’re going to add the 45. Again, we look at the root node. It already exists,

so we can’t put the 45 there. Instead, we will just kind of decide does the 45 belong on the

Okay, well, belongs on the left because it’s less than 73.

So that means I’m now going to make a little decision.

I’m going to jump down to the left.

If you’re in some code, you’re following the left child pointer down.

But notice how the left child pointer or the left child, it already exists.

So we can’t actually put 45 right there.

We have to make another decision.

Does 45 belong on the left or the right of the 12?

Well, it’s greater than 12.

So it belongs on the right side of 12.

So I’m going to highlight this and duplicate it.

and duplicate it. I guess I’ll just do it that way. Then I’m going to update that number

with 45 and then I’m going to connect the 12 and the 45 with the line. So now 45 is the right child

of 12 and 12 is the parent of 45. It’s at this point that a lot of people start to get frustrated

with me and they say, well, how come, how come the 12 is like all the way to the left and the 45 is

45 is like didn’t become like you know a level higher because it kind of seems like it’s closer

to 73 shouldn’t the 12 be hanging off the left child of the 45 no no no no don’t rearrange the

nodes as you’re building the tree just let the numbers let the nodes fall wherever they’re

supposed to go another tip is if you’re building a tree that has other data types as as the t types

inside of the nodes as the template types inside of the nodes for example right now I’m just using

type is int, at least in my mind, if you wanted to put dinosaur objects in the tree, all you’d

have to do is make sure that your code for your dinosaur class for your dinosaur object

had its inequality operators implemented, you know, less than, greater than, and then the tree

would still know where to put all the objects. So you could make any kind of custom object you want

and they would all fall in their correct places in the tree as long as the operators actually

just as a side note. Okay, so now we’re ready to add the next item. So I’m going to erase this

stuff here, and I’m going to move the arrow from the 45 to the 67. So now we’re going to try to

add the 67. We look at the root node, it’s occupied. We should go to the left because 67

is less than 73. We look at the 12, that’s occupied. So we go left or right. We should go

to the right because 67 is greater than 12. So we look at the 45. Again, it’s occupied. There’s a

a node there so we have to make another decision do we go to the left or to the right well 67 is

greater than 45 so it goes on the right side so i’m going to duplicate this off to the right side

and down a rank and we’ll call that the right child of 45. let me update the number here

to 67 and i’ll connect that as the right child okay

Any questions? I’m just kidding. That was rude. Just know that my heart is with you if you’re

asking questions. Send me a comment in the comments. So now I’m going to move over to the 10 here.

Again, we look at the 67. The 10 belongs on the left. So we kind of go to the left.

We look at the 12. The 10 belongs on the left of the 12 because it’s less than 12.

available slot that’s an available child pointer so I’m going to say the 10 is going to be the

left child of the 12 node maybe I’ll stick it all the way over there let’s see is there anything

less than 10 in there nope okay so we’ll be good we have enough space on the screen

so change that to a 10 do the connecting line so the 10 is now the left child

whoops the left child of the 12 node and now we’re ready to add the next node

node. Okay. So now the 43 is the next one we want to add. One more time, we look at the 73 node,

the root node is occupied. So we have to go to the left because 43 is less. So oops, that’s a line.

So now we look at the 12 node is 43 greater than or less than the 12. It’s greater than so that

means we go down to the right. But the 45 is there. So we have to make another decision. 43 is less

43 is less than 45 so we go to the left that means this 43 is going to be the left child of 45.

And again don’t try to make the tree pretty or better just let the nodes fall wherever they’re

supposed to fall according to the rules of less than or greater than. So now we got the uh whoops

I forgot to change that to a 43. The 43 right there and we are now ready to add another node

So I’m going to like erase this stuff here and I want to move the arrow to the 11.

Now once again, we’re looking for the root node.

It’s already occupied.

We say that 11 is supposed to go on the left because it’s less than.

We look at the 12.

It’s occupied.

So we have to go to the left because 11 is less than 12.

We go to the 10 and that’s also occupied.

So we have to make another decision.

Is 11 greater than or less than 10?

It’s greater than.

why the 11 goes on the right side of the 10. So I’m going to duplicate this over here. Notice how

I’m trying to keep same ranked children or same depth children physically at the same level. It’s

a lot easier to debug your diagrams if you do things this way. Notice also, as I mentioned in

a previous video, that every left descendant of a node should be physically on the left side in my

diagram and every right descendant should be physically on the right side. That just makes

right side that just makes the diagram way easier to debug what do I mean by this look at 73’s left

descendants its left subtree they’re all physically on the left look at the 12 node all of its right

descendants or its right subtree they’re all physically on the right so you if you follow

that rule it’s just way easier to debug I think I forgot to update that number from 43 to 11 so

I’m going to do that now and we are ready to add the next number the 99 so I’m going to do this

So I’m going to do this. We’re looking at 99.

So first we start off by looking at the root node.

It’s 73, occupied. 99 belongs on the right side.

So now we bounce to the right side and we look at the 98.

Whoops, whoops, whoops. We look at the 98.

That’s occupied, so we make another decision.

The 99 belongs on the right side of 98. That slot is available.

So now we can say that the 99 node is supposed to be

a right child of 99.

Sorry, sorry.

The 99 is the right child of the 98 node.

I’m getting a little confused.

Okay, so I’m gonna do a little connecting line there.

And we’re ready to add the final value into our tree.

So I’m gonna do, let’s see.

Oh, oh, I accidentally erased the arrow.

Oh, there it is.

We can add the 32 next.

add the 32 next and if we look at the 73 it’s occupied 32 belongs on the left so then we just

kind of like follow down to the left here we look at the 12 32 belongs on the right of 12 so we

follow down to the right 32 belongs on the left of 45 so we follow down to the left 32 belongs on

the left of 43 and so we will make 32 the left child of the 43 node so I’m going to like select

this real fast we go down a full rank and I’m going to try to split the difference between 12

And I’m going to try to split the difference between 12 and 43 here just to make the diagram easier to debug.

Okay, so then I’m going to do…

It’s looking a little gross, but at least we’re finished.

I have to update that 11 to be the 32.

And now we’re done building our tree.

Okay, so some things to point out real fast.

Notice how the tree is lopsided.

to look at various parts of the tree you might be frustrated why didn’t we put the 98 over there

why didn’t we put the right just it’s fine as long as we follow the rules of building a binary search

tree then this is the valid tree that we would have built of course later on you’ll learn techniques

to make the tree a little bit better looking a little bit faster but right now we’re just building

a tree with no optimizations no self balancing no anything like that this is our binary search tree

tree if we were to take all of the uh you know all the numbers that we added and sort them

then that should be the numbers we see from left to right this is another good argument for why we

should draw the diagram in this way again like uh same depth nodes let me just draw the the depths

real fast just to kind of illustrate the point a little bit same depth nodes should be on the same

y coordinate or the same uh horizontal plane notice how 73 is the root node and then 12 with 98 have

with 98 have a depth of 1 and then 10 45 and 99 have a depth of 2 and then 11 43 and 67 have a

depth of 3 and then 32 has a depth of 4 so the deepest node we can find has a depth of 4 that’s

the 32 node which means the height of the tree um height is 4 sorry 5 the height is always the

deepest nodes depth plus 1 or the number of nodes you would have to touch as you found your way

you found your way down to the deepest node for example if we wanted to get to that 32 we would

touch one two three four five nodes so the height of this tree is five

okay um let’s debug the order of our numbers because this is kind of easy to get wrong

so from left to right we should see a sorted list so let me just uh do little markings here

to indicate that i’m seeing increasing or at least non-decreasing numbers

If our tree supported duplicates, then it would be non-decreasing.

But since we don’t allow duplicates, it should be increasing or an ascending list.

So I’m going to do the 10.

And as we look towards the right, we should see increasing numbers.

So we got the 10 there.

And then we got the 11 there.

And then we got the 12 there.

32, 43, 45, 67.

So far, so good.

It’s all increasing.

73 increases, 98 increases, and 99 increases.

and 99 increases. So from left to right, it was basically a sorted list, which is what we want.

So we’ve created a valid ordering for the tree. Now maybe just think about all the rules of a

binary search tree to make sure we did that right too. So is this a graph? Yeah. Is it a connected

graph? Yeah. Is it a tree? You know, no cycles in the graph? Yeah. Is it a rooted tree? Yeah. The 73

root node is the common ancestor of all other nodes. We have one node that’s common to the

in terms of ancestry um does any node have more than two children no none of the nodes have more

than two children um they’ve all got zero or one or two children and then the numbers are in order

and therefore this is a valid binary search tree so in other videos i’m going to talk about the

time complexity and and like you know how fast it is to do certain operations or how imbalanced a

just so you know this is not a perfect binary search tree you can tell because it’s a little

lopsided um we calculated the height as five and let’s see where the heck is that calculator i

thought i had a calculator on here oh no oh there it is if we calculated the height as five

you could probably imagine and we’ll talk about searching in a future video like how do you search

in a way that makes the tree super super fast well we certainly built the tree in a way that

makes it super super fast we just have to get to searching later but if we

search properly through a properly built binary search tree then at most it

should only take us height number of examinations to find our way to any

piece of data or to determine that a piece of data doesn’t exist for example

I could say that the time complexity is O and we’ll do this in other videos of

of h no matter what the tree looks like no matter how lopsided it is and what is h here five that

just basically is saying in the worst case scenario i would have to touch five nodes to reach the very

bottom of the tree and determine that a value didn’t exist or you know find a value at the very

bottom of the tree so the worst case scenario touch five nodes so it’s o of h if we if we plug

log base 2 so if we did log base 2 of n where n is the number of nodes uh oh how many nodes do we

have shoot one two three four five six seven eight nine ten i think one two three four five six seven

eight nine ten yeah log base two of ten notice how the number here says well it should take like

somewhat close to three uh examinations at most four examinations but we just said it’s going to

of a divergence between the real speed of the tree.

It might take up to five examinations and log base two,

which would be a perfect binary search tree.

So the more lopsided a tree gets, the slower it actually becomes.

And we’ll deal with that in future videos.

We’ll learn how to like detect that and balance that and so forth.

But so we’ve built a binary search tree.

It’s definitely valid if not, you know, like super, super fast.

And I think that’s the end of this video.

Thank you so much for watching.

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

In the next video, I think I’m just going to build another tree for you so we can get

a second practice in.

Okay, future videos also are going to include searching and deleting nodes and modifying

existing nodes and just a whole bunch of other stuff.

Then eventually we’ll do self-balancing trees.

I’ll see you later.

Hey everybody.

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

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

right now you should see a QR code which you can scan in order to go to the website which I think

is also named somewhere at the bottom of this video and it’ll take you to my main website where

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

things that I offer and all that good stuff and if you have a suggestion for clarifications or

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

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

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

to me i would really appreciate it so again thank you so much for watching this video and um enjoy

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

Thank you.

hey there let’s talk about uh

hello there hello there let’s build a binary search tree by just inserting a bunch of numbers

inserting a bunch of numbers and will follow the rules

The post Building a Binary Search Tree – Insertion Tutorial 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.

Clear step-by-step explanation of what defines a Binary Search Tree (BST). We build the definition rule-by-rule starting from graphs all the way to the BST ordering property (all left descendants, node, all right descendants). Great first video before learning insert, delete, search, and Big-O.

What is a Binary Search Tree? 00:00
Intro to Graphs and Nodes 00:42
Connected Graph Requirement 03:16
Acyclic Graph – Removing Cycles 04:54
Turning Graph into Tree 07:05
Establishing a Root 07:09
Adding Hierarchy and Levels 09:05
Single Common Ancestor 11:18
Binary Tree Definition 17:30
BST Ordering Property 17:39
Left Subtree Less Than Node 18:29
Fixing Invalid BST Example 20:26
Valid BST Final Check 21:24
In-Order Ascending Order 24:11
Video Summary and Next Steps 25:02
Thanks and Call to Action 25:30

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

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 binary search trees specifically in this video I want to help you

define and identify what is a binary search tree all the rules that go into determining whether

or not something is a binary search tree so you can you can tell that you’re looking at one or

whether you’re not looking at one we’ll talk about some terminology but keep in mind I’m

going to save searching and sorting and like you know deleting and adding items and a whole bunch

extra stuff, especially the hard stuff for videos that’ll come right after this one.

For now, we’re just going to talk about what is a binary search tree.

So you can see on the screen right here, I hope that we have a binary search tree.

Let’s see.

Can you see that?

Yeah, I think you probably can.

Yeah, I think you can.

This is not drawn quite as well as I would like to draw ours.

I’ll tell you how to do that in a little while.

to do that in a little while but when you draw a tree in a really really nice pretty aligned way

it’s way easier to debug it’s way easier to tell that you’re looking at something that is sorted

and so forth anyway okay so first let’s start off with a graph so this is not a video about graphs

uh i guess i can probably expect that you already kind of know what a graph is at this point in time

and edges. So what do I mean by nodes? Well just imagine there’s like a little circle here

that contains some sort of data. If you know data structures already then

there would be a t-type sitting inside the node. We’ll just call the t-type an integer

and so for our nodes, for our trees, we’re just going to say that they hold integers even though

you know technically speaking in a binary search tree or a graph you could have all sorts of

Okay. So I’m just going to, you know, grab this and sort of like duplicate it and just duplicate it again.

I’m just going to make a bunch of duplicates. Something is definitely wonky about my setup right now.

I think I just upgraded the camera and the CPU is maxed out. I just upgraded the CPU on this computer too.

Oh well. Okay. So we aren’t going to support duplicate values in our binary search tree,

I’m going to say it doesn’t really matter for the graph. Later on, we’ll start making sure there’s

no duplicate data. For now, I think I can probably do that somewhat quickly. Let’s see. So a graph,

you know, for the for our purposes right now, a graph is just basically a collection of nodes and

edges. It could be empty. It could be just nodes. It couldn’t just be edges, it would have an edge

always has to have a node or two connected to it. So we just have like a bunch of nodes inside of

data values this is a valid graph but I’m going to draw some edges randomly here so we’re going

to do this it doesn’t really matter I’m just randomly drawing edges okay actually I should

probably do maybe like one that’s kind of separated okay so this is a graph this is not a binary search

tree so let’s add a bunch of rules let me just pull up my rules real fast here okay so what is

First we’ll start off with the graph like we have here and then we’ll say that the graph must be connected.

What is a connected graph? A connected graph is basically a graph where every single node can find every single other node

or find a path to every single other node only following along edges and only by respecting the direction of edges.

You can see this particular graph is undirected meaning the edges don’t really have a direction to them.

So that means we could travel along in any direction from node to node.

So just as a real quick, you know, I guess like tutorial, I’m going to say is 8 connected to every single other node?

Well, it can find a path to 12 and it can find a path to 33 and it can find a path to 76 and 45.

But it cannot find a path to 99, which means this is not a connected graph.

So that’s the first rule that we have to implement here.

We’re going to say this graph needs to be upgraded or modified so that it will be a connected graph.

start randomly adding edges until this is a connected graph I’m gonna do maybe

like an edge from 99 to 12 there and then now I think this is a connected

graph but let’s double check real fast so connected graph you know what I’m

gonna put graph connectedness in another video to keep this one short for now

check out my other videos if you would like to see whether or not a graph is

but long story short as I just said if every single node can find a path to

every single other node without you know skipping where there is no edge then

it’s connected okay so that’s the first thing the next thing that we need let me

just put the words connected up here we need a connected graph the next thing

that we need is we need an acyclic graph which basically means a graph with no

A cycle is, can you find a path in this graph that starts at one node and ends at the same node without repeating any edges?

So for example, if I was asking, you know, is 76 involved in any cycles?

Well, we could go from 76 to 33 and then 12.

And, you know, we could kind of take 8, 45, 12 again.

But by the time we turn around and try to get back to the 33, we’ve already crossed this edge twice.

so that means the 76 is not involved in any cycles because we cannot find our way back to 76

without repeating an edge so 76 is okay i’m just going to maybe put like a little check box here

and uh you can also tell that the 33 is not involved in any cycles because we go down to

the 76 and then come back up to 33 we already repeated an edge so that’s not valid same thing

again. Same thing for the 34, same thing for the 99. But if you look at the 12 here, we could

actually find a cycle. We could go from the 12 to the 8, and then from the 8 to the 45, and from the

45 to the 12. Now we’re back where we started. We’re at the 12 node again, and we did not repeat

any edges. So this is not a cyclic. This is a cyclic graph. It’s got a cycle. So that’s the

we want to make sure that our graph has no cycles. So, uh, the next rule I’m just going to say is,

is going to be satisfied by me removing some edges at random. So I don’t know, let’s get rid of, uh,

the eight to the 45 connection. See if that works. Um, let’s see. Well, wait a minute. What did I

just do? Something happened here. I just accidentally, oh, I erased too many edges

from the last slide. Okay. Let me add that one back in 33 to 76. That was supposed to be there.

33 to 76 that was supposed to be there.

So now we have an acyclic graph

and we can consider this graph a tree.

The next thing we need to do is add a hierarchy to this tree.

So this is gonna make more sense in a little bit

but for now I’m gonna say,

we’ll imagine a family tree kind of,

it’s not really exactly a family tree

but you know imagine there are parents

and children and grandchildren

and we’ll just try to like,

we’ll try to rank children according to

according to you know when they were born or or how many parents or children

they have you know their descendancy their lineage whatever you want to call

it so I think I’m just gonna maybe move the eight up a little bit so that it’s

on the same rank with the 12 and the 33 so I’m just gonna move these up a little

bit and then redo their connecting lines so I’m gonna do this and that and then

and then we’ll say that the 76 is still a child of the 33.

So I’ll just kind of move it over here.

Or sorry, we never said it was a child.

Now we’re saying it’s a child

because when you go from top to bottom,

imagine like a family tree,

we’ll say we have parents and children.

The children or the descendants are lower.

The ancestors or the parents or the grandparents are higher.

Maybe I want to put this 45 over on the left

so that it’s a child of the 8 node.

And maybe I’ll say that the 99 node

the 99 node is a child of the 12 node. Okay, so eventually this is going to look not exactly like

a family tree because usually in the family tree we have two parents that go to one or more children.

In this type of tree, in eventually our binary tree, we’re going to have one parent that has,

you know, children just by itself, like asexual reproduction. We’re pretending to be bacteria

What was that comedy skit a long time ago, Tiny Elvis?

And he was like, hey, see that protozoa over there?

The thing is huge.

Anyone?

No?

Okay.

So the next rule we need is we must have a rooted tree.

What is a rooted tree?

Actually, let me clean up the lineage real fast, the heritage.

I want to make nodes that have the same level with respect to their ancestors

respect to their ancestors to have the same physical y coordinate the same

physical level so notice how the 99 I just moved it down a little bit because

I wanted it to look like it’s the same you know number of generations lower

than the top row so like with aid it had a child 45 so that’s one level down 33

had a child that’s one level down that’s a 76 and the 12 also one level down

would have been 99 but the 99 was kind of too physically high this will help

will help you debug your binary trees in the future anyway so i’m just going to clean this up right now

and uh now that we have you know parent child relationships we need to look at the most common

ancestor in the whole entire tree or if there is one so notice how uh i guess i’m just kind of using

the word ancestor without explaining it so your ancestors are the people that you’re disappointing

or whatever it is, ancestors came before us, right?

Like my parents are my ancestors.

My grandparents are also my ancestors.

My great-grandparents are also my ancestors.

Going down in the family tree are your descendants.

You know, my children are my descendants.

My grandchildren are my descendants.

My great-grandchildren are my descendants and so forth.

So if you look at the number 34 here,

what is the greatest ancestor that it has?

Well, if you just go up and up and up

until you can’t go up anymore,

up until you can’t go up anymore it’s the 12th so that means the greatest ancestor of at least in

this tree of the 34 is the 12th the 45 the highest you can go is the 8 notice how 8 and 12 and 33 are

siblings there’s not really like a parent-child relationship they’re connected sideways we’ll

eventually get rid of the sideways connections for our binary search trees but for now we have

some siblings and so we actually have three different greatest ancestors in this tree we’ve

tree we’ve got 8 and 12 and 33 and that’s no good so the next rule that we need is we need

one common ancestor for every single other node in the entire tree so I’m going to duplicate this

slide right here and I’m going to say we need to clean this up so we got to choose 8 or 12 or 33

I don’t know I’m just going to maybe say that 8 and it’s 45 are children of the 12 so I’m just

line here arbitrarily so i’m gonna go like that notice how i’m trying to keep the 8 the 99 and

the 76 on the same y coordinate the same level now we have two uh you know greatest ancestors

we need to have only one so i think i’m probably going to say that the 33 and the 76 are going to

become children of the 12 node just for simplicity so i’m going to put this over here i’m going to

i’m gonna like move this over here this is a gross tree but we’ll fix it soon we’ll do that all right

okay okay

okay and then i have to get rid of that little sibling line and then i have to add another line

to say that 33 is a child of 12. okay so now we have a rooted tree what we had before was an

unrooted tree or just like not a rooted tree because there was no root there was no greatest

greatest common ancestor to the entire rest of the tree. But now we can say that 12 is the root

of the tree because it’s the ancestor for all other nodes. I guess even if 12 was by itself,

we could call it a root of tree. It just wouldn’t be a very good example. So I’m going to actually

get rid of the word acyclic here since we already handled that. And I’m going to do,

I’m going to say that 34’s greatest ancestor is 12, 99’s greatest ancestor is 12, 33’s greatest

all the nodes in the tree their greatest ancestor is 12 and it’s common to all of them so now we

have a rooted tree maybe I should type in my doomed I really hope the screen I really hope

the screen cast doesn’t freeze it probably will upgraded the CPU it’s 33 faster than it was before

board so i am still using an old cpu even though it’s new to me dang it i’m gonna have to spend

like 500 okay uh so the next rule is so we have a rooted tree and now let’s rearrange everything

hierarchically which we already kind of did so uh there’s not really much to do here except

we did hierarchical organization

we probably just need to move on to our next rule which is to say that

if our rooted tree is to become a binary tree

then each node in the entire tree

cannot have more than two children

every single node in the entire tree

can have zero or one or two children

if there are three or more anywhere in the entire tree

then it’s not a binary tree

so okay that means you know the 45 is okay

because it has no children

because it has no children. All the rows, all the leaves at the bottom are okay. All these nodes

over here are okay because they just have one child. But the 12 node, the root of the tree,

it’s got three children and that violates the rule. So now we need to rearrange this.

So I think I’m going to just move these numbers down here maybe. Whoops. Maybe move these nodes

descendants of the 33 node. So I’m going to do this.

Okay. So cool. Now we have a binary tree and now we need to rearrange the drawing a little bit.

This is not part of the definition, but this will make it easier to debug your trees. So what I want

to do is make it so that every left descendant of a node appears physically on that node’s left

every right descendant of a node should appear on its right side

or like further to the right on the x-coordinate

so sort of similar to you know like the y-coordinate ranking

but notice how the 12 its left child is 8 and its right child is 33

so that means all the nodes here on the left side you know that come underneath the 8

are left descendants or you could say that they are in the left subtree of the 12.

So, they’re okay because 8 is to the left of 12 and 45 is to the left of 12.

But notice how 33 is a right child of 12 and it’s part of the right subtree.

It’s part of the right descendancy, but it’s physically on the left of 12.

That’s going to be really bad because it’ll be harder to debug our trees later.

So, I’m just going to slide it over without rearranging the tree.

And I usually try to split the difference here.

and then their parent is kind of like physically in the middle that will also help you debug in

the future so i’m going to do this wrong let me get the blue i’m going to do this make sure that

my ranking is still okay not the best most neatest tree and so now i’m going to look at the eight

it’s left subtree or it’s left uh descendancy uh all of those nodes which is just the 45 are

it’s left child 76 is the only thing that’s on the left side in the left subtree so that’s all

right probably the 33 I think it’s still a little lopsided I probably could have you know dragged

it a little bit more to the right but I’m going to leave it so the 33 and the 76 are okay and then

the 99 is a right descendant or it’s part of the right subtree of the 33 so it should be on the

right side it is that’s good the 34 should be on the right side of the 33 because it’s it’s a it’s

It’s part of the right subtree of 33.

It’s part of the right descendancy.

And it should also be on the left side of the 99

because it’s part of the left subtree of the 99.

So, so far, this is okay.

This is not the best drawing.

So now we have a binary tree

and we have kind of drawn it in a slightly good way.

Not super great.

The last rule that we’re going to add here is,

whoops, what happened there?

I’m supposed to do that, yeah.

The last rule we’re going to add is

we must have ordering to our nodes, to the numbers in our nodes. So what do I mean by ordering? Well,

the whole reason that we want a binary search tree, at least usually, is because it’s really,

really fast to search through. This is going to be a tree that we can search through in log time,

which we’ll talk more about in another video. We’ll do time complexities and searching and stuff. But

in order for this to be a super fast tree to search through, we need to be able to

very quickly make a decision. Do we go down and to the left? Do we go down and to the right?

left do we go down into the right and every decision we make should help us eliminate half

of the remaining data set half of the tree at a time every time we go down a level and that’s only

possible if the nodes themselves are ordered so what i’m going to do is say every node that’s on

the left side or let’s say every descendant that’s on the left side of a node should be of a lesser

value than that particular node every node that is on the right side of a node meaning it’s a right

descendant of that node or part of the right subtree of the node should be greater than that

node. Please note that this would not allow us to support duplicate values in our tree.

You could use something like less than or equal to versus greater than if you wanted to support

duplicate values in your tree. You could also change the T type, you know, the template type

to a node from the data you want it to store to a list. So every single node has a list inside of it

and the items in the list are just, you know, the regular values that you wanted. There’s a whole

values that you wanted there’s a whole bunch of different ways you could actually do that

but for now we’re going to see our trees don’t support duplicate values

so okay we don’t support duplicate values but we need you know from left to right

the order needs to look sane and this is kind of why we’re drawing the tree in this special way

we’re trying to make our tree really easy to debug visually so check this out the way we’ve

drawn this every single node has its own x coordinate basically notice how the 12 there’s

nothing underneath it at least not directly underneath it the 33 the 34 all the nodes you

know you can draw a straight line down from the node and it shouldn’t cross over with any other

nodes or edges so that means now that we’ve drawn it this way and we’ve made sure that all the left

descendants are on the left and all the right descendants are on the right we could actually

just scan our eyes from left to right and be sure that we are seeing an increasing order or

Since duplicates aren’t allowed in this tree, we’ll say an increasing order or an ascending order.

So if we start at 45 and then we go to the right, we should see a higher number.

So if we look at 8, 8 is a lower number.

So this violates the ordering rule.

This is not a valid binary search tree.

It’s only a valid binary tree.

So sad.

Okay, so I could, you know, swap the 45 and the 8 or I could just increase the value of the 8 itself.

of the 8 itself, I think it’ll be faster for me to just increase the 8 value. So I’m going to make

it 52 now. So we’ve got 45, 52. Then we go to the right a little bit more. It should also increase.

So 52 should increase. I’m just going to randomly increase it to, you know, 59, let’s say. Then as

we go to the right, we see another number here. It is 76. That already is increased from 59.

So we don’t need, we don’t need to alter that number. Then we go to the right one more time

that because it’s lower than 76 so I’m going to put 87 then when we go to the right one more time

that’s the 34 down here that’s definitely a decrease so we have to increase it now so I’m

going to say 99 how about if I just do 92 yeah so now we have a 92 down here and then if we go

to the right a little bit more there’s the 99 and now we actually have a binary search tree let’s

just double check all the rules first off is this a graph yeah there’s nodes and edges there’s nothing

There’s nodes and edges.

There’s nothing weird happening.

There’s not like a edge floating in the middle of nowhere.

Is this a connected graph?

Yeah, it is.

Because every single node, if you followed, you know, the edges, you know, could find

every single other node.

Like the 45, it could find, you know, the 92 node if it just followed all these edges.

Notice again that these edges have no direction.

There’s no arrows on them.

So we could go up or down in any direction we want.

So that means the 76 can find everything else.

else and so this is a connected graph for sure okay now that we have a

connected graph is this an acyclic graph I don’t know about you but I can’t find

any cycles in the graph right like the 92 it goes out but it doesn’t come back in

same thing for the 76 if we went from the 76 up to the 87 and then took a

right turn we wouldn’t be able to come back towards it without repeating that

same edge so this is definitely an acyclic graph all of the nodes follow

they’re not involved in cycles is this a rooted tree yeah there’s only one common ancestor to the

entire tree it’s the 59 it’s the highest node in the entire tree and it’s common to all other of

all of its descendants um so let’s see i’m going to duplicate this real fast the next thing is

we arranged it hierarchically and we added the terminology of like i think i kind of just like

tried to sneak this one past you but we added the terminology of a left child and a right child

and a right child.

Right? We also added the terminology of a right subtree and a left subtree.

Just to clarify what I mean, what do I mean by a right subtree and a left subtree.

So imagine we’re considering the 59.

If we consider the 59, then the 52 is the root node of the left subtree of the 59 node.

If we consider the 59, then the 87 is the root node of the right subtree of the 59 node.

so the right child is basically the root of the subtree uh in in you know the right child is the

root of a subtree of the right subtree uh i think i’m getting muddled my words here okay

anyway so we have a little bit of terminology uh the 59 is the root node that’s like the

the only node in the entire tree without uh an ancestor or a parent so okay uh then we have a

Note, and the entire tree doesn’t have more than two children.

Notice how the 59 has two children.

That’s fine.

If it was three, that’s way too much.

52 has one.

87 has one.

No, 87 has two children.

99 has one child.

92 has zero children.

So, okay, we’re not violating that rule.

So, we definitely have a binary tree.

And then we, you know, kind of read from left to right.

Let me write down the numbers this time for fun.

physically without kind of like following edges or anything we just scan

our eyes from left to right we can see that we have an ascending list if we

supported duplicates it would be okay to just see a non decreasing list but we

see an increasing list or an ascended list ascending list okay whoops this is

left to right so this is actually a binary search tree and um i don’t know about you but i think i

need to like you know get a snickers or something right now because uh this video has been going on

for longer than i wanted it to go on so we’ve defined a binary search tree in future videos

we’ll talk about how to add nodes into a binary search tree how to build the tree what’s the time

complexity of the tree in various operations deleting nodes from a tree terminology like

terminology like what are these nodes called things like that so anyway thank you so much

for for watching i hope you learned a little bit of stuff and had a little bit of fun

i’ll see you at a later date in time

just kidding

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

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?

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 uh and subscribe

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,

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

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

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

stuff.

And if you have a suggestion for clarifications or errata or just future videos that you want

to 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 would really, it

it would 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 Binary Search Tree Definition Explained Step by Step appeared first on NeuralLantern.com.