Implement A Binary Heap - An Efficient Implementation of The Priority Queue ADT (Abstract Data Type) 

I don't see the code in the description or a link to it. Am I blind or is it gone?

The repository is deprecated - we only maintain backtobackswe.com now

@@BackToBackSWE So it's not free anymore?

where can i find c++ code... and I don't find any code in description

@@Rhythmswithruby public class Solution { /* A min heap implementation Array Form: [ 5, 7, 6, 10, 15, 17, 12 ] Complete Binary Tree Form: 5 / \ 7 6 / \ / \ 10 15 17 12 Mappings: Parent -> (childIndex - 1) / 2 Left Child -> 2 * parentIndex + 1 Right Child -> 2 * parentIndex + 2 */ private static class MinHeap { private int capacity = 5; private int heap[]; private int size; public MinHeap() { heap = new int[capacity]; } public boolean isEmpty() { return size == 0; } public int peek() { if (isEmpty()) { throw new NoSuchElementException("Heap is empty."); } return heap[0]; } public int remove() { if (isEmpty()) { throw new NoSuchElementException("Heap is empty."); } /* -> Grab the min item. It is at index 0. -> Move the last item in the heap to the "top" of the heap at index 0. -> Reduce size. */ int minItem = heap[0]; heap[0] = heap[size - 1]; size--; /* Restore the heap since it is very likely messed up now by bubbling down the element we swapped up to index 0 */ heapifyDown(); return minItem; } public void add(int itemToAdd) { ensureExtraCapacity(); /* -> Place the item at the bottom, far right, of the conceptual binary heap structure -> Increment size */ heap[size] = itemToAdd; size++; /* Restore the heap since it is very likely messed up now by bubbling up the element we just put in the last empty position of the conceptual complete binary tree */ siftUp(); } /*********************************** Heap restoration helpers ***********************************/ private void heapifyDown() { /* We will bubble down the item just swapped to the "top" of the heap after a removal operation to restore the heap */ int index = 0; /* Since a binary heap is a complete binary tree, if we have no left child then we have no right child. So we continue to bubble down as long as there is a left child. A non-existent left child immediately tells us that a right child does not exist. */ while (hasLeftChild(index)) { /* By default assume that left child is smaller. If a right child exists see if it can overtake the left child by being smaller */ int smallerChildIndex = getLeftChildIndex(index); if (hasRightChild(index) && rightChild(index) < leftChild(index)) { smallerChildIndex = getRightChildIndex(index); } /* If the item we are sitting on is < the smaller child then nothing needs to happen & sifting down is finished. But if the smaller child is smaller than the node we are holding, we should swap and continue sifting down. */ if (heap[index] < heap[smallerChildIndex]) { break; } else { swap(index, smallerChildIndex); } // Move to the node we just swapped down index = smallerChildIndex; } } // Bubble up the item we inserted at the "end" of the heap private void siftUp() { /* We will bubble up the item just inserted into to the "bottom" of the heap after an insert operation. It will be at the last index so index 'size' - 1 */ int index = size - 1; /* While the item has a parent and the item beats its parent in smallness, bubble this item up. */ while (hasParent(index) && heap[index] < parent(index)) { swap(getParentIndex(index), index); index = getParentIndex(index); } } /************************************************ Helpers to access our array easily, perform rudimentary operations, and manipulate capacity ************************************************/ private void swap(int indexOne, int indexTwo) { int temp = heap[indexOne]; heap[indexOne] = heap[indexTwo]; heap[indexTwo] = temp; } // If heap is full then double capacity private void ensureExtraCapacity() { if (size == capacity) { heap = Arrays.copyOf(heap, capacity * 2); capacity *= 2; } } private int getLeftChildIndex(int parentIndex) { return 2 * parentIndex + 1; } private int getRightChildIndex(int parentIndex) { return 2 * parentIndex + 2; } private int getParentIndex(int childIndex) { return (childIndex - 1) / 2; } private boolean hasLeftChild(int index) { return getLeftChildIndex(index) < size; } private boolean hasRightChild(int index) { return getRightChildIndex(index) < size; } private boolean hasParent(int index) { return index != 0 && getParentIndex(index) >= 0; } private int leftChild(int index) { return heap[getLeftChildIndex(index)]; } private int rightChild(int index) { return heap[getRightChildIndex(index)]; } private int parent(int index) { return heap[getParentIndex(index)]; } } }

hey

@@BackToBackSWE hey have one question. What would be time complexity (both iterative and recursive) for verifying/building a general K-ary max heap (not just binary but for ternary and so forth)?

If not the best

well, you do realise you are visiting this topic not the first time?

Well getting a PhD doesn't really correlate with how well you can explain a simple-data structure

hahahahhaha, thanks for noticing the details. Yeah each video takes from 4-6 hours from shooting to editing.

haha im not that skilled

sure

ye

Happy Holidays 🎉 Thank you for your kind words, MarkRosenthal! We'd love to offer you a 40% Off our exclusive lifetime membership just use the code CHEER40 - backtobackswe.com/checkout?plan=lifetime-legacy&discount_code=CHEER40

sure

thanks and thanks

thx - wish u the best

nice

thanks wish u the best!

Glad to hear that! Subscribe to our DSA course for some amazing content with a flat 30% discount b2bswe.co/3HhvIlV

Sure

Nice, sure, workin' on it

hey

sure

ye

lol ok

sure.

Glad to hear that!

Subscribe to our DSA course with a flat 30% discount for some amazing content b2bswe.co/3HhvIlV

I got u, thx 4 watching

sure

thanks

thanks and ok

thanks

great

great

thanks thanks

Thanks and no I don't, I had/have a mission and it has nothing to do with me. And yeah, I reply to everyone. And sure.

ye

hi

lol

sure

thanks and ok

lol, I don't think it is a real word

@@BackToBackSWE in python standard library: heapq.heapify(x) is a thing. :)

@@neurochannels nice

Yeah...something out of a spell from Harry Potter

thx - you instructor is probably giving an effort though

@@BackToBackSWE yes ofcourse, he is trying his best but still you are kinda better

no im a fan of u

thanks and ok

Thanks. The ADT is priority queue and the heap is the data structure, see en.wikipedia.org/wiki/Priority_queue#Implementation

I ran out of playlists on my channel. Wish I could.

@@han-shuchang4897 haha

Thank you, glad you liked it 😀 Do check out backtobackswe.com/platform/content and please recommend us to your family and friends 😀

I'm fine and thanks

hola

Thank you, We have complete course on our platform 😀 Do check out backtobackswe.com/platform/content and please recommend us to your family and friends 😀

Happy Holidays 🎉 Thank you for your kind words, Rheya! We'd love to offer you a 40% Off our exclusive lifetime membership just use the code CHEER40 - backtobackswe.com/checkout?plan=lifetime-legacy&discount_code=CHEER40

Thanks Terry

thank you!

thanks null

thanks and the repository is deprecated - we only maintain backtobackswe.com now.

lmao, comment of the year

thx

sure

Thank you, glad you liked it 😀 Do check out backtobackswe.com/platform/content and please recommend us to your family and friends 😀

ok

sure and great. "Am i right when say that min heap guarantees only and only 'every node is lower than its two children'?" Yes, any child will be >= than its given parent. No guarantees on level consistency.

@@BackToBackSWE Ok, got it, thanks!

sure

great to hear.

sure

Glad it was helpful

thanks and the respository is deprecated - we only maintain backtobackswe.com now.

No breadth first search, the heap will be encoded into an array. View the heap sort video.

No need. Just tell people about us.

What are the use cases? And what do you mean by tree set? The Java implementation of the Set ADT?

lol

sure