
English: 
Good morning.
It looks like 9:30 is getting
earlier and earlier for
everyone.
Hello to all the people
watching at home.
I think there should be a
requirement that if you're
watching the video,
you can only watch it
9:30-11:00 on Sunday,
or at least start watching then
just so you can all feel our
mornings.
Today, we're going to talk
about balanced search trees.
Now, we've hinted at this for a
while.
Our goal today is to get a
search tree data structure,
so we can insert,
delete, and search all at log n
time for operations.
So, we want a tree that's
guaranteed to be log n in
height.

Korean: 

좋은 아침입니다. 
9:30이 모두에게 점점 더 빨라져 가는 것 같군요. 
집에서 보고 있는 분들도 모두 안녕하세요. 
저는 여러분이 비디오를 보고 있다면, 
일요일 9:30-11:00에 보라는 요구 사항이  
있어야 한다고 생각해요, 
그래야 영상으로 보는 사람도 우리같은 아침을 느낄테니까요.
오늘, 우리는 균형 검색 트리에 대하여 이야기할 것입니다. 
이제, 우리는 잠시 이것에 대해 힌트를 얻을 것입니다. 
오늘 우리의 목표는 검색 트리 데이터 구조를 얻는 것입니다. 
우리는 삽입, 삭제할 수 있고 모든 연산에서 log n 시간에 검색할 수 있습니다. 
그래서, 우리는 높이가 log n으로 보장되는 
트리를 원합니다. 

Korean: 
그것은 균형 검색 트리 데이터 구조입니다.
그리고 우리는 연산을 위해 log n 시 동적인 n개의 인자를 유지할 수 있는 
데이터 구조를 원합니다. 
우리는 오더 log n 높이의 트리를 원합니다. 
이제, 여러분이 가까이 보면,  
우리는 사실 검색 트리 데이터 구조가 무엇인지 정의하지 않았습니다.
우리는 이진 검색 트리 데이터 구조가 무엇인지 정의했습니다,  
그것은 특정한 것입니다.
그것은 우리가 오늘 초점을 맞출 부분입니다. 
금요일에 우리는 

English: 
So, that's a balanced search
tree data structure.
And, we want a data structure
that can maintain a dynamic set
of n elements in log n time for
operation.
So, we'll say,
using a tree of height order
log n.
Now, if you look very closely,
we haven't actually defined
what a search tree data
structure is.
We've defined what a binary
search tree data structure is,
and that's one particular kind.
And that's what we will be
focusing on today.
In recitation on Friday,
we will look at,

English: 
or you will like that,
balanced search trees that are
not necessarily binary.
Each node can have a constant
number of children,
not just two.
So, I'm defining is generally.
You actually see what a search
tree is in the general case
later on.
Today, we will just be focusing
on the binary case.
So, I won't define this yet.
So, there are a lot of
different balanced search tree
data structures.
So, these are the main ones
that I know of.
The first one was AVL trees.
This was invented in 1962.
So, that was the beginning of
fast data structures.
The next three sort of come
together and this is what you
will cover in recitation this
week.
So, these are non binary trees.
Instead of binary,

Korean: 
필수적으로 이진이 아닌 균형 검색 트리를 볼 것입니다.
각 노드는 정수의 자식을 갖습니다, 
단지 2만이 아니라요. 
제가 정의하는 것은 일반적입니다.  
여러분은 사실 나중에 일반적으로 검색 트리가 무엇인지 보게 됩니다.
오늘 우리는 이진 케이스에만 초점을 맞춥니다. 
그래서 이것을 아직 정의하지 않을 겁니다.  
많은 다른 균형 검색 트리 데이터 구조가 있습니다.
이것들은 제가 아는 주요한 것들입니다. 
첫 번째는 AVL 트리입니다. 이것은 1962년에 고안되었습니다. 
그것은 빠른 데이터 구조의 시작입니다. 
다음 세 가지는 같이 있고 
이것은 이번 주 수업에서 보게 될 것입니다.
이것은 이진 트리가 아닙니다. 

English: 
we have maybe binary and
tertiary, or maybe binary and
tertiary, or quaternary,
over a general concept degree,
B.
So, that's another way you can
get balance.
Two-three trees,
which were the second trees to
be invented, they were invented
in 1970 by Hopcroft.
The trees we will cover today
are called red black trees.
These are binary search trees
of guaranteed logarithmic
height.
So then, there's some others.
So, skip lists are ones that we
will cover next week.
It's not exactly a tree,
but it's more or less a tree,
and one that you will see in

Korean: 
이진 대신, 우리는 이진과 삼진, 
또는 아마 이진 삼진 사진 등을 가질 겁니다.
그것은 여러분이 균형을 가질 수 있는 또 다른 방법입니다. 
2-3 트리는, 
두 번째로 고안된 트리이고 Hopcroft에 의해 1970년에 고안되었습니다. 
오늘 다룰 트리는 레드 블랙 트리입니다. 
이것들은 보장된 대수 높이를 가지는  
이진 검색 트리입니다.
다른 것들도 있습니다. 스킵 리스트는 우리가 다음주에 다룰 것입니다. 
그것은 정확히 트리는 아니지만 
트리 이상 혹은 이하의 것입니다, 

Korean: 
여러분이 문제 세트에서 보게 될 것은, 여기서 많이 이야기 하지 않겠습니다.
그것들은 어떤 면에서 더 쉽습니다 왜냐하면 필수적으로 
지난 월요일의 자료에 의존하기 때문입니다. 
월요일에 우리가 랜덤하게 이진 검색 트리를 구축하면, 
그것은 대부분의 시간에 log n 높이를 
가진다는 것을 보았습니다. 
Treeps는 그것을 동적으로 만드는 방법입니다, 
n개의 아이템의 동적 세트를 만드는 대신, 
여러분은 그것들에 삽입 또는 삭제를 할 수 있고 그것들을 효율적으로 
변경할 수 도 있고 트리에 넣을 수도 있습니다.
어떤 면에서, 그것은 가장 쉬운 것입니다. 
그것은 또한 가장 최근의 검색 트리 데이터 구조입니다. 
그것은 1996년에 
Rimon Sidell 과 Aragen에 의해 고안되었습니다. 
그것들은 검색 트리 데이터 구조입니다. 
우리가 이 수업에서 다루지 않는 유일한 트리는 AVL 트리입니다. 
그것들은 너무 어렵지 않습니다. 여러분이 관심 있으면, 

English: 
your problem set this week are
treeps, which I won't talk too
much about here.
But they are in some sense
easier to get because they
essentially just rely on the
material from last Monday.
So, on Monday we saw that if we
just randomly built a binary
search tree, it's going to have
log n height most of the time in
expectation.
So, treeps are a way to make
that dynamic,
so that instead of just having
a static set of n items,
you can insert and delete into
those items and still
effectively randomly permute
them and put them in a tree.
So in some sense,
it's the easiest.
It's also one of the most
recent search tree data
structures.
That was invented in 1996 by a
couple of geometers,
Rimon Sidell and Aragen.
So, those are just some search
tree data structures.
The only ones we will not cover
in this class are AVL trees.
They're not too hard.
If you're interested,

English: 
you should read about them
because they're fun.
I think they are a problem in
the textbook.
OK, but today,
we're going to focus on red
black trees, which is a fairly
simple idea, red black trees.
And, it's a particular way of
guaranteeing this logarithmic
height so that all the
operations can be supported in
log n time.
So, they are binary search
trees.
And, they have a little bit of
extra information in each node
called the color field.

Korean: 
읽어 보세요 재미있습니다. 
그것들은 교재의 문제에도 있을거에요.
오늘 우리는 레드 블랙 트리에 초점을 맞출 것인데, 
그것들은 꽤 간단한 아이디어입니다. 
그리고 이 대수의 높이를 보장하는 특정한 방법입니다 
그래서 모든 연산은 lg n 시간에 수행됩니다. 
그것들은 이진 검색 트리입니다. 
그것들은 컬러 필드라는 각 노드에서 
여분의 정보를 가집니다.

Korean: 
그리고 레드 블랙 트리로 불리기 위해 만족해야 하는  
몇 가지 속성들이 있습니다.
이것들은 레드 블랙 속성들입니다. 
이것은 쓰는데 약간 시간이 걸리지만, 
모두 매우 간단합니다. 
제가 한번 쓰면 저는 그것이 무엇을 의미하는지 말할 수 있습니다. 
4가지 속성이 있어요.
첫 번째는 매우 간단합니다. 모든 노드는 레드 혹은 블랙입니다. 
따라서 레드 블랙 트리의 이름입니다.  
컬러 필드는 레드 또는 블랙을 구체화합니다.
색 분필이 없으므로 
동그라미 두 개로 표시하겠습니다, 
블랙은 동그라미 하나입니다. 
여러분도 컬러 펜이 없을 수 있으므로, 

English: 
And there are several
properties that a tree with a
color field has to satisfy in
order to be called a red black
tree.
These are called the red black
properties.
And, this will take a little
bit of time to write down,
but it's all pretty simple.
So once I write them down I
will just say what they really
mean.
There's four properties.
The first one's pretty simple.
Every node is either red or
black, hence the name of red
black trees.
So, the color field is just a
single bit specifying red or
black.
And red nodes,
I'm going to denote by a double
circle because I don't have
colored chalk here,
and black nodes will be a
single circle.
And you probably don't have

English: 
colored pens either,
so it will save us some grief.
Red is double circle;
black is single circle.
And, we sort of prefer black
nodes in some sense.
Red nodes are a pain,
as we'll see.
OK, second property is that the
root and the leaves are all
black.
And, I'm going to pull a little
trick here.
Treat binary search trees a
little bit differently than we
have in the past.
Normally, you think of the tree
as a bunch of nodes.
Each node could have zero or
one or two children,
something like this.
I'm going to imagine appending
every place where a node does
not have a child.
I'm going to put a little dot
here, an external node,
which I call a leaf.
So, normally leaves would have
been these items.
I'm just going to add to every

Korean: 
이렇게 하세요. 
레드는 동그라미 두 개, 블랙은 하나입니다. 
우리는 블랙 노드를 선호합니다. 
레드는 좀 더 어렵습니다. 
두 번째 속성은 루트와 (노드를 나타내는)잎들이 모두 블랙이라는 겁니다. 
저는 여기서 약간의 트릭을 쓸 것입니다. 
이진 트리를 다루는 것은 예전에 
했던 것과 약간 다릅니다.
보통 우리는 트리를 노드로 다룹니다. 
각 노드는 0 또는 1 또는 2 개의 자식을 가집니다. 
저는 자식을 가지지 않는 
노드들을 상상할 것입니다. 
저는 여기에 점을 넣을 것입니다, 외부 노드, 그것은 리프 노드들입니다.  
보통 리프 노드들은 이 아이템들을 가집니다.
저는 모든 자식 포인터를 더할 것입니다. 

English: 
absent child pointer a leaf.
And, these will be my leaves.
These are really the nil
pointers from each of these
nodes.
So now, every internal node has
exactly two children,
and every leaf has zero
children.
OK, so these are those I'm
referring to.
These are black,
and this guy is black according
to rule two.
Now the properties get a little
bit more interesting.
The parent of every red node is
black.
So, whenever I have a red node,
its parent has to be black,
a single circle.
OK, so in other words,
if you look at a path in the
tree you can never have two red
nodes consecutive.
You can have,
at most, red,
black, red, black.
You can have several black
nodes consecutive,

Korean: 
그리고 이것들은 제 리프 노드들이 될 것입니다. 
이것들은 각 노드들로부터 nil 포인터입니다. 
이제 모든 내부 노드는 정확히 두 자식을 가지고 있고, 
모든 리프 노드는 0 자식을 가집니다.
이것들은 제가 언급하려는 것입니다. 
이것들은 블랙이고, 
두 번째 법칙에 따라 블랙입니다. 
이제 속성은 약간 더 흥미로워집니다. 
각 레드 노드의 부모는 블랙입니다.
제가 레드 노드를 가지는 곳에서, 그것의 부모는 블랙이어야 합니다. 
즉 여러분이 
트리에서 경로를 보면 여러분은 연이은 두 개의 레드 노드를 절대 가질 수 없습니다. 
여러분은 레드 블랙 
레드 블랙을 가집니다. 
여러분은 연이은 몇 개의 블랙 노드를 가질 수 있지만, 

English: 
but never two red nodes.
OK, and then one more rule.
It says a little bit more about
such paths.
So, if we take a simple path,
meaning it doesn't repeat any
vertices from a node,
x, to a descended leaf of x,
all such paths to all
descendant leaves have the same
number of black nodes on them.

Korean: 
두 레드 노드는 안됩니다. 그리고 하나의 법칙이 더 있습니다. 
경로에 대한 것입니다. 
우리가 간단한 경로를 취하면, 
그것은 노드의 축을 반복하지 않습니다, 
모든 경로는 블랙 노트와 같은 
수를 가집니다.

English: 
So, let me draw a picture.
We have some tree.
We have some node,
x, in the tree.
And, I'm looking at all the
paths from x down to some
descendant leaf down here at the
bottom of the tree.
All of these paths should have
the same number of black nodes.
So, here I'll draw that each
one has four black nodes,
the leaf, and three above it.
We know that from property
three, at most,
half of the nodes are red
because whenever I have a red
node, the parent must be black.
But I want all of these paths
to have exactly the same number
of black nodes.
One subtlety here is that the
black height,
I didn't really leave room.
So I'll write it over here.
This should be the same for all

Korean: 
그림을 그려 보겠습니다. 우리는 트리를 가지고 있습니다. 
우리는 트리에서 노드 x를 가지고 있습니다. 
우리는 이 트리에서 x에서 아래로의 
경로를 볼 것입니다. 
모든 경로들은 블랙 노드와 같은 수를 가집니다. 
여기서 저는 하나가 블랙 노드 4개를 가지는 것을 그릴 것입니다. 
세 속성으로부터 노드의 절반은 레드입니다, 
제가 레드 노드를 가질 때마다 
부모는 반드시 블랙이어야 하기 때문입니다.
저는 블랙 노드와 정확히 
같은 수의 경로를 원합니다. 
저는 여기서 공간이 없습니다. 
저는 그것을 여기서 쓸 것입니다. 이것은 모든 경로에 같지만

English: 
paths, but in particular,
the count I'm interested in
does not include x itself.
OK, so if x is black,
I'm only calling the black
height.
So, the black height of x is
this count four.
And even if x is black,
the black height is four.
So, these are just some minor
details to get all of the
algorithms a bit clean.
So, let's look at an example of
a red black tree.
So, yeah, I'll show you an
example.
Then I'll say why we care about
these properties.

Korean: 
특히 x를 포함하지 않는 것에 관심이 있습니다. 
x가 블랙이면, 
저는 블랙의 키만 호출합니다. 
x의 키는 이 4입니다. 
x가 블랙이더라도 키는 4입니다. 
이것들은 사소한 구체적인 것들입니다. 
레드 블랙의 예를 봅시다.
여러분에게 예를 보여주겠습니다. 
우리가 왜 이 속성들에 신경을 
쓰는지 말해줄 것입니다. 

