
Korean: 

좋은 아침입니다. 오늘 우리는 
균형 검색 구조에 대해 이야기할 것입니다,  
삽입 삭제 검색을 조건으로 
동적 집합을 유지하는 데이터 구조입니다.
저는 이것을 동적 검색 구조라고 부를 것입니다 
왜냐하면 그것은 데이터 구조이기 때문입니다. 
그것은 검색을 지원하고, 그것은 동적입니다, 삽입과 삭제를 의미합니다. 
비교를 위해 우리가 아는 
다른 동적 구조는 무엇이 있나요? 
말해 보세요,
연산 당 대수의 시간입니다. 

English: 
Good morning.
Today we're going to talk about
it a balanced search structure,
so a data structure that
maintains a dynamic set subject
to insertion,
deletion, and search called
skip lists.
So, I'll call this a dynamic
search structure because it's a
data structure.
It supports search,
and it's dynamic,
meaning insert and delete.
So, what other dynamic search
structures do we know,
just for sake of comparison,
and to wake everyone up?
Shut them out,
efficient, I should say,
also good, logarithmic time per
operation.

English: 
So, this is a really easy
question to get us off the
ground.
You've seen them all in the
last week, so it shouldn't be so
hard.
Treap, good.
On the problems that we saw
treaps.
That's, in some sense,
the simplest dynamic search
structure you can get from first
principles because all we needed
was a bound on a randomly
constructed binary search tree.
And then treaps did well.
So, that was sort of the first
one you saw depending on when
you did your problem set.
What else?
Charles?
Red black trees,
good answer.
So, that was exactly one week
ago.
I hope you still remember it.
They have guaranteed log n
performance.
So, this was an expected bound.
This was a worst-case order log
n per operation,
insert, delete,

Korean: 
이것은 정말 쉬운 질문입니다.
여러분은 그것들을 모두 지난 주에 보았습니다, 
그래서 그것은 어려워서는 안됩니다. 
다른 문제에서, 우리는 treaps를 보았습니다. 
그것은 첫 번째 원칙으로부터 
여러분이 얻을 수 있는 동적 검색 구조입니다 
왜냐하면 우리가 필요했던 모든 것은 랜덤하게 구축된 이진 검색 트리이기 때문입니다. 
그리고 treaps은 잘 했습니다. 
그래서 그것은 여러분이 언제 문제 세트를 보는지에 의존하는 첫 번째 것입니다. 
또 무엇이 있나요?
Chales? 레드 블랙 트리입니다, 
좋은 답변입니다. 그것은 정확히 한 주 전의 것이었습니다. 
저는 여러분이 기억하길 바랍니다. 
그것들은 lg n의 성능을 보장합니다. 
그래서 이것은 예상 바운드입니다. 이것은 연산 당  
최악의 케이스 O(lg n) 입니다.

English: 
and search.
And, there was one more for
those who want to recitation on
Friday: B trees,
good.
And, by B trees,
I also include two-three trees,
two-three-four trees,
and all those guys.
So, if B is a constant,
or if you want your B trees
knows a little bit cleverly,
that these have guaranteed
order log n performance,
so, worst case,
order log n.
So, you should know this.
These are all balanced search
structures.
They are dynamic.
They support insertions and
deletions.
They support searches,
finding a given key.
And if you don't find the key,
you find its predecessor and
successor pretty easily in all
of these structures.
If you want to augment some
data structure,
you should think about which
one of these is easiest to
augment, as in Monday's lecture.
So, the question I want to pose
to you is supposed I gave you
all a laptop right now,
which would be great.
Then I asked you,

Korean: 
그리고 하나 더 있습니다. 
B 트리입니다. 
B 트리에 의해, 
저는 2-3 트리를 포함합니다, 2-3-4도요. 
B가 상수이면, 
여러분이 B 트리를 원하면, 
이것은 lg n의 성능을 보장합니다. 
최악의 케이스, lg n 입니다. 
그래서 여러분은 이것을 알아야 합니다. 이것들은 모두 균형 검색 
구조들입니다. 그것들은 동적입니다. 
그것들은 삽입과 삭제를 지원합니다. 
그것들은 검색을 지원하고, 주어진 키를 찾습니다. 
여러분이 키를 찾지 않으면, 
여러분은 이 모든 구조에서 전임자와 후임자를 쉽게 찾습니다.
여러분이 데이터 구조를 논하고 싶으면, 
여러분은 이것들 중 하나가 가장 쉽다고 생각해야 합니다, 
월요일 강의처럼요. 
제가 제기하고 싶은 질문은 제가 여러분에게 지금 노트북을 주었다 해봅시다.
저는 여러분에게 묻습니다, 

English: 
in order to keep this laptop
you have to implement one of
these data structures,
let's say, within this class
hour.
Do you think you could do it?
How many people think you could
do it?
A couple people,
a few people,
OK, all front row people,
good.
I could probably do it.
My preference would be B trees.
They're sort of the simplest in
my mind.
This is without using the
textbook.
This would be a closed book
exam.
I don't have enough laptops to
do it, unfortunately.
So, B trees are pretty
reasonable.
Deletion, you have to remember
stealing from a sibling and
whatnot.
So, deletions are a bit tricky.
Red black trees,
I can never remember it.
I'd have to look it up,
or re-derive the three cases.
treaps are a bit fancy.
So, that would take a little
while to remember exactly how
those work.
You'd have to solve your
problem set again,
if you don't have it memorized.
Skip lists, on the other hand,
are a data structure you will
never forget,

Korean: 
여러분은 이 데이터 구조들 중 하나를 구현해야 합니다, 
이 수업 시간 내에서요. 
여러분은 그것들 할 수 있나요? 
얼마나 많은 학생들이 할 수 있다고 생각하나요? 
몇몇 되는군요. 
앞 줄 학생들도 그렇고요. 
저는 그것을 할 수 있습니다. 제 성능은 B 트리입니다. 
그것들은 가장 간단합니다. 
이것은 교재를 사용하지 않은 것입니다. 
이것은 교재 없이 보는 시험입니다. 
안타깝게도 저는 충분한 노트북이 없습니다.
B 트리는 매우 합리적입니다. 
삭제는, 형제에서 가져오는 것을 기억하세요. 
삭제는 약간 까다롭습니다. 
저는 그것을 절대 기억할 수 없습니다, 레드 블랙 트리에서요. 
저는 그것을 보아야 합니다, 또는 세 케이스를 끌어내야 합니다. 
Treaps는 약간 좋습니다. 그것들은 정확히  
어떻게 동작하는지 기억하는데 시간이 걸립니다.
여러분은 암기하지 않으면, 여러분의 문제 세트를 다시 풀어야 합니다. 
스킵 리스트는 
여러분이 절대 잃어 버리지 않을 

Korean: 
데이터 구조입니다, 
그리고 저는 항상 나쁘게 느꼈습니다 왜냐하면 저는 
그것을 실제로 절대 하지 않았기 때문입니다.
오늘 아침에 저는 스킵 리스트를 구현했습니다, 
그리고 연결 리스트를 구현하는데 10분이 걸리고 스킵 리스트를 구현하는데 30분이 걸렸습니다. 
다른 30분은 그것들을 디버깅 했습니다. 
그것은 다 될 수 있습니다. 
스킵 리스트는 정말 간단합니다. 
저는 코드를 쓰는 것을 생각하지 않아도 됐었지만, 
반면에 모든 다른 구조를 생각해야 합니다.
저는 어떻게 동전을 뒤집나요? 
그것은 전체의 양입니다. 
스킵 리스트는 랜덤 구조입니다. 
다른 형용사를 여기 넣어 봅시다, 
 '간단한'을 더해보죠.
우리는 간단한 효율적인 동적 랜덤 검색 구조를 가집니다. 
그것은 treaps이고 바운드는 
단지 랜덤 바운드입니다. 

English: 
and something you can implement
within an hour,
no problem.
I've made this claim a couple
times before,
and I always felt bad because I
had never actually done it.
So, this morning,
I implemented skip lists,
and it took me ten minutes to
implement a linked list,
and 30 minutes to implement
skip lists.
And another 30 minutes
debugging them.
There you go.
It can be done.
Skip lists are really simple.
And, at no point writing the
code did I have to think,
whereas every other structure I
would have to think.
There was one moment when I
thought, ah, how do I flip a
coin?
That was the entire amount of
thinking.
So, skip lists are a randomized
structure.
Let's add in another adjective
here, and let's also add in
simple.
So, we have a simple,
efficient, dynamic,
randomized search structure:
all those things together.
So, it's sort of like treaps
and that the bound is only a

Korean: 
그러나 오늘, 우리는 예상 바운드 보다 
더 강력한 바운드를 볼 것입니다.
특히, 스킵 리스트는 O(lg n) 예상 시간에 돌 것입니다. 
각 연산을 위한 러닝 타임은 
O(lg n)이 될 것입니다. 
그러나 우리는 높은 가능성으로 
더 강력한 결과를 증명할 것입니다. 
이것은 매우 강력한 주장입니다. 
그리고 각 연산의 러닝 타임이 거의 
항상 O(lg n)이라는 것을 의미합니다.  
왜 저는 조짐을 나타내지 않나요?
그것은 가능성과 같은 것입니다. 

English: 
randomized bound.
But today, we're going to see a
much stronger bound than an
expectation bound.
So, in particular,
skip lists will run in order
log n expected time.
So, the running time for each
operation will be order log n in
expectation.
But, we're going to prove a
much stronger result that their
order log n, with high
probability.
So, this is a very strong
claim.
And it means that the running
time of each operation,
the running time of every
operation is order log n almost
always in a certain sense.
Why don't I foreshadow that?
So, it's something like,
the probability that it's order

English: 
log n is at least one minus one
over some polynomial,
and n.
And, you get to set the
polynomial however large you
like.
So, what this basically means
is that almost all the time,
you take your skip lists,
you do a polynomial number of
operations on it,
because presumably you are
running a polynomial time
algorithm that using this data
structure.
Do polynomial numbers of
inserts, delete searches,
every single one of them will
take order log n time,
almost guaranteed.
So this is a really strong
bound on the tail of the
distribution.
The mean is order log n.
That's not so exciting.
But, in fact,
almost all of the weight of
this probability distribution is
right around the log n,
just tiny little epsilons,
very tiny probabilities you
could be bigger than log n.
So that's where we are going.
This is a data structure by

Korean: 
이것은 O(lg n)이고 적어도 (1 – 1/n^α)입니다.
그리고 여러분은 다항을 여러분이 
좋아하는 만큼 크게 설정할 수 있습니다. 
이것이 기본적으로 의미하는 것은 거의 
항상 여러분이 스킵 리스트를 가진다는 것입니다, 
여러분은 연산의 다항 수를 합니다 
왜냐하면 아마 여러분은 이 데이터 구조를 사용하여 
다항 시간 알고리즘을 돌리기 때문입니다. 
모든 다항의 수는 
O(lg n)시간이 걸립니다.
그래서 이것은 분배의 꼬리에서 정말 강력한 바운드입니다. 
의미는 O(lg n) 입니다. 
그것은 흥미롭지 않습니다. 그러나 사실, 
이 가능성 분배의 거의 모든 무게는 
lg n 입니다, lg n 보다 클 가능성이 
아주 조금 있습니다. 
그것은 여러분이 갈 곳입니다. 이것은 1989년에 Pugh에 의한 데이터 구조입니다. 

English: 
Pugh] in 1989.
This is the most recent.
Actually, no,
sorry, treaps are more recent.
They were like '93 or so,
but a fairly recent data
structure for just insert,
delete, search.
And, it's very simple.
You can derive it if you don't
know anything about data
structures, well,
almost nothing.
Now, analyzing that the
performance is log n,
that, of course,
takes our sophistication.
But the data structure itself
is very simple.
We're going to start from
scratch.
Suppose you don't know what a
red black tree is.
You don't know what a B tree
is.
Suppose you don't even know
what a tree is.
What is the simplest data
structure for storing a bunch of
items for storing a dynamic set?
A list, good,
a linked list.
Now, suppose that it's a sorted
linked list.

Korean: 
이것은 가장 최신입니다.
사실, treaps은 더 최신입니다. 
그것들은 93년도 입니다, 그러나 꽤 
최신 데이터 구조입니다. 
그것은 매우 간단합니다.
여러분이 데이터 구조에 대해 모르면 
여러분은 그것을 도출할 수 있습니다. 
그것을 분석하면 성능은 lg n 입니다. 
그러나 데이터 구조 자체는 매우 간단합니다. 
우리는 스크래치로부터 시작할 것입니다. 
여러분이 레드 블랙 트리가 무엇인지 모른다고 가정해보세요. 
여러분은 B 트리가 무엇인지 모릅니다. 
여러분이 트리가 무엇인지 모른다고 가정해보세요. 
동적 집합을 저장하기 위한 가장 간단한 
데이터 구조는 무엇입니까?
리스트죠, 좋아요. 연결 리스트입니다. 
그것이 정렬된 연결 리스트라고 가정해보세요.

English: 
So, I'm going to be a little
bit fancier there.
So, if you have a linked list
of items, here it is,
maybe we'll make it doubly
linked just for kicks,
how long does it take to search
in a sorted linked list?
Log n is one answer.
n is the other answer.
Which one is right?
n is the right answer.
So, even though it's sorted,
we can't do binary search
because we don't have
random-access into a linked
list.
So, suppose I'm only given a
pointer to the head.
Otherwise, I'm assuming it's an
array.
So, in a sorted array you can
search in log n.
Sorted linked list:
you've still got to scan
through the darn thing.
So, theta n,
worst case search.
Not so good,
but if we just try to improve
it a little bit,
we will discover skip lists

Korean: 
그럼 조금 더 좋을 것입니다.
여러분이 연결 리스트를 가지면, 
아마 우리는 그것을 두 배로 할 것입니다, 
정렬된 연결 리스트에서 검색하는데 얼마나 걸리나요? 
lg n은 하나의 답입니다. n은 다른 답입니다. 
어느 것이 맞나요? n이 맞습니다. 
왜냐하면 우리는 연결 리스트로 
랜덤접근을 하지않기 때문입니다. 
제가 머리로 하나의 포인터만 주어졌다고 가정해보세요.
그렇지 않으면, 저는 그것을 배열이라고 가정합니다. 
정렬된 배열에서, 여러분은 lg n 안에 검색할 수 있습니다. 
정렬된 연결 리스트입니다, 
여러분은 여전히 스캔해야 합니다. 
θ(n)입니다. 
그리 좋지 않습니다. 
그러나 여러분이 그것을 더 향상시키려고 하면, 우리는 스킵 리스트를 자동적으로 발견할 것입니다.

Korean: 
이것은 우리의 시작점입니다. 
정렬된 연결 리스트입니다. 
그리고 저는 당분간은 삽입과 삭제에 대해 너무 많이 생각하지 않을 것입니다. 
검색을 더 낫게 해 봅시다, 
그리고 우리는 날짜에 대해 걱정하지 않습니다. 
업데이트는 랜덤화가 들어갈 곳입니다.
검색은 매우 쉬운 생각입니다. 우리는 어떻게 연결 리스트를 낫게 만들 수 있나요?
우리가 하는 모든 것에 대해 가정해보세요. 
저는 그것을 빠르게 하기 위해 무엇을 할 수 있나요? 
이것은 여러분이 혁신, 
창의성이 필요한 곳입니다.
더 많은 연결, 좋은 생각입니다. 저는 몇 단계 앞에  
포인터를 더하지 않을 것입니다.
제가 lg n 포인터를 가지면, 저는 모든 2 제곱을 할 수 있습니다. 
그것은 매우 좋은 검색 구조입니다. 
몇몇 사람들은 그것을 사용합니다. 
peer-to-peer 네트워크는 그 아이디어를 사용합니다. 

English: 
automatically.
So, this is our starting point:
sorted linked lists,
data n time.
And, I'm not going to think too
much about insertions and
deletions for the moment.
Let's just get search better,
and then we'll worry about
dates.
Updates are where randomization
will come in.
Search: pretty easy idea.
So, how can we make a linked
list better?
Suppose all we know about our
linked lists.
What can I do to make it
faster?
This is where you need a little
bit of innovation,
some creativity.
More links: that's a good idea.
So, I do try to maybe add
pointers to go a couple steps
ahead.
If I had log n pointers,
I could do all powers of two
ahead.
That's a pretty good search
structure.
Some people use that;
like, some peer-to-peer
networks use that idea.

