In [1]:

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

Initial Heap Positions¶

We leave the initial index (0) empty to make indexing easier.

In [2]:

vector<int> heap{-1, 13,14,16,24,21,17,19,65,26,32,21};
heap

Out[2]:

{ -1, 13, 14, 16, 24, 21, 17, 19, 65, 26, 32, 21 }

In [3]:

unsigned int parent(unsigned int idx) {
    return idx / 2;
}

In [4]:

unsigned int leftChild(unsigned int idx) {
    return 2*idx;
}

In [5]:

unsigned int rightChild(unsigned int idx) {
    return 2*idx + 1;
}

In [6]:

heap[leftChild(1)] // returns value, 1 is the index

Out[6]:

In [7]:

heap[rightChild(1)]

Out[7]:

In [8]:

heap[rightChild(3)]

Out[8]:

Initial Heap Positions¶

Shift things over so that the root of the heap is at index 1. Need to redo the parent, leftChild, rightChild functions.

In [9]:

vector<int> heap{13,14,16,24,21,17,19,65,26,32,23};
heap

Out[9]:

{ 13, 14, 16, 24, 21, 17, 19, 65, 26, 32, 23 }

In [10]:

unsigned int parent(unsigned int idx) {
   return (idx+1) / 2 - 1;
}

In [11]:

unsigned int leftChild(unsigned int idx) {
    return 2*(idx+1) - 1;
}

In [12]:

unsigned int rightChild(unsigned int idx) {
    return 2*(idx+1) + 1 - 1;
}

In [13]:

heap[leftChild(0)]

Out[13]:

In [14]:

heap[rightChild(0)]

Out[14]:

In [15]:

heap[rightChild(2)]

Out[15]:

Inserting Values¶

In [16]:

heap.push_back(5);
heap

Out[16]:

{ 13, 14, 16, 24, 21, 17, 19, 65, 26, 32, 23, 5 }

In [ ]:

// be careful: this doesn't check that the parentIdx is valid!
// causes a segfault!
unsigned int newIdx = heap.size() - 1;
unsigned int parentIdx = parent(newIdx);
while (heap[newIdx] < heap[parentIdx]) {
    swap(heap[parentIdx], heap[newIdx]);
    newIdx = parentIdx;
    parentIdx = parent(newIdx);
}

In [17]:

void insert(vector<int> & heap, int val) {
    heap.push_back(val);
    
    unsigned int newIdx = heap.size() - 1;
    unsigned int parentIdx = parent(newIdx);
    while (newIdx > 0 && heap[newIdx] < heap[parentIdx]) {
        swap(heap[parentIdx], heap[newIdx]);
        newIdx = parentIdx;
        parentIdx = parent(newIdx);
    }
}

In [18]:

vector<int> heap{13,14,16,24,21,17,19,65,26,32,23};

In [19]:

insert(heap, 5)

In [20]:

heap

Out[20]:

{ 5, 14, 13, 24, 21, 16, 19, 65, 26, 32, 23, 17 }

Find Minimum¶

In [22]:

int findMin(vector<int> & heap) {
    return heap[0];
}

In [23]:

int minVal = findMin(heap);
minVal

Out[23]:

Delete Min¶

In [26]:

void minDelete(vector<int> & heap) {
    heap[0] = heap.back();
    heap.pop_back();

    unsigned int curIdx = 0;
    unsigned int leftIdx = leftChild(curIdx);
    unsigned int rightIdx = rightChild(curIdx);
    // be careful we don't go over the size of tree
    while ((leftIdx < heap.size() && heap[curIdx] > heap[leftIdx]) 
            || (rightIdx < heap.size() && heap[curIdx] > heap[rightIdx])) {
        if (rightIdx >= heap.size() || heap[leftIdx] < heap[rightIdx]) {
            swap(heap[curIdx], heap[leftIdx]);
            curIdx = leftIdx;
        } else {
            swap(heap[curIdx], heap[rightIdx]);
            curIdx = rightIdx;
        }
        leftIdx = leftChild(curIdx);
        rightIdx = rightChild(curIdx);
    }
}

In [27]:

minDelete(heap);
heap

Out[27]:

{ 13, 14, 16, 24, 21, 17, 19, 65, 26, 32, 23 }

In [28]:

minDelete(heap);
heap

Out[28]:

{ 14, 21, 16, 24, 23, 17, 19, 65, 26, 32 }

Heap Sort¶

Try to do this in-place. For you to implement.

Will need to use a max-heap
The "end" of the heap changes as you fill in the sorted values.

In [ ]: