The following content is provided
under a Creative Commons license.
Your support will help MIT OpenCourseWare continue
to offer high-quality educational resources for free.
To make a donation or view additional materials
from hundreds of MIT courses, visit MIT OpenCourseWare
at ocw.mit.edu.
PROFESSOR: Continuing in the theme
of sorting in general, but in particular, binary search
trees, which are a kind of way of doing
dynamic sorting, if you will, where
the elements are coming and going.
And at all times, you want to know the sorted order
of your elements by storing them in a nice binary search tree.
Remember, in general, a binary search tree is a tree.
It's binary, and it has the search property.
Those three things.
This is a rooted binary tree.
It has a root.
It's binary, so there's a left child and a right child.
Some nodes lack a right or left child.
Some nodes lack both.
Every node has a key.
This is the search part.
You store key in every node, and you have this BST property,
or also called the search property,
that every node-- if you have a node the stores key x,
everybody in the left subtree stores a key that's less than
or equal to x, and everyone that's in the right subtree
stores a key that's greater than or equal to x.
So not just the left and right children,
but every descendant way down there is smaller than x.
Every descendent way down there is greater than x.
So when you have a binary search tree like this,
if you want to know the sorted order,
you do what's called an in-order traversal.
You look at a node.
You recursively visit the left child.
Then you print out the root.
Then you recursively visit the right child.
So in this case, we'd go left, left, print 11.
Print 20.
Go right.
Go left.
Print 26.
Print 29.
Go up.
Print 41.
Go right.
Print 50.
Print 65.
Then check that's in sorted order.
If you're not familiar with in-order traversal,
look at the textbook.
It's a very simple operation.
I'm not going to talk about it more here,
except we're going to use it.
All right, we'll get to the topic of today's lecture
in a moment, which is balance.
What we saw in last lecture and recitation
is that these basic binary search
trees, where when you insert a node you just walk down
the tree to find where that item fits-- like if you're trying
to insert 30, you go left here, go right here, go right here,
and say, oh 30 fits here.
Let's put 30 there.
If you keep doing that, you can do insert.
You can do delete.
You can do these kinds of searches,
which we saw, finding the next larger element
or finding the next smaller element, also known
as successor and predecessor.
These are actually the typical names for those operations.
You can solve them in order h time.
Anyone remember what h was?
The height.
Yeah, good.
The height of the tree.
So h is the height of the BST.
What is the height of the tree?
AUDIENCE: [INAUDIBLE].
PROFESSOR: Sorry?
AUDIENCE: [INAUDIBLE].
PROFESSOR: Log n?
Log n would be great, but not always.
So this is the issue of being balance.
So in an ideal world, your tree's
going to look something like this.
I've drawn this picture probably the most in my academic career.
This is a nice, perfectly balanced binary search tree.
The height is log n.
This would be the balance case.
I mean, roughly log n.
Let's just put theta to be approximate.
But as we saw at the end of last class,
you can have a very unbalanced tree, which is just a path.
And there the height is n.
What's the definition of height?
That's actually what I was looking for.
Should be 6.042 material.
Yeah?
AUDIENCE: Is it the length of the longest path
always going down?
PROFESSOR: Yeah, length of the longest path always going down.
So length of the longest path from the root to some leaf.
That's right.
OK, so this is--
I highlight this because we're going
to be working a lot with height today.
All that's happening here, all of the paths are length log n.
Here, there is a path of length n.
Some of them are shorter, but in fact, the average path
is n over 2.
It's really bad.
So this is very unbalanced.
I'll put "very."
It's not a very formal term, but that's
like the worst case for BSTs.
This is good.
This does have a formal definition.
We call a tree balanced if the height is order log n.
So you're storing n keys.
If your height is always order log n,
we get a constant factor here.
Here, it's basically exactly log n, 1 times log n.
It's always going to be at least log n,
because if you're storing n things in a binary tree,
you need to have height at least log n.
So in fact, it will be theta log n if your tree is balanced.
And today's goal is to always maintain
that your trees are balanced.
And we're going to do that using the structure
called AVL trees, which I'll define in a moment.
They're the original way people found
to keep trees balanced back in the '60s,
but they're still kind of the simplest.
There are lots of ways to keep a tree balanced,
so I'll mention some other balance trees later on.
In particular, your textbook covers two other ways to do it.
It does not cover AVL trees, so pay attention.
One more thing I wanted to define.
We talked about the height of the tree,
but I'd also like to talk about the height of a node in a tree.
Can anyone define this for me?
Yeah?
AUDIENCE: It's the level that the node is at.
PROFESSOR: The level that the node is at.
That is roughly right.
I mean, that is right.
It's all about, what is the level of a node?
AUDIENCE: Like how many levels of children it has.
PROFESSOR: How many levels of children it has.
That's basically right, yeah.
AUDIENCE: The distance from it to the root.
PROFESSOR: Distance from it to the root.
That would be the depth.
So depth is counting from above.
Height is--
AUDIENCE: [INAUDIBLE].
PROFESSOR: Yes, longest path from that node to the leaf.
Note that's why I wrote this definition actually,
to give you a hint.
Here I should probably say down to be precise.
You're not allowed to go up in these paths.
[INAUDIBLE]
All right.
Sorry.
I've got to learn how to throw.
All right.
So for example, over here I'm going to write depths in red.
If you're taking notes it's OK.
Don't worry.
So length off the longest path from it down to a leaf.
Well, this is a leaf, so its height is 0.
OK.
Yeah, I'll just leave it at that.
It takes 0 steps to get from a leaf to a leaf.
This guy's not a leaf.
It has a child, but it has a path of length one to a leaf.
So it's one.
This guy has a choice.
You could go left and you get a path of length 1,
or you could go right and get a path of length 2.
We take the max, so this guy has height 2.
This node has height 1.
This node has height 3.
How do you compute the height of a node?
Anyone?
Yeah.
AUDIENCE: Max of the height of the children plus 1.
PROFESSOR: Right.
You take the max of the height of the children.
Here, 2 and 1.
Max is 2.
Add 1.
You get 3.
So it's going to always be-- this is just a formula.
The height of the left child maxed
with the height of the right child plus 1.
This is obviously useful for computing.
And in particular, in lecture and recitation
last time, we saw how to maintain
the size of every tree using data structure augmentation.
Data structure augmentation.
And then we started with a regular vanilla binary search
tree, and then we maintained-- every time
we did an operation on the tree, we also
updated the size of the subtree rooted
at that node, the size field.
Here, I want to store a height field,
and because I have this nice local rule that tells me
how to compute the height of a node using just
local information-- the height of its left child, the height
of its right child.
Do a constant amount of work here.
There's a general theorem.
Whenever you have a nice local formula
like this for updating your information in terms
of your children, then you can maintain
it using constant overhead.
So we can store the height of every node for free.
Why do I care?
Because AVL trees are going to use the heights of the nodes.
Our goal is to keep the heights small.
We don't want this.
We want this.
So a natural thing to do is store the heights.
When they get too big, fix it.
So that's what we're going to do.
Maybe one more thing to mention over here for convenience.
Leaves, for example, have children that are-- I mean,
they have null pointers to their left and right children.
You could draw them explicitly like this.
Also some nodes just lack a single child.
I'm going to define the depths of these things
to be negative 1.
This will be convenient later on.
Why negative 1?
Because then this formula works.
You can just think about it.
Like leaves, for example, have two children,
which are negative 1.
You take the max.
You add 1.
You get 0.
So that just makes things work out.
We don't normally draw these in the pictures,
but it's convenient that I don't have to do special cases when
the left child doesn't exist and the right child doesn't exist.
You could either do special cases
or you could make this definition.
Up to you.
OK.
AVL trees.
So the idea with an AVL tree is the following.
We'd like to keep the height order log n.
It's a little harder to think about keeping the height order
log n than it is to think about keeping the tree balance,
meaning the left and right sides are more or less equal.
In this case, we're going to think about them
as being more or less equal in height.
You could also think about them being
more or less equal in subtree size.
That would also work.
It's a different balanced search tree.
Height is kind of the easiest thing to work with.
So if we have a node, it has a left subtree.
It has a right subtree, which we traditionally
draw as triangles.
This subtree has a height.
We'll call it HL for left.
By the height of the subtree, I mean the height of its root.
And the right subtree has some height, r.
I've drawn them as the same, but in general they
might be different.
And what we would like is that h sub l and h
sub r are more or less the same.
They differ by at most an additive 1.
So if I look at h sub l minus h sub r in absolute value,
this is at most 1, for every node.
So I have some node x.
For every node x, I want the left and right subtrees
to be almost balanced.
Now, I could say differ by at most 0,
that the left and right have exactly the same heights.
That's difficult, because that really
forces you to have exactly the perfect tree.
And in fact, it's not even possible for odd n or even n
or something.
Because at the very end you're going
to have one missing child, and then you're unbalanced there.
So 0's just not possible to maintain,
but 1 is almost as good, hopefully.
We're going to prove that in a second.
And it turns out to be easy to maintain in log n time.
So let's prove some stuff.
So first claim is that AVL trees are balanced.
Balanced, remember, means that the height of them
is always order log n.
So we're just going to assume for now that we can somehow
achieve this property.
We want to prove that it implies that the height is
at most some constant times log n.
We know it's at least log n, but also
like it to be not much bigger.
So what do you think is the worst case?
Say I have n nodes.
How could I make the tree as high as possible?
Or conversely, if I have a particular height,
how could I make it have as few nodes as possible?
That'd be like the sparsest, the least balanced
situation for AVL trees.
Yeah?
AUDIENCE: You could have one node on the last level.
PROFESSOR: One node on the last level, yeah, in particular.
Little more.
What do the other levels look like?
That is correct, but I want to know the whole tree.
It's hard to explain the tree, but you
can explain the core property of the tree.
Yeah?
AUDIENCE: [INAUDIBLE].
PROFESSOR: For every node, let's make
the right side have a height of one larger than the left side.
I think that's worth a cushion.
See if I can throw better.
Good catch.
Better than hitting your eye.
So I'm going to not prove this formally,
but I think if you stare at this long enough it's
pretty obvious.
Worst case is when-- there are multiple worst cases,
because right and left are symmetric.
We don't really care.
But let's say that the right subtree
has height one more than the left for every node.
OK, this is a little tricky to draw.
Not even sure I want to try to draw it.
But you basically draw it recursively.
So, OK, somehow I've figured out this
where the height difference here is 1.
Then I take two copies of it.
It's like a fractal.
You should know all about fractals by now.
Problem set two.
And then you just-- well, that's not quite right.
In fact, I need to somehow make this one a little
bit taller and then glue these together.
Little tricky.
Let's not even try to draw the tree.
Let's just imagine this is possible.
It is possible.
And instead, I'm going to use mathematics
to understand how high that tree is.
Or actually, it's a little easier
to think about-- let me get this right.
It's so easy that I have to look at my notes
to remember what to write.
Really, no problem.
All right, so I'm going to define n sub h
is the minimum number of nodes that's
possible in an AVL tree of height h.
This is sort of the inverse of what we care about,
but if we can solve the inverse, we can solve the thing.
What we really care about is, for n nodes, how large
can the height be?
We want to prove that's order log n.
But it'll be a lot easier to think about the reverse, which
is, if I fix the height to be h, what's the fewest nodes
that I can pack in?
Because for the very unbalanced tree, I have a height of n,
and I only need to put n nodes.
That would be really bad.
What I prefer is a situation like this, where with height h,
I have to put in 2 to the h nodes.
That would be perfect balance.
Any constant to the h will do.
So when you take the inverse, you get a log.
OK, we'll get to that in a moment.
How should we analyze n sub h?
I hear something.
Yeah?
AUDIENCE: [INAUDIBLE] 2 to the h minus 1 [INAUDIBLE].
PROFESSOR: Maybe, but I don't think that will quite work out.
Any-- yeah?
AUDIENCE: So you have only 1 node in the last level,
so it would be 1/2 to the h plus 1.
PROFESSOR: That turns out to be approximately correct,
but I don't know where you got 1/2 to the h plus 1.
It's not exactly correct.
I'll tell you that, so that your analysis isn't right.
It's a lot easier.
You guys are worried about the last level
and actually what the tree looks like, but in fact, all you need
is this.
All you need is love, yeah.
AUDIENCE: [INAUDIBLE].
PROFESSOR: No, it's not a half.
It's a different constant.
Yeah?
AUDIENCE: Start with base cases and write a recursive formula.
PROFESSOR: Ah, recursive formula.
Good.
You said start with base cases.
I always forget that part, so it's good that you remember.
You should start with the base case,
but I'm not going to worry about the base case
because it won't matter.
Because I know the base case is always going to be n order 1
is order 1.
So for algorithms, that's usually all
you need for base case, but it's good that you think about it.
What I was looking for is recursive formula,
aka, recurrence.
So can someone tell me-- maybe even you-- could tell me
a recurrence for n sub h, in terms of n sub smaller h?
Yeah?
AUDIENCE: 1 plus [INAUDIBLE].
PROFESSOR: 1 plus n sub h minus 1.
Not quite.
Yeah?
AUDIENCE: N sub h minus 1 plus n sub h minus 2.
PROFESSOR: N plus-- do you want the 1 plus?
AUDIENCE: I don't think so.
PROFESSOR: You do.
It's a collaboration.
To combine your two answers, this
should be the correct formula.
Let me double check.
Yes, whew.
Good.
OK, why?
Because the one thing we know is that our tree looks like this.
The total height here is h.
That's what we're trying to figure out.
How many nodes are in this tree of height h?
Well, the height is the max of the two directions.
So that means that the larger has height h minus 1,
because the longest path to a leaf
is going to be down this way.
What's the height of this?
Well, it's one less than the height of this.
So it's going to be h minus 2.
This is where the n sub h minus 1 plus n sub h minus 2 come in.
But there's also this node.
It doesn't actually make a big difference in this recurrence.
This is the exponential part.
This is like itty bitty thing.
But it matters for the base case is pretty much
where it matters.
Back to your base case.
There's one guy here, plus all the nodes on the left,
plus all the nodes on the right.
And for whatever reason, I put the left
over here and the right over here.
And of course, you could reverse this picture.
It doesn't really matter.
You get the same formula.
That's the point.
So this is the recurrence.
Now we need to solve it.
What we would like is for it to be exponential,
because that means there's a lot of nodes in a height h AVL
tree.
So any suggestions on how we could figure out
this recurrence?
Does it look like anything you've seen before?
AUDIENCE: Fibonacci.
PROFESSOR: Fibonacci.
It's almost Fibonacci.
If I hid this plus 1, which you wanted to do,
then it would be exactly Fibonacci.
Well, that's actually good, because in particular, n sub h
is bigger than Fibonacci.
If you add one at every single level,
the certainly you get something bigger
than the base Fibonacci sequence.
Now, hopefully you know Fibonacci is exponential.
I have an exact formula.
If you take the golden ratio to the power h, divide by root 5,
and round to the nearest integer,
you get exactly the Fibonacci number.
Crazy stuff.
We don't need to know why that's true.
Just take it as fact.
And conveniently phi is bigger than 1.
You don't need to remember what phi
is, except it is bigger than 1.
And so this is an exponential bound.
This is good news.
So I'll tell you it's about 1.618.
And so we get is that-- if we invert this,
this says n sub h is bigger than some phi to the h.
This is our n, basically.
What we really want to know is how
h relates to n, which is just inverting this formula.
So we have, on the other hand, the phi
to the h divided by root 5 is less than n.
So I got a log base phi on both sides.
Seems like a good thing to do.
This is actually quite annoying.
I've got h minus a tiny little thing.
It's less than log base phi of n.
And I will tell you that is about 1.440 times log base 2
of n, because after all, log base 2 is what computer
scientists care about.
So just to put it into perspective.
We want it to be theta log base 2 of n.
And here's the bound.
The height is always less than 1.44 times log n.
All we care about is some constant,
but this is a pretty good constant.
We'd like one.
There are binary search tress that achieve 1, plus very,
very tiny thing, arbitrarily tiny, but this is pretty good.
Now, if you don't know Fibonacci numbers,
I pull a rabbit out of a hat and I've got this phi to the h.
It's kind of magical.
There's a much easier way to analyze this recurrence.
I'll just tell you because it's good to know but not
super critical.
So we have this recurrence, n sub h.
This is the computer scientist way to solve the recurrence.
We don't care about the constants.
This is the theoretical computer scientist
way to solve this recurrence.
We don't care about constants.
And so we say, aw, this is hard.
I've got n sub h minus 1 and n sub h minus 2.
So asymmetric.
Let's symmetrify.
Could I make them both n sub h minus 1.
Or could I make them both n sub h minus 2?
Suggestions?
AUDIENCE: [INAUDIBLE].
PROFESSOR: Minus 2 is the right way
to go because I want to know n sub h is greater than something
in order to get a less than down here.
By the way, I use that log is monatomic here,
but it is, so we're good.
So this is going to be greater than 1
plus 2 times n sub h minus 2.
Because if I have a larger height
I'm going to have more nodes.
That's an easy proof by induction.
So I can combine these into one term.
It's simpler.
I can get rid of this 1 because that only makes things bigger.
So I just have this.
OK, now I need a base case, but this
looks like 2 the something.
What's the something?
H over 2.
So I'll just write theta to avoid the base case.
2 to the h over 2.
Every two steps of h, I get another factor of 2.
So when you invert and do the log,
this means that h is also less than log base 2 of n.
Log base 2 because of that.
Factor 2 out here because of that factor 2
when you take the log.
And so the real answer is 1.44.
This is the correct-- this is the worst case.
But it's really easy to prove that it's, at most, 2 log n.
So keep this in mind in case we ask
you to analyze variance of AVL trees,
like in problem set three.
This is the easy way to do it and just get
some constant times log n.
Clear?
All right, so that's AVL trees, why they're balanced.
And so if we can achieve this property,
that the left and right subtrees have about the same height,
we'll be done.
So how the heck do we maintain that property?
Let's go over here.
Mobius trees are supposed to support
a whole bunch of operations, but in particular, insert
and delete.
I'm just going to worry about insert today.
Delete is almost identical.
And it's in the code that corresponds to this lecture,
so you can take a look at it.
Very, very similar.
Let's start with insert.
Well, it's pretty straightforward.
Our algorithm is as follows.
We do the simple BST insertion, which we already saw,
which is you walk down the tree to find where that key fits.
You search for that key.
And wherever it isn't, you insert a node there,
insert a new leaf, and add it in.
Now, this will not preserve the AVL property.
So the second step is fix the AVL property.
And there's a nice concise description of AVL insertion.
Of course, how do you do step two is the interesting part.
All right, maybe let's start with an example.
That could be fun.
Hey, look, here's an example.
And to match the notes, I'm going
to do insert 23 as a first example.
OK, I'm also going to annotate this tree a little bit.
So I said we store the heights, but what
I care about is which height is larger, the left or the right.
In fact, you could just store that,
just store whether it's plus 1, minus 1,
or 0, the difference between left and right sides.
So I'm going to draw that with a little icon, which
is a left arrow, a descending left arrow if this
is the bigger side.
And this is a right arrow.
This is even.
Left and right are the same.
Here, the left is heavier, or higher, I guess.
Here it's even.
Here it's left.
This is AVL, because it's only one
heavier wherever I have an arrow.
OK, now I insert 23.
23 belongs-- it's less than 41, greater than 20, less than 29,
less than 26.
So it belongs here.
Here's 23, a brand-new node.
OK, now all the heights change.
And it's annoying to draw what the heights are,
but I'll do it.
This one changes to 1.
This is 0.
This changes to 2.
This changes to 3.
This changes to 4.
Anyway, never mind what the heights are.
What's bad is, well, this guy's even.
This guy's left heavy.
This guy's now doubly left heavy.
Bad news.
OK, let's not worry about above that.
Let's just start.
The algorithm is going to walk up the tree
and say, oh, when do I get something bad?
So now I have 23, 26, 29 in a path.
I'd like to fix it.
Hmm, how to fix it?
I don't think we know how to fix it, so I will tell you how.
Actually, I wasn't here last week.
So did we cover rotations?
AUDIENCE: No.
PROFESSOR: OK, good.
Then you don't know.
Let me tell you about rotations.
Super cool.
It's just a tool.
That's x and y.
I always get these mixed up.
So this is called left rotate of x.
OK, so here's the thing we can do with binary search trees.
It's like the only thing you need to know.
Because you've got search in binary search trees
and you've got rotations.
So when I have a tree like this, I've highlighted two nodes,
and then there's the children hanging off of them.
Some of these might be empty, but they're trees,
so we draw them as triangles.
If I just do this, which is like changing
which is higher, x or y, and whatever the parent of x was
becomes the parent of y.
And vice versa, in fact.
The parent of y was x, and now the parent of x is y.
OK, the parent of a is still x.
The parent of b changes.
It used to be y.
Now it's x.
The parent of c was y.
It's still y.
So in a constant number of pointer changes,
I can go from this to this.
This is constant time.
And more importantly, it satisfies the BST order
property.
If you do an in-order traversal of this,
you will get a, x, b, y, c.
If I do an in-order traversal over here, I get a, x, b, y, c.
So they're the same.
So it still has BST ordering.
You can check more formally.
b has all the nodes between x and y.
Still all the nodes between x and y, and so on.
You can check it at home, but this works.
We call it a left rotate because the root moves to the left.
You can go straight back where you came from.
This would be a right rotate of y.
OK, it's a reversible operation.
It lets you manipulate the tree.
So when we have this picture and we're
really sad because this looks like a mess, what
we'd like to do is fix it.
This is a path of three nodes.
We'd really prefer it to look like this.
If we could make that transformation, we'd be happy.
And we can.
It is a right rotate of 29.
So that's what we're going to do.
So let me quickly copy.
I want to rotate 29 to the right, which
means 29 and 26-- this is x.
This is y.
I turn them, and so I get 26 here now,
and 29 is the new right child.
And then whatever was the left child
of x becomes the left child of x in the picture.
You can check it.
So this used to be the triangle a.
And in this case, it's just the node 23.
And we are happy.
Except I didn't draw the whole tree.
Now we're happy because we have an AVL tree again.
Good news.
So just check.
This is even.
This is right heavy.
This is even.
This is left heavy still.
This is left heavy, even, even, even.
OK, so now we have an AVL tree and our beauty is restored.
I'll do one more example.
Insert 55.
We want to insert 55 here.
And what changes is now this is even.
This is right heavy.
This is doubly left heavy.
We're super sad.
And then we don't look above that until later.
This is more annoying, because you
look at this thing, this little path.
It's a zigzag path, if you will.
If I do a right rotation where this is x and this
is y, what I'll get is x, y, and then this is b.
This is what's in between x and y.
And so it'll go here.
And now it's a zag zig path, which is no better.
The height's the same.
And we're sad.
I told you, though, that somehow rotations
are all we need to do.
What can I do?
How could I fix this little zigzag?
Just need to think about those three nodes,
but all I give you are rotations.
AUDIENCE: Perhaps rotate 50.
PROFESSOR: Maybe rotate 50.
That seems like a good idea.
Let's try it.
If you don't mind, I'm just going to write 41,
and then there's all the stuff on the left.
Now we rotate 50.
So 65 remains where it is.
And we rotate 50 to the left.
So 50 and its child.
This is x.
This is y.
And so I get 55 and I get 50.
Now, this is bad from an AVL perspective.
This is still doubly left heavy, this is left heavy,
and this is even.
But it looks like this case.
And so now I can do a right rotation on 65,
and I will get-- so let me order the diagrams here.
I do a right rotate on 65, and I will get 41.
And to the right I get 55.
And to the right I get 65.
To the left I get 50.
And then I get the left subtree.
And so now this is even, even, even.
Wow.
How high was left subtree?
I think it's still left heavy.
Cool.
This is what some people call double rotation,
but I like to call it two rotations.
It's whatever you prefer.
It's not really a new operation.
It's just doing two rotations.
So that's an example.
Let's do the general case.
It's no harder.
You might say, oh, gosh, why do you do two examples?
Well, because they were different.
And they're are two cases on the algorithm.
You need to know both of them.
OK, so AVL insert.
Here we go.
Fix AVL property.
I'm just going to call this from the changed node up.
So the one thing that's missing from these examples
is that you might have to do more than two rotations.
What we did was look at the lowest violation of the AVL
property and we fixed it.
When we do that, there's still may
be violations higher up, because when you add a node,
you change the height of this subtree,
the height of this subtree, the height of this subtree,
and the height of this subtree, potentially.
What happened in these cases when I was done,
what I did fixed one violation.
They were all fixed.
But in general, there might be several violations up the tree.
So that's what we do.
Yeah, I'll leave it at that.
So suppose x is the lowest node that is not AVL.
The way we find that node is we start at the node
that we changed.
We check if that's OK.
We update the heights as we go up using our simple rule.
And that's actually not our simple rule, but it's erased.
We update the height based on the heights of its children.
And you keep walking up until you
see, oh, the left is twice, two times-- or not two times,
but plus 2 larger than the left, or vice versa.
Then you say, oh, that's bad.
And so we fix it.
Yeah, question.
AUDIENCE: So here we continue to [INAUDIBLE].
PROFESSOR: Yes.
AUDIENCE: [INAUDIBLE].
add n to the level [INAUDIBLE] than 1.
So add [INAUDIBLE].
PROFESSOR: AVL property's not about levels.
It's about left subtrees and right subtrees.
So the trouble is that 65-- you have a left subtree, which
has height 2-- or sorry, height 1, I guess--
because the longest path from here to a leaf is 1.
The right subtree has height negative 1
because it doesn't exist.
So it's one versus negative 1.
So that's why there's a double arrow.
Yeah, good to ask.
It's weird with the negative 1s.
That's also why I wanted to define those negative 1s to be
there, so the AVL property is easier to state.
Other questions?
All right.
Good.
I think I want a symmetry assumption here.
I don't know why I wrote right of x.
I guess in modern days we write x dot right.
Same thing.
OK, I'm going to assume that the right child is the heavier
one like we did before.
Could be the left.
It's symmetric.
It doesn't matter.
So now there are two cases, like I said.
I'm going to use this term right heavy
because it's super convenient.
OK, right heavy is what I've been
drawing by a descending right arrow.
Balance is what I've been drawing by a horizontal line.
OK, so we're just distinguishing between these two cases.
This turns out to be the easy case.
So we have x, y, a, b, c.
Why are we looking at the right child?
Because we assumed that the right one is higher, so that x
was right heavy.
So this subtree as I've drawn it is higher than the left one
by 2, in fact.
And what we do in this case is right rotate of x.
And so we get x, y, a, b, c.
I could have drawn this no matter what case we're in,
so we need to check this actually works.
That's the interesting part.
And that's over here.
OK, so I said x is right heavy, in fact doubly so.
y is either right heavy or balanced.
Let's start with right heavy.
So when we do this rotation, what happens to the heights?
Well, it's hard to tell.
It's a lot easier to think about what the actual heights are
than just these arrows.
So let's suppose x has height k.
That's pretty generic.
And it's right heavy, so that means
the y has height k minus 1.
And then this is right heavy, so this has height k minus 2.
And this is something smaller then k minus 2.
In fact, because this is AVL, we assume
that x was the lowest that is not AVL.
So y is AVL.
And so this is going to be k minus 3,
and this is going to be k minus 3 because these differ by 2.
You can prove by a simple induction you never
get more than 2 out of whack because we're just adding 1,
off by 1.
So we got off by 2.
So this is the bad situation.
Now we can just update the heights over here.
So k minus 3 for a, k minus 3 for b, k minus 2 for c.
Those don't change because we didn't touch those trees,
and height is about going down, not up.
And so this becomes k minus 2, and this becomes k minus 1.
And so we changed the height of the root,
but now you can see that life is good.
This is now balanced between k minus 3 and k minus 3.
This is now balanced between k minus 2 and k minus 2.
And now the parent of y may be messed up,
and that's why after this we go to the parent of y,
see if it's messed up, but keep working our way up.
But it worked.
And in the interest of time, I will not
check the case where y is balanced,
but it works out, too.
And see the notes.
So the other case is where we do two rotations.
And in general, so here x was doubly right heavy.
And the else case is when the right child
of x, which I'm going to call z here, is left heavy.
That's the one remaining situation.
You do the same thing, and you check
that right rotating and left rotating, which
makes the nice picture, which is x, y, z,
actually balances everything and you restore the AVL property.
So again, check the notes on that.
I have a couple minutes left, and instead I'd
like to tell you a little bit about how
this fits into big-picture land.
Two things I want to talk about.
One is you could use this, of course,
to sort, which is, if you want to sort n numbers,
you insert them and you do in-order traversal.
How long does this take?
In-order traversal takes linear time.
That's the sense in which we're storing things in sorted order.
Inserting n items-- well, each insert takes h time,
but now we're guaranteed that h is order log n.
So all the insertions take log n time each, n log n total.
So this is yet another way to sort n items in n log n time,
in some ways the most powerful way.
We've seen heaps, and we've seen merge sort.
They all sort.
Heaps let you do two operations, insert and delete min, which
a lot of times is all you care about, like in p set two.
But these guys, AVL trees, let you
do insert, delete, and delete min.
So they're the same in those senses,
but we have the new operation, which
is that we can do find next larger and next smaller, aka
successor and predecessor.
So you can think about what we call an abstract data type.
These are the operations that you support,
or that you're supposed to support.
If you're into Java, you call this an interface.
But this is an algorithmic specification
of what your data structure is supposed to do.
So we have operations like insert and delete.
We have operations like find the min
and things like successor and predecessor,
or next larger, next smaller.
You can take any subset of these and it's an abstract data type.
Insert, delete, and min is called a priority queue.
So if you just take these first two,
it's called a priority queue.
And there are many priority queues.
This is a generic thing that you might want to do.
And then the data structure on the other side
is how you actually do it.
This is the analog of the algorithm.
OK, this is the specification.
You want a priority queue.
One way to do it is a heap.
Another way to do it is an AVL tree.
You could do it with a sorted array.
You could do lots of sub-optimal things, too,
but in particular, heaps get these two operations.
If you want all three, you basically
need a balanced binary search tree.
There are probably a dozen balanced binary search trees
out there, at least a dozen balanced search trees,
not all binary.
They all achieve log n.
So it doesn't really matter.
There are various practical issues, constant factors,
things like that.
The main reason you prefer a heap is that it's in place.
It doesn't use any extra space.
Here, you've got pointers all over the place.
You lose a constant factor in space.
But from a theoretical standpoint,
if you don't care about constant factors,
AVL trees are really good because they get everything
that we've seen so far and log n.
And I'll stop there.