English: 
OK, so this tree has several
properties.
The first thing is that it's a
binary search tree.
OK, and so you can check an [in
order traversal?].
It should give these numbers in
sorted order:
three, seven,
eight, ten, 11,
18, 22, 26.
So, it's a valid binary search
tree.
We've appended these leaves
with no keys in them.
They are just hanging around.
Those are the nil pointers.
So, each of these,
you can call them nil.
They are all just marked there,
wherever there is absent child.
And then, I've double circled
some of the nodes to color them
red.
OK, if I didn't,
the black heights wouldn't
match up.
So, I have to be a little bit
careful.
From every node,
we'd like to measure the number
of black nodes from that node

Korean: 
이것은 몇 가지 속성을 가집니다. 
첫 번째는 이것이 이진 검색 트리라는 것입니다. 
그래서 여러분은 검사할 수 있습니다. 
그것은 정렬된 순서의 수를 줍니다. 
3, 7, 8, 10, 11,
18, 22, 26. 그것은 명백한 이진 검색 트리입니다. 
우리는 키가 없는 이 리프 노드들을 붙입니다. 
그것들은 달려있습니다. 
그것들은 nil 포인터입니다. 
여러분은 그것을 nil이라고 부를 수 있습니다. 
그것들은 저기 모두 표시되어 있습니다. 자식이 없습니다. 
저는 레드를 표시하기 위해 동그라미 두 개를 그렸습니다. 
제가 하지 않았다면, 블랙의 키가 매치 되지 않습니다. 
저는 약간 신중해져야 합니다. 
모든 노드로부터, 
우리는 블랙 노드의 

Korean: 
수를 알고 싶습니다. 예를 들어 
블랙의 높이는 0입니다.
좋아요. 그것은 항상 답입니다. 
이것들은 항상 블랙 높이 0을 가집니다. 
저는 그것을 여기 표시할 것입니다. 
블랙 높이는 0과 같습니다. 3의 블랙 높이는 무엇이죠? 
0인가요? 아닌거 같은데요...이것들이 블랙이기 때문에 
블랙의 높이는 1입니다. 
여러분은 맞습니다. 
그것은 셈에 들어가지 않습니다. 
그러나 리프들은 셉니다. 오직 두 경로가 여기 있습니다. 
그것들은 같은 수의 블랙 노드를 가집니다. 
여기서 8은 또한 블랙은 높이 1을 가집니다  
그것이 레드이더라도요. 
11도 같고 2도 같습니다.
각각은 오직 두 경로만 가집니다. 

English: 
down to any descendent leaf.
So, for example,
the nil pointers,
their black height is zero.
Good.
That's always the answer.
So, these guys always have
black height zero.
I'll just represent that here.
Black height equals zero.
OK, what's the black height of
three?
Zero?
Not quite, because these nodes
are black.
So the black height is one.
You're right that we don't
count three even though it's
black.
It's not included in the count.
But the leaves count.
And there's only two paths
here, and they each have the
same number of black nodes as
they should.
Over here, let's say eight also
has black height one even though
it's red.
OK: same with 11,
same with 26.
Each of them only has two
paths.

Korean: 
각 경로는 하나의 블랙 노드를 갖습니다.
10: 블랙의 높이는 무엇입니까? 여전히 1입니다, 
좋아요. 우리가 10을 세지 않기 때문입니다. 
리프들에 4개의 경로가 있습니다. 
그것들은 각각 정확히 
하나의 블랙 노드를 포함합니다. 
22도 같습니다. 
이것은 점점 더 흥미로워집니다. 
여기 하나의 경로가 있습니다 그것은 블랙 노드를 가집니다. 
여기 더 간 다른 경로들이 있습니다. 
그러나 여전히 하나의 블랙 노드를 가집니다. 
우리가 레드 노드를 무시하면, 
모든 경로는 같은 길이를 갖습니다.
18은 더 커야 합니다, 
각 경로가 여기서 
하나의 블랙 노드를 
갖기 때문입니다.
마지막으로 루트는 높이 2를 가져야 합니다. 
여기서 보기 더 쉽습니다. 
이 패스들은 두 블랙 노드를 가집니다. 

English: 
Each path has one black node on
it.
Ten: what's the black height?
It's still one,
good, because we don't count
ten.
There's now four paths to
leaves.
Each of them contains exactly
one black node,
plus the root,
which we don't count.
22: same thing,
hopefully.
This is getting a little more
interesting.
There's one path here which has
one black node.
There are other paths here,
which are longer.
But they still only have one
black node.
So, if we just sort of ignore
the red nodes,
all these paths have the same
length.
OK: 18 should be bigger
hopefully, black height of two
because each of these paths now
has one black node here,
one black node in leaves,
or one black note here,
and one black node in the
leaves.
And finally,
the root should have a black
height of two.
It's easier to see over here,
I guess.
Each of these paths has two

Korean: 
여기서도 같습니다.
이 모든 속성들은 다 맞습니다. 
우리는 그것들은 전부 검사하지 않았습니다. 모든 레드 노드는 블랙 부모를 가집니다. 
여러분이 경로들을 보면, 
우리는 레드 블랙을 대체할 수 있습니다. 
우리는 또한 많은 블랙을 가집니다.  
그러나 우리는 열에서 두 레드를 반복하지 않습니다.
루트와 리프 노드들은 정의에 의해 블랙입니다. 
모든 노드는 레드 또는 블랙입니다. 쉽습니다. 
이것은 속성의 특정한 집합입니다. 
이 점에서 약간 임의적으로 보일 거에요. 
그것들은 결론을 보면 
더 정확해 집니다.
우리가 여기서 얻으려고 하는 목표들이 있습니다.
이 속성들은 
대수의 키를 가져야 합니다. 
그리고
그것들이 이 점에서 명확하지 않더라도요. 
그것은 모든 속성을 따릅니다. 
3과 4는 주요한 것입니다. 
그러나 여러분은 그것들이 모두 필요합니다.
우리가 이 속성들로부터 바라는 것은 그것들이 어쨌든 유지하기 쉬워야 한다는 것입니다.

English: 
black nodes.
Same over here.
OK, so hopefully these
properties make sense.
We didn't check all of them.
Every red node has a black
parent.
If you look at all of these
paths, we sort of alternate,
red, black at most.
Or we have just a bunch of
blacks.
But we never repeat two reds in
a row.
The root and the leaves are
black that we used pretty much
by definition.
Every node is red or black.
OK, that's easy.
This is a particular set of
properties.
It may seem a bit arbitrary at
this point.
They will make a lot more sense
as we see what consequences they
have.
But there are a couple of goals
that we are trying to achieve
here.
One is that these properties
should force the tree to have
logarithmic height,
order log n height.
And, they do,
although that's probably not
obvious at this point.
It follows mainly from all the
properties.
Three and four are the main
ones.
But you pretty much need all of
them.
The other desire we have from
these properties is that they

English: 
are somehow easy to maintain.
OK, I can create a tree in the
beginning that has this
property.
For example,
I could make,
I have to be a little bit
careful, but certainly if I take
a perfectly balanced binary tree
and make all of the nodes black,
it will satisfy those
properties.
OK, this is a red black tree.
OK, so it's not too hard to
make any these properties hold
just from the beginning.
The tricky part is to maintain
them.
When I insert a node into this
tree, and delete a node for this
tree, I want to make it not too
hard.
In log n time,
I've got to be able to restore
all these properties.
OK, that will be the hardest
part.
The first thing we will do is
prove that these properties
imply that the tree has to have
height order log n.
Therefore, all searches and
queries on a data structure will
run fast.

Korean: 
저는 이 속성을 가지는 
트리를 만들 수 있습니다. 
예를 들어, 
제가 완벽한 균형 이진 트리를 만들고 
노드를 블랙으로 하면, 
그것은 속성들은 만족시킵니다. 
이것은 레드 블랙 트리입니다. 그것은 
이 속성들을 처음에 지니기 어렵지 않습니다. 
까다로운 부분은 유지하는 부분입니다.
제가 노드를 이 트리에 삽입할 때 
저는 그것이 어렵지 않길 바랍니다. 
lg n 시간에서, 저는 이 속성들을 저장할 수 있습니다.
그것들은 가장 어려운 부분입니다. 
우리가 할 첫 번째 것은 이 속성들이  
트리가 오더 lg n 키를 가진다는 것을 내포하는 속성을 증명하는 겁니다.
우리가 할 첫 번째 것은 이 속성들이 트리가 오더 lg n 키를 가진다는 것을 내포하는 속성을 증명하는 겁니다. 
그러므로 데이터 구조에서 검색과 쿼리는 빠를 것입니다. 

English: 
The hard part will be to make
sure these properties stay true
if they initially held true when
we make changes to the tree.
So, let's look at the height of
a red black tree.
And from this we will start to
see where these properties come
from, why we chose these
properties.

Korean: 
어려운 부분은 이 속성들이 바뀌어도 
계속 유지되도록 하는 겁니다.
레드 블랙 트리의 높이를 봅시다. 
이것들로부터 우리는 속성이 어디서 왔는지, 
왜 우리가 이 속성들을 선택했는지 알 수 있습니다. 

Korean: 
저는 여기서 노드를 이야기 하지 않습니다, 
저는 우리가 더한 
외부 리프 노드가 아닌 내부 노드만 세길 
원하기 때문입니다. 
그러나 우리는 정확한 인자를 원합니다. 
교재에 이것의 증명이 있으니 
읽어보세요.
제가 여러분에게 주려고 하는 것은 증명 스케치입니다. 
여러분은 도입에 의한 증명을 읽어야 합니다 
왜냐하면 여러분이 증명을 하면서 얻는 모든 연습들이 좋기 때문입니다. 
증명 스케치는 많은 직관을 주고 
금요일 수업과 연결이 될 겁니다. 
여러분에게 대신 말해주겠습니다. 

English: 
So, the claim is that the
height of a red black tree with
n keys, so, I'm not saying nodes
here because I really only want
to count the internal nodes,
not these extra leaves that
we've added, has height,
at most, two times log of n
plus one, so order log n.
But, we have a pretty precise
bound of a factor of two.
There is a proof of this in the
textbook by induction,
and you should read that.
What I'm going to give us more
of a proof sketch.
But you should read the proof
by induction because all the
practice you can get with proof
by induction is good.
The proof sketch on the other
hand gives a lot more intuition
with what's going on with red
black trees and connects up with
recitation on Friday.
So, let me tell you that

Korean: 
저는 칠판을 비워두고 
여기로 가겠습니다.
제가 하려고 하는 첫 번째 것은 
그것이 이와 같아 보일 때까지 조작하는 겁니다. 
주요한 변화는 각 레드 노드를 그것의 부모와 합병하는 겁니다. 
우리는 레드 노드의 부모가 블랙이어야 한다는 걸 압니다. 
그래서 각 레드 노드를 블랙 부모로 합병합니다. 

English: 
instead.
I'm going to leave that board
blank and go over here.
So, the first thing I'm going
to do, I'm going to manipulate
this tree until it looks like
something that I know.
The main change I'm going to
make is to merge each red node
into its parent.
And we know that the parent of
a red node must be black.
So, merge each red node into

Korean: 
여기를 보세요. 
저는 이 레드 로드는 가지고, 그것의 부모를 합병하여, 
이 레드 노드를 가지고 경로에 더합니다. 
제가 닿을 수 없는 곳이 있습니다. 
그러나 저는 이제 이 그림을 다시 그릴 겁니다. 
탑 노드는 이제 
7과 18입니다. 
그것들은 함께 합쳐집니다, 그러나 그것들과 같이 되는 것은 없습니다.
왼쪽에서 우리는 3을 가집니다. 
그것들과 같이 되는 것은 없습니다. 
리프 노드들만 있습니다. 
저는 이것을 그려야 합니다. 
오 저는 그 소리를 전에 들었습니다. 
저는 이 노드들을 함께 합병할 것입니다  
레드 노드는 블랙으로 합병되기 때문입니다.
저는 두 노드를 함께 합병합니다. 
저는 이 레드 노드를 블랙으로 합병할 겁니다.

English: 
its black parent.
So, let's look at that here.
So, I'm going to take this red
node, merge it into its parent,
take this red node,
merge it into its path,
and so on.
There's one up there which I
can't reach.
But I'm going to redraw this
picture now.
So, seven, so the top node now
becomes, in some sense,
seven and 18.
They got merged together,
but no one else joined them.
Then, on the left,
we have three.
OK, nothing joined that,
and there's some leaves as
usual.
Now, if you look at,
maybe, I'm going to have to
draw this.
Uh-oh.
I heard that sound before.
So, I'm merging these nodes
together, and I'm merging all of
these nodes together because
each of these red nodes merges
into that black node.
And, I'm merging these two
nodes together.
So, I'm putting this red node

Korean: 
이제 여러분이 루트에서 보는 것은 7/18 입니다. 
3 자식이 있습니다. 
그림에서, 
저는 그것을 그리고 싶습니다. 
좋아요. 
7과 18 사이에서, 저는 복합 노드를 가집니다, 8 10 11. 
그리고 각 노드에 달려 있는 4개의 리프 노드가 있습니다. 
18 다음에, 복합 노드 22/26이 있습니다, 
그리고 거기 달린 3 리프 노드가 있습니다. 
우리는 지금까지 주로 이진 트리를 다뤘기 때문에 

English: 
into that black node.
So, now you can see from the
root, which is now 7/18.
There are three children
hanging off.
So, in that picture,
I'd like to draw that fact
assuming I can get this board
back down.
Good.
So, between seven and 18,
I have this conglomerate node,
eight, ten, 11.
And, there are four leaves
hanging off of that node.
And, off to the right,
after 18, I have a conglomerate
node, 22/26, and there are three
leaves hanging off of there.
OK, kind of a weird tree

English: 
because we dealt mainly with
binary trees so far,
but this is a foreshadowing of
what will come on Friday.
This is something called a
two-three-four tree.
Any guesses why it's called a
two-three-four tree?
Every node can have two,
three, or four kids,
yeah, except the leaves.
They have zero.
There is another nice property
of two-three-four trees maybe
hinted at.
So, there's really no control
over whether you have two
children or three children or
four children.
But, there is another nice
property.
Yeah?
All of the leaves have the same
depth, exactly.
All of these guys have the same
depth in the tree.

Korean: 
좀 이상한 트리지만 
이것은 금요일에 볼 것의 전조입니다. 
이것은 2-3-4 트리입니다.
왜 2-3-4 트리인지 알겠나요? 
모든 노드는 2 3 4를 가집니다. 
그들은 0을 가집니다. 
2-3-4 트리의 또 다른 좋은 속성도 있습니다. 
여러분이 2 또는 3 또는 4 자식을  
가지면 컨트롤 할 수가 없습니다.
그러나 또 다른 좋은 속성이 있습니다. 
네?
모든 리프 노드는 정확히 같은 깊이를 가집니다. 
이것들은 모두 트리에서 같은 깊이를 가집니다. 

Korean: 
왜 그렇죠? 속성 4 때문입니다.
금요일에, 여러분은 그 속성을 유지하는 방법을 볼 것입니다. 
이 변환에서 나와서,  
우리는 모든 리프 노드가 같은 깊이를 가진다는 것을 얻었습니다. 
이제 높이라고 부릅시다.
이 리프 노드들의 깊이는 
루트의 블랙 높이 입니다. 
우리는 모든 레드 노드를 올릴 것이고, 
경로를 보면, 우리는 모든 레드 노드를 무시하고, 
블랙 노드는 같습니다. 
이제 우리는 기본적으로 모든 블랙 노드를 남겨 둡니다.
모든 경로를 따라 우리는 같은 수의 블랙 노드를 갖습니다. 
그러므로 
모든 리프 노드는 같은 깊이를 갖습니다. 
이 속성들을 써 보겠습니다. 

English: 
Why is that?
Because of property four.
On Friday, you will see just
how to maintain that property.
But out of this transformation,
we get that all the leaves have
the same depth:
because their depth,
now, or let's say their height
in the tree is their black
height.
And, the depth of these leaves
will be the black height of the
root.
We are you raising all the red
nodes, and we said if we look at
a path, and we ignore all the
red nodes, then the number of
black nodes along a path is the
same.
Now we are basically just
leaving all the black nodes.
And so, along all these paths
we'll have the same number of
black nodes.
And therefore,
every leaf will have the same
depth.
Let me write down some of these
properties.

English: 
So, every internal node has
between two and four children.
And every leaf has the same
depth, namely,
the black height of the root.
This is by property four.
OK, so this is telling us a
lot.
So, essentially what this
transformation is doing is
ignoring the red nodes.
Then, if you just focus on the
black nodes, height equals black
height.
And then, black height is
telling us that all the root to
leaf paths have the same length.
Therefore, all these nodes are
at the same level.
Having leaves at the same level
as a good thing because it means

Korean: 
모든 내부 노드는 2와 4 사이의 자식을 갖습니다. 
모든 리프 노드는 같은 깊이를 갖습니다, 
즉 루트의 블랙 높이를요. 
이것은 속성 4에 의한 것입니다. 그래서 이것은 우리에게 많은 것을 알려 좁니다. 
필수적으로 이 변환이 
무엇을 하는지는 레드 노드를 무시하는 것입니다. 
여러분이 블랙 노드에 초점을 맞추면 높이는 블랙 높이와 같습니다. 
블랙 높이는 루트에서 리프 노드의 경로가  
같은 길이를 가진다는 것을 알려줍니다.
그러므로, 모든 이 노드들은 같은 단계에 있습니다. 
같은 단계에서 리프 노드를 갖는 것은 

Korean: 
여러분의 트리가 매우 균형 잡혔기 때문입니다.
여러분이 트리를 가지고 있으면, 그것은 적어도 두 자식을 갖고, 
모든 리프 노드들은 같은 레벨에 있습니다, 
그것은 매우 균형 잡혔어요. 
우리는 이제 이것의 형태를 증명할 것입니다. 
저는 이 트리의 높이를 h 프라임이라고 부를 것입니다. 
원래 트리의 높이는 h 입니다. 
그것은 여기서 우리가 바운드하려는 것입니다. 
첫 번째는 h 프라임을 바운드하는 것입니다. 
우리는 h와 h 프라임을 연결 시키고 싶습니다.
첫 번째 질문은 이 트리에 얼마나 많은 리프 노드가 있습니까?  
어떤 트리인지는 중요하지 않습니다.
모든 리프 노드는 블랙입니다. 
리프 노드는 변하지 않습니다. 
그러므로 이 트리에 
얼마나 많은 리프 노드가 있습니까? 
9 인가요? 
일반적으로를 의미했습니다. 

English: 
that your tree is pretty much
balanced.
If you have a tree where all
the nodes are branching,
so, they'll have at least two
children, and all the leaves are
at the same level,
that's pretty balanced.
OK, we will prove some form of
that now.
I'm going to call the height of
this tree h prime.
The height of the original tree
is h.
That's what we want to bound
here.
So, the first thing is to bound
h prime.
And then we want to relate h
and h prime.
OK, so the first question is
how many leaves are there in
this tree?
And, it doesn't really matter
which tree I'm looking at
because I didn't really do
anything to the leaves.
All the leaves are black.
So the leaves didn't change.
How many leaves are there in
this tree, and then therefore,
industry?
Sorry?
Nine.
Indeed, there are nine,
but I meant in general,

Korean: 
이 예에서는 9입니다. 
얼마나 많은 키가 있습니까? 8입니다. 
일반적으로 
여러분은 8의 함수로써 9를 어떻게 씁니까? 
네? 플러스 1입니다, 
좋아요
n 더하기 1입니다. 왜죠?
우리가 이해하고 있는 이진 트리 케이스를 봅시다. 
여러분이 키를 가지고 있으면, 두 가지가 있습니다. 
매우 좋은 인자는 아닙니다. 
우리는 여기서 이진 트리라는 것을 가집니다. 
모든 내부 노드는 정확히 두 자식을 가집니다. 
우리는 내부 노드의 수의 관점에서 
그 과정으로부터 리프 노드의 수를 셉니다. 
트리에서 리프 노드의 수는 1 

English: 
sorry.
In this example there are nine.
How many keys are there?
Eight.
So, in general,
how do you write nine as a
function of eight for large
values of nine or eight?
Sorry?
Plus one, good,
correct answer,
by guessing.
n plus one.
OK, why is it n plus one?
Let's look at the binary tree
case where we sort of understand
what's going on?
Well, wherever you have a key,
there are two branches.
And, that's not a very good
argument.
OK, we have what is here called
a branching binary tree.
Every internal node has exactly
two children.
And, we are counting the number
of leaves that you get from that
process in terms of the number
of internal nodes.
The number of leaves in a tree,

Korean: 
더하기 내부 노드의 수입니다.
여러분은 그것을 알아야 합니다. 
여러분은 그것을 도입에 의해 증명할 수 있습니다. 그래서 리프 노드의 수는 n 더하기 1 입니다. 
여러분이 단일 자식을 가지면 그것을 지니지 않습니다. 
모든 내부 노드가 2의 가지 인자를 
가지면 지니게 됩니다. 이것은 둘 다 아닙니다. 
이제 우리는 리프 노드의 수와 트리의  
높이 사이에 몇 식를 넣고 싶습니다.
여기서 사용할 좋은 식은 무엇입니까? 
우리는 얼마나 많은 리프 노드가 있는지 정확히 압니다. 
그것은 n과 연관된 것입니다. 
우리가 신경 쓰는 것은 높이입니다. 
이 트리의 높이를 봅시다. 
제가 2-3-4 트리의 높이 h 프라임을 가지면, 그것은 얼마나 많은 리프 노드들을 가집니까? 
h그것이 가질 수 있는 최대 최소 수는 무엇입니까?

English: 
or a branching tree,
as always one plus the number
of internal nodes.
You should know that.
You can prove it by induction.
OK, so the number of leaves is
n plus one.
It doesn't hold if you have a
single child.
It holds if every internal node
has a branching factor of two.
OK, this is a neither tree.
And now, we want to pull out
some relation between the number
of leaves and the height of the
tree.
So, what's a good relation to
use here?
We know exactly how many leaves
there are.
That will somehow connect us to
n.
What we care about is the
height.
And let's look at the height of
this tree.
So, if I have a two-three-four
tree of height h prime,
how many leaves could it have?
What's the minimum and maximum

Korean: 
우리가 2-3-4 트리에서 하는 것은 
리프 노드의 수가 
4와 h 프라임 사이여야 한다는 겁니다. 
저는 각 노드에서 4 가지 방법을 가집니다. 
그것은 적어도 h 프라임의 2입니다 왜냐하면 저는 모든 노드가 적어도 두 방법을 
가진다는 것을 알기 때문입니다. 그것은 키 입니다. 
저는 그것들 중 하나만 신경을 씁니다. 
저는 n 더하기 1을 얻습니다. 
리프 노드의 수는 n 더하기 1 입니다. 
우리는 그것을 정확히 압니다. 
우리는 다시 쓰고, 양 변에 로그를 취합니다. 
H는 많아 봐야 n+1의 로그입니다. 
우리는 좋은 균형 트리를 갖습니다. 
이것은 직관적이어야 합니다. 제가 모든 노드를 가지면, 
그것은 완벽한 트리입니다. 
그것은 정확히 로그 2의 

English: 
number of leaves it could have?
2^h to 4^h, or h prime.
So, we also know in the
two-three-four tree,
the number of leaves has to be
between four to the h prime,
because at most I could branch
four ways in each node.
And, it's at least two to the h
prime because I know that every
node branches at least two ways.
That's key.
So, I only care about one of
these, I think this one.
So, I get that two to the h
prime is, at most,
n plus one.
So the number of leaves is n
plus one.
We know that exactly.
So, we rewrite,
we take logs of both sides.
It says h one is at most log of
n plus one.
So, we have a nice,
balanced tree.
This should be intuitive.
If I had every node branching
two ways, and all the leaves at
the same level,
that's a perfect tree.
It should be exactly log base

Korean: 
n+1 이어야 합니다.
그것은 트리의 높이여야 합니다. 
여기서 저는 가지를 더 갖습니다. 
저는 같은 높이의 리프 노드를 
더 갖습니다. 
그러나 그것은 저에게만 좋습니다. 
그것은 리프 노드 수의 관점에서 키를 감소시킵니다. 
여기서 n 더하기 1은 리프 노드의 수입니다 좋아요. 
그것은 쉬운 상계입니다. 
이제 우리가 신경 쓰는 것은 이 트리의 높이 입니다. 
우리는 h와 h 프라임을 연관 시키고 싶습니다.
우리가 그것을 어떻게 하는지에 대한 생각 있나요?
우리는 이 트리의 높이를  
어떻게 아나요? 
우리는 이것이 많아 봐야 log n 이라는 것을 압니다. 
우리는 이것이 많아 봐야 2 log n 더하기 1이라는 것을 압니다. 
우리는 답을 압니다. 우리는 정리를 이야기 했습니다. 
네? 맞습니다. 
속성 3은 우리에게 모든 블랙에 대해 하나의 레드 노드를 갖는 다는 걸 알려줍니다. 
우리는 레드와 블랙을 대체할 수 있습니다.

English: 
two of n plus one,
and turns out not quite n.
That should be the height of
the tree.
Here, I might have even more
branching, which is making
things even shallower in some
sense.
So, I get more leaves out of
the same height.
But that's only better for me.
That will only decrease the
height in terms of the number of
leaves.
n plus one here is the number
of leaves.
So: cool.
That's an easy upper bound on
the height of the tree.
Now, what we really care about
is the height of this tree.
So, we want to relate h and h
prime.
Any suggestions on how we might
do that?
How do we know that the height
of this reduced tree is not too
much smaller than this one.
We know that this one is,
at most, log n.
We want this to be,
at most, two log n plus one.
We know the answer.
We've said the theorem.
Sorry?
Right.
So, property three tells us
that we can only have one red
node for every black one.
We can, at most,

Korean: 
우리가 경로들 중 하나를 보면, 
레드 노드의 수는 경로의 절반입니다. 
우리는 전체 경로의 최대를 취합니다, 
그것은 트리의 높이입니다. 
우리는 h가 
최대 2 곱하기 h 프라임이라는 
것을 압니다. 
H 프라임은 적어도 h의 절반입니다. 
노드의 절반이 레드이기 때문입니다.
적어도 그것들 중 절반은 블랙이어야 합니다. 
모든 블랙 노드는 이 그림에 있습니다, 

English: 
alternate red and black.
So, if we look at one of these
paths that goes from a root to a
leaf, the number of red nodes
can be, at most,
half the length of the path.
And we take the max overall
paths, that's the height of the
tree.
So, we know that h is,
at most, two times h prime,
or maybe it's easier to think
of h prime is at least a half,
h.
Assuming I got that right,
because at most a half of the
nodes on any root to leaf path
--
-- are red.
So, at least half of them have
to be black.
And, all-black nodes are

Korean: 
h는 최대 2 곱하기 
lg n 더하기 1입니다. 
매우 쉽습니다. 
그러나 여러분은 이 트리가 균형이어야 한다는 것을 기억해야 합니다. 
그것들은 서로 너무 멀지 않습니다. 
금요일에 여러분은 조작하는 법을 볼 것입니다. 
그것을 하는 좋은 방법입니다. 
그것이 2-3-4 트리입니다. 
오늘 우리는 이 형태에서 조작하는 법을 볼 것입니다. 
그리고 오늘 수업에서, 
그것들은 전혀 연관되지 않은 것처럼 보일 겁니다.
그러나 그것들은 같은 겁니다. 
그러나 그것들은 같은 겁니다. 
이것은 좋은 소식이에요. 우리는 이제 모든 레드 블랙 트리가 균형이라는 것을 압니다.

English: 
captured in this picture so we
have this relation,
and therefore,
h is, at most,
two times log n plus one.
OK: pretty easy.
But you have to remember,
this tree has to be balanced,
and they are not too far away
from each other.
OK, so in Friday's recitation,
you will see how to manipulate
trees with this form.
There is a cool way to do it.
That's two-three-four trees.
Today, we're going to see how
to manipulate trees in this form
as red black trees.
And, you'll see today's
lecture, and you'll see Friday's
recitation, and they won't
really seem to relate at all.
But they're the same,
just a bit hidden.
OK, so this is good news.
We now know that all red black
trees are balanced.
So as long as we can make sure

English: 
that our tree stays a red black
tree, we'll be OK.
We'll be OK in the sense that
the height is always log n.
And therefore,
queries in a red black tree,
so queries are things like
search, find a given key,
find the minimum,
find the maximum,
find a successor,
find a predecessor.
These are all queries that we
know how to support in a binary
search tree.
And we know how to do them in
order height time.
And the height here is log n so
we know that all of these
operations take order log n in a
red black tree.
OK --

Korean: 
우리의 트리가 레드 블랙 트리에 있다고 확신하는 한, 괜찮습니다. 
높이가 lg n 인 한 괜찮습니다. 
그러므로 레드 블랙 트리에서 
쿼리는 검색하고 
주어진 키, 
최대 최소를 찾는 것입니다. 
이것들은 우리가 이진 트리에서 아는 쿼리들입니다.
우리는 그것을 하는 방법을 압니다. 
여기소 높이는 lg n입니다 
그래서 우리는 모든 연산이 
O(lg n)이라는 것을 압니다. 

English: 
So, queries are easy.
We are done with queries,
just from balance:
not a surprise.
We know that balances is good.
The hard part for us will be to
do updates.
And in this context,
updates means insert and
delete.
In general, and a data
structure, we talk about queries
which ask questions about the
data in the structure,
and updates which modify the
data in the structure.
And most of the time here,
we are always thinking about
dynamic sets.
So, you can change the dynamics
set by adding or deleting an
element.
You can ask all sorts of
questions.
In priority queues,
there were other updates like

Korean: 
쿼리는 쉽습니다. 우리는 쿼리로 했습니다. 
놀랍지 않습니다. 
우리는 균형이 좋다는 것을 압니다. 어려운 부분은 업데이트 하는 것입니다. 
이 맥락에서, 업데이트는  
삽입과 삭제를 말합니다.
일반적으로 데이터 구조에서,  
우리는 쿼리에 대해 이야기 합니다.
여기서 대부분 우리는 항상 동적 집합에 대해 이야기 합니다. 
여러분은 인자를 더하거나 뺌으로써 
동적 집합을 바꿀 수 있습니다. 
여러분은 모든 질문을 할 수 있습니다. 
주요 큐에서, Min을 제거 하는 것과 같은 다른 업데이트가 있습니다.

