it's really a tree in the form of a list of nodes

Damn, if that blows your mind, your mind most be blown multiple times a day.

@@typingcat haha, i'm also been wondering why people easily got blown away by simply KZfaq videos, it must be like an ejaculation moment for them. 😂

@@typingcat mine is. There is so much to learn every day. My mind is blown on a daily basis. Its great because im never bored.

what in the hell we were you thinking of if that blew your mind? lol

Why not though?

EXACTLYYYY 😂😂😂

I think it shouldv'e been (Index-1)/2. while "/" rounds to bottom

You are right!

Actually that equation is not for the immediate parent of any given node but it gives you the min node (top most node ). Instead of saying parent she should have told its the min. There she made a mistake. At the same time actually there is no need to have that equation because simply the 0th element is always the min.

@@SupunNimantha no you are wrong. The formula (index-1)/2 returns the parent for any given node. And it is important, because you need the parent of any given node if you want to heapify up. ^^

@@SupunNimantha You could do the maths yourself: take the 9 at #3. Its parent is 4 at #1. Now let's compute: (3 - 2) / 2 = 0 (floor div). Oopsie, 9 at #3 has the root as its parent, while we know from the picture it's not.

ASMR, wikipedia it.

hate it.

😂😂😂 irritating

Nah. It seems as if her keyboard hates being used by her.

Agreed! Lovely sound

that's not pro, that's just math ... lmfao

I believe that calculation takes the ceiling (or whole integer value rounded up, depending on the programming language) of the operation. So, for instance, to get the parent of the node at index 7, we'd have: ceiling((7-2)/2) = ceiling(5/2) = ceiling(2.5) = 3, which is the appropriate index we're looking for.

Gbenga Ojo

Your are right. (index-2)/2 for parent index is a mistake. Look the code at 3:22 - here is the correct version (index-1)/2.

Yes I was gonna say the same thing!

In python 2, / is integer division and it truncates the result so 5/2 = truncate(2.5) = 2

goddess

only entertainment videos ll get more views.. useful videos wont get..😊

Agree with you. I watched quite a lot of her videos and it seems like she doesn't quite understand what she is talking about either.

@@intrepidsouls I agree too. Her book is good though.

Because it doesn't answer why heaps are used or when one should use them. It doesn't give a perfect concrete use-case where a heap would always be beneficial if used.

Best of luck

I don't have an exam, but i found it useful as well! I don't know why, but heaps were so confusing...until now! :)

@Chris Chu Learns ah shucks. thank you!

how it was?

Same, I'm terrible at heaps. These vids help a lot!

+1 for this. Doing an intro to CS course at uni rn and def if it wasn't for the coding assignments involving practical usr cases, I would've never appreciated such data structures... It's certainly very important to actually implement them in some use case in order to grasp them well.

why the hell graphs or heaps complex???

@@stas4985 because they are more complex than a simple non-resizable array or a linked list

Anwar Shaikh insertion and removal should be logarithmic. of course poll is constant and search is linear but you wouldn't want to use the structure for search

It should be O(nlog(n)).

time complexity O(nlog(n)) space complexity O(1)

Insertion and removal have a time complexity of O(log(n)), where 'n' is the number of nodes in the heap. This is because for example, during insertion, in the worst case scenario, you'll need to move the inserted element from the bottom all the way up. Therefore, the max number of swaps is the height of the tree, which is log2(n) approximately (note that this is just true if the tree is balanced, but they always are for heaps). For example, her tree had 10 nodes at some point, a height of 3 (or 4, depending on how you define 'height') and log2(10) = 3.32. The max number of swaps you might need when inserting is 3. The same idea applies for removal, since the element you place at the top might need to go all the way down. The space complexity of the structure is O(n), of course, since you need an array of size 'n'. The space complexity of the 2 operations, however, is indeed O(1), since they don't need additional space.

That's one application.

@@tamoorhamid519 what are the other applications?

@@jadanabil8044 They can be used to efficiently find the largest or smallest value in an array.

There is error at 2:56, parent is (index - 1 ) / 2 and not (index - 2) / 2

1 year later but that is not correct because what you see there is already swapped so there was 4 before the swap and 20 took the place of 4 and then took the place of 9. there isn't an error

Its quite clever

Nice!!!

Noticed that too, but I think they corrected that in their code implementation. lmk if I'm wrong cause I'm here for exam revision and I'm kinda weak at heaps.

The "size" variable maintains the boundary of the heap in the array and so there isn't a necessity to take care of elements with index >= size in the array. Also, "items[size-1] = 0" doesn't achieve the same result as assigning a dynamic node in a tree to null. Here, it simply gets assigned a value of 0. To help with understanding, consider the pop operation in the static implementation of a stack. The popped values remain in memory after pop but not in the stack because of the "TOP" pointer there. Similarly here, size keeps track of the boundary of the heap to help with add and poll operations.

A heap is used as a queue where the min (or max if max heap) is always accessed in O(1) time. If the min (which is always at index 0 is popped off, then the next smallest takes its place. Remember its stored linearly yet indexed logarithmically. Therefore its a "priority" queue.

Yeah, I've googled it afterward, though it's kind of you helping me here, thanks!

Thank you : )

What's the difference then between a heap data set and just a normal ordered data set using a binary search for the placing of each new element?

go read a book then.

It's more readable and less code, but "else" gives you an idea of flow.

You would have to re-write the code as follows : if( items[index] >= items[smallerChildIndex] ) //Notice the change in the binary operator from < to >= { swap(index, smallerChildIndex); } index = smallerChildIndex;

I don't think so

Me neither. haha I guess I wasn't paying too much attention.