- 2 days ago
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
binary search tree, bst deletion, delete node bst, binary search tree remove, bst remove node, inorder successor, data structures tutorial, binary tree deletion, cs data structures, coding interview, tree algorithms, bst operations
=-=-=-=-=-=-=-=-=
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
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
binary search tree, bst deletion, delete node bst, binary search tree remove, bst remove node, inorder successor, data structures tutorial, binary tree deletion, cs data structures, coding interview, tree algorithms, bst operations
=-=-=-=-=-=-=-=-=
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
Category
🤖
TechTranscript
00:00hello there let's talk about deletions in a binary search tree
00:10okay so hopefully at this point you already understand binary search trees
00:14in all other aspects than just deleting if you don't see my other videos in my other videos we
00:20talk about how to identify a binary search tree all the rules that define it some terminology
00:26we talk about how to build a binary search tree with the insert or add operation we talk about
00:31searching through a binary search tree and time complexities and even drawing the diagram in a
00:37really nice and pretty way so that your trees are easier to debug so for now i'm just going to
00:42say
00:43it's time to learn how to delete nodes from a binary search tree so there are three types of deletions
00:49um actually let me just kind of like for example suppose you want to delete uh to delete the number
00:5548 from the tree okay uh well first you'd have to go search for 48 so already you know this
01:02is going
01:02to be an o of h operation or log time if the tree was perfectly balanced or linear if the
01:07tree was
01:07really poorly balanced so we're going to search for what did i just say 48 i should write it down
01:13let's say we're going to search for 48 we have to go search for it first so that's going to
01:19be o of h
01:19once we find it we then have to determine what type of node it is how many children does it
01:25have
01:25is it a leaf with zero children is it a node with one child or is it a node with
01:30two children
01:32each type of node is deleted in a different way so let's see uh the first type we would delete
01:38is uh
01:39a node uh with uh zero children also known as a leaf also known as a in sorry external node
01:49the second type of deletion is a node with one child and the third type is going to be the
01:55hardest type we'll do that at the end of the video it's going to be a node with two children
02:01uh numbers two and three are going to be internal nodes but i i hope you already know that because
02:06you watch the videos anyway so let's start off with the easiest possible node to delete first
02:11just a regular leaf so i'm going to delete this stuff real quick um and then just kind of like
02:18erase down and down and down okay so let's identify a leaf well it could be anything that just doesn't
02:23have any children of its own let's do uh let's do the number 11 just to make things a little
02:28bit easier
02:28so let's delete the number 11 i'll put 11 here we first search for 11 so we look at the
02:34root node
02:3511 belongs on the left we look down here 11 belongs on the left we look down here 11 belongs
02:41on the right we find 11 you know if we reach the end of the tree and we couldn't find
02:44it then it's
02:45like i don't know maybe throw an exception at the user hey you tried to delete something that wasn't
02:49there but uh the 11 is there and now we have to figure out how to actually delete it so
02:56let me draw a
02:57couple of larger representations of these nodes real fast i'm just going to draw like a big old circle here
03:04and maybe duplicate it and we'll just pretend that that's the 9 and the 11.
03:09so i'll put like a tiny little 9 there because i don't want to change the font size and the
03:13tiny
03:13little 11 there and um when we draw our diagrams we usually just kind of do one line but you
03:21should
03:21know that if you're doing this in code actually what's happening is the 9 node it's got a right
03:26child pointer that points down to the 11 node and then the 11 node has a let me just redo
03:32this real
03:33fast to make it prettier and then the 11 node has a parent pointer that points up to the nine
03:39this is
03:40probably going to be true for almost every language at least that i can think of that you would code
03:44a
03:44tree in and then of course the nine would have a parent pointer to you know the 16 but we
03:48won't
03:48consider that so what are you really going to do uh well first you have to look at the 11
03:54node and
03:56travel up to its parent and let the parent know that it no longer has a right child so long
04:00story
04:01short we're going to null the right child pointer we're going to say disconnect that right child by
04:05setting it to null maybe i'll just put like a little null symbol here then we don't necessarily
04:11need to actually null the pointer on the 11 node because we can just delete the 11 node if we're
04:17using dynamic memory if we're using a smart pointer it should go away already at this point because it
04:22has no one else pointing to it but long story short once we kill the 11 node we also end
04:28up killing its
04:29pointer so we don't really need to tell its pointer to point to null it's just going to end up
04:33going away
04:33it's not going to be a memory leak because it was only pointing to the nine and the nine is
04:37not going
04:37to leak memory because the nine is still going to be inside of the tree so uh the time complexity
04:44once we find the the leaf the node with zero children is just going to be constant time we're
04:49just going to manipulate a couple pointers maybe call delete on that node so it's really all about
04:54log time to go find the node if it was perfectly balanced or just o of h to find it
04:58and then plus
05:00constant is going to get cancelled out so it's like an o of h operation or log time if the
05:04tree is perfect
05:05so let me just uh cross it out to let you know that this is what it's going to be
05:11like
05:11we're going to say the 11 is just gone and so is the pointer that the nine has pointing down
05:16to the
05:1611. that's how you delete a node with uh with zero children so deleted a leaf
05:25all right now the next thing which is slightly harder but not too hard
05:28is deleting a node that has one child long story short for this we're pretty much just going to
05:35uh oh i forgot to full screen the the annotator let me do that to get myself a little more
05:39room
05:40uh we're really just going to promote its one child to wherever that node was so let me erase this
05:49real
05:49fast and we'll say that uh let's first let's find a node with only one child it's not the 35
05:56it's the 32
05:57node okay i guess that's why i drew that um so let's kill the number 32 you know if there
06:05was
06:06just like one child like let's say the 23 was the only node that existed and there were no nodes
06:11underneath the 23 then this would really be the same operation we would literally just promote the
06:1523 up to where the 32 was but i wanted to do this example because it's a little bit more
06:20difficult so
06:21we want to kill the 32 what we're going to do is first search for it so this is already
06:26going to be
06:26an o of h operation or a log time if the tree is perfectly balanced we do uh we go
06:33down here we go
06:34down there you know where is the 32 we're just searching for it so we have to spend uh the
06:39time
06:40to search for the node we then look at the node okay we found the 32 we identify how many
06:45children it has
06:45we see that this is a node with only one child and that means the one child which in this
06:50case is 23
06:51just needs to be promoted up to where the 32 is so that means i'm going to
06:59just you know remove the 32 from the diagram maybe get rid of get get rid of one of these
07:05uh
07:05connecting lines and then just move the 23 up a level and that's pretty much it if you're thinking
07:11about this in terms of code uh you you want to have let's see let me duplicate this again in
07:17a
07:17different way if you're thinking about code what you want to do is have the 32 which is the node
07:25you're going to delete go to its child so determine if it's the left child or the right child that
07:28exists once you find that child you tell it that its new parent is the parent of the node you're
07:35trying to delete so that means the parent of the 23 is no longer 32 the parent of the 23
07:41is
07:41actually 35 you know it's its original grandparent or the the parent of the node you're trying to
07:46delete after you do that you tell the grandparent that it's no longer pointing down to the node
07:53you're trying to delete but instead to its grandchild so again we're just going to manipulate some
07:58pointers here we're going to say yep your left child is now the 23 and not the 32 notice that
08:03we're
08:03kind of you know drawing arrows around the original node we're sort of cutting it out of the situation
08:09just like in the linked list where you remove one node um and this is going to be a constant
08:15time operation at least after we search and find the 32 node uh finally of course you want to like
08:20delete the 32 but uh so if this is like a regular pointer that you have in your tree you
08:25would call
08:25delete on it depending on your language and then uh if it was a smart pointer uh as as soon
08:31as no other
08:32nodes are pointing to the 32 it's just going to go away so you don't really have to worry about
08:36it
08:37but yeah long story short uh notice how the 23 is actually the new left child of the 35
08:42so that's why i say that the the uh the one child that was on the 32 is going to
08:47get promoted
08:48uh to wherever the 32 was wherever the node you wanted to delete was this will be the same whether
08:53or not uh whether it's the left child or the right child in terms of what is the one child
08:57that the node
08:58had um and also you know how do you decide uh how to tell the uh the grandparent is its
09:06left child
09:06pointer going to be changing or is its right child pointer going to be changing well you know
09:11when you originally looked at that 32 and you're about to delete it you could tell
09:15that it had that that it had one child based on its left pointer and right pointer one of them
09:20was
09:20null and one of them was not so whichever one of them was null that tells you the direction that
09:24the grandparent should be pointing so in this case the 32 had a left child pointer that was not null
09:29and a right child pointer that was null because there was no right child so that's why we told
09:34the grandparent that its left child pointer is now the 23. and that's it for deleting a node
09:41that has one child okay so uh i'm going to go ahead and delete this or sorry i'm going to
09:47duplicate
09:47this one more time and we're going to do the deletion of a node let me let me write down
09:55you
09:55know deleted a node one child yay we did it you guys um okay i'm going to put that there
10:06too just for my
10:07notes so this is going to be the hardest uh part we're going to try to delete a node that
10:12has two
10:12children maybe i'm first going to delete the uh the 35 node since that's kind of where we're hanging
10:17out lately uh and then we'll delete the hardest node of all the 41 nodes so the first thing we
10:23need
10:23to know uh before we can get ready for deletion is the uh in order traversal sequence of the data
10:32in
10:32this tree uh if you're watching this video as soon as i published it uh then i i don't have
10:37videos up
10:37yet on traversal i'm going to upload those soon if you're watching this from the future
10:43then you can just check out one of my traversal videos but long story short in order traversal
10:48just means produce a sorted list an ascending list or a non-decreasing list based off the data that's
10:54inside of the tree so you know uh if i put this down here i can just say you know
11:00looking visually
11:00from left to right this is why i draw my trees in this way i see a six and then
11:05a nine and then an 11
11:07and then a 16 and then a 19 and then a 23 and then a 29 no no a 26
11:14and then a 29 and then a 32 35
11:2038 41 43 48 52 59 67 73 and 79 let me just double check
11:36that i've done this correctly uh they all the numbers seem to be increasing or at least not
11:41decreasing um let me just double check okay how many do i have one two three four five six seven
11:51eight nine 10 11 12 13 40 15 67 18 19 i already got lost i think it's 19 one
11:57two three four five six
11:59seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen okay
12:04did it right so basically a sorted list an ascending list of the original data that was inside of the
12:11tree and now we need to look at a concept called in order successor successor comes after predecessor comes
12:18before uh think of the think of like a king and a prince right the prince is the successor to
12:24the
12:24king eventually one day when the king grows very old and becomes grandpa king and the prince grows up
12:30and becomes the regular king then you would look at the uh the prince king and you would say who
12:34was
12:34your predecessor well it's grandpa king right so whoever comes before his predecessor whoever comes after
12:40is the successor so we want the in order successor of the node that we wish to delete
12:46so uh i can't remember what i said originally but let's just say we're going to delete the
12:5035 node i should have written it down let's delete the 35 first we have to find the 35 itself
12:57to make
12:57sure it exists in the tree so i'm going to look at the 41 i'm going to go left to
13:01the 16 i'm going to go
13:02right to the 35 there it is we found it in o of h time in the worst case so
13:07this is obviously not going
13:08to be the fastest operation but you know all the ops are kind of the same speed in a perfectly
13:12balanced
13:13binary search tree not empirically but in terms of time complexity so we found the 35 we identified
13:20that it has two children so then what we have to do is find the in order successor uh what
13:27is the
13:27in order successor of the 35 node it's uh well we just look at the sorted list 35 here and
13:33it appears
13:34to be 38 and that actually makes sense because since the data in the tree is going to look sorted
13:38if you
13:39sweep your eyes from left to right assuming you drew the diagram well you're really just looking
13:44for the uh the node that is as close as possible to the node you wish to delete but happens
13:50to be to
13:50the right of it there are some tutorials out there that use the in order predecessor so that would mean
13:56the 32 would be the one you select but let's not do that because i like to do successor so
14:01first we
14:02uh find the 35 then we find its in order successor we'll do another delete maybe next of the 16
14:09node
14:10because that'll be a little more difficult um once we find the in order successor we're actually just
14:16going to copy the data uh up into the tree so i'm gonna sorry up into the node we want
14:22to delete so
14:23that means uh i'm going to take this 35 and it no longer has 35 as its value
14:30instead we're going to steal the value of its uh in order successor so 35 up sorry 38 up here
14:39so now we have two 38s in the tree that's bad we need to recursively delete uh the 38 node
14:45it's not
14:46really a recursive delete it's more like you're inside the remove function or the delete function
14:50or whatever you chose to call it it's usually remove and after you've copied the value of the
14:56in order successor to the node you actually wanted to delete then you call delete or remove again on
15:02the the in order successor you probably want to use a pointer to that node uh or have some sort
15:09of a
15:09way to reference that node without telling the tree to start deleting from the top again because if we
15:14say if we just call tree dot remove with the number 38 it's going to actually find the 38 on
15:19top
15:19and that's going to be no good because then if you've written your code correctly uh at least after
15:24that point then it's going to find the 38 and copy its value up and then it's going to happen
15:29all
15:29over again we're going to just be stuck in an infinite loop um so instead you want to have like
15:34a pointer to this node or a reference to this node and then call a removal function or a delete
15:39function
15:39that can receive just like you know a reference or pointer directly to that node and then if you notice
15:46the number 38 node the one on the bottom it's a leaf it does not have two children
15:51children so there's actually a guarantee that when you find the in order successor it will only have
15:57zero or one children it's absolutely impossible unless your tree is super messed up in some way
16:03that the node would have two children because if it did then you have not gone far enough to the
16:08left
16:08towards the node you're trying to delete remember we we said we need to find the node that is as
16:13close
16:13as possible to the node that we want to delete but just like on the right side well if there's
16:17a left
16:18child let's say the 38 had a left child then we would actually want to follow the left child
16:22we wouldn't stop at the 38 node so it's impossible for the node to have two children which means it's
16:29going to end up being an easy deletion so the first thing we do is we're we're saying let's delete
16:34a
16:34node with two children that's the 35 we find it's in order successor we copy its value up and then
16:41we call
16:42delete again or remove again on this in order successor which is guaranteed to just be an easy
16:47leaf removal or a node with one child removal where we just like you know promote it's a child up
16:53and
16:53that's it so let me uh let me duplicate this real fast and uh let me say also that everything
17:02we just
17:02did was basically all it's just going to be o of h because it's going to be o of h
17:06to go find the node
17:07in the worst case and then o of h to find its in order successor uh some fraction of each
17:13you know o of
17:13h fraction of each fraction but when you just combine them it's just going to be o of h or
17:18or
17:18log time if it's a perfectly balanced tree and then once we find the in order successor and the node
17:23we
17:23wanted to delete it's just a matter of like just copying data and uh um maybe doing the second delete
17:31so you know the second delete itself would just be like another o of h or log time so you
17:36probably know
17:37at this point that if you have two times log of n it's just going to cancel out to log
17:42of n if we're
17:42talking about big o time complexity anyway so i'm going to duplicate this one more time and then
17:49revert uh everything to scratch uh to scratch here or to the very beginning again so we can delete
17:55something that's a little bit more difficult whoops that's bad can i get this nope can i get that yes
18:02okay
18:05so let's delete that 16 node so we can look at how you might find the in order successor
18:12in a program because you don't want to like traverse the whole entire tree and produce a
18:16giant list and then scan the list and then like find the successor and then once you know the number
18:20go search for the for the node that's like going to be way too slow the tree should be way
18:24faster than
18:25that so instead this is kind of how you do it let's search for the 16 first so we do
18:29like 41 16 belongs
18:31on the left side we found the 16 now we have to find the 16s in order successor the one
18:37that comes after
18:38you can tell just by eyeballing it that it's going to be the number 19 right but how do we
18:43find that
18:43number in the code to make it a little bit faster so again 16 and 19 they're just paired up
18:49right there
18:50well uh first you just take a hop to the right so you look at the right uh child if
18:55it exists
18:56if it doesn't then you have not tried to delete a node with two children it was definitely a node
19:00with
19:00the one child at most so we take a hop to the right to find its right child and then
19:06you follow
19:06left child pointers as far down as you can possibly go until you reach a dead end so that means
19:13i'm
19:13taking a hop to the right and then i'm just going to go maybe i'll do like another color here
19:17i'll go
19:18left child pointer left child pointer a left child pointer as far down as i can possibly go
19:23and that is the successor notice how that's the 19. again if the 19 had a child on its left
19:30side
19:30we would have to follow it down further which means it's guaranteed that you will stop at a node that
19:35has no left child if it had a right child same situation it's still going to be the in order
19:42successor that just but that just means when we call a remove a second time on that node it's going
19:48to
19:48be a leaf that gets removed and not a node with one child so it's just pretty easy let me
19:53uh let me
19:54say that now that we've found the in order successor we're just going to copy the value
19:59so i'm going to do maybe i'll put this in orange so this 16 is no longer in that particular
20:05node we're
20:05not even deleting that node we're just stealing a value from a different node we're going to steal
20:10the 19 value from the node which is the in order successor and now that we've done that we'll use
20:16our
20:16reference to the 19 node to call remove on it uh specifically so when we call remove or delete
20:25it's basically going to say all right what sort of node is this um it's not even going to have
20:31to search for the node because you gave a point to the node or a reference to the node it's
20:35going
20:35to go oh this is a leaf node that's easy i just tell the 23 that it has no left
20:39child anymore
20:40and then i just actually deallocate the 19 node or if it's a smart pointer let it die on its
20:45own
20:46uh anyway let's do something a little bit more difficult now so i'm going to duplicate this
20:52and try to revert all this stuff so i'll revert this okay okay okay okay let's delete the uh
21:03the root node the hardest node of all the 41. okay so if we want to delete the 41 node
21:10i'm just
21:10going to put 41 here so i don't forget uh first we search for 41 in the worst case you
21:16know it would
21:16have been o of h but oh we were lucky we just found it right away now we have to
21:20find the in order
21:20successor for the 41 so again take a hop to the right and then follow left child pointers as far
21:27down as you can possibly go so we'll look at the 48 here and then we'll look at the 43
21:32now we've hit a
21:33dead end and we know that the in order successor for the 41 is 43 and that makes sense because
21:38they're
21:38paired up here in this sorted list at the bottom so then the next thing that we do is we
21:44uh just
21:45copy the data you know we steal the data from the 43 so i'm going to cross out this 41
21:49here
21:51and it's going to end up being uh 43 up at the top
21:56and then we uh call delete a second time or remove a second time on the actual 43
22:03which is another easy removal because it could not possibly have two children it's only going
22:08to have zero or one children and uh well that's pretty much it it's just going to be
22:14just so fast and easy uh so that means the 43 is gone when we're finished here if you look
22:21at all
22:22the slides uh in this video uh you'll notice that the data is still ordered correctly so we do have
22:27a
22:27valid binary search tree even after we kind of do this weird data stealing let me see if i can
22:32find
22:32something that would have had one child so i want to look uh through the whole tree and see if
22:38i can
22:38find a node that has one child that would make a good in order successor and if i can't find
22:43one i'm
22:43just going to manufacture one real fast let's see um who has a right child only no one has a
22:51right
22:52child only that sucks all right uh let's say we want to delete the root node again and i think
22:58last time we just said it was the 43 how about we uh that's boring let's delete the 59 okay
23:06so i'm going
23:06to uh write 59 up here so i don't forget and then we're going to add another node real fast
23:12so that the
23:1250 uh sorry the 67 has a right child uh why am i doing this because the 67 is actually
23:19the in order
23:20successor of the 59 node so i'm just going to draw like another line real fast like that and i'm
23:27going to update uh some number let me just say 70 is going to be the number in that node
23:34which is
23:35double check that it's increasing 59 67 70 okay so we want to delete 79 sorry 59 the first thing
23:41we do
23:41is we go find the 59 so i'm going to take off my line uh tool okay so we're going
23:46to go to the root
23:4759 belongs on the right side so we find the 59 there it is now we're looking for the in
23:52order
23:52successor we go to the right side and then we follow all left child pointers until we hit a dead
23:58end
23:58left child pointer dead end already because i mean there is a right child but we're supposed to be
24:03going down left child pointers there is no left child pointer so we've hit a dead end so that means
24:09the 67 is the in order successor of the 59 which means we're going to steal the uh 67 data
24:17and put
24:18it where the 59 data was so again we're not really deleting the node that had two children we're going
24:24to eventually delete the node that had one child the successor but uh 67 is the number that's going to
24:29be
24:29there and then we call uh delete on this 67 and what's going to end up happening is
24:36our removal function identifies that that 67 had one child and so what it's really going to do is
24:42just promote uh the one child which is the 70 node just one level higher where the 67 was
24:48so that means the uh the 67 is just gone
24:54we do actually delete that and then the 70 node is going to be the new uh left child of
25:00the 73 node
25:05notice how the data still makes sense
25:08okay i think that's all i've got for you uh these are basically log time operations just one more time
25:13log time if the tree is perfectly balanced uh it's a little bit closer to linear time as the tree
25:19becomes
25:19more imbalanced um if this was a self-balancing tree then uh you know this would be like log time
25:27in terms of worst case scenario in general we'll say that this is still on average if we had just
25:33totally random data and totally random deletions on average this would be you know a log time operation
25:38even if we do log uh down to find the node and then another log to find the successor that's
25:43still not
25:43going to be you know worse than log or o of h in general okay that's all i've got for
25:49you thank you
25:49so much for watching this video i hope you learned a little bit of stuff and i hope you had
25:53a little
25:53bit of fun i need to see if someone is selling pie at this hour going on a search engine
26:09hey everybody thanks for watching this video again from the bottom of my heart i really appreciate it
26:14i do hope you did learn something and have some fun uh if you could do me a please a
26:18small little
26:19favor could you please subscribe and follow this channel or these videos or whatever it is you do
26:25on the current social media website that you're looking at right now it would really mean the world
26:29to me and it'll help make more videos and grow this community so we'll be able to do more videos
26:34longer videos better videos or just i'll be able to keep making videos in general so please
26:40do do me a kindness and uh and subscribe you know sometimes i'm sleeping in the middle of the night
26:45and i just wake up because i know somebody subscribed or followed it just wakes me up and i get
26:50filled with
26:50joy that's exactly what happens every single time so you could do it as a nice favor to me or
26:55you could
26:55you could troll me if you want to just wake me up in the middle of the night just subscribe
26:58and then i'll just wake up i promise that's what will happen also uh if you look at the middle
27:04of
27:04the screen right now you should see a qr code which you can scan in order to go to the
27:08website which i
27:09think is also named somewhere at the bottom of this video and it'll take you to my main website where
27:14you
27:14can just kind of like see all the videos i published and the services and tutorials and things that i
27:19offer
27:19and all that good stuff and uh if you have a suggestion for uh uh clarifications or errata or
27:28just future videos that you want to see please leave a comment or if you just want to say hey
27:32what's up
27:33what's going on you know just send me a comment whatever i also wake up for those in the middle
27:37of the night i get i wake up in a cold sweat and i'm like it would really it really
27:42mean the world to me i
27:43really appreciate it so again thank you so much for watching this video and um enjoy the cool music
27:50as as i fade into the darkness which is coming for us all
28:00so
28:06so
28:08so
30:59Hello there.
31:00Let's talk about...
Comments