Korean: 
우리는 Min을 찾았습니다, 그러나 우리는 그것을 삭제할 수 있습니다. 
전형적으로 이것들은 우리가  
신경 쓰는 연산입니다.
우리는 업데이트와 쿼리에 . 
대해 이야기할 것입니다
특히 문제 세트에서, 여러분은 서포트 할 수 있는 
다른 쿼리들을 볼 것입니다. 
우리는 업데이트를 어떻게 서포트하나요? 
우리는 이진 검색 트리 삽입을 가지고 있습니다.
우리는 이진 검색 트리 삭제를 가지고 있습니다. 
그것들은 이진 검색 트리 속성을 유지하지만,  
저는 그것들이 필수적으로 균형을 유지하지 않는다는 것을 압니다.
우리는 노드를 삽입할 수 있습니다.  
새 인자들을 가지고 여러분은 정밀 긴 경로를 가질 수 있습니다.
아마 그것들은 레드 블랙 속성을 유지하지 않을 겁니다 
우리는 레드 블랙이 균형을 내포한다는 것을 알기 때문입니다. 
특히 그것들은 속성 1을 만족하지 못합니다, 
그것은 각 노드가 
블랙 또는 레드여야 한다는 겁니다. 
그것은 노드를 더할 것이고 색을 할당하지 않습니다. 

English: 
delete Min.
Here we have find Min,
but we could then delete it.
Typically these are the
operations we care about.
And we'll talk about updates to
include those of these,
and queries to include all of
these, or whatever happens to be
relevant.
In problem sets especially,
you'll see all sorts of
different queries that you can
support.
OK, so how do we support
updates?
Well, we have binary search
tree insert, which we call tree
insert.
We have binary search tree
delete, tree delete.
They will preserve the binary
search tree property,
but we know they don't
necessarily preserve balance.
We can insert a bunch of nodes.
Just keep adding new minimum
elements and you will get a
really long path off the end.
So, presumably,
they do not preserve the red
black properties because we know
red black implies balance.
In particular,
they won't satisfy property
one, which I've erased,
which is every node is red or
black.
It'll add a node,
and not assign it a color.

English: 
So, we've got to assign it a
color.
And, as soon as we do that,
we'll probably violate some
other property.
And then we have to fix that
property, and so on.
So, it's a bit tricky,
but you play around with it and
it's not too hard.
OK, so updates must modify the
tree.
And to preserve the red black
properties, they're going to do
it in three different kinds of
modifications.
The first thing we will indeed
do is just use the BST
operation, tree insert or tree
delete.
That's something we know how to
do.
Let's just do it.
We are going to have to change
the colors of some of the nodes.
In particular,
the one that we insert better
be colored somehow.
And in general,
if we just rip out a node,

Korean: 
우리는 그것에 색을 할당해야 합니다. 
우리가 하자마자, 우리는 다른 속성을 위반하게 됩니다. 
그리고 우리는 그 속성을 고정시켜야 합니다. 
그것은 까다롭지만, 
우리는 그것을 가지고 놀 수 있고 어렵지 않습니다.
업데이트는 반드시 트리를 수정해야 합니다. 
레드 블랙 속성을 유지하기 위해, 
그것들은 3 종류의 변형에서 그것을 합니다. 
우리가 정말로 하는 첫 번째 것은  
BST 연산을 사용하는 것입니다.
그것은 우리가 알고 있는 방법입니다. 
해 봅시다. 
우리는 노드의 색을 바꾸어야 합니다. 
특히 우리가 삽입하는 것은 색이 있어야 합니다. 
일반적으로 우리가 노드를 삭제하면, 

English: 
we are going to have to recolor
it, recolor some nearby nodes.
There is one other kind of
operation we're going to do.
So, recoloring just means set
to red or black.
The other thing you might do is
rearrange the tree,
change the pointers,
change the links from one node
to another.
And, we're going to do that at
the very structured way.
And, this is one of the main
reasons that red black trees are
interesting.
The kinds of changes they make
are very simple,
and they also don't make very
many of them.
So, they're called rotations.
So, here's a rotation.
OK, this is a way of drawing a
generic part of a tree.
We have two nodes,
A and B.
There is some subtrees hanging
off, which we draw as triangles.
We don't know how big they are.
We know they better all have

Korean: 
우리는 그것에 색을 다지 입힙니다.
우리가 하는 또 다른 연산이 있습니다. 
색을 다시 입히는 것은 레드 또는 블랙을 말합니다. 
다른 것은 트리를 재배열하고, 
포인터를 바꾸고 링크를 바꾸는 것입니다.
우리는 모든 구조된 방법으로 그것을 할 수 있습니다. 
이것은 레드 블랙 트리가 흥미로운 
주요한 이유입니다. 
그것들이 만드는 변화는 
매우 간단합니다. 그것들은 로테이션이라고 불립니다. 
여기 로테이션이 있습니다.
이것은 트리의 일반적인 부분을 그리는 방법입니다. 
우리는 두 노드 A와 B가 있습니다. 
그리고 서브 트리가 있습니다. 
우리는 그것들이 얼마나 큰지는 모릅니다. 

Korean: 
우리는 그것이 레드 블랙 트리이면 같은 블랙 높이를 가지는 게 좋다는 것을 압니다. 
그러나 일반적으로, 그것은 이와 같아 보입니다.
부모가 있고 우리가 
그리지 않은 남은 트리가 있습니다. 
저는 이 서브 트리의 이름을 그리스 이름, 
알파 베타 감마로 줄 것입니다. 
그리고 연산을 정의할 겁니다. 
제가 노드 B를 가지면,
 저는 그것을 오른쪽으로 회전하고 싶습니다.
저는 이 트리를 만듭니다. 
제가 하는 모든 것은 이것을 90도 돌리는 것입니다. 
B의 자식은 이제 A의 부모입니다. 
A는 이제 B의 새로운 부모입니다. 서브 트리는 재배열됩니다. 
전에 그것들은 모두 서브 트리였습니다. 

English: 
the same black height if it's a
red black tree.
But in general,
it just looks like this.
There is some parent,
and there's some rest of the
tree out here which we don't
draw.
I'll give these subtrees names,
Greek names,
alpha, beta,
gamma.
And, I'll define the operation
right rotate of B.
So general, if I have a node,
B, I look at it and I want to
do it right rotation,
I look at its left child enjoy
this picture called the subtrees
of those two nodes.
And, I create this tree.
So, all I've done is turn this
edge 90∞.
What was the parent of B is now
the parent of A.
A is now the new parent of B.
The subtrees rearrange.
Before, they were both subtrees
of, these two were subtrees of

Korean: 
감마는 B의 서브 트리였습니다. 
알파는 여전히 A의 서브 트리입니다. 
베타는 B의 서브 트리로 되었습니다. 
여기서 확인해야 할 것은 이 연산이 
이진 검색 트리 속성을 유지한다는 겁니다. 
이진 검색 트리의 속성을 기억하세요. 
노드의 왼쪽 서브 트리에서 모든 인자는 
노드와 같거나 작고, 오른쪽 서브 트리에서 
인자는 그 값 보다 크거나 같습니다.
특히 우리나 어떤 노드를 취하면, 
a는 A 보다 작거나 같습니다, 
그것은 b 보다 작거나 같고, 
B보다 작거나 같고, 
c 보다 작거나 같습니다. 
이것은 양 변의 속성입니다. 

English: 
A.
And, gamma was a subtree of B.
Gamma is still a subtree of B,
and alpha still is a subtree of
A.
But, beta switched to being a
subtree of B.
OK, the main thing we want to
check here is that this
operation preserves the binary
search tree property.
Remember, the binary search
tree property says that all the
elements in the left subtree of
a node are less than or equal to
the node, and all the elements
in the right subtree are greater
than or equal to that value.
So, in particular,
if we take some node,
little a in alpha,
little b in beta,
and little c in gamma,
then a is less than or equal to
capital A, is less than or equal
to little b, is less than or
equal to capital B,
is less than or equal to little
c.
And, this is the condition both

English: 
on the left side and on the
right side because Alpha is left
of everything.
Beta is in between A and B,
and gamma is after B.
And the same thing is true over
here.
Beta is still,
it's supposed to be all the
nodes that come between capital
A and capital B.
So, this is good.
We could definitely do this
operation, still have the binary
search tree, and we are going to
use rotations in a particularly
careful way to make sure that we
maintain all these properties.
That's the hard part.
But, rotations will be our key.
This was the right rotate
operation.
The reverse operation is left
rotate.
So, this is left rotate of A.
In general, of the two nodes
that are involved,
we list the top one.
So, its right rotate of B will
give you this.
Left rotate of A will give you
this.
So, these are reversible
operations, which feels good.
The other thing is that they
only take constant time

Korean: 
알파는 모든 것의 나머지 입니다. 
베타는 A와 B 사이에 있고, 
감마는 B 다음에 있습니다.
같은 일이 여기도 있습니다.  
베타는 여전히 A와 B 사이에 있습니다. 
이것은 좋습니다.
우리는 이 연산을 분명히 할 수 있습니다. 
우리는 모든 속성들을 유지하기 위해 
회전을 사용할 것입니다. 
그것이 어려운 부분입니다. 그러나 회전이 우리의 키입니다. 
이것은 오른쪽 회전 연산입니다. 
역은 왼쪽 회전입니다. 
이것은 A의 왼쪽 회전입니다. 
일반적으로 두 노드는 포함됩니다. 
B의 오른쪽 회전은 여러분에게 이것을 줍니다. 
A의 왼쪽 회전은 여러분에게 이것을 줍니다. 
이것들은 좋은 연산입니다. 
다른 것은 정수 시간 연산이 걸리는데 우리가 

English: 
operations because we are only
changing a constant number of
pointers.
As long as you know the node,
B, that you are interested in,
you set the left pointer of B
to be, if you want it to be
beta, so you set left of B to be
right of A, and so on,
and so on.
You make constant number of
those changes.
You update the parents as well.
It's only a constant number of
links that are changing,
so, a constant number of
assignments you need to do.
So, you've probably seen
rotations before.
But we are going to use them in
a complicated way.
So, let's look at how to do
insertion.
We'll see it three times in

Korean: 
정수의 포인터를 바꾸기 때문입니다.
여러분이 
노드 B를 아는 한, 
여러분은 b의 왼쪽 포인터를 설정합니다. 
여러분은 그 변화의 정수개를 만들 수 있습니다. 
여러분은 또한 부모를 업데이트할 수 있습니다. 그것은 변하는 정수의 링크입니다.  
여러분이 필요한 정수입니다.
그래서 여러분은 전에 회전을 아마 보았을 겁니다.
그러나 우리는 그것을 복잡한 방법으로 사용할 것입니다. 
삽입을 어떻게 하는지 봅시다. 
우리는 그것을 세 번 볼 것입니다. 

Korean: 
먼저, 저는 여러분에게 기본 생각을 알려줄 것입니다, 
그것은 매우 간단합니다. 저는 그것을 이미 언급했습니다. 
우리는 예를 할 것입니다. 
그리고 나서 수도 코드를 줄 것이고 
여러분은 집에 가서 그것을 구현할 수 있습니다. 
저는 책에 
RB 삽입이라고 나온 
레드 블랙 삽입을 말해야 합니다.
첫 번째는 이진 검색 트리이고, 
그 노드를 삽입하는 것입니다. 
X는 이제 새로운 리프 노드가 됩니다. 우리는 그것이 될 x를 찾았습니다. 
우리는 만들고, 저는 그것을 이제 리프 노드로 부르면 안됩니다. 
그것은 이제 노드입니다. 
그것은 원래 노드에 달린 내부 노드입니다. 
아마 우리는 여기서 더했습니다. 
그것은 이제 두 새로운 리프 노드를 가집니다. 그것은 내부 자식이 없습니다. 
우리는 그것을 위한 색을 고릅니다. 

English: 
some sense.
First, I'll tell you the basic
idea, which is pretty simple.
I mentioned some of it already.
Then, we'll do it on an
example, feel it in our bones,
and then we'll give the
pseudocode so that you could go
home and implement it if you
wanted.
OK, this is,
I should say,
red black insert,
which in the book is called RB
insert, not for root beer,
but for red black.
OK, so the first thing we're
going to do, as I said,
is binary search tree,
insert that node.
So, x now becomes a new leaf.
We searched for x wherever it's
supposed to go.
We create, I shouldn't call it
a leaf now.
It's now at node hanging off.
It's an internal node hanging
off one of the original nodes.
Maybe we added it right here.
It now gets two new leaves
hanging off of it.
It has no internal children.
And, we get to pick a color for
it.

English: 
And, we will pick the color
red.
OK, why red?
We definitely have to pick one
of two colors.
We could flip a coin.
That might work,
but it's going to make our job
even messier.
So, we are adding a new node.
It's not a root or a leaf
presumably, so we don't really
need it to be black by property
two.
Property three,
every red node has a black
parent.
That might be a problem.
So, the problem is if its
parent is red.
Then we violate property two.
The parent might be red,
property three,
sorry.
OK, the good news is that
property four is still true
because property four is just
counting numbers of black nodes
down various paths.
That's really the hard property
to maintain.
If we just add a new red node,

Korean: 
우리는 레드를 고를 겁니다.
왜 레드죠? 우리는 두 컬러 중 하나를 골러야 합니다. 
우리는 동전 뒤집기를 할 수 있습니다. 
좀 복잡할 수도 있어요. 
우리는 새 노드를 더하려고 합니다. 
그것은 루트 또는 리프 노드가 아닙니다, 
우리는 속성 2에 의해 그것이 블랙이길 원하지 않습니다.
속성 3에서 모든 레드 노드는 블랙 부모를 갖습니다. 
그것이 문제입니다. 
문제는 그것의 부모가 레드일 때 입니다. 
우리는 속성 2를 위반합니다. 
부모는 레드일 수 있습니다. 
좋은 소식은 속성 4는  
여전히 맞습니다.
그것은 유지하기 정말 어려운 속성입니다. 
우리가 새 레드 노드를 더하면 

Korean: 
블랙 높이는 아무 것도 변하지 않습니다.
아무 것도요. 
이것은 유지 되어야 합니다. 우리가 위반 할 수 있는 유일한 속성은 3입니다.  
그것은 합리적입니다.
우리는 처음에 무엇을 위반합니다.  
우리는 이진 검색 트리 삽입을 할 수 없습니다.
그것을 이 트리에 해 봅시다. 
저는 이것을 고정하는 방법을 말해야 합니다. 
어떻게 속성 3을 고정하죠? 우리는 3의 위반을 옮길 것입니다. 
우리는 노드 x에서 시작할 것이고, 
루트로 움직일 것입니다. 
그것은 색을 다시 입히는 것입니다. 

English: 
none of the black heights
change.
None of the number of black
nodes along the path changes.
So, this still has to hold.
The only thing we can violate
is property three.
That's reasonable.
We know we've got to violate
something at the beginning.
We can't just do a binary
search tree insert.
OK, so, let's give it a try on
this tree.
I should say how we are going
to fix this.
How do we fix property three?
We are going to move the
violation of three up the tree.
So, we're going to start at
node x, and move up towards the
root.
This is via recoloring.
The only thing,