English: 
But that's a little too fancy
for me.
Ah, good.
You could try to build a tree
on this linear structure.
That's essentially where we're
going.
So, you could try to put
pointers to, like,
the middle of the list from the
roots.
So, you search between either
here.
You point to the median,
so you can compare against the
median, and know whether you
should go in the first half or
the second half that's
definitely on the right track,
also a bit too sophisticated.
Another list:
yes.
Yes, good.
So, we are going to use two
lists.
That's sort of the next
simplest thing you could do.
OK, and as you suggested,
we could maybe have pointers
between them.
So, maybe we have some elements
down here, some of the elements
up here.
We want to have pointers
between the lists.
OK, it gets a little bit crazy
in how exactly you might do
that.
But somehow,
this feels good.
So this is one linked list:
L_1.

Korean: 
그러나 그것은 제 생각엔 그다지 좋지않습니다. 
여러분은 이 선형 구조에서 트리를 구축할 수 있습니다. 
그것은 필수적으로 우리가 가는 곳입니다. 
그래서 여러분은  
루트로부터 리스트의 중간에 포인터를 둘 수 있습니다.
여러분은 여기서 둘 간에 검색합니다. 
여러분은 중앙값을 가리킵니다, 
그래서 여러분은 비교할 수 있고 
여러분이 어디로 가야 하는지 압니다, 
약간 복잡합니다. 
또다른 리스트를 사용하는 겁니다. 좋아요.
그래서 우리는 두 리스트를 사용할 것입니다. 
그것은 여러분이 할 수 있는 가장 간단한 것입니다. 
여러분이 제안한대로, 
우리는 그들 간의 포인터를 가질 수 있습니다. 
아마 우리는 여기서 인자들이 필요합니다. 
우리는 리스트 간에 포인터를 가지고 싶습니다. 
그것은 여러분이 얼마나 정확해 
지는지에 대한 것입니다. 
이것은 좋습니다. 
이것은 하나의 연결 리스트 L_1 이고, 

English: 
This is another linked list:
L_2.
And, to give you some
inspiration, I want to give you,
so let's play a game.
The game is,
what is this sequence?
So, the sequence is 14.
If you know the answer,
shout it out.
Anyone yet? OK, it's tricky.
It's a bit of a small class,
so I hope someone knows the
answer.

Korean: 
이것은 또 다른 연결 리스트 L_2 입니다.
여러분에게 영감을 주기 위해, 
게임을 해 봅시다. 이 수열은 무엇입니까?
시퀀스는 14입니다. 
여러분이 답을 알면, 말하세요. 
아직 모르겠나요? 그것은 까다롭습니다. 
저는 누군가 답을 알길 바랍니다. 

Korean: 
조교들은 몇 명이나 답을 알고 있나요? 몇 명 있군요, 
여러분이 슬라이드를 보면, 아마 답을 알 것입니다. 
그것은 속임수입니다. 
저는 여러분에게 힌트를 줄 것입니다. 그것은 수학적 수열이 아닙니다. 
이것은 실제 수열입니다.
네, 무슨 도시죠? 뉴욕, 
네, 이것은 7번가입니다. 
이것은 뉴욕에서 제가 가장 좋아하는 지하철 노선입니다. 
뉴욕 지하철의 좋은 특징은 무엇입니까? 
그것은 스킵 리스트입니다. 좋은 답변입니다. 
그것은 정말로 그렇습니다. 스킵 리스트는 매우 실용적입니다. 

English: 
How many TA's know the answer?
Just a couple,
OK, if you're looking at the
slides, probably you know the
answer.
That's cheating.
OK, I'll give you a hint.
It is not a mathematical
sequence.
This is a real-life sequence.
Yeah?
Yeah, and what city?
New York, yeah,
this is the 7th Ave line.
This is my favorite subway line
in New York.
But, what's a cool feature of
the New York City subway?
OK, it's a skip list.
Good answer.
[LAUGHTER] Indeed it is.
Skip lists are so practical.

Korean: 
그것들은 지하철 시스템에서 구현되었습니다. 
얼마나 좋은데요! 보스턴 지하철은 좋습니다, 
미국에서 가장 오래, 아마 세계에서 가장 오래되었거든요. 
뉴욕은 가깝고, 
24시간 열리는 장점을 가집니다. 
그러나 다른 라인도 가집니다. 
그것은 추상화입니다.
그러나 7번가 라인은 필수적으로 두 종류의 차를 가집니다. 
이것은 거리 번호입니다. 
Penn Station, 
Times Square 등입니다. 
필수적으로 두 라인이 있습니다. 
14 34 42 72 96으로 
가는 급행 라인이 있습니다. 
모든 정류소에서 멈추는 지역 라인도 있습니다. 
그것들은 이것을 네 트랙을 가지고 성취합니다. 
급행 라인은 전용 트랙을 가집니다. 
여러분이 59에서 멈추고 싶으면, 

English: 
They've been implemented in the
subway system.
How cool is that?
OK, Boston subway is pretty
cool because it's the oldest
subway definitely in the United
States, maybe in the world.
New York is close,
and it has other nice features
like it's open 24 hours.
That's a definite plus,
but it also has this feature of
express lines.
So, it's a bit of an
abstraction,
but the 7th Ave line has
essentially two kinds of cars.
These are street numbers by the
way.
This is, Penn Station,
Times Square,
and so on.
So, there are essentially two
lines.
There's the express line which
goes 14, to 34,
to 42, to 72,
to 96.
And then, there's the local
line which stops at every stop.
And, they accomplish this with
four sets of tracks.
So, I mean, the express lines
have their own dedicated track.
If you want to go to stop 59
from, let's say,

Korean: 
급행을 타세요.
여러분은 42로 배우 빠르게 이동합니다, 
그러면 지역 라인으로 옮겨서, 59 등으로 가고, 
이것은 급행 그리고 지역 라인입니다, 
우리는 그것을 몇 가지 리스트를 가지고 나타낼 수 있습니다. 
우리는 아래에서 하나의 리스트를 가집니다, 
그리고 여기서 확장합니다.
이것은 지역 라인 L_2, 34, 42, 

English: 
Penn Station,
well, let's say from lower west
side, you get on the express
line.
You jump to 42 pretty quickly,
and then you switch over to the
local line, and go on to 59 or
wherever I said I was going.
OK, so this is express and
local lines, and we can
represent that with a couple of
lists.
We have one list,
sure, we have one list on the
bottom, so leave some space up
here.
This is the local line,
L_2, 34, 42,

English: 
50, 59, 66, 72,
79, and so on.
And then we had the express
line on top, which only stops at
14, 34, 42, 72,
and so on.
I'm not going to redraw the
whole list.
You get the idea.
And so, what we're going to do
is put links between in the
local and express lines,
wherever they happen to meet.
And, that's our two linked list
structure.
So, that's what I actually
meant what I was trying to draw
some picture.
Now, this has a property that
in one list, the bottom list,
every element occurs.
And the top list just copies
some of those elements.
And we're going to preserve

Korean: 
50, 59, 66, 72, 79 입니다. 
그리고 우리는 위에서 급행 라인을 가집니다, 
그것은 14, 34, 42, 72 에서 멈춥니다. 
저는 전체 리스트를 다시 그리지 않을 것입니다. 
여러분은 생각을 얻습니다. 
우리는 지역과 급행 라인 간에 어떤 링크를 둡니까?
그것은 우리의 두 연결 리스트 구조입니다. 
그게 제가 그림을 
그리려고 했던 것입니다. 
이제, 이것은 리스트에서 속성을 가집니다. 
그리고 위의 리스트는 어떤 인자들을 복사합니다. 그
리고 우리는 그 속성을 유지할 것입니다. 

English: 
that property.
So, L_2 stores all the
elements, and L_1 stores some
subset.
And, it's still open which ones
we should store.
That's the one thing we need to
think about.
But, our inspiration is from
the New York subway system.
OK, there, that the idea.
Of course, we're also going to
use more than two lists.
OK, we also have links.
Let's say it links between
equal keys in L_1 and L_2.
Good.
So, just for the sake of
completeness,
and because we will need this
later, let's talk about searches
before we worry about how these

Korean: 
L_2는 모든 인자들을 저장합니다, 
L_1은 어떤 부분 집합을 저장합니다. 
그리고 그것은 우리가 저장하는 것입니다. 
그것을 우리가 생각해야 하는 것입니다. 
그러나 우리의 영감은 뉴욕 지하철 시스템으로부터 옵니다. 
그 생각이 저기 있습니다. 물론, 우리는 또한 두 리스트 이상을 사용할 것입니다. 
우리는 또한 링크를 가집니다. 
그것을 L_1과 L_2에 있는 동일한 키 간의 링크라고 합시다. 
완벽하게 하기 위해, 
우리가 이것이 나중에 필요하기 때문에 
이것이 실제로 어떻게 구축되는지에 대해 걱정하기 전에 검색에 대해 이야기해 봅시다.

Korean: 
물론, 제가 칠판을 원한다면요. 
제가 인자 x를 검색하고 싶으면, 
여러분은 어떻게 하나요? 
이것은 지하철 알고리즘을 취하는 것입니다. 
여러분이 항상 지하철 시스템의 왼쪽  
위 코너에서 시작한다고 가정해보세요.
정확히 어디인지 모르지만, 
맨해튼 아래 어딘가 입니다. 
여러분은 59와 같은 특정 역으로 가고 싶습니다.
여러분은 할 수 있는 한 
급행 라인에 머뭅니다. 
그리고 여러분은 내려갑니다. 
여러분은 나머지 길에서 지역 라인을 취합니다. 
여러분이 항상 왼쪽 위 코너에서 시작하면 그것은 명백히 옳은 것입니다. 
저는 그것을 알고리즘에서 쓸 것입니다 
왜냐하면 우리는 그것을 일반화할 것이기 때문입니다. 
그것은 이 점에서 매우 분명합니다. 

English: 
lists are actually constructed.
Of course, if I wanted that
board.
So, if you want to search for
an element, x,
what do you do?
Well, this is the taking the
subway algorithm.
And, suppose you always start
in the upper left corner of the
subway system,
if you're always in the lower
west side, 14th St,
and I don't know exactly where
that is, but more or less,
somewhere down at the bottom of
Manhattan.
And, you want to go to a
particular station like 59.
Well, you'd stay on the express
line as long as you can because
it happens that we started on
the express line.
And then, you go down.
And then you take the local
line the rest of the way.
That's clearly the right thing
to do if you always start in the
top left corner.
So, I'm going to write that
down in some kind of an
algorithm because we will be
generalizing it.
It's pretty obvious at this

English: 
point.
It will remain obvious.
So, I want to walk right in the
top list until that would go too
far.
So, you imagine giving someone
directions on the subway system
they've never been on.
So, you say,
OK, you start at 14th.
Take the express line,
and when you get to 72nd,
you've gone too far.
Go back one,
and then go down to the local
line.
It's really annoying
directions.
But this is what an algorithm
has to do because it's never
taken the subway before.
So, it's going to check,
so let's do it here.
So, suppose I'm aiming for 59.
So, I started 14,
say the first thing I do is go
to 34.
Then from there,
I go to 42.
Still good because 59 is bigger
than 42.
I go right again.
I say, oops,
72 is too big.

Korean: 
분명하게 상기해두죠.
저는 그것이 멀리 갈 때까지 위의 리스트에서 걷고 싶습니다. 
여러분은 전에 본적 없는 지하철 시스템에서 어떤 사람에게 
방향을 주는 것을 상상합니다. 
여러분은 14번에서 시작합니다. 
급행을 타세요, 여러분이 72에 갔을 때, 
여러분은 너무 멀리 간 것입니다. 돌아오세요, 
그리고 지역 라인으로 내려가세요. 
그것은 정말 짜증나는 방향입니다. 
그러나 이것은 알고리즘이 하는 것입니다. 왜냐하면 그것은 절대 전에 탔던 지하철이 아니기 때문입니다. 
그것은 확인해야 합니다, 
여기서 해 봅시다. 제가 59를 목표로 한다고 가정해보세요. 
저는 14에서 시작했습니다, 제가 하는 첫 번째는 34로 가는 것입니다. 
저기서부터, 
저는 42로 갑니다. 59가 42 보다 크기 때문에 여전히 좋습니다. 
저는 다시 갑니다, 
72는 너무 큽니다. 그것은 너무 멉니다.

English: 
That was too far.
So, I go back to where it just
was.
Then I go down and then I keep
going right until I find the
element that I want,
or discover that it's not in
the bottom list because bottom
list has everyone.
So, that's the algorithm.
Stop when going right would go
too far, and you discover that
with a comparison.
Then you walk down to L_2.
And then you walk right in L_2
until you find x,
or you find something greater
than x, in which case x is
definitely not on your list.
And you found the predecessor
and successor,
which may be your goal.
If you didn't find where x was,
you should find where it would
go if it were there,
because then maybe you could
insert there.
We're going to use this

Korean: 
저는 원래 있었던 곳으로 돌아 갑니다. 
그리고 내려가서 원하는 인자를 
찾을 때까지 계속 갑니다. 
그리고 아래 리스트가 모두 가지기 때문에 아래 리스트에 없는 것을 발견합니다. 
그것이 알고리즘입니다. 
멀리 갈 때 멈추세요, 그러면 여러분은 비교를 가지고 그것을 발견합니다.
여러분은 L_2로 내려갑니다. 
그리고 L_2에서 걷습니다 x를 찾을 때까지 또는 x 보다 더 큰 것을 찾을 때 까지요. 
그 케이스에서 x는 여러분의 리스트에 분명히 없습니다.
여러분은 전임자와 
후임자를 찾았습니다. 
여러분이 x가 어디 있었는지 찾지 못하면, 여러분은 어디로 가는지 찾아야 합니다.
왜냐하면 여러분은 저기서 삽입할 수 있기 때문입니다. 
우리는 이 알고리즘을 삽입에서 사용할 것입니다. 

English: 
algorithm in insertion.
OK, but that search:
pretty easy at this point.
Now, what we haven't discussed
is how fast the search algorithm
is, and it depends,
of course, which elements we're
going to store in L_1,
which subset of elements should
go in L_1.
Now, in the subway system,
you probably put all the
popular stations in L_1.
But here, we want worst-case
performance.
So, we don't have some
probability distribution on the
nodes.
We just like every node to be
accessed sort of as quickly as
possible, uniformly.
So, we want to minimize the
maximum time over all queries.
So, any ideas what we should do
with L_1?
Should I put all the nodes of
L_1 in the beginning?
OK, it's a strict subset.
Suppose I told you what the
size of L_1 was.
I can tell you,
I could afford to build this
many express stops.
How should you distribute them

Korean: 
그러나 그것은 이 점에서 매우 쉽습니다.
이제, 우리가 의논하지 않은 것은 
검색 알고리즘이 얼마나 빠른지 입니다.
물론, 그것은 우리가 L_1에서 저장하는 
인자에 달렸습니다. 
이제 지하철 시스템에서, 여러분은 아마 모든 유명한 역을 넣습니다. 
그러나 여기서, 우리는 최악의 케이스 수행을 원합니다. 
우리는 노드들에서 가능성 분배를 
가지지 않습니다. 
우리는 모든 쿼리에서 최대 시간을 최소화하고 싶습니다. 
우리가 L_1을 가지고 해야 하는 생각 있나요? 
저는 L_1의 모든 노드를 
처음에 두어야 합니까? 
그것은 엄격한 서브 집합입니다. 
제가 여러분에게 L_1의 크기가 무엇이었는지 말했다고 가정해보세요. 
저는 이 급행 정거장을 구축할 여유가 있습니다. 
여러분은 L_2의 인자들 가운데서 그것들을 어떻게 분배해야 하나요? 

Korean: 
단일하게요. 
어떤 키가 L_1으로 가나요? 
가장 좋은 것은 그것들은 
단일하게 퍼트리는 것입니다, 
그것은 7번가 라인이 보이는 것과 같지 않습니다.
우리가 모든 것을 다시 한다고 상상합시다. 
우리는 이것들을 약간 더 퍼트리려고 합니다. 
34와 42는 너무 가깝습니다. 
우리는 몇 정거장이 더 걸립니다. 
그리고 이제 우리는 분석할 수 있습니다. 
L_1 길이의 함수로써요. 

English: 
among the elements of L_2?
Uniformly, good.
So, what nodes,
sorry, what keys,
let's say, go in L_1?
Well, definitely the best thing
to do is to spread them out
uniformly, OK,
which is definitely not what
the 7th Ave line looks like.
But, let's imagine that we
could reengineer everything.
So, we're going to try to space
these things out a little bit
more.
So, 34 and 42nd are way too
close.
We'll take a few more stops.
And, now we can start to
analyze things.
OK, as a function of the length
of L_1.

