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

Down heapify is this notion that we've got.

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

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

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

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

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

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

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.

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

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

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.

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.

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

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

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

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

Just looks like a dilapidated heap

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.

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

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.

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

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

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

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

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

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

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

let's say, we have this one, is suddenly reduced.

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.

The natural place to get that node though is right there. The very last element to the heap.

We can move it to the tippy top and run down heapify.

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

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

The whole thing is a heap. We made a heap. Woohoo!

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

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

In your implementation, the thing you're going to have to really watch out for is making sure that when you update the value of the neighbor, you can find it in the heap.

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.

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.

We'll give you down heapify and the build heap algorithm so that you can take a list, create a heap out of it and then remove the min from it.

Let's look right now at the analysis of the algorithm.

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.

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.

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.