English: 
initially, we'll do is
recoloring until we get to some
point where we can fix the
violation using a rotation --
-- and probably also
recoloring.
OK, so let's see this algorithm
in action.
I want to copy this tree,
and you are going to have to
copy it, too.
So, I'll just redraw it instead
of modifying that diagram.
So, we have this nice red black

Korean: 
우리가 하는 것은 회전을 사용하여 
위반을 고정하는 포인트를 얻을 때까지 
색을 다시 입히는 것입니다.
이 알고리즘을 봅시다. 저는 이 트리를 복사하고 싶습니다, 
여러분은 그것을 복사해야 합니다. 
저는 이 도표를 수정하는 대신 다시 그리겠습니다. 
우리는 이 좋은 레드 블랙 트리를 가지고 있습니다. 

English: 
tree.
And, we'll try inserting a new
value of 15.
22 black.
22 is the new black.
OK, that should be the same
tree.
So now, I'm choosing the number
15 to insert,
because that will show a fairly
interesting insertion.
Sometimes, the insertion
doesn't take very much work.
We just do the rotation and
we're done.
I just like to look at an
interesting case.
So, we insert 15.
15 is bigger than seven.
It's less than 18.
It's bigger than ten.
It's bigger than 11.
So, 15 goes here.
So, we add a new red node of
652
00:45:53,000 --> 00:00:15,000
And, it has two black leaves
hanging off of it,
replaced one black leaf.

Korean: 
우리는 15의 새로운 값을 삽입할 것입니다. 
22 블랙입니다. 
22는 새로운 블랙입니다. 
그것은 같은 트리여야 합니다. 이제, 저는 수 15를 고릅니다 
왜냐하면 그것은 꽤 흥미로운 삽입이기 때문입니다.
삽입은 많은 것을 하지 않습니다. 
우리는 회전을 하면 다 합니다. 
저는 흥미로운 케이스를 보고 싶습니다. 
우리는 15를 삽입합니다.
15는 7보다 큽니다. 
그것은 18보다 작고 10보다 큽니다. 그리고 11보다 큽니다. 
그래서 15는 여기로 갑니다. 우리는 15의 새 레드 노드를 더합니다. 
그것은 두 블랙 리프 노드를 가지고, 
기존의 것을 대체합니다. 

English: 
Now we have two.
OK, now, we violate property
three because we added a new red
child of a red node.
So, now we have two consecutive
red nodes in a root to leaf
path.
We'd like to make this black,
but that would screw up the
black heights because now this
node would have one black node
over here, and two black nodes
down this path.
So, that's not good.
What can we do?
Well, let's try to re-color.
Yes.
This always takes a little
while to remember.
So, our fix is going to be to
recolor.
And, the first thing that
struck me, which doesn't work,
is we try to recolor around
here.
It doesn't look so good because
we've got red stuff out here,
but we've got a black node over
here.
So we can't make this one red,
and this one black.
It wouldn't quite work.

Korean: 
이제 우리는 두 개를 가집니다. 
우리가 레드 노드의 레드 자식을 더했기 때문에 속성 3을 위반합니다.
우리는 연속된 두 레드 노드를 가집니다.  
우리는 이것을 블랙으로 하고 싶지만,
블랙의 높이를 망칩니다 왜냐하면 이 노드는 여기서 블랙 노드를 가지고 
두 블랙 노드가 아래에 있기 때문입니다. 
그것은 좋지 않습니다. 
우리는 무엇을 할 수 있나요? 다시 색을 입힙시다. 
이것은 항상 기억하는데 시간이 걸립니다. 
우리의 고정은 색을 다시 입히는 것입니다. 
첫 번째는 동작하지 않고, 
우리는 여기서 색을 다시 입힙니다. 
그것은 좋지 않아 보입니다, 우리가 여기서 레드를 가지니까요, 
그러나 우리는 여기서 블랙을 가집니다. 
우리는 이것을 레드로 할 수 없고, 
이것을 블랙으로 할 수 없습니다. 그것은 작동하지 않습니다. 

English: 
If we look up a little higher
at the grandparent of 15 up
here, we have a black node here
and two red children.
That's actually pretty good
news because we could,
instead, make that two black
children and a red parent.
Locally, that's going to be
fine.
It's not going to change any
black heights because any path
that went through these nodes
before will still go through the
same number of black nodes.
Instead of going through a
black node always here,
it will go through a black node
either here or here because
paths always go down to the
leaves.
So, that's what we're going to
do, recolor these guys.
And, we will get ten,
which is red.
We'll get eight,
which is black,
11 which is black,
and these things don't change.
Everything else doesn't change.
We are going to leave 15 red.
It's no longer in violation.
15 is great because now its
parent is black.

Korean: 
우리는 부모의 부모를 봅니다. 
우리는 블랙 노드와 두 레드 자식을 갖습니다.
우리는 그것을 두 블랙 자식과 
레드 부모로 할 수 있어서 좋은 소식입니다. 
지역적으로, 그것은 좋을 겁니다. 
그것은 블랙 높이를 변화시키지 않습니다.
경로는 같은 블랙 노드 수를 가지니까요. 
블랙 노드를 살펴 보는 대신, 
그것은 여기 또는 여기서 블랙 노드를 살펴볼 것입니다. 
왜냐하면 경로는 아래로 항상 가기 때문입니다.
그것은 우리가 하려는 것입니다. 
우리는 10을 가지고, 그것은 레드입니다. 
우리는 8을 가지고 그것은 블랙입니다, 
11은 블랙이고, 이것들은 바뀌지 않습니다. 
모든 것은 바뀌지 않습니다. 
15는 레드로 둡니다. 더 이상 위반하지 않습니다.
15는 훌륭합니다 부모가 블랙이니까요. 

Korean: 
우리는 이제 여기서 18로 새로운 위반을 합니다. 18도 레드입니다. 
그것은 우리의 유일한 위반입니다. 
일반적으로 우리는
하나의 위반을 가집니다.
그리고 0 위반을 가지게 됩니다. 
이제 우리는 10과 18 사이의 위반을 가잡니다. 
그것은 항상 반직관적입니다.
저는 자료를 다시 보아야 합니다. 
좋아요.
우리는 더 이상 색을 다시 입힐 수 없습니다. 
저는 그리 나쁘지 않습니다. 
우리가 하려고 하는 것은 10의 부모의 부모를 보는 것인데 
그것은 7이고, 트리의 루트입니다. 
그것은 블랙이지만 그것의 자식 중 하나가 블랙입니다. 
다른 것들은 레드입니다. 
우리는 같은 게임을 할 수 없습니다. 

English: 
We now have a new violation up
here with 18 because 18 is also
red.
That's the only violation we
have.
In general, we'll have,
at most, one violation at any
time until we fix it.
Then we'll have zero
violations.
OK, so, now we have a violation
between ten and 18:
somehow always counterintuitive
to me.
I had to look at the cheat
sheet again.
Really?
No, OK, good.
I was going to say,
we can't recolor anymore.
Good.
I'm not that bad.
So, what we'd like to do is,
again, look at the grandparent
of ten, which is now seven,
the root of the tree.
It is black,
but one of its children is
black.
The other is red.
So, we can't play the same game
of taking the blackness of

Korean: 
그것은 2 자식으로 옮깁니다.
루트가 블랙이어야 한다는 것에 신경 쓰지 마세요. 
우리는 지금은 속성을 무시합니다. 
우리는 이 둘을 블랙으로 이것을 레드로 할 수 없습니다
왜냐하면 우리는 불균형을 가지니까요. 
이것은 이미 블랙입니다. 
이제 여기서 경로는 하나의 블랙 노드를 가집니다. 
우리는 7을 다시 색 입일 수 없습니다. 
대신 우리는 회전합니다. 
우리는 더 가까워집니다. 이 가장자리를 회전합니다. 
저는 8을 오른쪽으로 회전할 것입니다.
그것은 다음 연산입니다. 
18의 오른쪽 회전입니다. 

English: 
seven, and moving it down to the
two children.
Never mind that the root is
supposed to stay black.
We'll ignore that property for
now.
We can't make these two black
and make this one red,
because then we'd get an
imbalance.
This was already black.
So now, paths going down here
will have one fewer black node
than paths going out here.
So, we can't just recolor seven
and its children.
So, instead,
we've got to do a rotation.
We'd better be near the end.
So, what I will do is rotate
this edge.
I'm going to rotate eight to
the right.
So that's the next operation:
rotate right of 18.

English: 
We'll delete one more operation
after this.
So, we rotate right 18.
So, the root stays the same:
seven, three,
its children.
Now, the right child of seven
is no longer 18.
It's now ten.
18 becomes the red child of
ten.
OK, we have eight over here
with its two children.
11 and 15: that subtree fits in
between ten and 18.
So, it goes here:
11 and 15.
And then, there's the right
subtree.
Everything to the right of 18,
that goes over here:
22 and 26.
And hopefully I'm not changing
any colors during that

Korean: 
우리는 이 후에 하나 이상의 연산을 삭제할 것입니다. 
우리는 오른쪽 18을 회전합니다. 
루트는 여전히 같습니다. 
이제 7의 오른쪽 자식은 더 이상 18이 아니고 
10입니다. 18은 10의 레드 자식입니다. 
우리는 여기서 두 자식을 가지는 8을 가집니다. 
11과 15는 10과 18 사이에 맞는 서브 트리입니다. 
그것은 여기로 갑니다. 
오른쪽 서브 트리가 있습니다. 
그것은 여기로 갑니다: 
22 그리고 26. 
희망적으로 저는 그 연산 동안 아무 색도 바꾸지 않습니다. 

Korean: 
제가 바꾸었다면, 알려주세요.
그것은 좋아 보입니다. 저는 여전히 이 위반을 가집니다.  
10과 18 사이에 문제가 있습니다.
그러나 저는 이것을 직선으로 할 것입니다. 
우리가 하려는 것은 
연결을 하는 것입니다. 
왼쪽과 오른쪽을요. 
여기서 우리는 지그재그로 합니다. 
우리는 그것을 직선으로 하길 원합니다. 
그것은 균형 트리 같아 보이지 않습니다. 
사실 그것은 약간 잘못 되었습니다.
우리가 할 수 있는 것은 이제 회전하는 것입니다. 
저는 7을 왼쪽으로 회전하고 10을 루트로 만듭니다, 
그리고 모든 것은 균형되기 시작합니다. 
이것은 7의 왼쪽입니다. 
저는 동시에 색을 다시 입힐 것이고 그림을 다시 그릴 겁니다 

English: 
operation.
If I did, let me know.
OK, it looks good.
So, I still have this
violation, still in trouble
between ten and 18.
But, I've made this straighter.
OK, that's what we want to do,
it turns out,
is make the connection between
18, the violator,
and its grandparent,
a straight connection:
two rights or two lefts.
Here we had to zigzag right,
left.
We like to make it straight.
OK, it doesn't look like a much
more balanced tree that this
one.
In fact, it looks a little
worse.
What we can do is now rotate
these guys, or rather,
rotate this edge.
I'm going to rotate seven to
the left, make ten the root,
and that things will start to
look balanced.
This is a rotate left of seven.
And, I'm also going to do some
recoloring at the same time just

English: 
to save me drawing one more
picture because the root has to
be black.
I'm going to make 10 black
immediately.
I'll make seven red.
That's the change.
And that the rest is just a
rotation.
So, we have 18 over here.
I think I actually have to
rotate to keep some red
blackness here.
Eight comes between seven and
ten.
So it goes here.
11 goes between ten and 18,
so it goes here.
22 and 26 come after 18.
Now, if I'm lucky,
I should satisfy all of
properties that I want.
OK, now, if I'm lucky,
I should satisfy all the

Korean: 
루트가 블랙이어야 하기 때문입니다. 
저는 10 블랙을 즉시 만들겠습니다. 
저는 7 레드를 만들 겁니다. 
그것은 변화입니다. 그리고 나머지는 회전입니다. 
우리는 여기서 18을 가집니다. 
저는 사실 여기서 회전을 해야 합니다.
8은 7과 10 사이입니다. 
그것은 여기로 갑니다. 
11은 10과 18 사이 입니다. 그것은 여기로 갑니다. 
22와 26은 18 다음으로 갑니다. 제가 운이 좋다면 
저는 모든 속성을 만족합니다. 
저는 제가 원하는 모든 속성을 만족합니다. 

Korean: 
모든 노드는 레드 또는 블랙입니다. 
모든 블랙 노드는 자식을 갖습니다. 이것은 우리가 바꾸는 마지막 장소입니다. 
레드 노드는 블랙 자식을 갖고 
모든 블랙 높이는 잘 정의되어야 합니다. 
모든 노드를 위해서 
블랙 노드의 수는 같습니다. 
여러분은 맞는지 확인해야 하고,  
여기서 약간 색을 다시 입히는 것을 했습니다.
그러나 그것은 여전히 맞습니다.
여러분은 그것을 확인할 수 있습니다. 
우리는 약간 더 할 것입니다. 
지금은 그것은 예입니다. 
그것은 아마 분명하지 않지만 작동하고,  
그것은 적어도 여러분에게 그것이 가능하다는 것을 확신시킵니다.
이제, 우리는 그것을 하기 위한 
일반적인 알고리즘을 줄 겁니다. 계속 하기 전에 질문 있나요? 
그것은 정확하지 않지만, 

English: 
properties that I want.
Every node is red or black.
Every black node has a child.
This is the last place we
change.
Red nodes have black children,
and all the black heights
should be well defined.
For every node,
the number of black nodes along
any node to leaf path is the
same.
And you check,
that was true before,
and I did a little bit of
trickery with the recoloring
here.
But it's still true.
I mean, you can check that just
locally around this rotation.
OK, we'll do that in a little
bit.
For now, it's just an example.
It's probably not terribly
clear where these re-colorings
and rotations come from
necessarily, but it worked,
and it at least convinces you
that it's possible.
And now, we'll give a general
algorithm for doing it.
Any questions before we go on?
So, it's not exactly,
I mean, just writing of the

English: 
algorithm is not terribly
intuitive.
Red black trees of the sort of
thing where you play around a
bit.
You say, OK,
I'm going to just think about
recoloring and rotations.
Let's restrict myself to those
operations.
What could I do?
Well, I'll try to recolor.
If that works great,
it pushes the problem up
higher.
And, there's only log n levels,
order log n levels,
so that's going to take order
log n time.
At some point,
I'll get stuck.
I can't recolor anymore.
Then it turns out,
a couple of rotations will do
it.
Always, two rotations will
suffice.
And you just play with it,
and that turns out to work.
And here's how.
OK, so let's suppose we have a
red black tree.
And value x,
we want to insert.
Here's the algorithm.
First, we insert it into the
BST.
So that we know.