Korean: 
검색 비용은, 이제 대략적으로 
L_1과 L_2의 길이의 
함수를 원합니다.
제가 L_1에서 모든 인자를 단일하게 퍼트리면 검색 비용은 무엇입니까? 
네?
위의 리스트에서 총 인자 더하기 위 아래 
간의 분할입니다. 
저는 L_1의 길이 더하기 L_2의 길이 나누기 L_1을 쓸 것입니다. 
이것은 대략적으로 플러스 1입니다 
왜냐하면 최악의 케이스에서, 저는 L_1을 통해 
검색해야 하기 때문입니다 
제가 찾는 역은 최대일 수 있습니다. 
아마 저는 운이 좋지 않을 것이고 최대는 급행 라인에 있지 않습니다. 
저는 지역 라인으로 내려가야 합니다. 
저는 지역 라인에서 얼마나 많은 정거장으로 가야 하나요?

English: 
So, the cost of a search is now
roughly, so, I want a function
of the length of L_1,
and the length of L_2,
which is all the elements,
n.
What is the cost of the search
if I spread out all the elements
in L_1 uniformly?
Yeah?
Right, the total number of
elements in the top lists,
plus the division between the
bottom and the top.
So, I'll write the length of
L_1 plus the length of L_2
divided by the length of L_1.
OK, this is roughly,
I mean, there's maybe a plus
one or so here because in the
worst case, I have to search
through all of L_1 because the
station I could be looking for
could be the max.
OK, and maybe I'm not lucky,
and the max is not on the
express line.
So then, I have to go down to
the local line.
And how many stops will I have

English: 
to go on the local line?
Well, L_1 just evenly
partitions L_2.
So this is the number of
consecutive stations between two
express stops.
So, I take the express,
possibly this long,
but I take the local possibly
this long.
And, this is an L_2.
And there is,
plus, a constant,
for example,
go walking down.
But that's basically the number
of nodes that I visit.
So, I'd like to minimize this
function.
Now, L_2, I'm going to call
that n because that's the total
number of elements.
L_1, I can choose to be
whatever I want.

Korean: 
L_1은 L_2를 분할합니다. 
그래서 이것은 두 급행 정거장 간의 
연속적인 정류장 수입니다. 
저는 급행을 타지만, 
지역도 탑니다. 
이것은 L_2입니다. 
예를 들어 아래로 내려 가는 정수가 있습니다. 
그러나 그것은 기본적으로 제가 방문하는 노드의 수입니다. 
저는 이 함수를 최소화하고 싶습니다. 
저는 그것을 n으로 부를 것입니다 
왜냐하면 그것은 인자의 총 수이기 때문입니다. 
저는 제가 원하는 것이 무엇이든 그것을 고를 수 있습니다. 여기서 가 봅시다.

Korean: 
저는 L_1 더하기 n 나누기 L_1을 최소화하고 싶습니다. 
그리고 저는 L_1을 선택하고 싶습니다. 
이제 저는 이것을 차별화하고 싶습니다. 그것을 0으로 합시다. 
저는 그것을 깨달을 수 있습니다, 
그것은 어렵지 않습니다. 그러나 그것은 저에게 약간 좋습니다. 
이것은 L_1이 작을 때 
명백히 최고입니다. 
그리고 이것은 L_1이 클 때 최고입니다. 
저기서 상충점이 있습니다. 
그것은 대략 두 항이 같을 때 정수 요소를 최소화하는 것입니다. 
그것은 제가 좋은 균형을 
가질 때 입니다. 
그래서, 이것은 정수 인자입니다.

English: 
So, let's go over here.
So, I want to minimize L_1 plus
n over L_1.
And I get to choose L_1.
Now, I could differentiate
this, set it to zero,
and go crazy.
Or, I could realize that,
I mean, that's not hard.
But, that's a little bit too
fancy for me.
So, I could say,
well, this is clearly best when
L_1 is small.
And this is clearly best when
L_1 is large.
So, there's a trade-off there.
And, the trade-off will be
roughly minimized up to constant
factors when these two terms are
equal.
That's when I have pretty good
balance between the two ends of
the trade-off.
So, this is up to constant
factors.

English: 
I can let L_1 equal n over L_1,
OK, because at most I'm losing
a factor of two there when they
happen to be equal.
So now, I just solve this.
This is really easy.
This is (L_1)^2 equals n.
So, L_1 is the square root of
n.
OK, so the cost that I'm
getting over here,
L_1 plus L_2 over L_1 is the
square root of n plus n over
root n, which is,
again, root n.
So, I get two root n.
So, search cost,
and I'm caring about the
constant here,
because it will matter in a
moment.
Two square root of n:
I'm not caring about the
additive constant,
but the multiplicative constant
I care about.
OK, that seems good.
We started with a linked list
that searched in n time,
theta n time per operation.

Korean: 
저는 L_1을 n 나누기 L_1으로 둘 것입니다, 
그것들이 같을 때 두 인자를 잃기 때문입니다.
이제 저는 이것을 풉니다. 이것은 정말 쉽습니다. 
(L_1)^2 는 n과 같습니다. L_1는 n의 제곱근입니다. 
그래서 제가 여기서 얻는 비용은, 
L_1 더하기 L_2 나누기 L_1이고 그것은 n의 제곱근 더하기 n 입니다. 
그것은 다시 루트 n입니다. 
저는 2 루트 n을 얻습니다. 
저는 여기서 정수에 대해 걱정합니다,  
그것이 중요할 것이기 때문입니다.
저는 추가적인 정수에 대해 
신경 쓰지 않지만, 
증가하는 정수에 대해 신경 씁니다. 
그것은 좋아 보입니다. 우리는 연결 리스트를 가지고 시작합니다. 
연산 당 θ(n)시간입니다. 

Korean: 
이제 우리는 두 연결 리스트를 가집니다.
그것은 매우 좋아 보입니다. 이것은 구조와 같아 보입니다. 
우리는 여기서 루트 n을 가지고 있습니다. 
이것은 지역 라인에 있습니다. 우리는 그것을 나타내는 하나의 급행 정거장을 가집니다. 
그러나 우리는 또 다른 √n 값을 지역 라인에서 가집니다. 
그리고 우리는 그것을 나타내는 하나의 급행 정거장을 가집니다. 
이 둘은 연결되어 있습니다. 
저는 저기서 점, 점, 점을 두어야 합니다. 
이것들 각각은 길이 √n 을 가집니다 
여기서 대표 수는 n의 제곱근입니다. 
급행 정거장의 수는 n의 제곱근입니다. 
명백히, 그것들은 이제 균형 잡혔습니다. 
저는 여기서 
n의 제곱근을 검색합니다. 

English: 
Now we have two linked lists,
search and theta root n time.
It seems pretty good.
This is what the structure
looks like.
We have root n guys here.
This is in the local line.
And, we have one express stop
which represents that.
But we have another root n
values in the local line.
And we have one express stop
that represents that.
And these two are linked,
and so on.
Well, I should put some dot,
dot, dots in there.
OK, so each of these chunks has
length root n,
and the number of
representatives up here is
square root of n.
The number of express stops is
square root of n.
So clearly, things are balanced
now.
I search for,
at most, square root of n up
here.

Korean: 
그리고 저는 n의 제곱근을 위하여 이 리스트들 중 하나에서 검색합니다.
모든 검색은, 최대 2 √n 이 듭니다. 
우리는 다음에 무엇을 해야 하나요? 
다시, 삽입과 삭제를 무시하세요.  
저는 검색을 빠르게 하고 싶습니다.
네?
라인이 더 필요합니다. 급행 라인 또는 다른 연결리스트를 더합시다. 
이것은 2입니다. 
왜 3을 하지 않나요? 우리는 정렬된 연결 리스트를 가지고 시작했습니다. 
그리고 우리는 2로 갔습니다. 
이것은 우리에게 2 n의 제곱근을 줍니다. 
이제 저는 세 정렬된 연결 리스트를 원합니다. 
저는 여기서 복수로 만들지 않았습니다. 

English: 
Then I search in one of these
lists for, at most,
square root of n.
So, every search takes,
at most, two root n.
Cool, what should we do next?
So, again, ignore insertions
and deletions.
I want to make searches faster
because square root of n is not
so hot as we know.
Sorry?
More lines.
Let's add a super express line,
or another linked list.
OK, this was two.
Why not do three?
So, we started with a sorted
linked list.
Then we went to two.
This gave us two square root of
n.
Now, I want three sorted linked
lists.
I didn't pluralize here.
Any guesses what the running

English: 
time might be?
This is just guesswork.
Don't think.
From two square root of n,
you would go to,
sorry?
Two square root of two,
fourth root of n?
That's on the right track.
Both the constant and the root
change, but not quite so
fancily.
Three times the cubed root:
good.
Intuition is very helpful here.
It doesn't matter what the
right answer is.
Use your intuition.
You can prove that.
It's not so hard.
You now have three lists,
and what you want to balance
are at the length of the top
list, the ratio between the top
two lists, and the ratio between
the bottom two lists.
So, you want these three to
multiply out to n,
because the top times the ratio
times the ratio:
that has to equal n.
And, so that's where you get
the cubed root of n.
Each of these should be equal.

Korean: 
러닝 타임이 무엇인지에 대한 생각 있나요? 이것은 추측입니다.
생각하지 마세요. 
2 n의 제곱근으로부터, 
여러분은 갑니다 
그것은 오른쪽 트랙에 있습니다. 모든 정수와 루트는 변하지만, 
그리 좋지 않습니다. 
3 제곱근입니다, 좋아요. 
직관은 여기서 매우 도움이 됩니다. 옳은 답이 무엇인지 중요하지 않습니다. 
여러분의 직관을 사용하세요. 
여러분은 그것을 증명할 수 있습니다. 그것은 어렵지 않습니다. 
여러분은 이제 세 리스트를 가집니다, 
그리고 여러분은 여러분이 균형을 맞추고 싶은 것은 위의 리스트의 길이입니다, 
위의 두 리스트 간의 비율, 아래 두 리스트 간의 비율입니다. 
여러분은 이것들을 곱하길 원합니다 
왜냐하면 그것은 n과 같아야 하기 때문입니다. 
그래서 그것은 여러분이 n 세제곱을 얻는 곳입니다. 
이것들 각각은 같아야 합니다. 

Korean: 
여러분은 그것들을 설정합니다 왜냐하면 비용은 이 세 가지의 합이기 때문입니다. 
여러분은 그것을 n의 세제곱근으로 둡니다, 
그것들 중 세 가지가 있습니다. 
집에서 확인해 보세요. 
K 정렬 리스트에 대해 생각해보세요.
K 정렬 리스트는 k 곱하기 n의 k번째 루트입니다. 
여러분은 그것을 추측했습니다. 
우리는 k를 무엇으로 설정합니까? 
저는 최소값을 추출하길 원하지 않습니다. k를 위한 좋은 값은 무엇입니까? 
저는 그것을 n으로 설정해야 합니까?
n 번째 루트는 하나입니다. 
그것은 n입니다. 이것은 제가 걱정하는 이유입니다 
왜냐하면 제가 리스트를 더할수록 커지기 때문입니다. 
제가 사용할 수 있는 k의 가장 큰 합리적인 값은 무엇인가요?

English: 
So, you set them because the
cost is the sum of those three
things.
So, you set each of them to
cubed root of n,
and there are three of them.
OK, check it at home if you
want to be more sure.
Obviously, we want a few more.
So, let's think about k sorted
lists.
k sorted lists will be k times
the k'th root of n.
You probably guessed that by
now.
So, what should we set k to?
I don't want the exact minimum.
What's a good value for k?
Should I set it to n?
n's kind of nice,
because the n'th root of n is
just one.
Now that's n.
So, this is why I cared about
the lead constant because it's
going to grow as I add more
lists.
What's the biggest reasonable

Korean: 
제가 저기서 k를 가지면 lg n입니다.
저는 lg n 이상을 사용하길 원하지 않습니다. 
이것은 
그리기 어렵습니다.  
N의 n번째 루트는 무엇인가요?
그것은 여러분이 생각하는 것입니다. 
N-2의 n번째 루트는 무엇인가요? 
그것은 좋은 질문 중 하나입니다. 
루트의 정의를 기억하나요? 
루트는  
n^(1/(lg n)) 입니다. 
제곱을 가지는 정의를 기억하세요. 
그것은 2제곱과 같은가요? 

English: 
value of k that I could use?
Log n, because I have a k out
there.
I certainly don't want to use
more than log n.
So, log n times the log n'th
root, and this is a little hard
to draw of n.
Now, what is the log n'th root
of n?
That's what you're all thinking
about.
What is the log n'th root of n
minus two?
It's one of these good
questions whose answer is?
Oh man.
Remember the definition of
root?
OK, the root is n to the one
over log n.
OK, good, remember the
definition of having a power,
A to the B?
It was like two to the power,
B log A?

Korean: 
그것이 친숙하게 들리나요? 이것은 2제곱입니다, 
저는 여러분이 그것을 이점에서 얻길 바랍니다.
N-2의 n번쨰 루트는 0입니다. 
제가 가장 좋아하는 답입니다. 
그래서 이 전체는 2 lg n입니다. 
매우 좋습니다. 여러분은 더 좋을 수 있지만, 
2 lg n은 저에게 좋습니다. 
우리는 리스트를 더 이상 사용하고 싶지 않습니다. 
그러나 lg n 리스트는 좋아 보입니다. 
대수의 검색 시간입니다.  
확인해봅시다.
우리는 이것을 항상 직관적으로 했습니다. 
리스트가 무엇과 같아 보이는지 그려봅시다. 

English: 
Does that sound familiar?
So, this is two to the log n
over log n, which is,
I hope you can get it at this
point, two.
Wow, so the log n'th root of n
minus two is zero:
my favorite answer.
OK, this is to.
So this whole thing is two log
n: pretty nifty.
So, you could be a little
fancier and tweak this a little
bit, but two log n is plenty
good for me.
We clearly don't want to use
any more lists,
but log n lists sounds pretty
good.
I get, now, logarithmic search
time.
Let's check.
I mean, we sort of did this all
intuitively.
Let's draw what the list looks
like.

English: 
But, it will work.
So, I'm going to redraw this
example because you have to,
also.
So, let's redesign that New
York City subway system.
And, I want you to leave three
blank lines up here.
So, you should have this
memorized by now.
But I don't.
So, we are not allowed to
change the local line,
though it would be nice,
add a few more stops there.
OK, we can stop at 79th Street.
That's enough.
So now, we have log n lists.
And here, log n is about four.
So, I want to make a bunch of
lists here.
In particular,

Korean: 
그것은 작동할 것입니다. 저는 이 예를 다시 그릴 것입니다 
왜냐하면 여러분도 해야하기 때문입니다.
뉴욕 지하철 시스템을 재설계해 봅시다. 
저는 여러분이 세 공간을 남기길 바랍니다. 
여러분은 이것을 기억해야 합니다. 
저는 그렇지 않습니다. 
우리는 지역 라인을 바꾸도록 허용되지 않았습니다. 
우리는 79가에서 멈출 수 있습니다. 
그것은 충분합니다. 이제 우리는 lg n를 가집니다. 
여기서 lg n은 4에 대한 것입니다. 저는 여기서 많은 리스트를 만들고 싶습니다. 
특히 14는 그것들에 나타날 것입니다. 

English: 
14 will appear on all of them.
So, why don't I draw those in?
And, the question is,
which elements go in here?
So, I have log n lists.
And, my goal is to balance the
number of items up here,
and the ratio between these two
lists, and the ratio between
these two lists,
and the ratio between these two
lists.
I want all these things to be
balanced.
There are log n of them.
So, the product of all those
ratios better be n,
the number of elements down
here.
So, the product of all these
ratios is n.
And there's log n of them;
how big is each ratio?
So, I'll call the ratio r.
The ratio's r.
I should have r to the power of
log n equals n.
What's r?

Korean: 
왜 저는 그것을 그리지 않나요?
여기서 어떤 인자가 들어가나요? 
저는 lg n 리스트를 가집니다. 
제 목표는 아이템의 수, 두 리스트 간의 비율, 
이 두 리스트 간의 비율을 
균형 잡는 것입니다. 
저는 이것들이 모두 균형 잡히길 바랍니다. 
그것들 중 lg n이 있습니다. 
모든 것은 n 보다 낫습니다. 
모든 비율은 n입니다.
그것들의 lg n이 있습니다, 각 비율은 얼마나 큰가요? 
저는 비율을 r로 부릅니다. 
저는 r의 lg n 제곱을 가져야 합니다. 
R은 무엇입니까? 

