We can say to build a heap, rooted at this node, make this new heap, make this new heap and then down heapify.

Any leaf, anything that is a leaf already were done. That's our termination condition.

There's a sort of gaping volcanic hole at the top. Whatever will we do to fix this.

What's the running time of Dijkstra in terms of the number of nodes (n) and edges (m) when heaps are used?

Here is the code for up heapify, right now it is blank.

That seems like the sort of things that a heap would be really good at.

As I was describing it before, for each node we do this test to find the shortest distance so far.

We're going to start of at the root, which is node zero and we're going to say, okay, well, to make this into a heap, well first magically make this into a heap and make this into a heap and once we're done then we could do down heapify on this value and everything will be fine.

Down heapify is this notion that we've got.

The algorithm that I have found very useful in practice is to use the selection insertion approach but to use a different data structure than just a list to do the insertions into and that's a heap.

This is a heap. We'll check them off as we go. This is a heap.

Let me show you an example. Here's a balanced binary tree with 20 nodes.

Just looks like a dilapidated heap

Now that you've simulated and simulated the down heapify algorithm on an example and you've seen what the code looks like, tell me what the running time of down heapify would be if you have the heap of size n where the top node might be violating the heap property but it satisfied everyone else.

Given what we have build up so far, we can actually use the pieces to build a heap from scratch.

What if i has two children? So this is some internal node in the tree now. Or possibly a root of a large tree.

So 88 gets swap, this is down heapify 88 gets swap with 30 because 30 is the smaller of the children and now that down heapify is completed this whole thing is a heap.

Well, it would be nice if we had some kind of node someplace that we could fill in here and then maybe down heapify it.

The old boy grasped my hand warmly, and that was all that kept me from hitting the floor in a heap.

Now speaking precisely.

So we delete min, and we insert the new value that we just got into the heap and reestablish the heap property by well, we could do it as a down heapify, actually, because we deleted the node from the top.

The idea is that the new element that we're going to insert we stick at the sort of bottom right corner of the heap.

Notice we didn't use the sort of middle ground at all.

So what's the running time of this going to be?

I've implemented this in the past. It didn't run so fast for me.

Finding the shortest path in a weighted, undirected connected graph took time m times the logarithm of n.

That's the heap property so what that causes is that as we traverse down the tree we're always traversing down the sorted list.

Right. We're satisfied everywhere except for between i and its children, and i doesn't have any children.

Well, let's take it to reduce a lot. Let's take it's reduced all the way to 1.

If we run up heapify on this heap with a pointer to (I), what it's going to do is bubble this small value up as high as it needs to be in the tree.

We apply this in the notion where we've got a heap rooted at node i that satisfies the heap property except perhaps i to its children, to its immediate children.

In this case, with seven nodes and we filled them in with this random two digit numbers and it's not heap at the moment, but we can make the heap property be satisfied and this the way we're going to do it.

This is sometimes called heap sort. You give it a (L).

Or, if the heap was already full, then the far left.

It doesn't do as well a partition at this particular problem of finding the top k, but it actually is pretty useful for bunch of other things as well so let's dive into the whole universe of heaps now.

Then we check each of its neighbors possibly reducing the distance which wasn't a really big deal before, but it actually matters in the heap of limitation because once we reduced the value associated with the node, it needs to maybe be some place different in the heap.

We just run down heapify starting from there. When that's done, we can return.

And I'm going to fill values in here that satisfy the heap property.

So, for each of N times, we do possibly one insert into the heap, which is a log K operation.

We need to do this subtree, again same trick. This guys are already heaps.

How many times can you half (n) before you get down to 1 which is the root?

It's just what we did when we're doing it by hand and then we can return.

To make this into a heap, we have to swap it with the smaller of the children 13.

Alright. How do we build a heap out of this smaller piece? Well, we can do it again recursively.

Let's talk about how we actually will go with this.