Korean: 
알고리즘을 쓰는 것은 직관적이지 않습니다.
레드 블랙 트리 같은 것들이요. 
네.
저는 색을 다시 입히는 것과 회전에 대해 생각해볼 것입니다. 
이 연산들에 스스로 엄격해 집시다.  
저는 무엇을 할 수 있나요? 저는 색을 다시 입힐 수 있습니다.
그것이 훌륭하면, 더 높은 문제를 줍니다.
lg n 레벨만 있습니다, 
그래서 그것은 오더 lg n 시간이 걸립니다. 
어떤 점에서, 저는 막힙니다. 
저는 더 이상 색을 입힐 수 없습니다. 
몇 회전이 그것을 할 것입니다.
항상 두 회전은 충분합니다. 
여러분은 그것을 가지고 놀 수 있고 작동합니다. 
여기 방법이 있습니다. 
우리가 레드 블랙 트리를 가진다고 가정해 보세요. 
우리는 값 x를 삽입하길 원합니다. 
여기 알고리즘이 있습니다.  
먼저 우리는 그것을 BST에 삽입하고 싶습니다.

Korean: 
그리고 우리는 노드를 레드로 합니다. 여기서 저는 약간 더 정확한 개념을 사용할 것입니다. 
색은 x의 공간입니다. 
이제, 우리는 while 루프를 돌면서 
루트를 얻을 때까지 계속 할 것입니다. 
일반적으로 x는 초기에 우리가 삽입했던 인자입니다. 
그러나 우리는 x를 트리로 이동할 것입니다.
우리가 x가 블랙 노드인 것을 찾으면, 
행복합니다, 그것의 부모가 레드니까요. 
아마 그렇지 않을 겁니다. 상관 없어요. 
블랙 노드는 임의의 색 부모를 가질 수 있습니다. 
우리가 걱정 하는 것은 레드 노드입니다. 
X가 레드이면, 우리는 이 루프를 계속해야 합니다. 
물론, 저는 잘 못된 것을 썼습니다. 
색이 레드인 반면, 우리는 이것을 계속 할 것입니다. 

English: 
Then, we color the node red.
And here, I'm going to use a
slightly more precise notation.
Color is a field of x.
And now, we are going to walk
our way up the tree with a while
loop until we get to the root,
or until we reach a black node.
So, in general,
x initially is going to be the
element that we inserted.
But, we're going to move x up
the tree.
If ever we find that x is a
black node, we're happy because
maybe its parent is red.
Maybe it isn't.
I don't care.
Black nodes can have
arbitrarily colored parents.
It's red nodes that we worry
about.
So, if x is red,
we have to keep doing this
loop.
Of course, I just wrote the
wrong one.
While the color is red,

English: 
we're going to keep doing this.
So, there are three cases,
or six, depending on how you
count.
That's what makes this a little
bit tricky to memorize.
OK, but there are some
symmetric situations.
Let me draw them.
What we care about,
I've argued,
is between x and its
grandparent.
So, I'm using p of x here to
denote parent of x just because
it's shorter.
So, p of x is x's grandparent.
Left of p of x is the left
child.
So, what I'm interested in is I
look at x.
And, if I don't assign any
directions, x is the child of
some p of x, and p of x is the
child of the grandparent,
p of p of x.
Now, these edges aren't
vertical.

Korean: 
여러분이 세는 방법에 따라 
세 케이스가 있습니다. 
그것은 외우기 힘들게 하는 부분입니다.
그러나 대칭적인 상황이 있습니다. 
그것들을 그려 봅시다. 
우리가 신경 쓰는 것은 x와 그 부모의 부모 사이입니다.
저는 여기서 x의 p를 사용합니다 
왜냐하면 그것이 더 짧기 때문입니다. 
x의 p는 x의 
부모의 부모입니다. 
왼쪽 x의 p는 왼쪽 자식입니다. 
제가 관심 있는 것은 조부모의 자식입니다. 
이제, 가장자리는 수직이 아닙니다. 

Korean: 
그것들은 왼쪽 또는 오른쪽입니다. 저는 각 하나에 대해 신경 씁니다. 
특히, 저는 부모가 
조부모의 왼쪽인지 봅니다. 
그것은 이와 같아 보입니까?
저는 x가 부모의 왼쪽인지 오른쪽인지 모릅니다. 
그러나 그것은 
왼쪽 또는 오른쪽 자식입니까? 
이 두 케이스는 완전히 대칭적입니다. 
그러나 저는 하나의 방법을 가정해야 합니다. 
다시 말해, 저는 그림을 그릴 수 없습니다. 
그것을 카테고리 A로 부릅시다. 
이것은 카테고리 B입니다. 
저는 여러분에게 카테고리 A에서 무엇을 하는지 알려 줄 겁니다. 카테고리 B는 대칭적입니다. 
여러분은 왼쪽과 오른쪽을 뒤집습니다. 그래서 이것은 A입니다. 
A 안에서, 세 케이스가 있습니다. 

English: 
They are either left or right.
And, I care about which one.
In particular,
I'm looking at whether the
parent is the left child of the
grandparent.
So, I want to know,
does it look like this?
OK, and I don't know whether x
is to the left or to the right
of the parent.
But, is parent of x the left
child of p of x,
or is it the right child?
And these two cases are totally
symmetric.
But I need to assume it's one
way or the other.
Otherwise, I can't draw the
pictures.
OK, so this will be,
let's call it category A.
And, this is category B.
And, I'm going to tell you what
to do in category A.
And category B is symmetric.
You just flip left and right.
OK, so this is A.
So, within category A,
there are three cases.

English: 
And within category B,
there is the same three cases,
just reversed.
So, we're going to do is look
at the other child of the
grandparent.
This is one reason why we sort
of need to know which way we are
looking.
If the parent of x is the left
child of the grandparent,
we're going to look at the
other child of the grandparent,
which would be the right child
of the grandparent,
call that node y.
This is also known as the uncle
or the aunt of x,
depending on whether y is male
or female.
OK, so this is uncle or aunt.
Unfortunately,
in English, there is no
gender-free version of this as
far as I know.
There's parent and child,
but no uncle-aunt.
I'm sure we could come up with
one.
I'm not going to try.
It's going to sound bad.
OK, so why do I care about y?

Korean: 
역으로 B 안에서 같은 세 케이스가 있겠죠.
우리가 하려고 하는 것은 
조부모의 다른 자식을 보는 겁니다. 
이것은 우리가 정렬하는 하나의 이유입니다. 
X의 부모가 조부모의 왼쪽 자식이면,  
우리는 조부모의 
다른 자식을 볼 것입니다, 
그것은 노드 y입니다.
이것은 x의 삼촌 또는 숙모입니다, 
y의 성에 따라서요. 
이것은 삼촌 또는 숙모입니다. 
영어에서, 성 구분 없는 버전이 없습니다. 
부모와 자식은 있지만요. 
저는 우리가 하나를 떠올 릴 수 있다고 생각해요. 
저는 시도하지 않을 것입니다.
나쁘게 들릴 것이거든요. 그래서 우리는 왜 y에 대해 신경 쓰나요? 

English: 
Because, I want to see if I can
do this recoloring step.
The recoloring idea was,
well, the grandparents,
let's say it's black.
If I can push the blackness of
the grandparent down into the
two children,
then if both of these are red,
in other words,
then I'd be happy.
Then I'd push the problem up.
This guy is now red.
This guy is black.
So these two are all right.
This one may violate the great
grandparent.
But we will just keep going up,
and that will be fine.
Today, if we're lucky,
y is red.
Then we can just do recoloring.
So, if the color of y is red,
then we will recolor.
And, I'm going to defer this to
a picture called case one.
OK, let me first tell you how
the cases breakup,

Korean: 
제가 색 입히는 단계를 할 수 있는지 
알기 원하기 때문입니다.
그것을 블랙이라고 합시다. 
저는 조부모를 두 자식으로 넣을 수 있으면, 
이것들이 레드 이면, 저는 행복합니다. 
저는 문제를 올립니다. 
이것들은 이제 레드입니다. 이것은 블랙입니다. 
이 둘은 모두 옳습니다. 이것은 훌륭한 조부모를 위반합니다.
그러나 우리는 계속 할 것이고, 괜찮습니다. 
우리가 운이 좋으면, 
y는 레드입니다.
y의 색이 레드이면, 우리는 다시 색을 입힐 것입니다. 
저는 이것을 그림에서 인용할 겁니다.
먼저 여러분에게 케이스를 깨는 방법을 이야기 하고,  

Korean: 
그것들이 동작하는 방법을 볼 것입니다.
우리가 케이스 1에 있지 않으면, 이 L은 그것에 맞추어 조정되어야 합니다. 
우리는 케이스 2 또는 3에 있습니다. 
여기서 이분이 있습니다. 
우리는 사실 모든 케이스를 보았습니다,  
그러나 우리는 매우 시작 
케이스도 보았습니다.
그것은 케이스 1입니다.  
우리가 볼 다음 것은 짜증나는 것인데 
7과 10이 직선이 아닙니다.

English: 
and then we will see how they
work.
So, if we're not in case one,
so this L should be aligned
with that, then,
then we are either in case two
or three.
So, here's the dichotomy.
It turns out we've actually
seen all of the cases,
maybe not A versus B,
but we've seen the case of the
very beginning where we just
recolor.
That's case one.
The next thing we saw is,
well, it's kind of annoying
that the grandparent and ten,
so seven and ten were not
straight.

Korean: 
그것은 지그재그입니다. 
케이스 2는 그것들이 지그재그일 때 입니다.
X가 부모의 오른쪽 자식이면, 
부모는 조부모의 왼쪽 자식입니다. 그것이 지금까지 우리가 가정한 케이스 2입니다.
다른 케이스는 x가 부모의 왼쪽 자식인 것입니다. 
그러면 우리는 왼쪽 체인, x, x의 부모,
 x의 조부모를 갖습니다. 
그것은 케이스 3입니다. 
저는 여기서 쓰지 않았습니다 
케이스 2가 하는 것이 케이스 3을 줄이는 것이기 때문입니다. 
케이스 2에서, 우리는 여기 있는 것을 할 것입니다. 
케이스 3을 위해 우리는 여기서 합니다. 
케이스 3을 위해 우리는 여기서 합니다. 
또는 케이스 1에서, 우리는 여기서 합니다. 그것은 케이스 3에서 끝납니다,  

English: 
They were zigzagged.
So, case two is when they are
zigzagged.
It turns out if x is the right
child of its parent,
and the parent is the left
child of the grandparent,
that's a we've assumed so far,
that is case two.
OK, the other case is that x is
the left child of its parent.
So, then we have a left chain,
x, parent of x,
grandparent of x.
That is case three.
OK, I did not write else here
because what case two does is it
reduces to case three.
So, in case two,
we are going to do the stuff
that's here.
And then, we're going to do the
stuff here.
For case three,
we just do the stuff here.
Or in case one,
we just do the stuff here.
And then, that finishes the

Korean: 
그리고 이곳으로 돌아옵니다.
이것은 케이스 B이고, A와 같습니다, 
그러나 왼쪽과 오른쪽의 개념이 바뀌었습니다, 
자연스러운 방법입니다.
우리가 그것의 왼쪽을 쓸 때 마다 우리는 그것의 오른쪽을 씁니다,  
역도 성립합니다.
이것은 정말 모든 것을 뒤집는 것입니다. 
우리는 카테고리 A에만 초점을 맞춥니다. 우리가 하는 것이 케이스 3에서 무엇인지 봅시다. 
우리는 예에서 보았습니다. 
그러나 그것을 일반적으로 해 봅시다. 여기서 해 봅시다. 
알고리즘에 하나의 라인이 더 있습니다. 
그것은 여기와 맞춰지지 않습니다. 
우리는 루트의 색을 칠합니다. 여러분이 이것을 할 때  
루트는 레드가 됩니다.

English: 
three cases on the A side,
then back to this if.
We say else,
this is case B,
which is the same as A,
but reversing the notions of
left and right,
OK, in the natural way.
Every time we write left of
something, we instead write
right of something,
and vice versa.
So, this is really just
flipping everything over.
We'll just focus on category A.
And, let's see what we do in
each of the three cases.
We've seen it in an example.
But let's do it generically.
Let's do it here.
Sorry, there's one more line to
the algorithm,
I should say.
It's not aligned with here.
We color the root.
There's a chance when you do
all of this that the root
becomes red.

English: 
We always want the root to be
black.
If it's red,
we set it to black at the very
end of the algorithm.
This does not change the black
height property.
Everything will still be fine
because every path either goes
to the root or it doesn't,
every x to leaf path.
So, changing the root from red
to black is no problem.
It will increase the black
heights of everyone,
but all the paths will still
have the same value.
It will be one larger.
So, let's look at the three
cases.
And, I'm going to use some
notation.
Remember, we had triangles in
order to denote arbitrary
subtrees when we define a
rotation.

Korean: 
우리는 항상 루트가 블랙이길 원합니다.
그것이 레드이면, 우리는 알고리즘의 마지막에서 그것을 블랙으로 설정합니다. 
이것은 블랙 높이 속성을 변화시키지 않습니다. 
모든 것은 좋을 것입니다 
왜냐하면 모든 경로가 루트로 가기 때문입니다. 
루트를 레드에서 블랙으로 바꾸는 것은 문제가 없습니다. 
그것은 모든 블랙의 높이를 증가시키지만, 
모든 경로는 같은 값을 가집니다. 
그것은 더 커집니다.
세 케이스를 봅시다. 
저는 어떤 개념을 사용할 것입니다. 
우리가 회전을 정의할 때 임의의 서브 트리를 나타내기 위해 
삼각형을 가진 것을 기억하세요. 

English: 
I'm going to use triangle with
a dot on top to say that this
subtree has a black root.
So, when I fill something
white, it means black because
I'm on a black board.
Sorry.
OK, and I also have the
property that each of these
triangles have the same black
height.
So, this will let me make sure
that the black height property,
property four,
is being observed.
So, let me just show you case
one.
We always want to make sure
property four is preserved
because it's really hard to get
that back.
It's essentially the balance of
the tree.
So, let's suppose we have some
node, C, left child,
A, right child,

Korean: 
저는 블랙 루트를 가지는 삼각형을 사용할 겁니다. 
제가 무엇을 화이트로 채울 때, 
그것은 블랙을 의미합니다. 
그리고 저는 이 삼각형이 
같은 블랙 높이를 가진다는 속성을 갖습니다.
블랙 높이 속성을 확실히 하고, 
속성 4는 유지 됩니다. 
여러분에게 케이스 1을 보여주겠습니다. 
우리는 항상 속성 4가 유지되길 원합니다 
그것은 돌이키기 정말 어렵기 때문입니다. 
그것을 필수적으로 트리의 균형입니다.
우리가 어떤 노드 C, 왼쪽 자식 A, 
오른쪽 자식 B 그리고 어떤 서브 트리를 가진다고 

English: 
B, and some subtrees hanging
off of those guys.
And, all of those subtrees have
the same black height.
So, in other words,
these things are all at the
same level.
OK, this is not quite what I
wanted, sorry.
So, I'm considering,
this is node x.
x is red, and its parent is
red.
Therefore, we need to fix
something.
We look at the node,
y, which is over here.
And, I'll call it,
the key is D.
The node is called y.
OK, it has subtrees hanging off
as well, all with the same black
height.
So, that will be true.
If all of these nodes are red,
then all of these nodes have
the same black height.
And therefore,
all of the child subtrees,
which have black roots,
all had to have the same black
height as well.
OK, so we're looking at a big
chunk of red children subtree of
a black node,
looking at all the stuff that