Korean: 
R-2는 무엇인가요? 0입니다. 
이것은 2의 lg n 제곱이어야 합니다. 
그래서 두 인자 간의 비율이 있으면, 
저는 아래에서 인자를 가질 것입니다, 
그것은 제가 원하는 것입니다. 
다시 말해, 
저는 여기서 인자의 절반을 원합니다, 
여기서 4분의 1을, 여기서 8분의 1을 원합니다. 
저는 인자들을 점점 더 늘립니다.
이것은 새로운 표현 라인입니다. 
매우 빠르지 않지만, 
여러분은 저기로 가기 위한 두 인자를 줄입니다. 
여러분이 다 했을 때,  
내려가서 걷습니다. 
그리고 여러분은 찾습니다.
그리고 우리는 인자를 다 써버릴 때까지 같은 것을 계속합니다. 
저는 제가 쓴 것을 읽을 수 없습니다. 
그것은 79번째입니다. 

English: 
What's r minus two?
Zero.
OK, this should be two to the
power of log n.
So, if the ratio between the
number of elements here and here
is to all the way down,
then I will have an elements at
the bottom, which is what I
want.
So, in other words,
I want half the elements here,
a quarter of the elements here,
an eighth of the elements here,
and so on.
So, I'm going to take half of
the elements evenly spaced out:
34th, 50th, 66th,
79th, and so on.
So, this is our new
semi-express line:
not terribly fast,
but you save a factor of two
for going up there.
And, when you're done,
you go down,
and you walk,
at most, one step.
And you find what you're
looking for.
OK, and then we do the same
thing over and over and over
until we run out of elements.
I can't read my own writing.
It's 79th.

English: 
OK, if I had a bigger example,
I would be more levels,
but this is just barely enough.
Let's say two elements is where
I stop.
So, this looks good.
Does this look like a structure
you've seen before,
at all, vaguely?
Yes?
A tree: yes.
It looks a lot like a binary
tree.
I'll just leave it at that.
In your problem set,
you'll understand why skip
lists are really like trees.
But it's more or less a tree.
Let's say at this level,
it looks sort of like binary
search.
You look at 14;
you look at 15,
and therefore,
you decide whether you are in
the left half for the right
half.
And that's sort of like a tree.
It's not quite a tree because
we have this element repeated
all over.
But more or less,
this is a binary tree.
At depth I, we have two to the

Korean: 
제가 더 큰 예를 가지면, 저는 더 많은 레벨에 있지만, 
이것은 충분합니다. 두 인자는 제가 멈추는 곳입니다. 
이것은 좋아 보입니다,
이것이 여러분이 전에 보았던 구조 같아 보이나요? 
네?
트리입니다. 그것은 이진 트리 같아 보입니다.
저는 그것을 남길 것입니다. 
여러분의 문제 세트에서, 여러분은 왜 스킵 리스트가 트리 같은지 이해할 것입니다. 
그것은 트리 이상 혹은 이하입니다
이 레벨에서, 그것은 이진 검색 같아 보입니다. 
여러분은 14를 보고, 
15를 봅니다, 그러므로, 
여러분은 왼쪽 또는 오른쪽에 있는지 결정합니다. 
그리고 그것은 트리와 같습니다. 
그것은 트리가 아닙니다 왜냐하면 우리는 이 인자를 반복하기 때문입니다. 
그러나, 
이것은 이진 트리입니다. 깊이 i에서, 우리는 i 노드의 2를 가집니다, 

English: 
I nodes, just like a tree,
just like a balanced tree.
I'm going to call this
structure an ideal skip list.
And, if all we are doing our
searches, ideal skip lists are
pretty good.
Maybe at practice:
not quite as good as a binary
search tree, but up to constant
factors: just as good.
So, for example,
I mean, we can generalize
search, just check that it's log
n.
So, the search procedure is you
start at the top left.
So, let's say we are looking
for 72.
You start at the top left.
14 is smaller than 72,
so I try to go right.
79 is too big.
So, I follow this arrow,
but I say, oops,
that's too much.
So, instead,
I go down 14 still.
I go to the right:
oh, 50, that's still smaller
than 72: OK.
I tried to go right again.
Oh: 79, that's too big.
That's no good.

Korean: 
균형 트리와 같습니다.
저는 이 구조를 이상적인 스킵 리스트라고 부를 것입니다. 
우리가 검색을 하면, 이상적인 스킵 리스트는 매우 좋습니다. 
아마 연습에서, 
이진 검색 트리만큼 좋지 않을 것이지만, 정수 인자까지는 좋습니다. 
예를 들어, 
우리는 검색을 일반화할 수 있습니다. 그것은 lg n 입니다. 
검색 과정은 왼쪽 위에서 시작합니다. 
우리가 72를 찾는다고 합시다. 
여러분은 왼쪽 위에서 시작합니다. 
14는 72 보다 작습니다. 저는 오른쪽으로 갑니다.  
79는 너무 큽니다.
저는 이 배열을 따릅니다, 그러나 너무 큽니다. 
대신에, 저는 14로 내려갑니다.
저는 오른쪽으로 갑니다. 50은 72 보다 적습니다. 
저는 다시 오른쪽으로 갑니다. 
79는 너무 큽니다. 좋지 않습니다. 

Korean: 
저는 내려 갑니다. 저는 50을 얻습니다. 
저는 같은 것을 계속합니다.
저는 오른쪽으로 가려고 합니다. 그것은 좋습니다. 
오른쪽으로 갑니다. 79는 너무 큽니다. 
저는 내려갑니다. 이제 저는 오른쪽으로 갑니다. 
72입니다. 다시 말해, 저는 멀리 가서 아래로 내려갑니다 
t인자는 저기 있어야 하지 않습니다. 
그것은 매우 간단한 검색 알고리즘입니다 
L_1과 L_2를 제거하는 것을 제외하고 여기서 같습니다. 
그것이 멀리 갈 때까지 오른쪽으로 갑니다
그리고 내려갑니다. 그리고 우리가 멀리 갈 때까지 오른쪽으로 가고 내려갑니다. 
여러분은 이것을 lg n 번 해야 합니다.
각 단계에서, 
여러분은 명백히 몇 단계를 걷습니다 
왜냐하면 이 두 크기 간의 비율은 2이기 때문입니다. 
그래서, 이것은 검색을 하는데 2 lg n 비용이 듭니다. 
좋아요, 그래서 그것은 확인해야 합니다 
왜냐하면 우리는 여기서 직관을 사용하기 때문입니다.
이것은 이상적인 스킵 리스트입니다, 우리는 삽입과 삭제를 지원해야 합니다. 
우리가 삽입 삭제를 하자마자, 
우리는 구조를 유지할 방법이 없습니다. 

English: 
So, I go down.
So, I get 50.
I do the same thing over and
over.
I try to go to the right:
oh, 66, that's OK.
Try to go to the right:
oh, 79, that's too big.
So I go down.
Now I go to the right and,
oh, 72: done.
Otherwise, I'd go too far and
try to go down and say,
oops, element must not be
there.
It's a very simple search
algorithm: same as here except
just remove the L_1 and L_2.
Go right until that would go
too far.
Then go down.
Then go right until we'd go too
far, and then go down.
You might have to do this log n
times.
In each level,
you're clearly only walking a
couple of steps because the
ratio between these two sizes is
only two.
So, this will cost two log n
for search.
Good, I mean,
so that was to check because we
were using intuition over here;
a little bit shaky.
So, this is an ideal skip list,
we have to support insertions
and deletions.
As soon as we do an insert and
delete, there's no way we're
going to maintain the structure.

English: 
It's a bit too special.
There is only one of these
where everything is perfectly
spaced out, and everything is
beautiful.
So, we can't do that.
We're going to maintain roughly
this structure as best we can.
And, if anyone of you knows
someone in New York City subway
planning, you can tell them
this.
OK, so: skip lists.
So, I mean, this is basically
our data structure.
You could use this as a
starting point,
but then you start using skip
lists.
And, we need to somehow
implement insertions and
deletions, and maintain roughly

Korean: 
그것은 너무 특별합니다.
모든 것이 완벽하게 넓은 간격이 있는 것들 중 하나입니다, 모든 것은 아름답습니다. 
우리는 그것을 할 수 없습니다. 
우리는 대략적으로 이 구조를 할 수 있는 한 최선으로 유지할 것입니다. 
누가 뉴욕 지하철 계획에 대해 물으면, 
여러분은 이것을 말할 수 있습니다.
스킵 리스트입니다. 
이것은 기본적으로 우리의 데이터 구조입니다. 
여러분은 시작점을 사용할 수 잇습니다.
우리는 삽입과 삭제를 구현할 필요가 있고, 
이 구조가 검색이 O(lg n)시간이 들도록 

Korean: 
유지해야 합니다.
삽입에 초점을 맞춥시다. 
우리가 삽입을 제대로 하면, 삭제는 정말 
사소한 것입니다. 
그리고 다시, 이것은 첫 원칙으로부터의 모든 것입니다. 
우리는 좋은 것을 사용하도록 허용되지 않았습니다. 
그러나 그것은 좋은 분필을 사용하면 좋습니다. 
이것은 더 나아 보입니다. 여러분이 인자 x를 삽입하길 원한다고 가정해보세요. 
우리는 인자를 검색하는 방법을 말했습니다. 
우리는 그것을 어떻게 삽입하나요?
우리가 해야 하는 첫 번째 것은 그것이 어디로 가는지 알아내는 것입니다. 
우리는 x를 위해 검색합니다. 우리는

English: 
this structure well enough that
the search still costs order log
n time.
So, let's focus on insertions.
If we do insertions right,
it turns out deletions are
really trivial.
And again, this is all from
first principles.
We're not allowed to use
anything fancy.
But, it would be nice if we
used some good chalk.
This one looks better.
So, suppose you want to insert
an element, x.
We said how to search for an
element.
So, how do we insert it?
Well, the first thing we should
do is figure out where it goes.
So, we search for x.
We call search of x to find

English: 
where x fits in the bottom list,
not just any list.
Pretty easy to find out where
it fits in the top list.
That takes, like,
constant time.
What we want to know:
because the top list has
constant length,
we want to know where x goes in
the bottom list.
So, let's say we want to insert
a search for 80.
Well, it is a bit too big.
Let search for 75.
So, we'll find the 75 fits
right here between 72 and 79
using the same path.
OK, if it's there already,
we complain because I'm going
to assume all keys are distinct
for now just so the picture
stays simple.
But this works fine even if you
are inserting the same key over
and over.
So, that seems good.
One thing we should clearly do
is insert x into the bottom
list.
We now know where it fits.
It should go there.
Because we want to maintain
this invariant,

Korean: 
x가 리스트 아래에 맞는지 찾기 위해 x의 검색을 호출합니다.
그것이 맞는지 찾는 것은 매우 쉽습니다. 
그것은 상수 시간이 듭니다. 
우리가 원하는 것은, 위의 리스트가 정수 길이를 갖기 때문에 
우리는 x가 아래 리스트에서 어디로 가는지 알고 싶습니다. 
우리가 80을 위한 검색을 삽입하고 싶다고 해 봅시다. 
그것은 너무 큽니다. 
75로 합시다. 우리는 같은 경로를 사용하여 
72와 79 사이에 맞는 75를 찾을 것입니다. 
그것이 이미 있으면, 우리는 불평합니다 왜냐하면 저는 모든 키가 구분된다고 
가정하기 때문입니다 그래서 그림은 간단하게 머뭅니다.
그러나 여러분이 같은 키를 계속 삽입하길 원한다고 하더라도 
이것은 잘 동작합니다. 
그것은 좋아 보입니다. 우리나 해야 하는 하나는 
x를 아래 리스트에 삽입하는 것입니다. 
우리는 이제 그것이 어디에 맞는지 압니다. 그것은 저기로 가야 합니다. 
우리가 이 불변을 유지하고 싶기 때문에, 

Korean: 
아래 리스트는 모든 인자들을 갖습니다. 
우리는 갑니다. 우리는 불변을 유지했습니다. 
아래 리스트는 모든 인자들을 포함합니다. 
우리는 75를 위해 찾습니다. 75는 여기로 갑니다. 
그리고 우리는 75에서 연결합니다. 여러분은 연결리스트를 하는 방법을 압니다. 
그 포인터를 지우겠습니다.
스킵 리스트를 구현하는 것에서 모든 일은 연결 리스트 조작입니다. 
그것이 충분한가요?
아닙니다, 그것은 지금은 좋습니다 
왜냐하면 이제 여러분이 이 범위에서 무엇을 찾으면 
걸어야 하는 세 길이의 체인이 있기 때문입니다. 
그러나 제가 75 76를 계속 삽입하면, 
이 체인은 정말 
길 것입니다. 
이제 갑자기 그것은 균형 잡히지 않습니다. 
제가 검색을 하면, 

English: 
that the bottom list contains
all the elements.
So, there we go.
We've maintained the invariant.
The bottom list contains all
the elements.
So, we search for 75.
We say, oh, 75 goes here,
and we just sort of link in 75.
You know how to do a linked
list, I hope.
Let me just erase that pointer.
All the work in implementing
skip lists is the linked list
manipulation.
Is that enough?
No, it would be fine for now
because now there's only a chain
of length three here that you'd
have to walk over if you're
looking for something in this
range.
But if I just keep inserting
75, and 76, than 76 plus
epsilon, 76 plus two epsilon,
and so on, just pack a whole
bunch of elements in here,
this chain will get really
long.
Now, suddenly,
things are not so balanced.
If I do a search,

English: 
I'll pay an arbitrarily long
amount time here to search for
someone.
If I insert k things,
it'll take k time.
I want it to stay log n.
If I only insert log n items,
it's OK for now.
What I want to do is decide
which of these lists contain 75.
So, clearly it goes on the
bottom.
Every element goes in the
bottom.
Should it go up a level?
Maybe.
It depends.
It's not clear yet.
If I insert a few items here,
definitely some of them should
go on the next level.
Should I go to levels up?
Maybe, but even less likely.
So, what should I do?

Korean: 
저는 임의의 시간을 지불할 것입니다. 
제가 k를 삽입하면, 그것은 k 시간이 듭니다. 
저는 그것이 lg n에 머물길 원합니다. 
제가 lg n 아이템을 삽입하고 싶으면, 지금은 괜찮습니다. 
제가 원하는 것은 75를 포함하는 리스트를 결정하는 것입니다. 
그것은 아래로 갑니다. 
모든 인자는 아래에서 갑니다. 
그것이 단계를 올려야 하나요? 아마도요.  
그것은 아직 명확하지 않습니다.
제가 여기서 몇 아이템을 삽입하면, 그것들 중 몇 가지는 명백히 다음 단계를 올려야 합니다. 
제가 단계를 올려야 하나요? 
아마도요. 제가 무엇을 해야 하나요?

Korean: 
네, 그래서 여러분은 이상적인 분할 사이즈를 유지합니다, 
그것은 이 체인의 길이와 같을 것입니다. 
그리고 그것이 너무 길어지면, 
저는 그것을 중간에서 쪼개야 합니다,  
여기서 같은 것을 합니다.
이 체인이 두 연속적인 단계 간에 너무 길면, 
저는 중간 것을 촉진합니다. 
그것을 여러분이 문제 세트에서 할 것입니다. 
너무 좋지 않습니다. 저는 고약한 카운터가 필요하지 않습니다.
제가 무엇을 할 수 있나요? 
저는 이상적인 스킵 리스트 구조를 유지하려고 합니다. 
그것은 너무 비싸지 않을 것입니다. 75는 촉진되는 것이고, 
이것은 강등됩니다. 
그러나 그것은 모든 것을 아래쪽으로 전파합니다. 
그리고 그것은 업데이트를 위해 선형 시간이 듭니다. 

English: 
Yeah?
Right, so you maintain the
ideal partition size,
which may be like the length of
this chain.
And you see,
well, if that gets too long,
then I should split it in the
middle, promote that guy up to
the next level,
and do the same thing up here.
If this chain gets too long
between two consecutive next
level express stops,
then I'll promote the middle
guy.
And that's what you'll do in
your problem set.
That's too fancy for me.
I don't need no stinking
counters.
What else could I do?
I could try to maintain the
ideal skip list structure.
That will be too expensive.
Like I say, 75 is the guy that
gets promoted,
and this guy gets demoted all
the way down.
But that will propagate
everything to the right.
And that could cost linear time

English: 
for update.
Other idea?
If I only want half of them to
go up, I could flip a coin.
Good idea.
All right, for that,
I will give you a quarter.
It's a good one.
It's the old line state,
Maryland.
There you go.
However, you have to perform
some services for that quarter,
namely, flip the coin.
Can you flip a coin?
Good.
What did you get?
Tails, OK, that's the first
random bit.
But we are going to do is build
a skip list.
Maybe I should tell you how
first.
OK, but the idea is flip a
coin.
If it's heads,
so, sorry, if it's heads,
we will promote it to the next

Korean: 
다른 생각 있나요? 
제가 그것들 중 반을 원하면, 저는 동전 뒤집기를 할 수 있습니다. 
좋은 생각입니다. 그것을 위해서, 
저는 여러분에게 4분의 1을 줄 것입니다. 그것은 좋은 것입니다. 
그것은 오래된 라인, Maryland입니다. 
그러나, 여러분은 그 쿼터를 위한 서비스, 
즉 동전 뒤집기를 수행해야 합니다.
여러분은 동전 뒤집기를 할 수 있나요? 좋습니다. 
여러분은 무엇을 얻었나요? 꼬리입니다. 첫 번째 랜덤입니다.
그러나 우리가 하려고 하는 것은 스킵 리스트를 구축하는 것입니다. 
아마 저는 여러분에게 얼마나 빠른지 알려주어야 합니다. 
그러나 그것은 동전 뒤집기입니다. 
그것이 머리이면, 
우리는 그것을 다음 단계로 촉진합니다, 다시 뒤집습니다. 

English: 
level, and flip again.
So, this is an answer to the
question, which other lists
should store x?
How many other lists should we
add x to?
Well, the algorithm is,
flip a coin,
and if it comes out heads,
then promote x.
to the next level up,
and flip again.
OK, that's key because we might
want this element to go
arbitrarily high.
But for starters,
we flip a coin.
It doesn't go to the next
level.
Well, we'd like it to go to the
next level with probability one
half because we want the ratio
between these two sizes to be a
half, or sorry,
two, depending which way you
take the ratio.
So, I want roughly half the
elements up here.
So, I flip a coin.
If it comes up heads,

Korean: 
그래서 이것은 질문의 답입니다, 
다른 리스트가 x를 저장하나요? 
얼마나 많은 리스트에 x를 더해야 하나요? 
알고리즘은 동전 뒤집기입니다, 
그리고 그것이 머리이면, x를 촉진합니다. 
단계를 올리고 다시 뒤집습니다.
그것이 키입니다 왜냐하면 우리는 이 인자를 임의로 높게 하고 싶기 때문입니다. 
그러나 출발자들을 위해, 
우리는 동전을 뒤집습니다. 그것은 다음 단계로 가지 않습니다. 
우리는 그것이 절반의 가능성으로 다음 단계로 가길 바랍니다  
왜냐하면 우리는 이 두 사이즈가 절반이 되는 비율을 원하기 때문입니다, 
그것은 여러분이 비율을 취하는 
방법에 달려있습니다.
저는 대략적으로 여기서 절반의 인자를 원합니다. 
저는 동전을 뒤집습니다. 그것이 머리로 오면, 

English: 
I go up here.
This is a fair coin.
So I want it 50-50.
OK, then how many should that
element go up to the next level
up?
Well, with 50% probability
again.
So, I flip another point.
If it comes up heads,
I'll go up another level.
And that will maintain the
approximate ratio between these
two guys as being two.
The expected ratio will
definitely be two,
and so on, all the way up.
If I go up to the top and flip
a coin, it comes up heads,
I'll make another level.
This is the insertion
algorithm: dead simple.
The fancier one you will see on
your problem set.
So, let's do it.
OK, I also need someone to
generate random numbers.
Who can generate random
numbers?

Korean: 
저는 여기로 갑니다. 이것이 동전입니다.
그것이 50-50이길 바랍니다. 
얼마나 많은 인자가 다음 단계로 가나요? 
50 퍼센트의 가능성을 가집니다. 
저는 다른 포인트를 뒤집습니다. 그것이 머리이면, 
저는 다른 단계로 갑니다. 
그리고 그것은 대략적인 비율을 유지합니다. 
예상 비율은 정확히 2입니다. 
제가 위로 가서 동전을 뒤집으면, 그것은 머리로 가고, 
저는 다른 단계를 만들 것입니다. 
이것은 삽입 알고리즘입니다. 간단합니다.
여러분은 문제 세트에서 더 좋은 것을 볼 것입니다. 
그것을 해 봅시다.
저는 랜덤한 수를 생성할 사람이 필요합니다. 
누가 랜덤한 수를 생성 할 수 있나요? 

Korean: 
저는 여러분에게 4분의 1을 줄 것입니다. 저는 여기서 하나를 가집니다. 
여러분은 여기서 갑니다. 
그것은 지루합니다. 누가 랜덤한 수를 생성하고 싶나요? 
자원할 사람 있나요? 
여기서 해 봅시다.
여러분은 쿼터를 가지지만, 
여러분은 그것을 뒤집도록 허용되지 않았습니다. 
랜덤함이 없습니다. 여러분은 생성할 수 있고, 수를 계산합니다. 
저에게 수를 주세요. 
44는 답일 수 있습니다. 
우리는 이미 동전을 뒤집었고, 꼬리를 가집니다. 다 했습니다. 
그것이 삽입 알고리즘입니다.
저는 더 많은 공간을 만들 것입니다. 44는 촉진되지 않습니다 
우리가 꼬리를 가지기 때문입니다. 
저에게 다른 수를 주세요. 저는 이 리스트에서 9를 찾습니다. 
저는 하나 더 언급해야 합니다. 
저는 작은 변화가 필요합니다. 
이것은 검색이 여전히 작동한다는 것을 확실히 합니다. 

English: 
Pseudo-random?
I'll give you a quarter.
I have one here.
Here you go.
That's a boring quarter.
Who would like to generate
random numbers?
Someone volunteering someone
else: that's a good way to do
it.
Here you go.
You get a quarter,
but you're not allowed to flip
it.
No randomness for you;
well, OK, you can generate
bits, and then compute a number.
So, give me a number.
44, can answer.
OK, we already flipped a coin
and I got tails.
Done.
That's the insertion algorithm.
I'm going to make some more
space actually,
put it way down here.
OK, so 44 does not get promoted
because we got a tails.
So, give me another number.
Nine, OK, I search for nine in
this list.
I should mention one other
thing, sorry.
I need a small change.
This is just to make sure
searches still work.

Korean: 
제가 더 큰 것을 삽입하고 그것을 삭제한다고 가정해보세요. 
이것은 스킵 리스트 데이터 구조를 위해 매우 나쁩니다. 
왜냐하면 저는 항상 왼쪽 위에서 시작하고 싶기 때문입니다. 
이제 왼쪽 위가 없습니다. 
작은 변화입니다. 그것을 기억해보겠습니다. 
작은 변화는 제가 모든 리스트에서 특별한 값 
마이너스 무한대를 저장하는 것입니다. 
마이너스 무한대는 항상 아래로 촉진됩니다.
초기에, 
저는 항상 왼쪽 위를 가질 것입니다. 
저는 그것을 언급하는 것을 잊었습니다. 
초기에, 저는 마이너스 무한대를 가집니다. 
그리고 44를 삽입합니다. 
44는 다 되었습니다. 
이제 우리는 9를 삽입합니다. 
9는 여기로 갑니다. 동전을 던집니다, 
머리입니다. 

English: 
So, the worry is suppose I
insert something bigger and then
I promote it.
This would look very bad for a
skip list data structure because
I always want to start at the
top left, and now there's no top
left.
So, just minor change:
just let me remember that.
The minor change is that I'm
going to store a special value
minus infinity in every list.
So, minus infinity always gets
promoted all the way to the top,
whatever the top happens to be
now.
So, initially,
that way I'll always have a top
left.
Sorry, I forgot to mention
that.
So, initially I'll just have
minus infinity.
Then I insert 44.
I say, OK, 44 goes there,
no promotion,
done.
Now, we're going to insert
nine.
Nine goes here.
So, minus infinity to nine,
flip your coin,
heads.

Korean: 
실제로 뒤집었나요? 좋습니다. 
그는 전에 뒤집었습니다. 
저는 여러분에게 어려운 시간을 줄 것입니다. 
우리는 9를 가집니다. 우리는 이 마이너스 무한대를 유지할 필요가 있습니다 
그것이 촉진되는 것을 확실히 하기 위해서요. 
그것은 좋은 스킵 리스트 같아 보입니다. 
그것을 다시 뒤집으세요. 
꼬리입니다. 그래서 이것은 이상적인 스킵 리스트 같아 보입니다. 
그것이 훌륭하지 않은가요? 
그것은 매번 동작합니다. 저에게 다른 수를 주세요. 
26. 그래서 저는 26을 위해 검색합니다. 
26은 여기로 갑니다.
저는 아래 리스트로 갑니다. 
우리는 26으로 가서 44를 올립니다. 
뒤집습니다. 꼬리, 좋은 수입니다. 50, 큰 수입니다. 
그것은 검색하는데 좀 듭니다. 50. 
뒤집습니다. 머리입니다, 좋아요. 

English: 
Did he actually flip it?
OK, good.
He flipped it before,
yeah, sure.
I'm just giving you a hard
time.
So, we have nine up here.
We need to maintain this minus
infinity just to make sure it
gets promoted along with
everything else.
So, that looks like a nice skip
list.
Flip it again.
Tails, good.
OK, so this looks like an ideal
skip list.
Isn't that great?
It works every time.
OK, give me another number.
26, OK, so I search for 26.
26 goes here.
It clearly goes on the bottom
list.
Here we go, 26,
and then I you raised 44.
Flip.
Tails, OK, another number.
50, oh, a big one.
It costs me a little while to
search, and I get over here.
50.
Flip.
Heads, good.

English: 
So 50 gets promoted.
Flip it again.
Tails, OK, still a reasonable
number.
Another number?
12, it takes a little while to
get exciting here.
OK, 12 goes here between nine
and 26.
You're giving me a hard time
here.
OK, flip.
Heads, OK, 12 gets promoted.
I know you have to work a
little bit, but we just came
here to search for 12.
So, we know that nine was the
last point we went down.
So, we promote 12.
It gets inserted up here.
We are just inserting into this
particular linked list:
nothing fancy.
We link the two twelves
together.
It still looks kind of like a
linked list.
Flip again.
OK, tails, another number.
37.

Korean: 
50은 촉진됩니다. 다시 뒤집습니다. 
꼬리입니다. 여전히 합리적인 수입니다. 
다른 수인가요? 12입니다. 그것은 좀 걸립니다. 
12는 9와 26 사이로 갑니다. 여러분은 저에게 여기서 
어려운 시간을 주었습니다
뒤집으세요. 
머리 입니다. 12는 촉진됩니다. 
저는 여러분이 작동해야 한다는 것을 알지만, 우리는 여기로 12를 찾기 위해 왔습니다.
우리는 9가 마지막 점이라는 것을 압니다. 
우리는 12를 촉진합니다. 그것은 여기서 삽입됩니다. 
우리는 이 특정 연결 리스트를 삽입할 것입니다. 
우리는 같이 연결합니다. 
그것은 여전히 연결 리스트 같아 보입니다. 
다시 뒤집으세요. 
꼬리, 다른 수 입니다. 37. 

Korean: 
그것은 기억의 테스트입니다
37. 44와 50이었나요? 
50은 다음 단계에 있었습니다. 
저는 인자를 계속 붙이고 동전을 뒤집어야 합니다. 
우리는 37을 삽입했습니다.
꼬리입니다. 그것은 긴 체인입니다. 
그것은 나빠 보입니다. 
저에게 50 보다 더 큰 수를 주세요. 5
1, 좋은 답입니다.
고마워요. 다시 뒤집으세요. 
다시요. 꼬리입니다. 다른 수 입니다. 
기다리세요, 누가 수를 가져야 합니다. 
그것은 동작하지 않습니다. 여러분은 뭐라고 말했나요? 
52, 좋은 답입니다. 뒤집으세요. 
꼬리입니다. 놀랍지 않습니다. 우리는 많은 머리를 저기서 갖습니다. 

English: 
Jeez.
It's a good test of memory.
37, what was it,
44 and 50?
And 50 was at the next level
up.
I think I should just keep
appending elements and have you
flip coins.
OK, we just inserted 37.
Tails.
OK, that's getting to be a long
chain.
That looks a bit worse.
OK, give me another number
larger than 50.
51, good answer.
Thank you.
OK, flip again.
And again.
Tails.
Another number.
Wait, someone else should pick
a number.
It's not working.
What did you say?
52, good answer.
Flip.
Tails, not surprising.
We've gotten a lot of heads

English: 
there.
OK, another number.
53, thank you.
Flip.
Heads, heads,
OK.
Heads, heads,
you didn't flip.
All right, 53,
you get the idea.
If you get two consecutive
heads, then the guy goes up two
levels.
OK, now flip for real.
Heads.
Finally.
Heads we've been waiting for.
If you flipped three heads in a
row, you go three levels.
And each time,
we keep promoting minus
infinity.
Look again.
Heads, oh my God.
Where were they before?
Flip again.

Korean: 
다른 수가 있습니다. 
53, 고마워요. 뒤집으세요. 
머리, 머리입니다. 
머리, 머리, 여러분은 뒤집지 않았습니다. 
좋아요, 53, 여러분은 생각을 얻습니다. 
여러분이 두 연속적인 머리를 얻으면, 그것은 두 단계 올라갑니다. 
이제 실제로 뒤집으세요.
머리입니다. 마지막으로요. 
머리는 우리가 기다리는 것입니다. 여러분이 한 열의 3 머리를 뒤집으면, 
여러분은 세 단계 갑니다. 
그리고 각 시간에, 우리는 마이너스 무한대를 촉진해야 합니다. 
계속 보세요. 머리입니다. 
그것들은 전에 어디 있었나요? 다시 뒤집으세요. 

Korean: 
그것은 이번에 꼬리인 것이 더 낫습니다. 꼬리입니다, 좋아요. 
여러분은 생각을 얻습니다. 결국 여러분은 칠판 공간을 다 써버렸습니다.
이제 여러분이 너무 높이 올라가는 것은 매우 드뭅니다. 
여러분이 lg n 보다 더 높이 올라갈 가능성은 무엇입니까? 
다른 쉬운 로그 계산이 있습니다. 
매 시간 저는 50 퍼센트의 가능성으로 올라갑니다. 
n의 1은 lg n으로 올라갑니다. 
그것은 n에 달렸습니다, 
그러나 저는 너무 높이 가지 않을 것입니다.
직관적으로, 
이것은 너무 나쁘지 않습니다. 이것들은 스킵 리스트입니다. 
여러분은 비율을 가집니다, 그것은 약한 문장입니다. 
이것은 이 변화에 대해 아무 것도 말하지 않습니다. 
그러나 직관적으로, 
그것은 매우 좋습니다. 그것이 평균적으로 좋다고 합시다.

English: 
It better be tails this time.
Tails, good.
OK, you get the idea.
Eventually you run out of board
space.
Now, it's pretty rare that you
go too high.
What's the probability that you
go higher than log n?
Another easy log computation.
Each time, I have a 50%
probability of going up.
One in n probability of going
up log n levels because half to
the power of log n is one out of
n.
So, it depends on n,
but I'm not going to go too
high.
And, intuitively,
this is not so bad.
So, these are skip lists.
You have the ratios right in
expectation, which is a pretty
weak statement.
This doesn't say anything about
the lengths of these change.
But intuitively,
it's pretty good.
Let's say pretty good on

English: 
average.
So, I had two semi-random
processes going on here.
One is picking the numbers,
and that, I don't want to
assume anything about.
The numbers could be
adversarial.
It could be sequential.
It could be reverse sorted.
It could be random.
I don't know.
So, it didn't matter what he
said.
At least, it shouldn't matter.
I mean, it matters here.
Don't worry.
You're still loved.
You still get your $0.25.
But what the algorithm cares
about is the outcomes of these
coins.
And the probability,
the statement that this data
structure is fast with high
probability is only about the
random coins.
Right, it doesn't matter what
the adversary chooses for
numbers as long as those coins
are random, and the adversary
doesn't know the coins.
It doesn't know the outcomes of
the coins.
So, in that case,
on average, overall of the coin
flips, you should be OK.
But the claim is not just that
it's pretty good on average.
But, it's really,