Korean: 
가정해 보세요.  
모든 서브 트리들은 같은 블랙 높이를 가집니다.
다시 말해, 이것들은 같은 레벨에 있습니다.
이것은 제가 원한 것이 아닙니다. 
이것은 노드 x입니다. 
x는 레드이고, 그것의 부모는 레드입니다. 
그러므로, 우리는 무엇을 고정시킬 필요가 있습니다. 
우리는 노드 y를 봅니다. 
그것은 여기 있습니다. 저는 그것을 호출할 것입니다,
높이는 D입니다. 노드는 y입니다. 
그것은 서브 트리를 가집니다. 
그것은 옳습니다. 
모든 노드가 레드이면, 이 노드는 같은 블랙 높이를 가집니다. 
그러므로,  
모든 자식 서브 트리는 
같은 블랙 높이를 가져야 합니다.
그래서 우리는 블랙 노드의 레드 자식을 봅니다. 
그것은 레드 일 수 있습니다.

Korean: 
케이스 1에서, 
그것은 왜 레드입니까? 
이것을 생각하는 방법은, 
이것을 하나의 노드로 합병합니다. 
그것은 여기서 우리가 필수적으로 하는 것입니다. 
이것은 2-3-4 트리가 아닙니다. 
우리는 이제 5 자식을 갖는데, 이것은 나쁩니다. 
이것은 우리가 고정하길 바라는 이유입니다. 
우리는 케이스 1에서 색을 다시 입힙니다. 
그리고 우리는 C를 취합니다. C를 블랙으로 하는 대신, 
우리는 A와 D를 블랙으로 하고, 
C를 레드로 합니다.
C는 레드이고, A와 D는 블랙입니다. 
서브 트리들은 모두 같습니다. B는 같습니다. 
여전히 레드입니다. 
이제 우리는 속성 4를 유지하는지 확인해야 합니다. 
그것은 모든 경로가 같은 블랙 노드 수를 가진다는 것입니다. 

English: 
happens to be red.
In case one,
why is red so it participates?
So, a way to think of this as
if we converted into the
two-three-four-tree,
or tried to,
we would merge all of this
stuff into one node.
That's essentially what we're
doing here.
This is not a two-three-four
tree, though.
We now have five children,
which is bad.
This is why we want to fix it.
So, we're going to recolor in
case one.
And, we're going to take C.
Instead of making C black,
and A and D red,
we are going to make A and D
black, and C red.
So, C is red.
A is black.
D is black.
And, the subtrees are the same.
B is the same.
It's still red.
OK, now we need to check that
we preserve property four,
that all of the paths have the
same number of black nodes.
That follows because we know we

Korean: 
우리는 이 서브 트리를 건드리지 않았다는 것을 압니다. 그것들은 모두 같은 블랙 높이를 가집니다. 
우리가 경로를 보면, 
모든 경로는 블랙 높이를 가집니다. 
C의 모든 경로는 블랙 높이 더하기 1입니다 
왜냐하면 왼쪽과 오른쪽에 
블랙 노드가 있기 때문입니다. 
모든 블랙 링크는 같습니다. 
이것은 속성 4를 유지합니다. 
B가 A를 위반하곤 했기 때문에 지역적으로 속성 3을 유지합니다.
B는 아무 것도 위반하지 않습니다, 
C는 이제 위반 됩니다. 
우리가 하려고 하는 것은 집합 x입니다, 
우리의 새로운 값은 C입니다. 그것은 B이곤 했습니다. 
우리는 몇 단계 올립니다. 원래의 트리에서, 
우리는 그것을 몇 단계 올립니다. 
우리는 트리를 올리고 싶습니다. 
그리고 우리는 이 루프를 계속합니다. 그것이 케이스 1입니다, 

English: 
didn't touch these subtrees.
They all have the same black
height.
And, if you look at any path,
like, all the paths from A are
going to have that black height.
All the paths from C are going
to have that black height plus
one because there's a black node
in all the left paths,
and there is a black node in
all the right paths.
So, all the black links are the
same.
So, this preserves property
four.
And, it fixes property three
locally because B used to
violate A.
Now B does not violate
anything.
C, now, might be violated.
So, what we're going to do is
set x, our new value of x,
will be C.
So, it used to be B.
We move it up a couple levels.
Or, in the original tree,
yeah, we also move it up a
couple levels.
So, we're making progress up
the tree.
And then we continue this loop.
That's case one:

English: 
recolor, go up.
C may violate its parent in
which case we have to recurse.
So, we are recursing,
in some sense,
or continuing on C.
So now, let's look at case two.
So, I'm still,
in some sense,
defining this algorithm by
picture.
This is some nice,
graphical, programming

Korean: 
컬러를 다시 입히고, 계속 하세요. C는 그것의 부모를 위반합니다. 
우리는 재귀하고, 
C를 계속합니다.
케이스 2를 봅시다. 
저는 여전히 이 알고리즘을 정의합니다. 
이것은 좋은, 
그래픽적인 프로그래밍 언어입니다. 

Korean: 
케이스 2를 그려 봅시다. 
저는 케이스 1에 대해 언급하는 것을 잊었습니다. 
저는 여기서 무엇을 그렸습니다. 제가 알고 있는 것이 맞나요? 
역으로 된 알고리즘을 봅시다. 
우리는 우리가 카테고리 A에 있다고 가정합니다. 
즉 
부모는 조부모의 왼쪽 자식입니다. 
A는 C의 왼쪽 자식입니다. 그것은 제가 아는 것입니다. 
그러므로, y는 오른쪽 자식입니다. 
D는 C의 오른쪽 자식입니다.
저는 B가 왼쪽인지 오른쪽인지 몰랐습니다.
그것은 중요하지 않았습니다. 
케이스 1에서 그것은 중요하지 않습니다. 
A의 자식은 역으로 되었습니다. 
그러나 그것은 같은 그림입니다. 
w는 이것에 대해 생각했습니다.  
케이스 1은 우리가 신경 쓰지 않습니다.
케이스 2는 

English: 
language.
So, let's draw case two.
Yeah, I forgot to mention
something about case one.
So, I drew some things here.
What do I actually know is
true?
So, let's look at the algorithm
in which I've now reversed.
But, we are assuming that we
are in category A.
In other words,
the parent is the left child of
the grandparent.
So, A is the left child of C.
That much I knew.
Therefore, y is the right
child.
D is the right child of C.
I didn't actually know whether
B was the right child or the
left child.
It didn't matter.
In case one,
it doesn't matter.
OK, so I should've said,
the children of A may be
reversed.
But it just said the same
picture.
OK, I thought of this because
in case two, we care.
So, case one:
we didn't really care.
In case two,
we say, well,

English: 
case two is up there,
is x the right child of the
parent, or the left child?
If it's the right child,
we are in case two.
So now, I can really know that
x here, which is B,
is the right child of A.
Before, I didn't know and I
didn't care.
Now, I'm assuming that it's
this way.
OK, y is still over here.
And now, now we know that y is
black.
So, y over here is a black
node.
So now, if I did the
contraction trick,
all of these nodes,
A, B, and C,
would conglomerate into one.
I only have four children.
That actually looks pretty
good.
y would not be involved because
it's black.
So, in this case,
we are going to do a left
rotation on A.

Korean: 
저기로 올라갑니다, 
x는 부모의 오른쪽 자식인가요? 왼쪽 자식인가요?
그것이 오른쪽 자식이면, 우리는 케이스 2에 있습니다. 
이제, 저는 정말 여기서 x를 알아야 합니다, B는 A의 오른쪽 자식입니다. 
저는 모르고 신경 쓰지도 않았습니다. 
이제 저는 그것을 이 방법이라고 가정합니다. 
y는 여전히 여기 있습니다.  
이제 우리는 y가 블랙이라는 것을 압니다.
여기서  
y는 블랙 노드입니다. 
이제, 모든 노드들은 하나로 복합됩니다.
저는 4 자식을 가집니다. 그것은 매우 좋아 보입니다. 
y는 포함되지 않습니다 그것은 블랙이라서요. 
이 케이스에서, 
우리는 A에서 왼쪽 회전을 합니다.

Korean: 
우리는 가장자리에서 90도 회전합니다.
우리가 얻는 것은 왼쪽에서 A, 오른쪽에서 B입니다. 
그것은 유지됩니다. 
우리는 y 서브 트리를 갖습니다. 
우리는 B에 달린 다른 세 서브 트리 중 하나를 갖습니다, 
다른 두 개는 A에 있습니다. 
이것은 일반적인 회전 그림입니다. 
그것이 하는 것은 
x와 그 조부모 사이입니다. 
이제 우리는 지그재그를 갖습니다.
우리는 x 사이의 직선을 갖습니다. X는 여전히 여기 아래에 있습니다. 
저는 이 케이스에서 x를 바꾸지 않습니다. 왜냐하면 제가 케이스 2를 한 후에, 즉시 3을 하기 때문입니다. 
이것은 케이스 3입니다. 

English: 
So, we take the edge,
we turn at 90∞.
What we get is A on the left,
B on the right still.
It should preserve the in order
traversal, C up top still.
We have the y subtree hanging
off, as before.
We have one of the other three
subtrees hanging off B,
and the other two now hang off
A.
So, this is just a generic
rotation picture applied to this
edge.
OK, what that does,
is before we had a zigzag
between x and its grandparent.
Now, we have a zigzig.
We have a straight path between
x.
So, x is still down here.
I'm not changing x in this case
because after I do case two,
I immediately do case three.
So, this is what case three

English: 
will look like.
And now, I continue on to case
three.
So, finally,
here's case three.
And, this will finally complete
the insertion algorithm.
We have a black node,
C.
We have a red left child from
C.
We have a red,
left, grandchild which is x.
And then, we have these black
subtrees all of the same black
height hanging off,
OK, which is exactly what we
had at the end of case two.
So, that definitely connects
over.
And remember,
this is the only case left in
category A.
Category A, we assumed that B
was the parent of x,
was the left child of the
grandparent, B or C.
So, we know that.
We already did the case one,
y over here as red.
That was case one.
So, we are assuming y is black.

Korean: 
이제 저는 케이스 3을 계속합니다. 
마지막으로 
여기 케이스 3이 있습니다. 이것은 완벽한 삽입 알고리즘입니다. 
우리는 블랙 노드 C를 갖습니다. 
우리는 C로부터 레드 왼쪽 자식을 갖습니다. 
우리는 그 x를 갖습니다. 
그리고 우리는 모든 같은 블랙 높이의 이 블랙 서브 트리를 갖습니다, 
그것은 정확히 우리가 케이스 2의 
마지막에서 갖는 것입니다.
그것은 분명히 연결 됩니다. 
이것이 카테고리 A에서 왼쪽 케이스라는 것을 기억하세요. 
우리는 B가 x의 부모라고 가정했습니다,  
그것은 조부모의 왼쪽 자식입니다. 
우리는 그것을 알고 있습니다.
우리는 이미 케이스 1을 했습니다, 그것은 케이스 1이었습니다. 
우리는 y가 블랙이라고 가정합니다. 

English: 
Now, we look at whether x was
the left child or the right
child.
If it was the right child,
we made it into the left child.
x actually did change here.
Before, x was B.
Now, x is A.
OK, and then case three,
finally, is when x is the left
child of the parent who is the
left child of the grandparent.
This is the last case we have
to worry about.
And, what we do is another
rotation just like the last
rotation we did in the example.
That was case three.
So, we're going to do a right
rotate in this case of C.
And, we are going to recolor.
OK, so, what do we get?

Korean: 
우리는 x가 왼쪽 또는 오른쪽 자식인지 봅니다. 
그것이 오른쪽 자식이면, 그것을 왼쪽으로 바꿉니다. 
X는 사실 여기서 바뀌었습니다. 
X는 전에 B였습니다. 이제 x는 A입니다. 
마지막으로, 케이스 3은 x가 
왼쪽 자식일 때 입니다. 
이것은 우리가 걱정하는 마지막 케이스입니다. 
우리가 하는 것은 예에서 했던 마지막 회전입니다.
그것은 케이스 3입니다. 
우리는 케이스 C에서 오른쪽 회전을 할 것입니다. 
우리는 색을 다시 입힐 겁니다. 우리는 무엇을 얻죠?

English: 
Well, B now becomes the root.
And, I'm going to make it
black.
OK, remember,
this is the root of the
subtree.
There is other stuff hanging
off here.
I really should have drawn
extra parents in all of these
pictures.
There was somewhere in the
middle of the tree.
I don't know where.
It could be a rightward branch;
it could be a leftward branch.
We don't know.
C becomes the child of B,
and I'm going to make it a red
child.
A becomes a child of B,
as it was before,
keep it red.
And, everything else just hangs
off.
So, there were four subtrees
all at the same black height.
And, in particular,
this last one had y,
but we don't particularly care
about y anymore.
Now, we are in really good
shape because we should have no
more violations.
Before, we had a violation
between x and its parent,
A and B.
Well, A and B still have a
parent child relation.
But B is now black.

Korean: 
B는 이제 루트가 됩니다.  
저는 그것을 블랙으로 할 것입니다.
 이것은 서브 트리의 루트라는 것을 기억하세요.
여기서 다른 것들도 있습니다. 
저는 이 그림에서 여분의 그림을 그려야 합니다. 
트리의 중간에 있습니다. 
저는 어디에 있는지 모릅니다. 
그것은 오른쪽 가지입니다. 그것은 왼쪽 가지일 수 있습니다. 
우리는 모릅니다. C는 B의 자식이 되고 
저는 그것을 레드 자식으로 할 것입니다. 
A는 B의 자식이 됩니다, 전처럼, 그것을 레드로 하세요. 
모든 것은 달려있습니다. 
같은 블랙 높이에 4 서브 트리가 있습니다.
특히, 마지막 것은 y를 가지지만 
우리는 더 이상 신경 쓰지 않습니다. 
이제 우리는 정말 좋은 모양에 있습니다  
우리는 더 이상 위반하지 않습니다.
우리는 전에 x와 그 부모 사이에서 위반을 했습니다. 
A와 B는 여전히 부모 자식 관계를 가집니다. 
그러나 B는 이제 블랙입니다. 

Korean: 
B는 블랙이고 우리는 그것의 부모가 무엇인지 신경 쓰지 않습니다. 
그것은 레드 또는 블랙입니다. 
모두 좋습니다. 우리는 속성 3을 더 이상 위반하지 않습니다. 
우리는 이 케이스에 있어야 합니다.
속성 3은 이제 옳습니다. 여러분이 원하면, 
x는 이 노드가 되어야 합니다. 
x는 더 이상 레드가 아닙니다. 
저는 다 했습니다. 우리는 속성 4가 이 과정 동안 
유지되는지 확인할 필요가 있습니다. 
그것은 2-3-4 트리 변환 때문에 어렵지 않습니다. 
제가 모든 레드를 부모로 연결하면, 
모든 것은 일정합니다, 
모든 경로는 같은 길이를 갖습니다 
그것들이 같은 블랙 길이를 갖기 때문입니다. 
여기서, 그것은 여전히 옳습니다. 그것은 여기서 약간 까다롭습니다 
왜냐하면 우리는 동시에 다시 색을 입힙니다. 
여러분이 경로를 보면, 
그것은 블랙 노드 C를 살펴 봅니다. 
저는 신경 쓰지 않아요. 