Korean: 
저는 두 랜덤 과정을 가졌습니다. 
하나는 수를 고르는 것입니다, 
저는 가정하길 원하지 않습니다. 
수는 역일 수 있습니다. 
그것은 순차적일 수 있습니다. 그것은 역으로 정렬될 수 있습니다. 
그것은 랜덤일 수 있습니다. 저는 모릅니다. 
그가 말했던 것은 중요하지 않습니다
적어도, 그것은 중요해서는 안됩니다. 그것은 여기서 중요합니다. 
걱정하지 마세요. 여러분은 여전히 사랑 받습니다. 
여러분은 여전히 $0.25를 얻습니다. 그러나 알고리즘이 
신경 쓰는 것은 이 동전의 결과 입니다. 
이 데이터 구조는 높은 확률로 빠릅니다, 
그 확률은 랜덤 동전에 대한 것입니다.
좋아요, 동전이 랜덤인 한 수를 역으로 
선택하는 것은 중요하지 않습니다. 
역은 동전을 모릅니다.
그것은 동전의 결과를 모릅니다. 
그 케이스에서, 평균적으로, 여러분은 전반적인 동전 뒤집기일 수 있습니다. 
그러나 그것은 평균적으로 매우 좋습니다. 
그러나 그것은 정말 항상 좋습니다. 

English: 
really good almost always.
OK, with really high
probability it's log n.
So, for example,
with probability,
one minus one over n,
it's order of log n,
with probability one minus one
over n^2 it's log n,
probability one minus one over
n^100, it's order log n.
All those statements are true
for any value of 100.
So, that's where we're going.
OK, I should mention,
how do you delete in a skip
list?
Find the element.
You delete it all the way.
There's nothing fancy with
delete.
Because we have all these
independent, random choices,
all of these elements are sort
of independent from each other.
We don't really care.
So, delete an element,
just throw it away.
The tricky part is insertion.
When I insert an element,
I'm just going to randomly see
how high it should go.

Korean: 
높은 가능성을 가지고 그것은 lg n 입니다. 
예를 들어, 
1 – 1/n의 가능성으로 그것은 O(lg n)입니다.
1 – 2/n^2의 가능성으로, 그것은 lg n 입니다. 
1 – 1/ n^100의 가능성으로 그것은 O(lg n) 입니다.
모든 문장은 100의 값에 대해 옳습니다. 
그것이 우리가 하려는 겁니다.
여러분은 스킵 리스트에서 어떻게 삭제하나요? 
인자를 찾으세요. 
여러분은 그것을 삭제합니다. 삭제로 좋은 것은 없습니다. 
왜냐하면 우리가 이것들을 독립적으로 해야 하기 때문에, 
이 모든 인자들은 각각 독립적입니다. 
우리는 정말 신경 쓰지 않습니다. 
인자를 삽입하는 것은, 그것을 던지는 것입니다. 
까다로운 부분은 삽입입니다. 제가 인자를 삽입할 때, 
저는 그것이 어떻게 높이 가야 하는지 랜덤하게 봅니다.

English: 
With probability one over two
to the i, it will go to height
i.
Good, that's my time.
I've been having too much fun
here.
I've got to go a little bit
faster, OK.
So here's the theorem.
Let's see exactly what we are
proving first.
With high probability,
this is a formal notion which I
will define a second.
Every search in n elements skip
lists costs order of log n.

Korean: 
1 나누기 2의 I 가능성을 가지고, 그것은 높이 i로 갑니다.
좋아요, 그것은 제 시간입니다. 
저는 여기서 너무 많이 재미있었습니다. 
조금 더 빨리 해야겠네요
그래서 여기 정리가 있습니다. 우리가 먼저 증명하는 것을 봅시다. 
높은 가능성으로, 
이것은 제가 정의할 공식적인 개념입니다. 
n인자 스킵 리스트에서 모든 검색은 O(lg n)의 비용이 듭니다. 

English: 
So, that's the theorem.
Now I need to define with high
probability.
So, with high probability.
And, it's a bit of a long
phrase.
So, often we will,
and you can abbreviate it WHP.
So, if I have a random event,
and the random event here is
that every search in an n
element skip list costs order
log n, I want to know what it
means for that event E to occur
with high probability.
So this is the definition.
So, the statement is that for

Korean: 
그것은 정리입니다. 이제 저는 높은 가능성을 가지고 정의할 필요가 있습니다. 
높은 가능성을 가지고요.
그것은 긴 구절입니다. 
종종, 여러분은 그것을 줄여 쓸 수 있습니다. WHP로요. 
제가 랜덤 사건을 보면, 여기서 랜덤한 사건은 n 인자 스킵 리스트에서 모든 검색이 
O(lg n)의 비용이 드는 것입니다. 
저는 그 사건 e를 위해 일어나는 것이 
무엇인지 알고 싶습니다.
이것은 정의입니다. 

Korean: 
문장은 1 보다 크거나 같은 알파를 위해, 정수의 적합한 
선택입니다
E는 제가 언급하는 이 가능성으로 일어납니다. 
적어도 
1 – 1/n의 알파의 가능성입니다. 
이것은 정확하지 않습니다, 그러나 그것은 우리의 목적을 위해 충분합니다. 
여러분이 정말 공식적인 정의를 원하면, 
강의 노트를 읽으면 됩니다.
사이트에 이 강의를 위한 특별 강좌가 있습니다. 

English: 
any alpha greater than or equal
to one, there is a suitable
choice of constants --
-- for which the event,
E, occurs with this probability
I keep mentioning.
So, the probability at least
one minus one over n to the
alpha.
So, this is a bit imprecise,
but it will suffice for our
purposes.
If you want to really formal
definition, you can read the
lecture notes.
There are special lecture notes
for this lecture on the stellar

Korean: 
SMA 사이트에 파워포인트 노트가 있습니다.
여기서 미묘한 상수의 
선택이 있습니다. 
여기 이 상수의 선택이 있고
이쪽의 이 상수의 선택이 있습니다. 
이것들은 연결되었습니다. 알파가 있고, 
그것은 우리가 원하는 것입니다. 
아래 라인은, 이것이 옳길 바라는 가능성으로 
선택합니다. 
제가 그것이 옳길 q라면, 1 – 1/ n^100의 가능성으로, 저는 그것을 할 수 있습니다. 
저는 알파를 100으로 하고, n의 알파 보다 
느리게 가는 작은 정수까지 합니다.
저는 오류 확률을 얻습니다. 
이것은 오류 확률입니다. 
실패할 확률은 다항적으로 작습니다.
이제 같은 데이터 구조를 가지고, 
저는 데이터 구조를 고정했습니다. 
그것은 알파에 의존하지 않습니다. 

English: 
site.
And, there's the PowerPoint
notes on the SMA site.
But, right, there's a bit of a
subtlety in the choice of
constants here.
There is a choice of this
constant.
And there's a choice of this
constant.
And, these are related.
And, there's alpha,
which we get to whatever we
want.
But the bottom line is,
we get to choose what
probability we want this to be
true.
If I want it to be true,
with probability one minus one
over n^100, I can do that.
I just sat alpha to a hundred,
and up to this little constant
that's going to grow much slower
than n to the alpha.
I get the error probability.
So this thing is called the
error probability.
The probability that I fail is
polynomially small,
for any polynomial I want.
Now, with the same data
structure, right,
I fixed the data structure.
It doesn't depend on alpha.
Anything you want,

Korean: 
이 데이터 구조는 O(lg n)시간이 듭니다.
이제 이 정수는 알파에 달려 있습니다. 
그래서
여러분은 오류 확률 1/ n^100이 100 lg n과 같길 원합니다. 
그것은 여전히 lg n 입니다. 
이것은 검색 러닝 타임의 분배에 대한 매우 강력한 
주장입니다. 
여러분에게 그것이 어떻게 강력한지에 대한 생각을 주겠습니다.
얼마나 많은 사람이 Boole 부등식이 무엇인지 아나요? 
얼마나 많은 학생이 union bound에 대해 아나요? 
여러분은 알아야 합니다. 그것은 부록 c에 있습니다. 
아마 여러분은 정리에 의해 그것을 알 것입니다. 
그것은 대화하기 더 쉽습니다. 기대값의 선형성입니다. 
어디서 여러분은 모든 기대값을 더하나요, 

English: 
any alpha value you want,
this data structure will take
order of log n time.
Now, this constant will depend
on alpha.
So, you know,
you want error probability one
over n^100 is probably going to
be, like, 100 log n.
It's still log n.
OK, this is a very strong claim
about the tale of the
distribution of the running time
of search, very strong.
Let me give you an idea of how
strong it is.
How many people know what
Boole's inequality is?
How many people know what the
union bound is in probability?
You should.
It's in appendix c.
Maybe you'll know it by the
theorem.
It's good to know it by name.
It's sort of like linearity of
expectations.
It's a lot easier to

Korean: 
그리고 그것은 합의 기대값인가요? 
기대값의 선형성을 말하는 것은 더 쉽습니다.
다른 방법으로 
퀴즈를 내보겠습니다. 
제가 많은 사건을 가지면, 
그리고 union을 가지면, 
이것 또는 이것이 일어납니다. 
이것은 k 사건의 일체의 OR 입니다. 
그리고
대신에, 저는 이 사건들의 확률의 합을 봅니다
쉬운 질문입니다. 이것들이 같나요? 
아니요, 그것들이 독립적이지 않으면요. 
그러나 저는 그것에 대해 어떤 것을 할 수 있나요? 
더 작은 것을요. 이것은 그것보다 작거나 같습니다. 
이것은 확률의 견해로부터 여러분에게 .
직관적이어야 합니다

English: 
communicate to someone.
Linearity of expectations:
instead of saying,
you know that thing where you
sum up all the expectations of
things, and that's the
expectation of the sum?
It's a lot easier to say
linearity of expectation.
So, let me quiz you in a
different way.
So, if I take a bunch of
events, and I take their union,
either this happens or this
happens, or so on.
So, this is the inclusive OR of
k events.
And, instead,
I look at the sum of the
probabilities of those events.
OK, easy question:
are these equal?
No, unless they are
independent.
But can I say anything about
them, any relation?
Smaller, yeah.
This is less than or equal to
that.
OK, this should be intuitive to
you from a probability point of
view.

Korean: 
교재를 보세요. 매우 기본적인, 사소한 결과입니다. 
이것이 우리에게 무엇을 말해주나요? 
E_i가 오류 사건이라고 가정해보세요. 
우리는 그것이 일어나길 원하지 않습니다. 여기서 철자들을 섞으세요.
제가 높은 확률로 일어나는 사건을 가진다고 
가정해보세요. 
그것들을 E_i 보수라고 합시다. 
E_i 보수는 높은 가능성으로 일어납니다
그래서 E_i의 확률은 매우 작습니다, 
다항적으로 작습니다. 
1 나누기 n의 알파입니다.
이제 제가 이 전체의 사건을 가진다고 가정해보세요. 
그리고 그 k가 n에서 다항적이라고 합시다. 
저는 많은 사건을 가지고, 그것들은 제가 일어나길 바라는 것입니다. 
그것들은 모두 높은 가능성으로 일어납니다
다항적으로 많은 것들이 있습니다. 

English: 
Look at the textbook.
OK: very basic result,
trivial result almost.
What does this tell us?
Well, suppose that E_i is some
kind of error event.
We don't want it to happen.
OK, and suppose,
mix some letters here.
Suppose I have a bunch of
events which occur with high
probability.
OK, call those E_i complement.
So, suppose,
so this is the end of that
statement, E_i complement occurs
with high probability.
OK, so then the probability of
E_i is very small,
polynomially small.
One over n to the alpha for any
alpha I want.
Now, suppose I take a whole
bunch of these events,
and let's say that k is
polynomial in n.
So, I take a bunch of events,
which I'd like to happen.
They all occur with high
probability.
There is only polynomially many
of them.

Korean: 
제가 이 상수에 이름을 주겠습니다. 
그것을 c라고 합시다.
저는 n의 c 사건을 가집니다. 
모든 사건이 함께 일어나는 확률은 무엇입니까? 
그것들이 함께  
일어나기 때문에, 
높은 확률로 일어납니다.
저는 E_1 바 E_2 바를 보고 싶습니다. 
이것들은 각각 높은 확률로 일어납니다. 
그것들이 모두 일어날 확률은 무엇입니까? 
그것은 높은 확률입니다. 
저는 알파를 바꿀 것입니다. 
union bound는 저에게 이것들이 실패할, 
또는 이것이 실패할  
어떤 확률을 알려줍니다. 
각 실패의 확률의 
합입니다.
이것들은 오류 확률입니다. 
저는 그것들이 최대 1 나누기 n의 알파라는 것을 합니다. 
제가 그것들을 모두 더하면, 
그것은 n의 c입니다. 

English: 
So let's say,
let me give this constant a
name.
Let's call it c.
Let's say I take n to the c
such events.
Well, what's the probability
that all those events occur
together?
Because they should rest of the
time occurred together because
each one occurs most of the
time, occurs with high
probability.
So, I want to look at E_1 bar
intersect, E_2 bar,
and so on.
So, each of these occurs as
high probability.
What's the chance that they all
occur?
It's also with high
probability.
I'm changing the alpha.
So, the union bound tells me
the probability of any one of
these failing,
the probability of this
failing, or this failing,
or this failing,
which is this thing,
is, at most,
the sum of the probabilities of
each failure.
These are the error
probabilities.
I know that each of them is,
at most, one over n to the
alpha, with a constant in front.
If I add them all up,
there's only n to the c of
them.

English: 
So, I take this error
probability, and I multiply by n
to the c.
So, I get like n to the c over
n to the alpha,
which is one over n to the
alpha minus c.
I can set alpha as big as I
want.
So, I said it much,
much bigger than c,
and this event occurs with high
probability.
I sort of made a mess here,
but this event occurs with high
probability because of this.
Whatever the constant is here,
however many events I'm taking,
I just set alpha to be bigger
than that.
And, this event will occur with
high probability,
too.
So, when I say here that every
search of cost order log n with
high probability,
not only do I mean that if you
look at one search,
it costs order log n with high
probability.
You look at another search,
and it costs log n with high
probability.
I mean, if you take every
search, all of them take order
log n time with high
probability.
So, this event that every

Korean: 
저는 이 오류 확률을 가지고, 그것을 n의 c와 곱합니다.
저는 n의 c 나누기 n의 알파 같은 것을 얻습니다, 
그것은 1 나누기 n의 알파 마이너스 c 입니다. 
저는 알파를 원하는 만큼 크게 할 수 있습니다. 
그것은 c 보다 훨씬 더 큽니다, 
그리고 이 사건은 높은 가능성으로 일어납니다.  
저는 여기서 엉망을 만들었지만,
이 사건은 이것 때문에 높은 확률로 일어납니다. 
여기서 정수가 무엇이든, 제가 얼마나 많은 사건을 가지든,  
저는 알파를 그것 보다 크게 설정합니다.
그리고 이 사건은 높은 확률로 일어납니다. 
모든 검색 비용이 O(lg n)이라고 말할 때, 
여러분이 
하나의 검색을 보면 그것은 
높은 확률로 lg n입니다. 
여러분은 다른 검색을 봅니다, 그리고 그것은 높은 가능성으로 lg n입니다. 
여러분이 모든 검색을 취하면, 
모든 것은 높은 확률로 O(lg n) 입니다. 
이 사건은 모든 단일 검색이 

Korean: 
O(lg n)입니다, 측정 수는 
다항적으로 n 입니다.
저는 이 데이터 구조를 영원히 사용하지 않는다고 가정합니다, 
다항의 시간 양에 대해서요. 
그러나 누가 다항 시간 보다 
더 많이 가지나요? 
이것은 MIT 입니다. 희망적으로, 그것은 명확합니다. 
우리는 몇 번 더 볼 것입니다. 
알고리즘은 알파에 의존하지 않습니다. 
여러분은 알고리즘에서 알파를 어떻게 선택하나요? 
우리는 필요하지 않습니다. 이것은 일종의 분석 툴을 위한 것입니다. 
확률은 10 lg n 이상입니다. 
그것은 1 나누기  
n^10와 같습니다. 그것이 선형이라고 합시다.
여러분이 20 n^10 이상일 가능성은 무엇인가요? 
그것은 1 나누기 n^20 입니다.
핵심은 이 분배의 꼬리가 정말 
작고 빠르다는 것입니다. 
알파를 사용하는 것은 여러분의 느낌을 좋게 하기 위한 것입니다. 

English: 
single search you do takes order
log n, is true with high
probability estimate the number
of searches you are doing is
polynomial in n.
So, I'm assuming that I'm not
using this data structure
forever, just for a polynomial
amount of time.
But, who's got more than a
polynomial amount of time
anyway?
This is MIT.
So, hopefully that's clear.
We'll see it a few more times.
Yeah?
The algorithm doesn't depend on
Alpha.
The question is how do you
choose alpha in the algorithm.
So, we don't need to.
This is just sort of for an
analysis tool.
This is saying that the farther
out you get, so you say,
well, what's the probability
that more than ten log n.
Well, it's like one over n^10.
Let's say it's linear.
Well, what's the chance that
you're more than 20 log n?
Well that's one over n^20.
So, the point is the tail of
this distribution is getting a
really small,
really fast.
And, such using alpha is more
like sort of for your own

English: 
feeling good.
OK, you can set it to 100,
and then n is at least two.
So, that's like one over 2^100
chance that you fail.
That's damn small.
If you've got a real random
number generator,
the chance that you're going to
hit one over 2^200 is pretty
tiny, right?
So, let's say you set alpha to
256, which is always a good
number.
2^256 is much bigger than the
number of particles in the known
universe, so,
the light matter.
So, actually I think this even
accounts for some notion of dark
matter.
So, this is really,
really, really big.
So, the chance that you pick a
random particle in the universe
that happens to be your favorite
particle, this one right here,
that's over one over 2^256,
or even smaller.
So, set alpha to 256,
the chance to your algorithm
takes more than order log n time
is a lot smaller than the chance
that a meteor strikes your
computer at the same time that
it has a flooding point error,

Korean: 
여러분은 그것을 100으로 설정할 수 있습니다, 그리고 n은 적어도 2입니다.
그것은 여러분이 실패하는 1 나누기 2^100의 가능성과 같습니다. 
작습니다. 
여러분이 실제 랜덤 수 생성기를 가지면, 
여러분이 1 나누기 2^200을 칠 가능성은 매우 작습니다.
그래서, 여러분은 알파를 256으로 설정합니다, 
그것은 항상 좋은 수 입니다. 
2^256은 알려진 우주에서 입자의 수 보다 
훨씬 더 큽니다. 
사실 저는 그것이 어두운 문제의 개념을 위한 것이라고 생각합니다. 
이것은 정말, 정말, 정말 큽니다. 
여러분이 우주에서 랜덤 입자를 고르는 가능성은 
여러분의 가장 좋아하는 입자입니다, 그것은 여기 있습니다, 
1 나누기 2^256 이거나 더 작습니다. 
알파를 256으로 설정합시다. 
여러분의 알고리즘이 O(lg n)보다 
더 들 확률은 유성이 동시에 
여러분의 컴퓨터를 치고, 지구가 폭발하는 확률 보다 더 작습니다. 

English: 
at the same time that the earth
explodes because they're putting
a transport through this part of
the solar system at the same
time, I mean,
I could go on,
right?
It's really,
really unlikely that you are
more than log n.
And how unlikely:
you get to choose.
But it's just in the analysis
the algorithm doesn't depend on
it.
It's the same algorithm,
very cool.
Sometimes, with high
probability, bounds depends on
alpha.
I mean, the algorithm depends
on alpha.
But here, it will not.
OK, away we go.
So now you all understand the
claim.
So let's do a warm up.
We will also need this fact.
But it's pretty easy.
The lemma is that with high

Korean: 
왜냐하면 그것들이 
우주 시스템의 이 부분을 통해 이동하기 때문입니다.
정말로
그것은 여러분이 lg n 보다 클 법하지 않습니다. 
여러분은 선택합니다. 
그러나 그것은 알고리즘 분석에서 그것에 의존하지 않습니다. 
그것은 같은 알고리즘입니다, 
매우 좋아요. 때때로, 높은 가능성으로 
바운드는 알파에 의존합니다. 
알고리즘은 알파에 의존합니다. 
그러나 여기서 그것은 아닐 것입니다. 
그래서 이제 여러분은 이 주장을 모두 이해합니다. 
준비 운동을 해 봅시다. 우리는 이 사실이 필요할 것입니다. 
그러나 그것은 매우 쉽습니다. 

English: 
probability, the number of
levels in the skip list is order
log n.
I think it's order log n,
certainly.
So, how do we prove that
something happens with high
probably?
Compute the probability that it
happened; show that it's high.
Even if you don't know what
high probability means,
in fact, I used to ask that
earlier on.
So, let's compute the chance
that it doesn't happen,
the error probability,
because that's just a one minus
the cleaner.
So, I'd like to say,
let's say, that it's,
at most, c log n levels.
So, what's the error
probability for that event?
This is sort of an event.
I'll put it in squiggles just
for, all set.
This is the probability that
they are strictly greater than c
log n levels.

Korean: 
부명제는 높은 확률로, 스킵 리스트에서 단계의 수가 O(lg n)이라는 것입니다.
저는 그것이 확실히 O(lg n)이라고 생각합니다. 
우리는 그것이 높은 확률로 일어난다는 것을 
어떻게 증명하나요? 
그것이 일어난 가능성을 계산하세요. 그것이 크다는 것을 보여주세요. 
여러분이 높은 확률이 의미하는 것을 모르더라도, 
사실, 저는 더 일찍 물어보곤 했습니다. 
그것이 일어나지 않을 확률, 오류 확률을 계산합니다 
왜냐하면 그것이 1 마이너스 클리너 이기 때문입니다. 
그래서
그것은 최대 c lg n 단계입니다. 
그 사건을 위한 오류 확률은 무엇입니까? 
이것은 일종의 사건입니다. 저는 그것을 구불구불한 선에 둘 것입니다.
이것은 그것들이 c lg n 단계 보다 
엄격히 더 클 확률입니다. 

English: 
So, I want to say that that
probability is particularly
small, polynomially small.
Well, how do I make levels?
When I insert an element,
the probability half,
it goes up.
And, the number of levels in
the skip list is the max over
all the elements of how high it
goes up.
But, max, oh,
that's a mess.
All right, you can compute the
expectation of the max if you
have a bunch of unknown
variables; there is expectation
there is a constant,
and you take the max.
It's like log in and
expectation, but we want a much
stronger statement.
And, we have this Boole's
inequality that says I have a
bunch of things,
polynomially many things.
Let's say we have n items.
Each one independently,
I don't even care if it's a
dependent.
If it goes up more than c log
n, yeah, the number of levels is
more than c log n.
So, this is,

Korean: 
저는 그 확률이 특별히, 다항적으로 작다고 말하고 싶습니다.
저는 어떻게 단계를 만드나요? 
제가 인자를 삽입할 때, 확률 절반은 올라갑니다. 
그리고 스킵 리스트에서 단계의 수는 최대값 나누기 
그것이 높이 올라가는 것의 모든 인자입니다. 
그러나 최대값은 엉망입니다. 
좋아요, 여러분은 많은 알려지지 않은 변수들을 가지면, 
최대값의 기대값을 계산할 수 있습니다. 
기대값이 있고 정수가 있습니다, 그리고 여러분은 최대값을 취합니다. 
그것은 로그와 같은 것이지만, 
우리는 더 강력한 문장을 원합니다.
그리고 우리는 이 Boole 부등식을 가집니다,  
저는 다항적으로 많은 것을 가지고 있습니다.
우리가 n개의 아이템을 가진다고 말해봅시다. 각 하나는 독립적입니다, 
그것이 의존적이라고 하더라도 신경 쓰지 않습니다. 
그것이 c lg n 보다 더 크게 올라가면, 
단계의 수는 c lg n 이상입니다. 

Korean: 
이 사건들이 어떤 n 인자들을 
위해 일어나나요? 
저는 n을 곱했습니다. 
그것은 최대 n 곱하기 x가 촉진되는 가능성입니다, 
lg n 보다 크거나 같습니다.
저는 선택합니다 
그것이 각 인자들을 위해 같기 때문입니다. 
그것들은 독립적으로 되었습니다.
저는 여기서 x를 더할 것이고 그것은 n의 인자입니다. 
명확하나요?
이것은 Boole 부등식입니다. 
이제 x가 c lg n 번 촉진되는 확률은 무엇인가요?
우리는 전에 lg n을 위해서 이것을 했습니다. 그것은 1 나누기 n 이었습니다.
c lg n을 위해 그것은 1나누기 n의 c입니다. 
이것은 n 곱하기 2입니다. 더 좋게 해 봅시다. 
2분의 1의 c lg n 제곱입니다. 
2분의 1의 c lg n 제곱은 1 나누기 2의 c lg n 입니다. 
lg n은 여기서 나옵니다, 
n이 됩니다. 우리는 n의 c를 얻습니다. 

English: 
at most, and then I want to
know, do any of those events
happen for any of the n
elements?
So, I just multiplied by n.
It's certainly,
at most, n times the
probability that x gets
promoted, this much here,
greater than or equal to log n
times.
OK, if I pick,
for any element,
x, because it's the same for
each element.
They are done independently.
So, I'm just summing over x
here, and that's just a factor
of n.
Clear?
This is Boole's inequality.
Now, what's the probability
that x gets promoted c log n
times?
We did this before for log n.
It was one over n.
For c log n,
it's one over n to the c.
OK, this is n times two.
Let's be nicer:
one half to the power of c log
n.
One half to the power of c log
n is one over two to the c log
n.
The log n comes out here,
becomes an n.
We get n to the c.

Korean: 
그래서 이것은 n 나누기 n의 c입니다, 그것은 n의 c 마이너스 1입니다.
저는 c를 원하는 것으로 선택합니다. 
제가 c-1을 알파로 선택합니다. 
저는 그것을 정확하게 생각합니다. 
미안해요, 1 나누기 n의 c 마이너스 1입니다. 
고마워요. 그것은 작은 것이 더 낫습니다. 
이것은 상계입니다. 확률은 다항적으로 작습니다. 
저는 선택하고, 이것은 약간의 트릭입니다. 
저는 이 정수를 알파를 위해 
충분히 크게 고릅니다. 
핵심은, c가 커질 때, 알파가 커진다는 것입니다. 
그러므로 저는 알파를 원하는 것으로 둡니다. 
여기서 가야 하는 단어가 약간 더 있습니다. 
그것들은 노트에 있습니다. 
저는 알파를 원하는 만큼 크게 둘 수 있습니다. 
저는 이 확률을 다항 집합에서 가능한 작게 만들 수 있습니다. 
그것입니다. 
단계의 수는 O(lg n) 입니다, 쉽지 않나요?

English: 
So, this is n divided by n to
the c, which is n to the c minus
one.
And, I get to choose c to be
whatever I want.
So, I choose c minus one to be
alpha.
I think exactly that.
Oh, sorry, one over n to the c
minus one.
Thank you.
It better be small.
This is an upper bound.
So, probability is polynomially
small.
I get to choose,
and this is a bit of the trik.
I'm choosing this constant to
be large, large enough for
alpha.
The point is,
as c grows, alpha grows.
Therefore, I can set alpha to
be whatever I want,
set c accordingly.
So, there's a little bit more
words that have to go here.
But, they're in the notes.
I can set alpha to be as large
as I want.
So, I can make this probability
as small as I want in the
polynomial sets.
So, that's it.
Number of levels,
order log n:

Korean: 
규칙과 등식입니다, 
핵심은 여러분이 높은 확률을 다룰 때, Boole 부등식을 사용하세요. 
그리고 그것은 하나의 인자가 다른 
모든 것들을 위해 옳을 때 옳습니다. 
의 인자를 잃지만, 그것은 알파에서 1입니다. 
알파는 큽니다. 큰 정수입니다. 
그래서 정리를 증명해봅시다. 
높은 확률 검색은 O(lg n)의 비용이 듭니다. 
우리는 이제 높이가 O(lg n) 이라는 것을 알지만, 
그것은 이것이 어떻게 균형 잡혔는지에 달려 있습니다.
검색이 lg n인지 아는 것은 연쇄가 얼마나 긴지에 달려있습니다.
이진 트리와 달리 높이에서 바운드를 아는 것은 충분하지 않습니다. 
우리는 이 분석을 위한 하나의 좋은 아이디어를 가지고 있습니다. 
그것은 후방 분석입니다. 
보통 여러분은 검색을 여러분이 찾는 아이템을 얻을 때까지 
왼쪽 위 모서리에서 시작해서 아래로 가는 트리에 

English: 
wasn't that easy?
Rules and equality,
the point is that when you're
dealing with high probability,
use Boole's inequality.
And, anything that's true for
one element is true for all of
them, just like that.
Just lose a factor of n,
but that's just one in the
alpha, and alpha is big:
big constant,
but it's big.
OK, so let's prove the theorem.
High probability searches cost
order log n.
We now know the height is order
log n, but it depends how
balanced this thing is.
It depends how long the chains
are to really know that a search
costs log n.
Just knowing a bound on the
height is not enough,
unlike a binary tree.
So, we have one cool idea for
this analysis.
And it's called backwards
analysis.
So, normally you think of a
search as starting in the top
left corner going left and down

Korean: 
대해 생각합니다. 
저는 역의 과정을 볼 것입니다. 
여러분은 찾는 아이템에서 시작합니다, 
그리고 왼쪽 위로 갑니다. 
단계의 수는 같습니다. 
저는 알고리즘을 여기서 구현하지 않고,  
분석만 할 것입니다. 그것들은 같은 과정들입니다,
그러나 역입니다. 여기 그것과 같은 것이 있습니다.
여러분은 검색을 가지고 그것은 시작합니다, 
그것은 아래의 리스트의 노드에서 끝나는 것을 의미합니다.
여러분이 이 검색에서 노드를 방문할 때 마다 매번, 여러분은 왼쪽 또는 위로 갑니다. 
언제 왼쪽 또는 위로 가나요? 
그것은 동전 뒤집기가 무엇이었는지에 달립니다. 

English: 
until you get to the item that
you're looking for.
I'm going to look at the
reverse process.
You start at the item you're
looking for, and you go left and
up until you get to the top left
corner.
The number of steps in those
two walks is the same.
And, I'm not implementing an
algorithm here,
I'm just doing analysis.
So, those are the same
processes, just in reverse.
So, here's what it looks like.
You have a search,
and it starts,
which really means that it ends
at a node in the bottom list.
Then, each time you visit a
node in this search,
you either go left or up.
And, when do you go left or up?
Well, it depends with the coin
flip was.

Korean: 
노드가 이 레벨에서 촉진되지 않으면요.
그래서, 그것이 높이 촉진되지 않았으면, 그것은 우리가 꼬리를 얻을 때 정확히 일어납니다. 
그리고 우리는 왼쪽으로 갑니다, 
그것은 우리가 왼쪽에서 온 것을 의미합니다
또는, 우리가 머리를 얻으면, 
이 노드가 다음 레벨로 촉진 되었으면, 
그것은 우리가 특정 순간에서 머리를 얻을 때 마다 일어납니다.
이것은 우리가 삽입을 했던 과거입니다. 
그리고 우리는 가고 올라갑니다. 
그리고 우리는 루트에서 멈춥니다. 이것은 . 
우리가 시작하는 곳입니다, 같습니다

English: 
So, if the node wasn't promoted
at this level.
So, if it wasn't promoted
higher, and that happened
exactly when we got a tails.
Then, we go left,
which really means we came from
the left.
Or, if we got a heads,
so if this node was promoted to
the next level,
which happened whenever we got
a heads at that particular
moment.
This is in the past some time
when we did the insertion.
Then we go, or came from,
up.
And, we stop at the root.
This is really where we start;
same thing.
So, either at the root or I'm

English: 
also going to think of this as
stopping at minus infinity.
OK, that was a bit messy,
but let me review.
So, normally we start up here.
Well, just looking at
everything backwards,
and in brackets is what's
really happening.
So, this search ends at the
node you were looking for.
It's always in the bottom list.
Then it says,
well, was this node promoted
higher?
If it was, I came from above.
If not, I came to the left.
It must have been in the bottom
chain somewhere.
OK, and that's true at every
node you visit.
It depends whether that quite
slipped heads or tails at the
time that you inserted that node
into that level.
But, these are just a bunch of
events.
I'm just going to check,
what is the probability that
its heads, and what is the
probability that a tails?
It's always a half.
Every time I look at a coin
flip, when it was flipped,
there was a probability of half
going out of their way.
That's the magic.
And, I'm not using that these