English: 
And, B is black,
so we don't care what its
parent looks like.
It could be red or black.
Both are fine.
We are no longer violating
property three.
We should be done in this case.
Property three is now true.
If you want,
you can say,
well, x becomes this node.
And then, the loop says,
oh, x is no longer red.
Therefore, I'm done.
We also need to check that
property four is preserved
during this process.
Again, it's not hard because of
the two-three-four tree
transformation.
If I contract all the red
things into their parents,
everything else has a constant,
I mean, every path in that tree
has the same length because they
have the same black length.
And over here,
that will still be true.
It's a little bit trickier
here, because we are recoloring
at the same time.
But, if you look at a path that
comes through this tree,
it used to go through a black
node, C, and then maybe some red
stuff; I don't care.
And then, it went through these

English: 
trees, which all have the same
black height.
So they were all the same.
Now, you comment,
and you go through a black node
called B.
And then, you go through some
red nodes.
It doesn't really matter.
But all the trees that you go
through down here have the same
black height.
So, every path through this
tree will have the same black
length, OK, if it starts from
the same node.
So, we preserve property four.
We fix property three.
That is the insertion
algorithm.
It's pretty long.
This is something you'll
probably just have to memorize.
If you try a few examples,
it's not so hard.
We can see that all the things
we did in this example were the
three cases.
The first step,
which unfortunately I had to
erase for space,
all we did was recolor.
We recolored ten,
and eight, and 11.
That was a case one.
Ten was the grandparent of 15.
Then, we looked at ten.
Ten was the violator.
It was a zigzag case relative
to its grandparent.
So, we did a right rotation to
fix that, took this edge,

Korean: 
그것은 이 트리를 통과하고, 그것은 같은 블랙 높이를 가집니다.
그것들은 모두 같습니다. 이제 
여러분은 B라는 블랙 노드를 살펴 봅니다. 
그리고 여러분은 레드 노드도 살펴 봅니다. 
그것은 정말 중요하지 않아요. 그러나  
모든 트리는 여기서 같은 블랙 높이를 가집니다.
이 트리의 모든 경로는 같은 블랙 높이를 가집니다. 
그것은 같은 노드에서 시작합니다. 
우리는 속성 4를 유지합니다. 우리는 속성 3을 고정합니다.  
그것은 삽입 알고리즘입니다.
매우 깁니다. 이것은 여러분이 아마 기억해야 하는 것입니다.
여러분이 예제를 해 보면, 그리 어렵지 않습니다. 
우리는 예에서 했던 것들을 
볼 수 있습니다. 
첫 번째 단계에서 우리가 한 모든 것은 
색을 다시 입히는 것입니다. 
우리는 10 8 11을 다시 색 입혔습니다. 
그것은 케이스 1이었습니다. 10은 15의 조부모입니다. 
그리고 우리는 10을 봅니다. 10은 위반자입니다. 
그것은 조부모와 연관된 지그재그 케이스입니다. 
우리는 그것을 고정하기 위해 오른쪽 회전을 했고 

Korean: 
10은 다음 7이 되었습니다.
위의 그림입니다. 18은 새로운 
위반자이고, 지그재그입니다. 
그것들은 모두 같은 방향에 있습니다. 
이제 우리는 그것을 고정하기 위해 회전을 더 합니다. 
그것을 여러분이 기억해야 하는 것입니다.  
여러분이 할 수 있으면 조부모를 다시 칠하세요.
그것을 지그재그로 만드세요. 그리고 마지막 회전을 하세요. 
다시 칠하세요. 그럼 작동할 것입니다. 
여러분이 기억한다면, 여러분은 특정 예를 알아 낼 수 있습니다.
우리는 10을 회전합니다. 그것은 블랙인 것이 낫습니다, 
이 케이스에서 그것은 루트가 되기 때문입니다. 
그러나 우리는 그것을 블랙으로 할 것입니다 
왜냐하면 저기 하나의 블랙 노드가 있어야 하기 때문입니다. 
우리가 동시에 다시 칠하지 않으면, 
속성 4를 위반합니다. 
시간이 얼마 안 남았군요. .
우리가 여기서 회전을 하면, 

English: 
and turned it so that ten
became next to seven.
That's the picture on the top.
Then, 18, which is the new
violator, with its grandparent,
is a zigzig.
They are both going in the same
direction.
And, now, we do one more
rotation to fix that.
That's really the only thing
you have to remember.
Recolor your grandparent if you
can.
Otherwise, make it zigzig.
And then, do one last rotation.
And recolor.
And that will work.
I mean, if you remember that,
you will figure out the rest on
any particular example.
We rotate ten over.
That better be black,
because in this case it's
becoming the root.
But, we will make it black no
matter what happens because
there has to be one black node
there.
If we didn't recolor at the
same time, we would violate
property four.
Why don't I draw that just for,
OK, because I have a couple
minutes.
So, if we just did the rotation

English: 
here, so let's say,
not the following,
we take B.
B is red.
This will give some intuition
as to why the algorithm is this
way, and not some other way.
And, C is black.
That's what we would have
gotten if we just rotated this
tree, rotated B,
or rotated C to the right.
So, these subtrees hang off in
the same way.
Subtrees look great because
they all have the same black
height.
But, you see,
there's a problem.
If we look at all the paths
starting from B and going down
to a leaf, on the left,
the number of black nodes is
whatever the black height is
over here.
Label that: black height,
whereas all the paths on the
right will be that black height
plus one because C is black.
So now, we've violated property
four.
So, we don't do this in case
three.
After we do the rotation,

Korean: 
우리는 B를 취합니다
B는 레드입니다. 
이것은 알고리즘이 왜 이 방법인지에 대한 직관을 줍니다. 
C는 블랙입니다. 
그것은 우리가 
가진 것입니다.
이 서브 트리는 같은 방법으로 달립니다. 서브 트리는 훌륭해 보입니다 
그것들이 모두 같은 블랙 높이를 가지기 때문입니다.
그러나 문제가 있습니다. 
여러분이 B에서 
시작하는 모든 경로를 보면, 
블랙 노드의 수는 
블랙의 키가 여기 있습니다.
오른쪽에서 모든 경로는 블랙 높이 더하기 1입니다 
왜냐하면 C가 블랙이기 때문입니다. 이제 우리는 속성 4를 위반했습니다. 
우리는 케이스 3에서 이것을 하지 않습니다. 
회전한 후에, 

English: 
we also do a recoloring.
So, we get this.
In other words,
we are putting the black node
at the top because then every
path has to go through that
node, whereas over here,
some of the nodes went through
the C.
Some of them went through A.
So, this is bad.
Also, we would have violated
property three.
But, the really bad thing is
that we are violating property
four over here.
OK, let me sum up a little bit.
So, we've seen,
if we insert into a red black
tree, we can keep it a red black
tree.
So, RB insert adds x to the set
to the dynamic set that we are

Korean: 
또 색을 칠합니다. 우리는 이것을 얻습니다. 
즉, 우리는 
블랙 노드를 위에 둡니다
 왜냐하면 모든 경로는 그 노드를 살펴야 하기 때문입니다. 
그것들 중 몇 가지는 A를 살핍니다. 
이것은 나쁩니다. 우리는 속성 3을 위반합니다. 
정말 나쁜 것은 우리가 
여기서 속성 4를 위반한다는 것입니다. 
약간 더 더해 봅시다.
우리가 레드 블랙 트리로 삽입하면, 
우리는 그것을 레드 블랙 트리로 유지할 수 있습니다. 
RB 삽입은 x를 동정집합으로 더합니다, 

Korean: 
그리고 레드 블랙을 유지합니다. 
그것은 레드 블랙 트리를 유지하고, 좋습니다 
왜냐하면 우리는 그것이 대수 높이라는 것을 알기 때문입니다. 
그러므로 모든 쿼리는 대수의 시간이 걸립니다. 
레드 블랙 삽입은 얼마나 걸리나요? 
우리는 lg n 시간을 목표로 합니다. 
우리는 그것을 공식적으로 증명하지 않지만, 
그것은 매우 직관적이어야 합니다. 
잘못 된 곳에서 케이스 
2와 3은 종결됩니다.
우리가 케이스 3을 할 때, 우리는 다 한 것입니다. 
우리가 케이스 2를 할 때, 우리는 케이스 3을 하려고 합니다. 
우리가 세는 유일한 것은 케이스 1입니다 
각 연산이 정수 시간이 걸립니다. 
그것들은 다시 색을 입히고, 회정합니다, 그것들은 모두 정수 시간이 걸립니다.
중요한 것은
얼마나 많이 있습니까?

English: 
trying to maintain,
and preserves red blackness.
So, it keeps the tree a red
black tree, which is good
because we know then it keeps
logarithmic height.
Therefore, all queries in red
black trees will keep taking
logarithmic time.
How long does red black insert
take?
We know we are aiming for log n
time preparation.
We are not going to prove that
formally, but it should be
pretty intuitive.
So, cases two and three,
sorry, pointing at the wrong
place, cases two and three are
terminal.
When we do case three,
we are done.
When we do case two,
we are about to do case three,
and then we are done.
OK, so the only thing we really
have to count is case one
because each of these
operations, they are recoloring,
rotation, they all take
constant time.
So, it's a matter of,
how many are there?
Case one does some recoloring,

Korean: 
케이스 1은 색을 다시 입히고, 트리를 전혀 바꾸지 않습니다, 그리고 x를 두 단계 올립니다.
우리는 트리의 키가 최대 2 lg n 더하기 1이라는 것을 압니다. 
케이스 1의 수는 최대 lg n 더하기 1입니다. 
케이스 1의 수는 최대 lg n 입니다. 
그것은 lg n 시간이 걸립니다. 
케이스 2와 3은 
이 열들의 하나입니다. 
2와 3은 최대 2입니다. 
그래서 lg n 시간입니다. 
다른 흥미로운 것은 
그것이 O(1) 회전을 한다는 겁니다. 
대부분의 변화는 색 입히기 입니다. 
케이스 1은 색을 다시 입히고, 회전을 하지 않습니다. 
케이스 2는 아마 회전을 합니다. 
케이스 3은 한번의 회전을 합니다 만약 여러분이 그 케이스에 있다면요. 
회전의 수는 최대 2입니다. 

English: 
doesn't change the tree at all,
and moves x up by two levels.
We know that the height of the
tree is, at most,
two log n plus one.
So, the number of case ones is,
at most, log n plus one.
OK, so the number of case ones
is, at most, log n.
So, those take log n time.
And then, the number of case
twos and threes is,
at most, one for one of these
columns.
Well, together,
twos and threes is,
at most, two.
OK, so, log n time,
cool.
The other thing that is
interesting about red black
insertion is that it only makes
order one rotations.
So, most of the changes are
recolorings.
Case one just does recoloring,
no rotations.
Case two maybe does one
rotation.
Case three does one rotation if
you happen to be in those cases.
So, the number of rotations is,

Korean: 
그것은 삽입에서 1 또는 2입니다.
회전이 색 입히기 보다 
더 성가시기 때문에 좋습니다. 
왜죠? 여러분이 데이터 구조를 가지면, 
여러분이 검색 트리를 가지면, 
사람들은 검색 트리를 가집니다. 
그들은 쿼리를 만듭니다. 
예를 들어, 
검색 트리는 구글에서 워드 컴퓨터와 매칭되는 모든 문서를 나타냅니다. 
여러분은 여기서 구글 티셔츠를 얻습니다, 구글을 사용해 봅시다.
여러분은 검색 트리를 갖습니다. 
그것은 단어 구글을 포함한 모든 것을 저장합니다. 
여러분은 수정된 것을 
검색하고 싶습니다. 
여러분은 이 트리에서 쿼리를 합니다. 
사람들은 이상한 쿼리를 합니다. 
그들은 엄청난 것을 얻습니다. 그것에 대해 언급하지 않겠습니다. 
수는 정확하지 않습니다. 
엄청난 수입니다. 그러나 사람들은 항상 검색을 합니다. 
여러분이 트리에 색을 다시 입히면, 사람들은 여전히 검색을 합니다. 
그것은 여러분이 건너 뛰는 것입니다. 
저는 검색에서 노드가 레드인지 블랙인지 신경 쓰지 않습니다 
왜냐하면 저는 그것이 대수 높이라는 것을 알기 때문입니다.

English: 
at most, two.
It's either one or two in an
insertion.
It's kind of nice because
rotating a tree is a bit more
annoying than recoloring a tree.
Why?
Because if you had,
say, a data structure,
you have a search tree,
presumably, people are using
the search tree for something.
They are, like,
making queries.
For example,
the search tree represents all
the documents matching the word
computer in Google.
You've got the Google T-shirt
on here, so let's use a Google
reference.
You have the search tree.
It stores all the things
containing the word Google.
You'd like to search may be for
the ones that were modified
after a certain date,
or whatever it is you want to
do.
So, you're doing some queries
on this tree.
And, people are pummeling
Google like crazy with queries.
They get a zillion a second.
Don't quote me on that.
The number may not be accurate.
It's a zillion.
But, people are making searches
all the time.
If you recolor the tree,
people can still make searches.
It's just a little bit you are
flipping.
I don't care in a search
whether a node is red or black
because I know it will have

Korean: 
여러분은 수시 업데이트를 하면서 
변화를 알 수 있습니다. 
색 다시 입히기는 좋습니다. 
회전은 더 비쌉니다 여러분이 노드를 잠그고 
회전하는 동안 아무도 건드리지 못하게 해야 하기 때문입니다, 
그리고 그것들을 풀어줍니다. 
회전 수가 작다는 것은 좋습니다 
우리가 정렬 리스트를 
필수적으로 삽입하기 때문에 
시간은 lg n 입니다. 
삭제는 하지 않을 것입니다.
책에서 읽어 보세요. 
약간 더 복잡할 것이지만, 같은 생각입니다. 
그것은 같은 바운드를 가집니다, 
lg n 시간 O(1)회전입니다. 확인해보세요. 그것은 레드 블랙 트리입니다. 
이제 여러분은 lg n 시간에 데이터를 유지할 수 있습니다 
좋아요. 우리는 그것을 하기 위한 세 가지 방법을 볼 것입니다.

English: 
logarithmic height.
So, you can come along and make
your occasional updates as your
crawler surfs the Web and finds
changes.
And, recoloring is great.
Rotation is a bit expensive
because you have to lock those
nodes, make sure no one touches
them for the duration that you
rotate them, and then unlock
them.
So, it's nice that the number
of rotations is small,
really small,
just two, whereas the time has
to be log n because we are
inserting into a sorted list
essentially.
So, there is an n log n lower
bound if we do n insertions.
OK, deletion and I'm not going
to cover here.
You should read it in the book.
It's a little bit more
complicated, but the same ideas.
It gets the same bounds:
log n time order one rotations.
So, check it out.
That's red black trees.
Now, you can maintain data in
log n time preparation:
cool.
We'll now see three ways to do
it.