Korean: 
루트에서 또는 이것을 마이너스 무한대에서 멈추는 것으로 생각합니다. 
그것은 약간 엉망이지만, 다시 복습해 보겠습니다. 
보통 우리는 여기서 시작합니다. 모든 것을 뒤에서 봅니다, 
그리고 괄호에서, 그것은 정말 일어나는 것입니다. 
이 검색은 여러분이 찾고 있었던  
노드에서 끝납니다.
그것을 항상 아래 리스트에 있습니다. 이 노드가 더 높이 촉진 되었나요? 
그렇다면, 저는 위에서부터 왔습니다. 
그렇지 않다면, 저는 왼쪽으로 갔습니다. 그것은 아래 체인 어딘가에 있어야 합니다.
그리고 그것은 여러분이 방문하는 모든 노드에서 옳습니다.
그것은 여러분이 노드를 그 단계로 삽입할 때,  
잘린 머리 또는 꼬리에 달려있습니다.
그러나 이것들은 많은 사건들입니다. 
저는 무엇이 머리인 확률이고, 
꼬리인 확률인지 확인할 것입니다. 
그것은 항상 절반입니다. 
제가 뒤집어 졌는지 볼 때 마다 매번, 
절반의 확률이 있습니다. 
그것은 마법입니다. 그리고 저는 이 사건들이 독립적이라는 것을 사용하지 않을 것입니다.

Korean: 
제가 찾는 모든 인자에 대해서, 
그것은 또 다른 검색입니다. 
이 사건들은 독립적이지 않을 수 있습니다. 
저는 여전히 Boole 부등식을 사용할 수 있고 
그것들이 모두 O(lg n)이라는 것으로 결론 지을 수 있습니다. 
제가 하나의 사건이 높은 확률로 일어난다는 것을 증명하는 한요. 
그래서 저는 독립성이 필요하지 않습니다, 
저는 단일 검색에서 이 동전 뒤집기가 독립적이라는 것을 알지만, 
모든 다른 것에 대해 신경 쓰지 않습니다.
이 과정은 얼마나 오래 걸리나요? 
우리는 제가 이 것을 얼마나 많이 하는지 알고 싶습니다. 
제가 루트 노드를 칠 때, 저는 다 한 것입니다. 
저는 얼마나 빠르게 루트 노드를 치나요? 
절반의 확률을 가지고 저는 각 단계로 올라갑니다. 
제가 올라가는 수는  

English: 
events are independent anyway.
For every element that I search
for, for every value,
x, that's another search.
Those events may not be
independent.
I can still use Boole's
inequality and conclude that all
of them are order log n with
high probability.
As long as I can prove that any
one event happens with high
probability.
So, I don't need independence
between, I knew that these coin
flips in a single search are
independent, but everything
else, for different searches I
don't care.
So, how long can this process
go on?
We want to know how many times
can I make this walk?
Well, when I hit the root node,
I'm done.
Well, how quickly would I hit
the root node?
Well, with probability,
a half, I go up each step.
The number of times I go up is,

Korean: 
최대 단계의 수 마이너스 1 입니다. 
그리고 그것은 O(lg n)입니다.  
이것은 다른 아이디어 입니다.
우리는 이제 이 정리를 향상시킬 것입니다. 
올라가는 수는 레벨의 수 
보다 작습니다. 
여러분은 검색에서 단계 보다 더 많이 
올라갈 수 없습니다. 
삽입에서, 여러분은 임의로 높이 올라갈 수 있습니다. 
그러나 검색은 여러분이 여러분이 갈 수 있는 만큼을 말합니다.
이것은 최대 c lg n 입니다. 
이것은 우리가 부명제에서 증명했던 것입니다. 
그래서 우리는 올라가는 수에서 바운드를 가집니다. 
움직임의 절반은 대략 
올라가는 것일 겁니다. 
이것은 아래로 내려가는 것일 겁니다. 
완전히 그렇지는 않습니다. 그래서 이것이 의미하는 것은 
이것이 같은 확률이지만, 
제가 c를 원하는 만큼 충분히 크게 설정함으로써 그것을 선택할 수 있습니다

English: 
at most, the number of levels
minus one.
And that's order log n with
high probability.
So, this is the only other
idea.
So, we are now improving this
theorem.
So, the number of up moves in a
search, which are really down
moves, but same thing,
is less than the number of
levels.
Certainly, you can't go up more
than there are levels in the
search.
And in insert,
you can go arbitrarily high.
But a search:
as high as you can go.
And this is,
at most, c log n with high
probability.
This is what we proved in the
lemma.
So, we have a bound on the
number of up moves.
Half of the moves,
roughly, are going to be up
moves.
So, this pretty much down to
the number of moves.
Not quite.
So, what this means is that
with high probability,
so this is the same
probability, but I could choose
that as high as I want by

English: 
setting c large enough.
The number of moves,
in other words,
the cost of the search is at
most the number of coin flips
until we get c long n heads,
right, because in every step of
the search, I make a move,
and then I flip another coin,
conceptually.
There is another independent
coin lying there.
And it's either heads or tails.
Each of those is independent.
So, how many independent coin
flips does it take until I get c
log n heads?
The claim is that that's order
log n with high probability.
But we need to prove that.
So, this is a claim.
So, if you just sit there with
a coin, and you want to know how
many times does it take until I

Korean: 
움직임의 수는, 
다시 말해, 검색의 비용은 최대 동전 
다시 말해, 검색의 비용은 최대 동전 뒤집기의 수입니다. 
우리가 c lg n을 얻을 때까지요. 왜냐하면 각 검색 단계에서, 
저는 움직임을 만들 수 있고, 다른 동전을 개념적으로 뒤집기 때문입니다. 
다른 독립적인 동전이 있습니다. 
그리고 그것은 머리 또는 꼬리입니다. 그것들 각각은 독립적입니다. 
제가 c lg n을 얻을 때까지 동전 뒤집기는 얼마나 많이 독립적입니까?
그것은 O(lg n) 입니다. 
그러나 우리는 그것을 증명할 필요가 있습니다. 
이것은 주장입니다. 
여러분이 동전을 가지고 앉으면, 

English: 
get c log n heads,
the claim is that that number
is order log n with high
probability.
As long as I prove that,
I know that the total number of
steps I make,
which is the number of heads
and tails is order log n because
I definitely know the number of
heads is, at most,
c log n.
The claim is that the number of
tails can't be too much bigger.
Notice, I can't just say c
here.
OK, it's really important that
I have log n.
Why?
Because with high probability,
it depends on n.
This notion depends on n.
Log n: it's true.
Anything bigger that log n:
it's true, like n.
If I put n here,
this is also true.
But, if I put a constant or a
log log n, this is not true.
It's really important that I
have log n here because my
notion of high probability
depends on what's written here.
OK, it's clear so far.
We're almost done,
which is good because I just

Korean: 
여러분은 lg n을 얻을 때까지 몇 번이 걸리는지 알고 싶습니다. 
수는 O(lg n) 입니다.
제가 그것을 증명하는 한, 
저는 제가 하는 총 단계의 수를 알고, 
머리와 꼬리의 수는 lg n 입니다. 왜냐하면 저는 머리의 수가 최대 
c lg n 이라는 것을 알기 때문입니다. 
꼬리의 수는 너무 클 수 없습니다.
저는 여기서 c를 말할 수 없음에 주목하세요. 
좋아요, 제가 lg n을 가진다는 것은 정말 중요합니다. 
왜죠? 높은 확률로, 
그것이 n에 의존하기 때문입니다. 이 개념은 n에 의존적입니다.
lg n: 그것은 옳습니다. lg n 보다 큰 것: 그것도 옳습니다. 
제가 여기 n을 두면, 이것은 또한 옳습니다.
제가 여기서 lg n을 가진다는 것은 
정말 중요합니다 
제 개념이 여기 쓰여진 것에 의존하기 때문입니다. 
그것은 지금까지 명확합니다. 
우리는 거의 다 했습니다 그것은 좋습니다 저는 시간을 다 써버렸기 때문입니다. 

Korean: 
미안해요, 우리는 몇 분 더 할 것입니다.
저는 여기서 오류 확률을 계산하고 싶습니다. 
저는 c lg n 보다 작은 확률을 
계산하고 싶습니다. 
이 단계를 스킵하겠습니다. 저는 대략적일 것입니다 
c lg n 머리가 있는 확률은 무엇입니까? 
저는 이 사건에 대한 동전을 얼마나 뒤집는지에 
대해 말할 필요가 있습니다. 
저는 이것을 구체화해야 합니다. 
10 c lg n 동전을 던진다고 합시다. 
이제 저는 그 사건 아래의 오류 확률을 보고 싶습니다.
10 c lg n 뒤집기 가운데 최대 c lg n인 확률입니다. 
이것은 매우 작아야 합니다. 
그것은 10에 달려있습니다. 

English: 
ran out of time.
Sorry, we're going to go a
couple minutes over.
So, I want to compute the error
probability here.
So, I want to compute the
probability that there is less
than c log n heads.
Let me skip this step.
So, I will be approximate and
say, what's the probability that
there is, at most,
c log n heads?
So, I need to say how many
coins we are flipping here for
what this event is.
So, I need to specify this
constant.
Let's say we flip ten c log n
coins.
Now I want to look at the error
probability under that event.
The probability that there is
at most c log n heads among
those ten c log n flips.
So, the claim is this should be
pretty small.
It's going to depend on ten.

English: 
Then I'll choose ten to be
arbitrarily large,
and I'll be done,
OK, make my life a little bit
easier.
Well, I would ask you normally,
but this is 6.042 material.
So, what's the probability that
we have, at most,
this many heads?
Well, that means that nine c
log n of the coins,
because there are ten c log n
flips, c log n heads at most,
nine c log n at least better be
tails.
So this is the probability that
all those other guys become
tails, which is already pretty
small.
And then, there is this
permutation thing.
So, if I had exactly c log n
heads, this would be the number
of ways to rearrange c log n
heads among ten c log n coin
flips.
OK, that's just the number of
permutations.
So, this is a bit big,
which is kind of annoying.
This is really,
really small.
The claim is this is much
smaller than that is big.

Korean: 
그리고 저는 10을 임의의 큰 것으로 고를 것입니다, 그러면 다 한 것입니다. 
제 인생을 더 쉽게 만들 것입니다.
저는 여러분에게 평범하게 묻지만, 이것은 6.042 수업 내용입니다. 
그래서 우리가 
가지는 확률은 무엇입니까? 
그것은 9 c lg n 입니다. 
왜냐하면 10 c lg n 동전 뒤집기가 있고, 
c lg n 머리가 최대, 9 c lg n 꼬리가 최소인 것이 낫기 때문입니다. 
이것은 모든 것이 꼬리가 되는 확률입니다. 
매우 작습니다.
그리고 이 순열이 있습니다. 
제가 정확히 c lg n을 가지면, 이것은 10 c lg n 동전 뒤집기 가운데 
c lg n 머리를 재배열하는 방법의 수일 것입니다. 
그것은 순열의 수입니다. 
이것은 약간 큽니다,  
그리고 짜증나는 것입니다.
이것은 정말, 정말 작습니다. 
이것은 그것보다 더 작습니다.

Korean: 
이것은 수학입니다. 
여러분은 오래 머물러서는 안됩니다. 
그러나 여러분은 그것을 검토해야 합니다. 
여러분은 y가 x를 고르는 것을 알아야 합니다. 
그러므로, 이것은 최대 10 c lg n 나누기 c lg n 입니다. 그것은 10입니다. 
소거됩니다. 
여기 e가 있습니다. 그리고 저는 c lg n 제곱을 올립니다. 
그리고 저는 2 제곱으로 나눕니다, 9 c lg n 입니다. 
이것은 무엇입니까? 
이것은 e 곱하기 10의 c lg n 나누기 2의 9 c lg n 입니다.

English: 
So, this is just some math.
I'm going to whiz through it.
So, you don't have to stay too
long.
But you should go over it.
You should know that y choose x
is, at most, ey over x to the x,
good fact.
Therefore, this is,
at most, ten c log n over c log
n, also known as ten.
These cancel.
There's an e out here.
And then I raise that to the c
log n power.
OK, then I divide by two to the
power, nine c log n.
OK, so what's this?
This is e times ten to the c
log n divided by two to the nine

English: 
c log n.
OK, claim this is very big.
This is not so big,
because I have a nine here.
So, let's work it out.
This e times ten,
that's a good number,
we can put upstairs.
So, we get log of e times ten,
ten times, e,
and then c log n.
And then, we have over two to
the nine c log n.
So, we have this two to the c
log n in both cases.
So, this is two to the log,
ten e minus nine,
c, log n: some basic algebra.
So, I'm going to set,
not quite.
This is one over two to the
nine minus log:
so, just inverting everything
here, negating the sign in here.

Korean: 
이것은 매우 큽니다.  
이것은 그리고 크지 않습니다 왜냐하면 저는 여기서 9를 가지기 때문입니다.
그것을 해 봅시다. 이 e 곱하기 10은  
좋은 수입니다, 우리는 위에 둘 수 있습니다.
그래서 우리는 e 곱하기 10의 로그를 얻습니다. 
그리고, 우리는 여기서 2의 9 c lg n를 가집니다.
우리는 2의 c lg n을 양쪽 케이스에서 가집니다. 
이것은 2^{[lg(10 e)- 9] c lg n} 입니다, 
기본적인 대수입니다. 
저는 설정할 것입니다. 
이것은 1 나누기 2의 9 마이너스 로그입니다. 
여기서 도치시킵니다. 

Korean: 
A이것은 나머지가 n이기 때문에 제 알파입니다.
그래서 이것은 1 나누기 n의 알파입니다. 알파가 이 특정 값: 
9 마이너스 10의 로그 곱하기 e 곱하기 c 일 때요. 
그것은 약간 이상한 것입니다. 
그러나 핵심은, 10이 무한대로 갈 때, 
여기서 9는 10 보다 작은 수입니다. 
우리는 1을 뺐습니다. 
10이 무한대로 갈 때, 이것은 10에서 대수적입니다. 
이것은 10 -1 입니다.
이것은 로그 10 곱하기 e 입니다. e는 정말 중요하지 않습니다.
이것은 10에서 선형입니다
10에서 선형인 것은 10에서 대수인 것  
보다 훨씬 더 큽니다.
이것은 남용되는 개념입니다. 
10이 무한대로 갈 때, 이것은 무한대로 가고, 더 커집니다. 
여기 c가 있습니다. 
그러나 여러분이 원하는 c의 값을 위해, 
저는 알파를 임의로 크게 만들 수 있습니다, 

English: 
And, this is my alpha because
the rest is n.
So, this is one over n to the
alpha when alpha is this
particular value:
nine minus log of ten times e
times c.
It's a bit of a strange thing.
But, the point is,
as ten goes to infinity,
nine here is the number one
smaller than ten,
right?
We subtracted one somewhere
along the way.
So, as ten goes to infinity,
this is basically,
this is ten minus one.
This is log of ten times e.
e doesn't really matter.
The point is,
this is logarithmic in ten.
This is linear in ten.
The thing that's linear in ten
is much bigger than the thing
that's logarithmic in ten.
This is called abusive
notation.
OK, as ten goes to infinity,
this goes to infinity,
gets bigger.
And, there is a c out here.
But, for any value of c that
you want, whatever value of c
you wanted in that claim,
I can make alpha arbitrarily

English: 
large by changing the constant
in the big O,
which here was ten.
OK, so that claim is true with
high probability.
Whatever probability you want,
which tells you alpha,
you set a constant effort of
the log N to be this number,
which grows,
and you're done.
You get the claim that is order
log N heads, order log N flips
with the high probability,
therefore.
[None of the steps?] in the
search is order log N with high
probability.
Really cool stuff;
read the notes.
Sorry I went so fast at the
end.

Korean: 
정수를 바꿈으로써요. 
그래서 주장은 높은 확률로 옳습니다. 
여러분이 원하는 확률이 무엇이든, 
여러분은 정수를 설정합니다, 
그것은 커집니다, 그러면 다한 것입니다. 
여러분은 O(lg n) 머리인 
주장을 얻습니다. 
그러므로, 검색에서 
그것은 O(lg n) 입니다. 
정말 좋은 것입니다. 노트를 읽어보세요. 
미안해요 제가 마지막에 너무 빠르게 나갔습니다.
