
Korean: 
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다.
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다. 오픈 콘텐츠가 저작권을 적용하여 
제공되고 있습니다. 
여러분의 지원이 MIT OpenCourseWare가 
계속해서 높은 품질의 교육 자료를 무료로 제공할 수 있게 합니다. 
또 다른 MIT의 수업을 시청하고 싶으시면 
MIT OpenCourseWare 로 방문해 주세요 
ocw.mit.edu
[ERIC GRIMSON 교수] 우리가 어디쯤 왔는지 정리해보죠. 
지난 시간에 우리는 
효율성,
수행시간에 대한 성장차수,
복잡도에 대해서 이야기 했습니다. 
지난 시간, 우리가 몇 개의 알고리즘들을 보았고, 
제 목표 중의 한 부분이 여러분들로 하여금 특정 수업으로 연결되는 
알고리즘들의 특징을 인식하게 하는 것이었다는 것을 다시 상기시켜 드리고 싶습니다. 
알고리즘들의 특징을 인식하게 하는 것이었다는 것을 다시 상기시켜 드리고 싶습니다. 
선형 알고리즘들에 대해서 보았습니다. 
항상 그런 것은 아니지만, 
일반적인 정의는 선형 알고리즘들이 한 개 또는 일정한 양만큼 
매 시간 문제의 사이즈를 줄인다는 것입니다. 
이것이 선형 알고리즘의 일반적인 예라고 볼 수 있습니다. 

English: 
ANNOUNCER: Open content is
provided under a creative
commons license.
Your support will help MIT
OpenCourseWare continue to
offer High-quality educational
resources for free.
To make a donation, or view
additional materials from
hundreds of MIT courses, visit
MIT OpenCourseWare at
ocw.mit.edu .
PROFESSOR ERIC GRIMSON: Let's
recap where we were.
Last lecture, we talked about,
or started to talk about,
efficiency.
Orders of growth.
Complexity.
And I'll remind you, we saw a
set of algorithms, and part of
my goal was to get you
to begin to recognize
characteristics of algorithms
that map into
a particular class.
So what did we see?
We saw linear algorithms.
Typical characterization, not
all the time, but typical
characterization, is an
algorithm that reduces the size
of a problem by one, or
by some constant amount each
time, is typically an example
of a linear algorithm.

English: 
And we saw a couple of examples
of linear algorithms.
We also saw a logarithmic
algorithm. and we like log
algorithms, because they're
really fast. A typical
characteristic of a log
algorithm is a pro-- or sorry,
an algorithm where it reduces
the size of the problem by a
constant factor.
Obviously-- and that's a bad
way of saying it, I said
constant the previous time--
in the linear case, it's
subtract by certain amount.
In the log case, it's
divide by an amount.
Cut the problem in half.
Cut the problem in half again.
And that's a typical
characterization of a log algorithm.
We saw some quadratic
algorithms, typically those
are things with multiple nested
loops, or iterative or
recursive calls, where you're
doing, say, a linear amount of
time but you're doing it a
linear number of times, and so
it becomes quadratic, and you'll
see other polynomial
kinds of algorithms.
And finally, we saw an example
of an exponential algorithm,
those Towers of Hanoi.
We don't like exponential
algorithms, or at least you
shouldn't like them, because
they blow up quickly.
And we saw some examples
of that.
And unfortunately, some problems
are inherently

Korean: 
그리고 우리는 그 외에도 몇 개의 선형 알고리즘들을 보았습니다.  
우리는 또한 로그 알고리즘을 보았습니다. 
우리는 로그 알고리즘을 좋아합니다. 무척 빠르기 때문이지요. 
로그 알고리즘의 일반적인 특징은 
일정한 양만큼 
문제의 사이즈를 줄인다는 것입니다. 
안타깝게도,
선형 알고리즘의 경우에는 
어떤 양 만큼이 빠집니다. 
로그 알고리즘의 경우에는 어떤 양으로 나눠지게 됩니다. 
반으로 나눠지고, 
다시 반으로 나눠지게 됩니다. 
그것이
로그 알고리즘의 정의입니다.  
우리는 이차 알고리즘들도 보았습니다. 
일반적으로 이차 알고리즘은 다중 중첩 루프, 반복 
또는 재귀 호출을 가진 것들이었습니다. 
선형 시간의 양, 선형 숫자를 여러 번 반복하게 되면 
이차 알고리즘이 됩니다. 앞으로 여러분은 여러 종류의 
다항 알고리즘들도 보게 될 것입니다.  
그리고 마지막으로, 우리는 지수 알고리즘의 예를 보았습니다. 
‘하노이의 탑’이죠. 
우리는 지수 알고리즘들을 좋아하지 않습니다. 
굉장히 빨리 커지기 때문입니다.  
우리는 지수 알고리즘의 몇몇 예를 보았습니다. 
그리고 안타깝게도 몇몇 문제들은 본질적으로 지수적으로 나타납니다. 

English: 
exponential, you're sort of
stuck with that, and then you
just have to try be as
clever as you can.
OK.
At the end of the lecture last
time, I also showed you an
example of binary search.
And I want to redo that in a
little more detail today,
because I felt like I did that
a little more quickly than I
wanted to, so, if you really got
binary search, fall asleep
for about ten minutes, just
don't snore, your neighbors
may not appreciate it, but
we're going to go over it
again, because it's a problem
and an idea that we're going
to come back to, and I really
want to make sure that I do
this in a way that makes
real good sense you.
Again.
Basic premise of binary search,
or at least we set it
up was, imagine I have a sorted
list of elements.
We get, in a second, to how
we're going to get them
sorted, and I want to know,
is a particular
element in that list..
And the basic idea of binary
search is to start with the
full range of the list,
pick the midpoint,
and test that point.
If it's the thing I'm looking
for, I'm golden.
If not, because the list is
sorted, I can use the

Korean: 
여러분은 그것을 어쩔 수 없이 하게 될 것이고, 
그러므로 할 수 있는 한 영리하게 해보려고 노력해야겠죠.  
좋습니다. 
지난 수업 시간의 마지막에, 
이진 탐색의 한 가지 예를 보여드렸습니다. 
지난 시간에 제가 생각했던 것 보다 좀 빨리 나간 것 같다는 생각이 들어서 
오늘 좀 더 자세하게 다시 해보고자 합니다. 
만약 이진 탐색을 이미 잘 알고 있으면, 
약 10분간 잠을 자도 좋습니다. 단지 코만 골지 마세요. 옆의 친구들은 
아직 이해하지 못했을지도 모르니까요. 앞으로 이진 탐색을 또 다시 다루게 될 것입니다. 
이것은 우리가 앞으로 돌아가게 될 문제이고 아이디어입니다. 
저는 여러분이 이 부분을 정말 
잘 이해할 수 있도록 해드리고 싶습니다. 
다시 가봅시다.
이진 탐색의 기본적인 전제, 적어도 우리가 세운 것은, 
우리가 정렬된 원소들의 리스트를 가지고 있다고 상상해 보는 것입니다. 
그리고 
그 리스트에 있는 
특정한 원소를 알고 싶습니다. 
이진 탐색의 기본적인 아이디어는 우선 리스트의 전 범위에서 시작합니다. 
중점으로 잡고, 
그 지점을 테스트 해 봅니다. 
만약 그곳에 내가 찾던 것이 있으면 저는 성공한 거죠. 
만약 아니라면, 이 리스트는 정렬되어 있기 때문에

Korean: 
제가 찾고자 하는 것과 중간지점사이의 차이를 
이용해 찾을 수 있습니다. 리스트의 위쪽 반을 봐야 할까요? 
아래쪽 반을 봐야 할까요? 
계속 그렇게 진행해 나갑니다. 
좀 더 자세하게 보여 드리겠습니다. 
여기에 단순한 작은 리스트 하나를 만듭니다. 
됐죠?
그 안에 뭐가 들었는지는 상관없습니다. 
그냥 제 리스트라고 가정해 보죠. 여러분 교재를 보시거나,
스크린을 보셔도 됩니다. 
다시 예전에 배운 것을 떠올려 보겠습니다. 
이진 탐색이라고 부르도록 하겠습니다.  
그리고 그것을 보시면 됩니다. 한번 보면서 
어떻게 작동하는지 생각해 보세요. 
우리는 이진 탐색이라고 부를 것입니다. 
리스트를 탐색해서 원소를 찾게 해줍니다. 
또한 여기는 리스트의 start 부분이라고 불리고,여기에는 리스트의 last 부분이 있습니다. 
그것들은 저 코드 안에서 무슨 일을 하나요? 
음, 한번 보세요. 2보다 더 큰가요? 
저기에 원소가 2개 보다 더 많나요? 

English: 
difference between what I'm
looking for and that midpoint
to decide, should I look in the
top half of the list, or
the bottom half of the list?
And I keep chopping it down.
And I want to show you a little
bit more detail of
that, so let's create a simple
little list here.
All right?
I don't care what's in there,
but just assume that's my
list. And just to remind you, on
your handout, and there it
is on the screen, I'm going to
bring it back up, there's the
little binary search
algorithm.
We're going to call
search, which just
calls binary search.
And you can look at it, and
let's in fact take a look at
it to see what it does.
We're going to call binary
search, it's going to take the
list to search and the element,
but it's also going
to say, here's the first part
of the list, and there's the
last part of the list,
and what does it
do inside that code?
Well, it checks to see,
is it bigger than two?
Are there more than two
elements there?

English: 
If there are less than two
elements there, I just check
one or both of those to
see if I'm looking
for the right thing.
Otherwise, what does that
code say to do?
It says find the midpoint, which
says, take the start,
which is pointing to that place
right there, take last
minus first, divide it by
2, and add it to start.
And that basically, somewhere
about here,
gives me the midpoint.
Now I look at that element.
Is it the thing I'm
looking for?
If I'm really lucky, it is.
If not, I look at the value of
that point here and the thing
I'm looking for.
And for sake of argument, let's
assume that the thing
I'm looking for is smaller
than the value here.
Here's what I do.
I change-- oops!
Let me do that this way--
I change last to here, and keep
first there, and I throw
away all of that.
All right?
That's just the those-- let me
use my pointer-- that's just

Korean: 
만약 저기에 원소가 2개보다 적다면 
제가 찾고자 하는 것을 제대로 찾았는지 
1개나 그 2개를 검사해 보겠습니다.  
그렇지 않으면, 저 코드는 무엇을 하라고 말하고 있나요? 
중점을 찾으라고 하고 있습니다. 
여기를 start로 잡고, 이것은 바로 여기를 가리키고 있습니다. 
last 빼기 first를 구하고, 그것을 2로 나누어서 start에 더해줍니다. 
그것은 기본적으로 여기 어딘가가 되고, 
그 지점이 중점이 됩니다. 
자 그러면 그 원소를 봅니다. 
제가 찾던 것인가요? 
만약 그렇다면 정말 운이 좋은 거죠. 
그렇지만, 만약 그렇지 않다면, 
지점의 값과 제가 찾고 있는 값을 보고
토론의 실마리로서 제가 찾고 있는 값이
여기에 있는 값보다 작다고 가정해봅시다.  
이 부분에서 제가 해야 할 일은 
에고, 실수했네요!
last는 여기로 옮기고, first는 원래 있던 곳에 계속 두는 것입니다. 
그리고 여기 부분은 모두 버립니다. 
이해가나요?
이 과정이 바로 스크린의 이 부분입니다. 포인터를 사용하겠습니다.

Korean: 
그것이 바로 여기 2줄입니다. 
그 값을 검사하고, 
이런 경우에는 last를 mid-1 위치로 옮깁니다. 
그리고 다시 호출하죠.  
알겠죠?
저는 전과 완전히 같은 것을 호출할 것입니다.
자, first가 여기를 가리키고 있고, last는 저기를 가리키고 있습니다.
봅시다. 두 가지가 남았죠?
이러한 경우에 그렇다면 
무엇을 해야 할까요? 
(last-first)를 2로 나누어 
start에 더해줌으로써 중점을 찾습니다.
이런 과정을 통해서 중점이 이곳이라는 것을 추정할 수 있고, 
전과 똑같은 작업을 합니다. 
이 값이 제가 찾던 값인가요?
또 다시 그것이 제가 찾던 값이 아니라고 해봅시다. 
그리고 제가 찾는 값이 
이것보다는 크다고 가정해 봅시다. 
그러면 저는 여기 부분을 모두 버립니다. 
저 코드의 아래쪽에 해당합니다. 
음, 
저것은 무슨 일을 하나요? 

English: 
these two lines here.
I checked the value, and in
one case, I'm changing the
last to be mid minus 1, which is
the case I'm in here, and I
just call again.
All right?
I'm going to call exactly
the same thing.
Now, first is pointing here,
last is pointing there, again,
I check to see, are there more
than two things left?
There are, in this case.
So what do I do?
I find the midpoint by taking
last minus first, divide by 2,
and add to start.
Just for sake of argument, we'll
assume it's about there,
and I do the same thing.
Is this value what
I'm looking for?
Again, for sake of argument,
let's assume it's not.
Let's assume, for sake of
argument, the thing I'm
looking for is bigger
than this.
In that case, I'm going to throw
away all of this, I'm
going to hit that bottom
line of that code.
Ah.
What does that do?
It changes the call.
So in this case, first
now points

English: 
there, last points there.
And I cut around.
And again, notice
what I've done.
I've thrown away most of the
array-- most of the list, I
shouldn't say array-- most
of the list. All right?
So it cuts it down quickly
as we go along.
OK.
That's the basic idea
of binary search.
And let's just run a couple of
examples to remind you of what
happens if we do this.
So if I call, let's
[UNINTELLIGIBLE], let's set up
s to be, I don't know, some
big long list. OK.
And I'm going to look to see, is
a particular element inside
of that list, and again, I'll
remind you, that's just giving
me the integers from zero up
to 9999 something or other.
If I look for, say, minus 1,
you might go, gee, wait a
minute, if I was just doing
linear search, I would've

Korean: 
호출을 변화시킵니다. 
그래서 이런 경우에는 first가 여기를 가리키게 되고, last가 이곳을 가리키게 됩니다.  
그리고 다시 우리가 했던 것을 확인해 보세요. 
배열의 대부분을 버렸습니다. 
리스트의 대부분을 버렸습니다. 리스트의 대부분. 
알겠습니까? 
우리가 진행해 나갈 때 빠르게 그것을 지우죠. 
좋습니다.
이것이 이진 탐색의 기본적인 아이디어입니다. 
이것이 작동하면 어떤 일이 일어나는지 
알려주기 위해 몇 가지 예시를 실행시켜 보겠습니다.  
만약 제가 호출하면, s를 어느 정도 크기로 할까요. 
음 모르겠네요. 좀 큰 리스트로 하죠. 
좋습니다. 
그 안에 특정한 원소가 있고,
0부터 9999사이의 
정수들을 줄 것입니다. 
만약 제가 -1을 찾는 다고 하면, 
선형 탐색에서 했었더라면 

English: 
known right away that minus
one wasn't in this list,
because it's sorted
and it's smaller
than the first elements.
So this looks like it's doing
a little bit of extra work,
but you can see, if you look at
that, how it cuts it down
at each stage.
And I'll remind you, what I'm
printing out there is, first
and last, with the range I'm
looking over, and then just
how many times the
iteration called.
So in this case, it just keeps
chopping down from the back
end, which kind of makes
sense, all right?
But in a fixed number, in fact,
twenty-three calls, it
gets down to the point
of being able to say
whether it's there.
Let's go the other direction.
And yes, I guess I'd better say
s not 2, or we're going to
get an error here.
Again, in twenty-three checks.
In this case, it's cutting up
from the bottom end, which
makes sense because the thing
I'm looking for is always
bigger than the midpoint, and
then, I don't know, let's pick
something in between.

Korean: 
저는 이 리스트에 없는 -1을 즉시 알았을 것입니다. 
정렬이 되어 있고, 첫 번째 원소보다 작기 때문입니다. 
그래서 이것은 아마도 좀 더 추가적인 일을 한 것으로 보입니다. 
그러나 이것을 보면, 각각의 단계에서 
어떻게 잘라내고 있는지를 볼 수 있을 것입니다. 
그리고 여기 출력된 것에서는 
제가 써넣은 범위 내에서 first와 last 
그리고 몇 번 반복이 불려 졌는지를 볼 수 있습니다.  
그래서 이런 경우에 뒤쪽 끝에서부터 
계속 잘라왔다는 것을 볼 수 있습니다. 좀 이해가 되죠, 그렇죠? 
숫자의 개수가 정해져 있는 상태에서, 23번 호출했고, 
제가 찾는 수가 배열에 있는지 없는지 말해줄 수 있습니다. 
다른 명령을 줘보죠.
좋습니다. 2를 하지 않는 게 좋을 것 같네요. 
아니면 에러가 발생할 겁니다. 
또 23번 되었네요. 
이 경우에는 아래쪽 끝부터 잘려졌습니다.
이해가 가는 것이, 제가 찾는 것이 항상 중간지점보다
컸기 때문입니다. 그리고... 잘 모르겠네요. 
중간 것을 한번 골라볼까요. 

English: 
Somebody want-- ah, I keep doing
that-- somebody like to
give me a number?
I know you'd like to give
me other things, other
expression, somebody
give me a number.
Anybody?
No?
Sorry.
Thank you.
Good number.
OK, walks in very quickly.
OK?
And if you just look at the
numbers, you can see how it
cuts in from one side and then
the other side as it keeps
narrowing that range, until it
gets down to the place where
there are at most two things
left, and then it just has to
check those two to say whether
it's there or not.
Think about this compared
to a linear search.
All right?
A linear search, I start at the
beginning of the list and
walk all the way through it.
All right, if I'm lucky and it's
at the low end, I'll find
it pretty quickly.
If it's not, if it's at the
far end, I've got to go
forever, and you saw that last
time where this thing paused
for a little while
while it actually
searched a list this big.
OK.
So, what do I want you to
take away from this?

Korean: 
누가 원하는 숫자 
한번 말해보세요. 
다른 것을 하고 싶다는 것을 알고 있습니다. 
누가 원하는 숫자 한번 말해보세요. 
누구 없나요? 
없어요?
뭐라고요? 
네 감사합니다.
좋은 숫자네요.  
좋습니다. 굉장히 빨리 되네요. 
그렇죠? 
숫자들을 보면, 
많아야 2개 남아있는 곳에 닿을 때까지 
한쪽에서 버려지고 또 다른 쪽에서 버려지면서 
범위를 좁히는 것을 볼 수 있을 것입니다. 그러고 나서 
찾는 숫자가 그곳에 있는지 없는지 말하기 위해서 2개를 검사해보죠. 
선형 탐색과 비교해서 생각해 보겠습니다. 
알겠죠?
선형 탐색은 리스트의 처음에서부터 시작해서
한 개씩 쭉 검사하게 됩니다. 
만약 운이 좋거나 리스트가 길지 않다면 
빨리 찾을 것입니다. 
그러나 만약 end 가 굉장히 멀다면 영원히 찾겠죠. 
여러분은 이미 지난 시간에 잠시 동안 멈추어져 있는 것 같은 것을 보았습니다.
그러나 사실은 이렇게 큰 리스트를 검색하고 있는 것이었죠.  
좋습니다. 
그래서, 여기서 제가 여러분이 무엇을 줄이기를 원할까요? 

Korean: 
이진 탐색의 아이디어는 
정말로 훌륭한 도구입니다. 
이러한 특성을 지니죠. 다시 말씀 드리자면, 
반으로 쪼개서 2부분으로 나누어 줍니다. 
그러면 실제로 여기서 
수행시간에 대한 성장차수는 무엇을 암시할까요? 
복잡도는 어떻게 될까요? 
예 그렇습니다. 
log(n)입니다.
왜 그렇죠? 
전에 말해주셨습니다.
예, 
감사합니다. 
제 말은, 어느 정도 여러분께 그것을 말한 것은 알고 있지만, 맞아요. 
이것은 로그입니다. 그렇죠? 
반으로 나누는 특성을 가집니다. 
왜 이것이 로그인지 생각해보는 다른 방법도 있습니다. 
약간 다른 질문을 해보도록 하겠습니다. 
우리는 이것이 항상 멈춘다는 것을 어떻게 알지요? 
제 말은, 저는 여기서 세 번의 시험을 해봤죠. 그리고 모두 멈췄습니다. 
그렇지만, 저는 이것이 항상 멈춘다는 것을 어떻게 생각해냈을까요? 
한번 봅시다. 
이것들 중 마지막 테스트가 어디 있죠? 
마지막 테스트가 위쪽, 
지금 제가 보고 있는 곳에 있네요. 
(last-first)가 2보다 작거나 같았나요? 
좋습니다. 
단지 그 안에 2개의 원소만 있는 리스트에 도달하게 되면, 
끝난 것입니다.
이것을 알아야 합니다. 
작거나 같습니다. 

English: 
This idea of binary search
is going to be a
really powerful tool.
And it has this property,
again, of
chopping things into pieces.
So in fact, what does that
suggest about the order of
growth here?
What is the complexity of this?
Yeah.
Logarithmic.
Why?
STUDENT: [UNINTELLIGIBLE]
PROFESSOR ERIC GRIMSON: Yeah.
Thank you.
I mean, I know I sort of said
it to you, but you're right.
It's logarithmic, right?
It's got that property of,
it cuts things in half.
Here's another way to think
about why is this log.
Actually, let me ask a slightly
different question.
How do we know this
always stops?
I mean, I ran three trials
here, and it did.
But how would I reason about,
does this always stop?
Well let's see.
Where's the end test
on this thing?
The end test-- and I've got
the wrong glasses on-- but
it's up here, where I'm looking
to see, is last minus
first less than or equal to 2?
OK.
So, soon as I get down to a list
that has no more than two
elements in it, I'm done.
Notice that.
It's a less than or equal to.

English: 
What if I just tested to see
if it was only, say, one?
There was one element
in there.
Would that have worked?
I think it depends on
whether the list is
odd or even in length.
Actually, that's probably
not true.
With one, it'll probably always
get it down there, but
if I've made it just equal to
two, I might have lost.
So first of all, I've got to be
careful about the end test.
But the second thing is, OK, if
it stops whenever this is
less than two, am I convinced
that this will always halt?
And the answer is sure.
Because what do I do?
At each stage, no matter which
branch, here or here, I take,
I'm cutting down the length
of the list that I'm
searching in half.
All right?
So if I start off with a list
of length n, how many times
can I divide it by 2, until
I get to something no
more than two left?
Log times, right.?
Exactly as the gentleman said.
Oh, I'm sorry.
You're patiently waiting
for me to reward.
Or actually, maybe you're not.
Thank you.
OK.

Korean: 
원소가 1개만 있는지 알아보기 위해 시험해봤다면 어떻게 되었을까요? 
그 안에 단 하나의 원소만이 있습니다.
작동 했을까요? 
제 생각에 이것은 리스트의 길이가 
홀수이냐 짝수이냐에 달려있는 것 같습니다. 
아마도 사실은 아닙니다. 
1개의 원소만을 가지고 있다면 아마도 항상 거기에 도달하게 될 것입니다. 
그러나 만약 2와 같게 된다면, 길을 잃을 수도 있죠.
그래서 무엇보다도 마지막 테스트에 주의를 기울어야 합니다. 
두 번째는, 2개 보다 적을 때마다 이것이 멈춘다면, 
이것이 항상 멈출 것이라고 생각하게 될까요? 
대답은 확실히 그렇다는 것입니다. 
왜냐하면, 제가 무엇을 할까요? 
각각의 단계에서, 어떤 branch라 하더라도, 여기 또는 여기. 
저는 제가 찾고 있는 리스트의 길이를
반으로 자를 것입니다.
알겠죠?
이가 n인 리스트로 시작하면, 
얼마나 많이 2로 나누어야 할까요? 
단지 2개가 남는 것에 도달할 때까지 말입니다. 
log 번입니다. 알겠습니까? 
저 분이 말씀 하신 것이 딱 맞죠.  
죄송합니다. 
제가 보상하기를 기다리고 계셨군요. 
사실 그렇지 않을지도 모르지만, 
하여간 감사합니다. 
좋습니다. 

Korean: 
사실은 이런 것이 로그입니다. 
제가 이전에 말했지만,
여러분이 말했던 겁니다.
그리고 그것을 좀 더 강화하기 위해 몇 분 더 쓰고 싶네요. 
만약 저 위쪽의 코드를 보면, 
우리는 이것에 좀 더 조심 해야 합니다. 
우리가 무엇을 하라고 말했었죠? 죄송합니다. 
각각의 단계에서 원래 작업의 수를 세어봅시다.  
좋습니다. 
만약 이 코드를 보면, 우선 이것은 탐색이라고 부르고,
한번만 호출됩니다. 
bsearch에서 무슨 일이 일어나는지는 모르지만, 
탐색은 일정하게 일어나는 것처럼 보입니다. 
그래서 bsearch를 보아야 합니다.
그러면 한번 보죠. 
첫 번째 줄에, 저 인쇄된 부분은 
분명히 일정합니다. 그렇죠? 
일정한 양의 작업입니다. 
그러나 다음 이 부분을 보면, 두 번째 줄이요.
좋아요.
만약 (last-first)가 2보다 크거나 같다면, 죄송합니다.
2보다 작다면, 그러면 이것을 봐야 할까요,
저것을 봐야 할까요? 

English: 
So this is, in fact, log.
Now, having said that,
I actually snuck
something by you.
And I want to spend a
couple of minutes
again reinforcing that.
So if we look at that code,
and we were little more
careful about this, what
did we say to do?
We said look an-- sorry.
Count the number of primitive
operations in each step.
OK.
So if I look at this code,
first of all I'm calling
search, it just has one call,
so looks like search is
constant, except I
don't know what
happens inside of b search.
So I've got to look
at b search.
So let's see.
The first line, that
print thing, is
obviously constant, right?
Just take it as a constant
amount of operations But.
let's look at the next one here,
or is that second line?
OK.
If last minus first is greater
than or equal to 2-- sorry,
less than 2, then either
look at this thing or
look at that thing.

Korean: 
이 부분이 바로 제가 조심 해야 한다고 말한 부분입니다.
이것이 리스트의 원소에 접근하고 있는 것이고,
꼭 확인해야 합니다. 
사실 이 알고리즘은 선형 구조가 아니거든요.
약간 확장시켜 보겠습니다. 지난 시간에 했지만, 
한번 더 하는 것이 좋을 것 같습니다. 
리스트를 어떻게 실행하는지에 관해서 
주의 깊게 보아야 합니다. 
예를 들면, 이러한 경우에 제 리스트에는 많은 정수들이 있습니다. 
제가 이용할 수 있는 것들 중 한 가지는 
단지 정수를 나타낼 유한한 공간이
필요하다는 것입니다.  
그래서 예를 들어 꽤 큰 범위의 정수들을 원한다면, 
정수를 나타내기 위해서
이어져 있는 4개의 메모리 셀이 필요하다고 말할지도 모릅니다. 
0이 한 개 있다면, 많은 1들이 있을 것이고,
0이 많다면, 그러므로 1은 한 개가 있을 것입니다.

English: 
And that's where I said we've
got to be careful.
That's accessing an element of
a list. We have to make sure
that, in fact, that operation
is not linear.
So let me expand on that very
slightly, and again, we did
this last time but I want
to do one more time.
I have to be careful about how
I'm actually implementing a
list.
So, for example: in
this case, my list
is a bunch of integers.
And one of the things I could
take advantage of, is I'm only
going to need a finite
amount of space to
represent an integer.
So, for example, if I want to
allow for some fairly large
range of integers, I might say,
I need four memory cells
in a row to represent
an integer.
All right, if it's a zero, it's
going to be a whole bunch
of ones-- of zeroes, so one,
it may be a whole bunch of

English: 
zeroes in the first three and
then a one at the end of this
thing, but one of the way to
think about this list in
memory, is that I can decide in
constant time how to find
the i'th element of a list.
So in particular, here's where
the zero-th element of the
list starts, there's where the
first element starts, here's
where the third element starts,
these are just memory
cells in a row, and to find the
zero-th element, if start
is pointing to that memory
cell, it's just at start.
To find the first element,
because I know I need four
memory cells to represent an
integer, it's at start plus 4.
To get to the second element,
I know that that's-- you get
the idea-- at the start plus 2
times 4, and to get to the

Korean: 
처음 3개가 0이라면 마지막의 끝은 1일지도 모릅니다. 
그러나 메모리 안에서 이 리스트에 대해서 생각하는 방법들 중 한 가지는 
일정한 시간 안에서 리스트의 i번째를 찾는 방법을 결정할 수 있다는 것입니다.  
특히, 여기 리스트의 0번째 원소가 시작하고, 여기는 첫 번째 원소, 
여기는 세 번째 원소가 시작합니다. 
이것들은 단지 연이어 있는 메모리 셀입니다. 
그리고 0번째 원소를 찾을 수 있죠. 만약 start가 이 메모리 셀을 가리킨다면, 
0번째 원소는 start에 있습니다.  
첫 번째 원소를 찾으려면 정수를 나타내는
4개의 메모리 셀이 필요하기 때문에 
첫 번째 원소는 start + 4에 있습니다.
두 번째 원소를 찾기 위해서는, 

Korean: 
여러분도 아셨을 것 같은데, start + 2*4에서 시작하고, 
k 번째 원소에 도달하려면 start가 무엇이든지 간에 
메모리 상에서 이 지점을 가리키고, 
k*4를 찾기 위해서는 정확히 여기까지 가야 함을 말해주고 있습니다.  
미묘한 차이가 있는 것처럼 들릴지도 모릅니다. 그러나 매우 중요합니다. 
왜냐하면
이것이 일정한 접근이기 때문입니다. 잘 따라오고 있나요? 
메모리 상에서 어떤 곳에 도달하기 위해서 그리고 리스트의
어떠한 값을 얻기 위해서는 어떤 원소를 찾고 싶은지 말하고, 
이러한 원소들은 특정한 사이즈 안에 저장되어 있으며, 
그 인덱스에 4를 곱한 다음 start에 더해주면 
내가 가고자 하는 곳에 도달할 때의 일정한 시간이 나오게 되는 것입니다. 
그리고 그 셀을 나오게 되는 것이지요.  
좋습니다. 
만약 내가 찾고자 하는 것이 일정한 사이즈 안에 저장되어 있다는 것을 안다면 
정말 잘 작동될 것입니다. 
그러나 리스트들의 리스트를 가진다면? 
동질의 리스트, 정수 리스트, 문자열 리스트,
실수 리스트, 리스트, 리스트, 리스트, ... 들의
리스트를 가진다면 어떻게 될까요? 

English: 
k'th element, I know that I
want to take whatever the
start is which points to that
place in memory, take care,
multiply by 4, and that tells me
exactly where to go to find
that location.
This may sound like a nuance,
but it's important.
Why?
Because that's a constant
access, right?
To get any location in memory,
to get to any value of the
list, I simply have to say which
element do I want to
get, I know that these things
are stored in a particular
size, multiply that index by 4,
add it to start, and then
it's in a constant amount of
time I can go to that location
and get out the cell.
OK.
That works nicely if I know that
I have things stored in
constant size.
But what if I have
a list of lists?
What if I have a homogeneous
list, a list of integers and
strings and floats and lists and
lists of lists and lists
of lists of lists and all
that sort of cool stuff?

English: 
In that case, I've got to
be a lot more careful.
So in this case, one of the
standard ways to do this, is
to use what's called a linked
list. And I'm going to do it
in the following way.
Start again, we'll point to the
beginning of the list. But
now, because my elements are
going to take different
amounts of memory, I'm going
to do the following thing.
In the first spot, I'm going to
store something that says,
here's how far you
have to jump to
get to the next element.
And then, I'm going to use the
next sequence of things to
represent the first
element, or
the zero-th element,
if you like.
In this case I might
need five.
And then in the next spot, I'm
going to say how far you have
to jump to get to the
next element.
All right, followed by whatever
I need to represent
it, which might only
be a blank one.
And in the next spot, maybe I've
got a really long list,

Korean: 
이러한 경우에는 더 신중해야 합니다.  
그래서 이러한 경우에는, 이것을 하는 표준적인 방법들 중 하나인 
이른바 연결 리스트(링크드 리스트)를 사용합니다.
그리고 다음의 방법으로 이것을 할 것입니다. 
또 start 는 리스트의 시작을 가리킵니다. 
그러나 원소들은 다른 메모리 양을 가질 것이기 때문에
다음에 오는 방식을 따를 것입니다.
첫 번째 장소에, 무언가를 저장할 것입니다. 
다음 원소에 도달하기 위해서 얼마나 멀리 점프해야 할까요?
그리고 첫 번째 원소와 
0번째 원소를 나타내기 위해서
다음 시퀀스들을 사용할 것입니다.
여러분들이 좋다면, 이 경우에는 5개를 사용하게 될 것입니다.
그리고 다음 장소에서, 
그 다음 원소에 도달하기 위해서 얼마나 멀리 점프 해야 할까요? 
제가 나타내고자 하는 것이 무엇인지에 따라 정해질 것이고, 
단지 1개의 빈칸만 두면 될 것 같습니다.  
그리고 그 다음 장소에서는 아마도 정말 긴 리스트를 차지하게 됩니다. 

English: 
and I'm going to say
how to jump to
get to the next element.
All right, this is actually
kind of nice.
This lets me have a way of
representing things that could
be arbitrary in size.
And some of these things
could be huge, if
they're themselves lists.
Here's the problem.
How do I get to the nth-- er,
the k'th element in the list,
in this case?
Well I have to go to the zero-th
element, and say OK,
gee, to get to the next
element, I've got
to jump this here.
And to get to the next element,
I've got to jump to
here, and to get to the next
element, I've got to jump to
here, until I get there.
And so, I get some power.
I get the ability to store
arbitrary things, but what
just happened to
my complexity?
How long does it take
me to find the
k'th element?
Linear.
Because I've got to walk
my way down it.
OK?
So in this case, you
have linear access.
Oh fudge knuckle.
Right?

Korean: 
그리고 그 다음 원소로 어떻게 점프하는지. 
말씀드릴 것입니다
좋습니다. 이것은 정말 멋집니다. 
크기를 마음대로 정해서
나타낼 수 있게 해줍니다. 
만약 그것이 리스트 자체가 되면 
매우 크기가 커질 수도 있습니다. 
문제는
리스트 안에서 k 번째 원소에 어떻게 가느냐
하는 것입니다.
음, 0번째 원소에 가야 합니다. 
좋습니다. 그 다음 원소에 가려고 하면 
여기로 점프 해야 합니다. 
그리고 그 다음 원소로 가려면 여기로 점프해야 하고
그 다음 원소로 가려면 
이곳으로 점프 해야 합니다.  
그러므로 저는 힘을 가집니다. 
임의의 것들을 저장할 수 있는 능력이 있습니다. 
그러나 저의 복잡도에는 무슨 일이 일어났을까요?
k 번째 원소를 찾는데
얼마나 걸릴까요?
선형이 나올 겁니다.
왜냐하면 한 개씩 밟아 가야 하기 때문 이지요. 
이해됐나요?
그래서 이러한 경우에 여러분은 선형 접근을 해야 합니다. 
아, 
알겠나요?

English: 
If that was the case in that
code, then my complexity is no
longer log, because I need
linear access for each time
I've got to go to the list,
and it's going to be much
worse than that.
All right.
Now.
Some programming languages,
primarily Lisp, actually store
lists these ways.
You might say, why?
Well it turns out there's
some trade-offs to it.
It has some advantages in terms
of power of storing
things, it has some
disadvantages, primarily in
terms of access time.
Fortunately for you, Python
decided, or the investors of
Python decided, to store
this a different way.
And the different way is to say,
look, if I redraw this,
it's called a box and pointer
diagram, what we really have
for each element
is two things.
And I've actually just reversed
the order here.
We have a pointer to the
location in memory that
contains the actual value, which
itself might be a bunch

Korean: 
만약 저 코드에서 그 상황이라면 
복잡도는 더 이상 log가 아닙니다.
list에 가기 위해서는 매번 선형 접근을 필요로 하기 때문입니다. 
그리고 그것은 저것보다는 훨씬 나쁘게 되겠지요.  
좋아요.
봅시다.
몇몇 프로그래밍 언어에서, 
특히 LISP는 사실 리스트들을 이러한 방식으로 저장합니다. 
왜냐고 물으실 겁니다. 
음, 여기에는 균형이 있습니다.
어떤 것을 저장하는 힘에 있어서 이점이 있고, 
그러나 주로 접근 시간에 있어서는
불리한 점이 있습니다.  
다행스럽게도, Python 개발자들은 
이것을 다른 방식으로 저장하기로 결정했습니다. 
다른 방식을 보여드리면, 이것은 박스와 포인터 그림이라고 부르고, 
각각의 원소에 대해
우리가 정말로 가지고 있는 것은 2가지입니다. 
사실 여기 순서를 바꿨습니다.
진짜 값을 포함하는 메모리의 
특정 위치를 가리키는 포인터가 있습니다.

English: 
of pointers, and we have a
pointer to the actual-- sorry,
a pointer the value and we have
a pointer to the next
element in the list.
All right?
And one of the things we could
do if we look at that is, we
say, gee, we could reorganize
this in a pretty
straightforward way.
In particular, why don't we
just take all of the first
cells and stick them together?
Where now, my list is a list of
pointers, it's not a set of
values but it's actually a
pointer off to some other
piece of memory that
contains the value.
Why is this nice?
Well this is exactly like this.
All right?
It's now something that I can
search in constant time.
And that's what's going to
allow me to keep this

Korean: 
그것 자체가 많은 포인터들일 수 있습니다. 
우리는 value를 가리키는 포인터들이 있고, 
리스트 안에서 그 다음 원소를 가리키는 포인터들을 가지고 있습니다.  
알겠나요?
우리가 이런 것을 본다면 할 수 있는 것들 중에 하나는, 
이것을 매우 간단한 방법으로 
재조직 하는 것입니다.
특히, 첫 번째 셀들을
모두 가져다가 모아 놓을까요? 
저의 리스트는 포인터들의 리스트입니다.
이것은 값들의 집합이 아니고, 
값을 포함하는 메모리들의 포인터를 떼어다 놓은 것입니다.
왜 이것이 좋을까요? 
이것은 정확히 이것과 같습니다.
이해가나요?
일정한 시간에서 
검색할 수 있는 것이지요. 

English: 
thing as being log.
OK.
With that in mind, let's go
back to where we were.
And where were we?
We started off talking about
binary search, and I suggested
that this was a log algorithm,
which it is, which is really
kind of nice.
Let's pull together what this
algorithm actually does.
If I generalize binary search,
here's what I'm going to stake
that this thing does.
It says one: pick
the midpoint.
Two: check to see if this is
the answer, if this is the
thing I'm looking for.

Korean: 
그리고 log로 있도록 유지해줍니다. 
좋습니다. 
그것을 명심해 두고 우리가 있었던 곳으로 돌아가 봅시다. 
우리가 어디까지 했었죠? 
이진 탐색(binary search)에 대한 이야기를 시작해 봅시다. 
이것이 log 알고리즘이라고 말씀 드렸습니다. 
이 말은, 좋다는 것을 뜻하죠. 
다 함께 이 알고리즘이 실제로 무엇을 하는지 알아보도록 합시다.  
이진검색을 일반화한다면,
여기 제가 하는 대로 따라해보세요.
1. 중간지점을 뽑아라.  
2. 이것이 내가 찾고자 했던 것인지
확인해보아라. 

English: 
And then, three: if not, reduce
to a smaller problem,
and repeat.
OK, you're going, yeah, come on,
that makes obvious sense.
And it does.
But I want you to keep that
template in mind, because
we're going to come
back to that.
It's an example of a very common
tool that's going to be
really useful to us, not just
for doing search, but for
doing a whole range of problems.
That is, in essence,
the template the describes
a log style algorithm.
And we're going to
come back to it.
OK.
With that in mind though,
didn't I cheat?
I remind you, I know you're not
really listening to me,
but that's OK.
I reminded you at the beginning
of the lecture, I
said, let's assume we have
a sorted list, and then
let's go search it.
Where in the world
did that sorted list
come from?
What if I just get a list of
elements, what do I do?
Well let's see.

Korean: 
3. 만약 아니라면, 
더 작은 문제로 줄이고 반복해라.  
분명히 잘 이해됐을 것입니다. 
그렇죠?
그러나 이 템플릿을 잘 기억하고 있기를 바랍니다. 
왜냐하면 다시 하게 될 것이기 때문입니다. 
이것은 단지 탐색을 하는 것에만 쓰이는 것이 아니라
우리에게 매우 유용할 도구의 예입니다. 
또한 모든 범위의 문제들을 다루는 것이 아니라면 말입니다. 
본질적으로 이 템플릿은 
log 스타일의 알고리즘을 설명하고 있습니다. 
그리고 다시 이 논의로 돌아올 것입니다.  
좋아요.
이것들을 잘 새겨두시기 바랍니다.
여러분께 상기시켜 드립니다. 저는 여러분이 제 말을 정말로 잘 듣지 않고 있는 것을 
알고 있지만, 뭐 괜찮습니다. 
그리고 강의의 시작에서 우리가 정렬된 리스트를 가지고 있다고 가정하고,
그것을 탐색해보자라고 했었습니다.  
정렬된 리스트는 그렇다면 어디서 왔을까요? 
정렬된 리스트는 그렇다면 어디서 왔을까요? 
정렬되지 않은 채 원소들이 들어있는 리스트가 있으면 무엇을 해야 할까요? 
자, 한번 봅시다.

English: 
My fall back is, I could just
do linear search, walk down
the list one at a time, just
comparing those things.
OK.
So that's sort of my base.
But what if I wanted, you know,
how do I want to get to
that sorted list?
All right?
Now.
One of the questions, before we
get to doing the sorting,
is even to ask, what should I do
in a search case like that?
All right, so in particular,
does it make sense, if I'm
given an unsorted list,
to first sort it,
and then search it?
Or should I just use the
basically linear case?
All right?
So, here's the question.
Should we sort before
we search?
OK.
So let's see, if I'm going to
do this, how fast could we
sort a list?

Korean: 
만일의 경우를 대비한 저의 대비책은 선형 탐색을 하는 것입니다. 
한 번에 하나의 리스트만 검색합니다. 이런 것들을 비교하면서 말이죠. 
좋습니다. 
그것이 나의 기본이 되겠죠. 
그렇지만, 제가 원했다면,  
어떻게 그 정렬된 리스트에 도달할 수 있을 수 있을까요?
좋아요.
자,
정렬을 하기 전에 질문이 하나 있습니다. 
이런 검색의 경우에는 무엇을 해야 할까요? 
특히, 만약 제가 정렬되지 않은 리스트를 가지고 있는데, 
정렬을 하고 그것을 검색하면 
말이 되지 않을까요?
아니면 기본적인 선형을 이용해야 할까요?
어떨까요?
검색하기 전에 정렬 해야 할까요? 
라는 질문이 있습니다. 
좋습니다. 
한번 보죠. 만약 제가 이것을 한다면, 
얼마나 빠르게 리스트를 정렬할 수 있을까요? 

Korean: 
우리는 버금선형 시간(sublinear time) 안에서 정렬을 할 수 있을까요?
버금 선형의 의미는 선형 시간(linear time)시간보다 적은 log 같은 것이라고 할까요? 
어떻게 생각하시나요? 
가능할 것 같나요?
어떤 생각 없으신가요? 
여기서 여러분이 대답하기를 기다리며 서있는 교수들을
싫어하는 건 아니겠죠? 캔디도 가지고 있는데 말입니다. 
선형시간보다 적은 시간 안에 이것을 할 수 있다고
생각하는 게 말이 되는 걸까요? 
여러분도 알다시피, 이것은 좀 생각 해야 하는 문제죠.
손 드신 분이 있는 것 같은데, 
예, 저 뒤쪽이요. 
감사합니다. 
저 분이 제가 여기서 일을 할 수 있게 도와주셨네요. 
저기 먼 곳까지 갈 수 있을지 모르겠습니다. 
친구가 도와줄 거예요.
감사합니다.
저 분이 정확하게 맞췄습니다. 
버금선형 시간 안에 어떻게 할 수 있을까요? 
적어도 한번 원소를 보게 되는데, 
이것을 생각해 내는 것은 약간 직관적이기는 하지만,
이것을 생각해 내는 것은 약간 직관적이기는 하지만,
대답은 ‘no'입니다. 

English: 
Can we sort a list in
sublinear time?
Sublinear meaning, something
like log
less than linear time?
What do you think?
It's possible?
Any thoughts?
Don't you hate professors who
stand here waiting for you to
answer, even when
they have candy?
Does it make sense to think we
could do this in less than
linear time?
You know, it takes a little
bit of thinking.
What would it mean--
[UNINTELLIGIBLE PHRASE] do I see
a hand, way at the back,
yes please?
Thank you.
Man, you're going to really make
me work here, I have no
idea if I can get it that
far, ah, your friend
will help you out.
Thank you.
The gentleman has it
exactly right.
How could I possibly do it in
sublinear time, I've got to
look at least every
element once.
And that's the kind of instinct
I'd like you to get
into thinking about.
So the answer here is no.

Korean: 
좋습니다.
선형 시간 안에는 가능할까요?
음... 
분명하지는 않지만,
잠시 이것에 대해 생각해 보겠습니다. 
선형 시간 안에서 리스트를 정렬하기 위해서,
기껏해야 일정한 시간에서 
각각의 원소를 보아야 합니다.
딱 한번 일 필요는 없고, 
2번이나 3번도 가능하죠.  
음... 
잠시 만요. 
만약 제가 리스트를 정렬하고 싶고, 하나의 원소를 가지면, 
아마도 리스트의 많은 다른 원소들을 보아야 합니다. 
그것이 어디로 가는지 결정하기 위해서죠. 
그리고 이것은 리스트가 얼마나 긴가에 따라 달라진다는 것을 의미하죠. 
좋습니다. 그래서 설득력이 약합니다. 그러나 사실은,
나타내는 하나의 방법입니다. 이 질문에 대한 답은 ‘그렇지 않다' 입니다. 
좋습니다. 
그러면 저는 리스트를
얼마나 빠르게 정렬할 수 있을까요? 

English: 
OK.
Can we sort it in linear time?
Hmmm.
That one's not so obvious.
So let's think about
this for a second.
To sort a list in linear time,
would say, I have to look at
each element in the
list at most a
constant number of times.
It doesn't have to be
just once, right?
It could be two or three times.
Hmm.
Well, wait a minute.
If I want to sort a list, I'll
take one element, I've got to
look at probably a lot of the
other elements in the list in
order to decide where it goes.
And that suggests it's going
to depend on how
long the list is.
All right, so that's a weak
argument, but in fact, it's a
way of suggesting,
probably not.
All right.
So how fast could
I sort a list?
How fast can we sort it?

Korean: 
다시 여기로 돌아올 것입니다.
그리고 이 질문에 대한 답은 
‘n log n 시간 안에 할 수 있다’입니다. 
이 논의로 다시 돌아올 거예요. 
알겠죠?
n log n 은 아마도
우리가 할 수 있는 최고일 것입니다.
아니면, 리스트의 크기 정도이겠죠.
좋습니다. 다시 제 질문으로 돌아가죠.
만약 리스트를 탐색하고 싶으면 저는 
먼저 정렬을 하고 그 다음에 탐색 해야 할까요? 
음... 
비교를 해보겠습니다.
정렬되지 않은 리스트가 있고 그것을 검색합니다.
저는 선형 시간 안에 그것을 해낼 수 있습니다. 
한 번에 하나씩
제가 찾는 원소를 발견할 때 까지 탐색해 나갑니다. 
그것은 order n 이 될 것입니다.(n) 
다른 한편으로 먼저 그것을 정렬하고, 
좋습니다. 정렬하고 검색하고 싶다면, 

English: 
And we're going to come back to
this, probably next time if
I time this right, but the
answer is, we can do it in n
log n time.
We're going to come
back to that.
All right?
And I'm going to say-- sort of
set that stage here, so that--
It turns out that that's
probably about the best we can
do, or again ends at the
length of the list.
OK, so that's still comes
back to my question.
If I want to search a list,
should I sort it first and
then search it?
Hmmm.
OK, so let's do the
comparison.
I'm just going to take an
unsorted list and search it, I
could do it in linear
time, right?
One at a time.
Walk down the elements
until I find it.
That would be order n.
On the other hand, if I want
to sort it first, OK, if I
want to do sort and search, I
want to sort it, it's going to

Korean: 
정렬하는데 n log n 시간이 걸릴 것입니다. 
그리고 나서 검색하는데 log n 시간이 걸릴 것입니다.(n log n + log n) 
음,
어떤 것이 더 나은가요? 
네, 학생?
아하.
감사합니다.
그 생각을 잠시 가지고 계시기 바랍니다.  
다시 돌아와서 생각해 볼 것입니다.
그것은 제가 검색을 실행하고 있다는 것을 가정하지 않았습니다.
어떤 것이 더 좋을까요? 
정렬 안 된 것이요. 정확히 이해했습니다. 
어떻게 대답하는 학생들이 모두 
저렇게 멀리 앉아 있는 걸까요? 
와, 팀 웨이크필드(보스턴 레드삭스의 투수)가 던진 공 같군요. 좋습니다. 
감사합니다. 
저 학생이 정확히 맞았죠. 
그렇죠? 
이것이 저것보다 작은가요? 
아닙니다. 
약간의 거짓입니다. 
죄송합니다. 이러한 것들이 수행시간에 대한 
성장차수가 되어야 한다는 점에서 
약간 잘못 말했네요.
그 안에 몇몇의 상수들이 있고, 
그것은 입력의 

English: 
take n log n time to sort it,
and having done that, then I
can search it in log n time.
Ah.
So which one's better?
Yeah.
Ah-ha.
Thank you.
Hold on to that thought for
second, I'm going to
come back to it.
That does not assume I'm running
a search it wants,
which one's better?
The unsorted, and you have
exactly the point I want to
get to-- how come all the guys,
sorry, all the people
answering questions are way,
way up in the back?
Wow. that's a Tim Wakefield
pitch right there, all right.
Thank you.
He has it exactly right.
OK?
Is this smaller than that?
No.
Now that's a slight lie.
Sorry, a slight misstatement,
OK?
I could run for office, couldn't
I, if I can do that
kind of talk.
It's a slight misstatement in
the sense that these should
really be orders of growth.

English: 
There are some constants in
there, it depends on the size,
but in general, n log n has
to be bigger than n.
So, as the gentleman back there
said, if I'm searching
it once, just use the
linear search.
On the other hand, am I likely
to only search a list once?
Probably not.
There are going to be multiple
elements I'm going to be
looking for, so that suggests
that in fact, I want to
amortize the cost.
And what does that say?
It says, let's assume
I want to do k
searches of a list. OK.
In the linear case, meaning in
the unsorted case, what's the
complexity of this?
k times n, right?
Order n to do the search, and
I've got to do it k times, so
this would be k times n.
In the [GARBLED PHRASE]

Korean: 
크기에 의존합니다. 
그러나 일반적으로 n log n이 n보다는 커야 하죠.  
뒤쪽의 저 학생이 말했듯이. 
만약 제가 한번만 검색을 한다면 선형 탐색을 사용할 겁니다. 
그러나 다른 한편으로 리스트를 단지 한번만 검색할까요? 
아마도 아닐 것입니다. 
제가 찾고 있는 다양한 원소들이 있을 것입니다.  
그래서 사실 저는 그것의 비용을
측정하고 싶습니다.
이것은 무엇을 말하는 것일까요? 
제가 리스트의 k serarch를 하고 싶다고 가정해보자는 것을 뜻합니다. 
좋습니다.
선형이고 정렬되지 않은 경우, 이것의 복잡도는 무엇일까요?  
kn이죠? 그렇죠?
검색을 하기 위한 n순서 그리고 거기에 k배를 합니다.
kn 일 것입니다. 

Korean: 
비용은 얼마가 될까요? 
정렬 해야 합니다. 다음 시간에 좀 더 하게 될 것입니다. 
저는 n log n 안에 정렬할 수 있습니다. 
이 경우에 탐색은 어떻게 될까요? 
한 개를 탐색하는데, log n이 들어가고, 
k 번 하게 되니까, k log n 이 됩니다. 
좀 더 좋아 보이죠? 
특히 n이 크거나, k가 많은 경우에는 
일반적으로 이것보다 더 작아질 것입니다. 
이것이 비용이 축소되는 것이 
우리를 도와주는 부분입니다. 
뒤에 앉은 학생이 질문한 것도 맞고, 
이것은 우리가 무엇을 하려고 하는지에 따라 달라집니다. 
그러므로 제가 분석을 할 때에는 여기서 무엇을     
하는지를 생각하고 싶습니다.
여기 2개의 변수가 있습니다. 문제는 리스트의 길이가 무엇이냐는 
것이고 얼마나 많이 그것을 검색할 것인가 입니다.

English: 
sort and search case,
what's my cost?
I've got to sort it, and we
said, and we'll come back to
that next time, that I can do
the sort in n log n, and then
what's the search
in this case?
Let's log n to do one search, I
want to do k of them, that's
k log n, ah-ha!
Now I'm in better
shape, right?
Especially for really large n or
for a lot of k, because now
in general, this is going
to be smaller than that.
So this is a place where
the amortized cost
actually helps me out.
And as the gentleman at the
back said, the question he
asked is right, it depends
on what I'm trying to do.
So when I do the analysis, I
want to think about what am I
doing here, am I capturing
all the pieces of it?
Here, the two variables that
matter are what's the length
of the list, and how many times
I'm going to search it?

Korean: 
이 경우에는 n log n + k log n 이 이기고, 
이 경우에는 n 이 이기게 됩니다.
좋습니다. 
말씀 드렸지만, 정렬하는 것을 몇 개 보도록 하겠습니다. 
우선 바보 정렬 메커니즘들을 
시작해 보도록 하겠습니다. 
사실 그렇게 말하는 것은 잘못된 것입니다. 그것들은 단순히 뇌에 손상을 
받은 것이지요. 바보가 아닙니다. 알겠죠? 
그러나 처음에 이런 알고리즘들을 보는 것은 알고리즘을 어떻게 하고 
정렬을 어떻게 하는지에 대해서 이해하는데 좋습니다.  
지금은 더 좋은 것들이 있고, 다음 시간에 보게 될 것입니다. 
그러나 처음에 이런 알고리즘들을 보는 것은 
알고리즘을 어떻게 하고 
정렬을 어떻게 하는지에 대..
엇, 다시 해봅시다.
대해서 이해하는데 좋습니다.
제가 첫 번째로 이야기하고 싶은 것은 
선택 정렬(selection sort)입니다. 
교재에도 나와 있고, 코드 또한 여기 올려 놓을 것입니다. 
그것을 봐도 
좋습니다. 
이것이 어떻게 작동하는지 봅시다. 
좋습니다. 

English: 
So in this case, this one wins,
whereas in this case,
that one wins.
OK.
Having said that, let's look
at doing some sorts.
And I'm going to start with
a couple of dumb sorting
mechanisms. Actually, that's
the wrong way saying it,
they're simply brain-damaged,
they're not dumb, OK?
They are computationally
challenged, meaning, at the
time they were invented, they
were perfectly good sorting
algorithms, there are better
ones, we're going to see a
much better one next time
around, but this is a good way
to just start thinking about
how to do the algorithm, or
how to do the sort.
Blah, try again.
How to do this sort.
So the first one I want to talk
about it's what's called
selection sort.
And it's on your handout, and
I'm going to bring the code up
here, you can see it, it's
called cell sort, just for
selection sort.
And let's take a look
at what this does.
OK.

English: 
And in fact I think the easy
way to look at what this
does-- boy.
My jokes are that bad.
Wow--
All right.
I think the easiest way to look
at what this does, is
let's take a really
simple example--
I want to make sure I put
the right things out--
I've got a simple little
list of values there.
And if I look at this code, I'm
going to run over a loop,
you can see that there, i is
going to go from zero up to
the length minus 1, and I'm
going to keep track of a
couple of variables.
Min index, I think I
called it min val.
OK.
Let's simulate the code.
Let's see what it's
doing here.
All right, so we start off.
Initially i-- ah, let me do it
this way, i is going to point
there, and I want to make sure
I do it right, OK-- and min

Korean: 
그리고 사실 저는 이것이 선택 정렬이 어떻게 작동하는지 
보는 가장 쉬운 방법이라고 생각합니다.  
오 저런, 제 농담이 그렇게 나빴군요.
와우. 좋습니다.
선택정렬이 어떻게 돌아가는지 보는 가장 쉬운 방법이라고 생각해요. 
정말 단순한 예를 하나 보겠습니다. 
- 정확한 숫자를 적겠습니다. - 
저기 단순하고 작은 리스트가 하나 있습니다. 
이 코드를 보면, 루프를 빠르게 살펴보겠습니다. 
저기서도 볼 수 있고, i가 0에서 length-1로 올라갑니다. 
그리고 몇몇 변수들이 변화하는 것을 
계속해서 살펴보도록 하겠습니다. 
MinIndx, minVal 이라고 불러야 할 것 같군요. 
좋습니다. 
코드가 어떻게 될지 생각해보겠습니다. 
여기 어떻게 돌아가는지 보죠. 
좋습니다. 자. 그러면 시작합니다. 
i는 이 지점이 되어야 합니다. 
제가 제대로 썼는지 한번 확인하고요. 좋습니다. 

Korean: 
MinIndx는 여기 i의 값을 가리킬 것이고,
minVal는 1의 값을 가질 것입니다. 
그래서 간단하게 첫 번째 값이  
어떻게 되는지 보았습니다.
그리고 나서 우리는 무엇을 해야 할까요? 
j는 여기를 가리키고, 이 루프가 무엇을 할지를 
볼 수 있을 것입니다. j는 증가해 나갈 것입니다.
그러면 리스트의 나머지를 보도록 하겠습니다. 
그것이 무엇을 하나요?
옳다고 말하네요.
만약 j가-- 음 j가 그 길이보다 적게 존재 한다고 말할때까지요. 
만약 minVal이 제가 지금 보고 있는 수(8) 보다 크다면,  
저는 무언가 할 것입니다. 알겠죠?
minVal이 1이고, 옆으로 하나씩 
가면서 비교해보겠습니다. 
1이 8보다 큰가요? 
아니요. 
j를 하나 증가시킵니다. 
1이 3보다 큰가요? 
아니요. 
1이 6보다 큰가요? 
아니요. 
1이 4보다 큰가요? 
아니요 입니다.  
이렇게 루프의 마지막에 도착하게 되고, 
저는 사실 쓸데 없는 일을 한 셈이 된 거죠. 
쓸데 없는 일이란 i에 있는 값을 가져다가 임시로 

English: 
index is going to point to the
value of i, which is there,
and min value is initially going
to have the value 1.
So we're simply catting a hold
of what's the first value
we've got there.
And then what do we do?
We start with j pointing here,
and we can see what this
loop's going to do, right? j
is just going to move up.
So it's going to look at the
rest of the list, walking
along, and what does it do?
It says, right.
If j is-- well it says until j
is at the less than the length
of l-- it says, if min value is
bigger than the thing I'm
looking at, I'm going to do
something, all right?
So let's walk this.
Min value is 1,.
Is 1 bigger than 8?
No.
I move j up.
Is 1 bigger than 3?
No.
1 bigger than 6?
No.
1 bigger than 4?
No.
I get to the end of the loop,
and I actually do a little bit
of wasted motion there.
And the little bit of wasted
motion is, I take the value at

English: 
i, store it away temporarily,
take the value where min index
is pointing to, put it
back in there, and
then swap it around.
OK.
Having done that, let's move i
up to here. i is now pointing
at that thing.
Go through the second
round of the loop.
OK.
What does that say?
I'm going to change min index to
also point there n value is
8, j starts off here, and I
say, OK, is the thing I'm
looking at here smaller
than that?
Yes.
Ah-ha.
What does that say to do?
It says, gee, make min
index point to there,
min value be 3.
Change j.
Is 6 bigger than 3?
Yes.
Is 4 bigger than 3?
Yes.
Get to the end.
And when I get to the
end, what do I do?

Korean: 
저장해두고 MinIndx가 가리키는 곳의 값을 가져다가 다시 
제자리에 가져다 놓고 위치를 바꿔주는 것을 말합니다. 
좋습니다. 
이제 i를 여기로 옮겨보겠습니다. 
i는 저곳을 가리키고 있습니다. 
루프의 2번째 라운드를 진행합니다. 
좋습니다. 
저것이 무엇을 말하고 있나요? 
MinIndx는 여기를 가리키게 되고, n의 값은 8이 
되고 j는 여기서 시작하게 됩니다. 좋습니다. 
저는 지금 이 부분을 보고 있습니다. 3이 8보다 작나요? 
그렇습니다. 
아하.
저것은 무엇을 하라고 말하고 있나요? 
MinIndx는 여기를 가리키고, minVal은 3을 가리키게 합니다.  
j도 바꾸어 줍니다.
6이 3보다 큰가요? 
그렇습니다. 
4가 3보다 큰가요? 
그렇습니다. 
끝나게 됩니다. 
끝나게 되면 저는 무엇을 해야 할까요? 

English: 
Well, you see, I say, take temp,
and store away what's
here, all right?
Which is that value, and then
take what min index is
pointing to, and stick it in
there, and finally, replace
that value.
OK.
Aren't you glad I'm
not a computer?
Slow as hell.
What's this thing doing?
It's walking along the list,
looking for the smallest thing
in the back end of the list,
keeping track of where it came
from, and swapping it
with that spot in
the list. All right?
So in the first case, I didn't
have to do any swaps because 1
was the smallest thing.
In the second case, I found in
the next smallest element and
moved here, taking what was
there and moving it on, in
this case I would swap the 4 and
the 8, and in next case I
wouldn't have to do anything.
Let's check it out.

Korean: 
음, temp가 있고, 8을 여기에 저장합니다. 
이것이 그 값이고요. 맞죠?
그리고 MinIndx가 가리키는 것을 이곳에 넣어주고요. 
마지막으로 값을 여기에 넣어줍니다. 
좋습니다. 
제가 컴퓨터가 아닌 것이 기쁘지 않나요? 
정말 느리죠. 
무엇을 하고 있나요? 
리스트의 뒤쪽에서 최소 값을 발견하고, 
최소 값이 온 자리를 파악하고 
있다가 값을 서로 교환해줍니다.  
맞나요?
그래서 첫 번째 경우에 저는 값을 교환해줄 필요가 없습니다. 
1이 최소 값이었기 때문이죠. 
두 번째 경우에는 1 다음으로 작은 값(3)을 
여기서 찾았고, 여기에 있던 값(8)을 
이곳으로 옮겨주죠. 
4와 8의 경우도 교환해 줍니다. 
한번 보겠습니다. 

Korean: 
제가 여기에 테스트 스크립트를 써 
놓았고 테스트를 해보겠습니다. 각 라운드의 
마지막에 어떻게 출력되는가를 보겠습니다.  
아하. 
제가 가리키는 곳을 보세요. 
이 경우에 무슨 일이 일어나는지 주목하세요. 
첫 번째 라운드가 끝난 후에는 첫 번째에 
가장 작은 원소가 놓여있습니다.
두 번째 라운드가 끝난 후에는 앞쪽에 가장 작은 원소 2개가 
놓여있습니다. 모든 원소들이 정렬되었습니다.
루프가 여러 번 돌아가면서 모든  
원소들을 정렬시켜 줍니다.
다른 예를 보겠습니다. 
좋습니다. 
앞쪽에 가장 작은 원소가 있습니다. 
그 다음에 2번째로 작은 원소가 있고 
그 다음에 3번째로 작은 원소가 있습니다
4번째 작은 원소가 있고, 이 과정을 보면서 여러분은 선택 
정렬의 아이디어를 이해했을 것입니다. 5번째 작은 원소도 있습니다. 
이것은 멋지고 작은 검색입니다. -죄송합니다. 
멋지고 작은 정렬 알고리즘입니다. 
그리고 사실 이것은 우리가 논의하기 위해 돌아가야 할 것에 달려있습니다. 
그것은 루프 불변성(loop invariant) 이라고 불립니다. 

English: 
I've written a little bit of a
test script here, so if we
test cell sort, and I've written
this so that it's
going to print out what
the list is at the end
of each round, OK.
Ah-ha.
Notice what-- where am
I, here-- notice what
happened in this case.
At the end of the first round,
I've got the smallest element
at the front.
At the end of the second round,
I've got the smallest
two elements at the front,
in fact I got all
of them sorted out.
And it actually runs through
the loop multiple times,
making sure that it's
in the right form.
Let's take another example.
OK.
Smallest element at the front.
Smallest two elements
at the front.
Smallest three elements
at the front.
Smallest four elements at the
front, you get the idea.
Smallest five elements
at the front.
So this is a nice little
search-- sorry, a nice little
sort algorithm .
And in fact, it's relying on
something that we're going to
come back to, called
the loop invariant.

Korean: 
여러분이 볼 수 있게 이 칠판에 적겠습니다.  
루프 불변성(loop invariant)의 뜻은 무엇일까요? 
루프를 통과할 때마다 
항상 참이 되는 특성을 말합니다. 
루프 불변성은 다음과 같은데, 
리스트는 처음 요소와 마지막 요소로 나누어지고, 
처음 요소는 정렬 되어 지고 
마지막 요소는 정렬되지 않습니다. 
이 루프는 기본적으로 마지막 요소에서부터
시작하고, 리스트의 끝에 닿을 때까지 

English: 
Actually, let me put it on this
board so you can see it.
The loop invariant what does
the loop invariant mean?
It says, here is a property that
is true of this structure
every time through the loop.
In the loop invariant here is
the following: the list is
split, into a prefix or a first
part, and a suffix, the
prefix is sorted, the suffix
is not, and basically, the
loop starts off with the prefix
being nothing and it
keeps increasing the size of the
prefix by 1 until it gets
through the entire list, at
which point there's nothing in

English: 
the suffix and entire
prefix is sorted.
OK?
So you can see that, it's just
walking through it, and in
fact if I look at a couple of
another-- another couple of
examples, it's been a
long day, again, you
can see that property.
You'll also notice that this
thing goes through the entire
list, even if the list
is sorted before it
gets partway through.
And that you might look at,
for example, that first
example, and say, man by this
stage it was already sorted,
yet it had to go through and
check that the third element
was in the right place, and then
the fourth and then the
fifth and then the six.
OK.
What order of growth?
What's complexity of this?
I've got to get rid
of this candy.
Anybody help me out?
What's the complexity of this?
Sorry, somebody at the back.
n squared.
Yeah, where n is what?
Yeah, and I can't even see
who's saying that.
Thank you.
Sorry, I've got the wrong
glasses on, but you're

Korean: 
1씩 증가해갑니다. 
알겠죠? 
그래서 여러분은 그것이 하나씩 진행해 나가는 것을 볼 수 있을 겁니다. 
사실 다른 예들을 본다면, 
또 보게 되네요. 
여러분은 여기서 저 특성을 볼 수 있습니다. 
또한 중간 정도에서 정렬이 모두 되어도 
전체 리스트를 모두 검사하며 지나가는 것을  
알 수 있을 것입니다.
이 첫 번째 예를 보세요.  
이미 정렬이 되어 있습니다. 그러나 계속 지나가면서 
3번째 원소가 제 자리에 놓여 있는지 확인합니다. 
그러고 나서 4번째 원소도 5번째 원소도 그리고 
마지막으로 6번째 원소도 확인 합니다. 
좋습니다. 
이것의 복잡도는 무엇일까요? 
이것의 복잡도는 무엇일까요? 
이 캔디가 어서 없어져야 할 텐데, 
누구 도와줄 분 없나요? 
이것의 복잡도가 무엇인가요? 
죄송합니다. 뒤쪽에 앉은 분.  
n^2. 
네, N은 어디있나요? 네?
예. 누가 말씀 하신지 보이지가 않네요. 
감사합니다. 
죄송합니다 제가 잘 안 보이는 안경을 쓰고 있네요. 
그렇지만, 정확히 맞추었습니다.  

Korean: 
다른 분들은 듣지 못했을 것 같습니다. n^2.
제가 어떻게 알았을까요? 
음, 전 리스르 아래쪽으로 루프하고 있습니다. 맞나요?
리스트를 하나씩 검사하며 내려갑니다.
그러면 리스트의 길이는 분명히, 
적어도 선형일 것입니다.
각각의 시작 점에서 저는 어떻게 해야 하나요? 
리스트의 나머지 부분을 보고 다음 장소에서  
교환 해야 할 원소는 무엇인지 결정합니다.
자, 여러분은, 음, 잠시 만요. 리스트를 지나가며 검사해 
나갈 때, 남아있는 부분은 점점 작아집니다. 이것은 항상 리스트의 
처음 길이가 아니예요. 라고 말할지도 모릅니다. 예, 여러분이 맞습니다. 
그렇지만 만약 여러분이 합을 구하거나 이런 방식으로 생각하고 싶다면, 
또는 더 일반적으로 이것을 생각한다면, 이것은 평균적으로 
항상, 적어도 리스트의 길이일 것입니다. 
그래서 저는 n개의 것들을 n번 하게 되고,  
이것이 정렬에서 이차가 되는 것이지요.
좋습니다. 
이것은 이러한 정렬을 하는 한 가지 방법 이예요. 
다른 것을 해보죠. 
우리가 두 번째로 할 정렬은 버블 정렬(bubble sort)입니다. 
맞나요?
버블 정렬 역시 여러분의 교재에 나와 있습니다. 

English: 
absolutely right, and in case
the rest of you didn't hear
it, n squared.
How do I figure that out?
Well I'm looping down
the list, right?
I'm walking down the list. So
it's certainly at least linear
in the length of the list.
For each starting
point, what do I do?
I look at the rest of the list
to decide what's the element
to swap into the next place.
Now, you might say, well,
wait a minute.
As I keep moving down, that part
gets smaller, it's not
always the initial length of
the list, and you're right.
But if you do the sums, or if
you want to think of it this
way, if you think about this
more generally, it's always on
average at least the length of
the list. So I've got to do n
things n times.
So it's quadratic, in
terms of that sort.
OK.
That's one way to
do this sort.
Let's do another one.
The second one we're going to
do is called bubble sort.
All right?
And bubble sort is also
on your handout.

Korean: 
이것의 첫 번째 것을 보도록 하죠. 죄송합니다. 잠시 만요. 
됐습니다. 
좋아요. 저기 버블 정렬의 코드가 있습니다. 
잠시 코드를 보겠습니다. 그러고 나서 버블 정렬의 예 몇 개를 
다뤄보도록 하겠습니다. 그러면 이것이 실제로 어떤 일을 하는지 이해할  
수 있을 것입니다. 버블 정렬, 바로 여기 위쪽에 있습니다. 
그것은 무엇을 할까요? 
j는 리스트 길이 전체를 이동 합니다. 
한 지점에서 시작해서 옮겨갑니다. 
그리고 i의 범위는 이동하게 되는데 그것은 딱 j보다 
1이 작습니다. 거기서 어떤 일을 할까요? 
연속적인 짝들을 보고 있습니다. 그렇죠? 
i 번째 원소와 i +first 원소를 보고 있습니다.  
만약 i 번째 원소가 i + first 원소보다 크다면 세 개의 
다음 집합들은 무엇을 할 것이냐고 묻고 있습니다.
단지 그것들을 교환해 줍니다. 맞나요?

English: 
And you want to take the first
of these, let me-- sorry, for
a second let me uncomment
that, and let me
comment this out--
All right, you can see the code
for bubble sort there.
Let's just look at it for a
second, then we'll try some
examples, and then we'll
figure out what
it's actually doing.
So bubble sort, which
is right up here.
What's it going to do?
It's going to let j run over
the length of the list, all
right, so it's going to start
at some point to move down,
and then it's going to let i
run over range, that's just
one smaller, and what's
it doing there?
It's looking at successive
pairs, right?
It's looking at the i'th and the
i plus first element, and
it's saying, gee, if the i'th
element is bigger than the
i'th plus first element, what's
the next set of three
things doing?
Just swapping them, right?
I temporarily hold on to what's
in the i'th element so

English: 
I can move the i plus first one
in, and then replace that
with the i'th element.
OK.
What's this thing doing then,
in terms of sorting?
At the end of the first pass,
what could I say about the
result of this thing?
What's the last element
in the list look like?
I hate professors who do this.
Well, let's try it.
Let's try a little test. OK?
Test bubble sort-- especially if
I could type-- let's run it
on the first list. OK, let's
try it on another one.
Oops sorry.
Ah, I didn't want to do it this
time, I forgot to do the
following, bear with me.
I gave away my punchline.
Let's try it again.

Korean: 
i번째 원소를 잠시 잡고 있고,  
i +first 원소가 이동해오면 
i 번째 원소와 바꿔줍니다.
네.
그러면 이것은 정렬의 관점에서 봤을 때 
어떤 일을 하게 될까요? 
한번 통과하게 되면 결과가 어떻게 될까요? 
리스트의 마지막 원소는 어떤 것일까요? 
이런 것 하는 교수들이 싫다고요? 
자, 그렇다면 한번 해보겠습니다. 
작은 테스트를 해볼까요? 
네?
버블정렬을 테스트해 보세요. 첫 번째 리스트에서 
실행시켜 보겠습니다. 
좋습니다. 다른 것에서 해보겠습니다. 
오, 죄송합니다. 
이번에 이것을 하고자 했던 것이 아닌데, 
다음에 해야 하는 것을 잊어버렸군요. 
잠시만 기다려 주세요. 
다시 해보겠습니다. 

English: 
Test bubble sort.
OK, there's the first run, I'm
going to take a different
list. Can you see
a pattern there?
Yeah.
STUDENT: The last cell in the
list is always going to
[INAUDIBLE]
PROFESSOR ERIC GRIMSON: Yeah.
Why?
You're right, but why?
STUDENT: [UNINTELLIGIBLE PHRASE]
PROFESSOR ERIC GRIMSON:
Exactly right.
Thank you.
The observation is, thank you,
on the first pass through, the
last element is the biggest
thing in the list. On the next
pass through, the next largest
element is at the second point
in
the list. OK?
Because what am I doing?
It's called bubble sort
because it's literally
bubbling along, right?
I'm walking along the list once,
taking two things, and
saying, make sure the
biggest one is next.
So wherever the largest element
started out in the
list, by the time I get through
it, it's at the end.

Korean: 
버블정렬을 테스트해 보세요
예, 첫 번째 실행 결과이고요. 다른 리스트를 테스트 해보겠습니다. 
여기 패턴이 보이나요? 
네.
학생 : 그 리스트의 마지막 셀은 
.. 그렇게 될 것입니다.
교수 : 예,  
왜 그런가요?
맞습니다. 그런데 이유가 뭘까요? 
교수: 정확하게 맞췄습니다. 
감사합니다. 
한번 실행된 후에는 마지막 원소가 
리스트에서 가장 큰 원소가 됩니다. 
그 다음 두 번째 실행이 끝난 후에는 두 번째로 큰 원소가 
가장 큰 원소 다음에 놓이게 됩니다. 
네?
리스트 중에서 제일 가벼운(작은) 항목이 물속의 거품처럼 제일 위로 상승하고, 
그 다음 가벼운 것이 다음 자리로 상승하고 제일 무거운 것이 끝자리로 오기 때문에  
말 그대로 버블 정렬이라고 불립니다.
리스트를 통과하면서, 2개의 원소를 
비교하고 큰 것을 옆에 놓습니다. 
가장 큰 원소는 어디에서 시작하든지 간에 한번 통과하고 
나면 그것은 가장 끝에 놓이게 됩니다. 

English: 
And then I go back and
I start again, and
I do the same thing.
OK.
The next largest element
has to end up in
the second last spot.
Et cetera.
All right, so it's called bubble
sort because it does
this bubbling up until
it gets there.
Now.
What's the order
of growth here?
What's the complexity?
I haven't talked to the side
of the room in a while,
actually I have. This gentleman
has helped me out.
Somebody else help me out.
What's the complexity here?
I must have the wrong glasses
on to see a hand.
No help.
Log?
Linear?
Exponential?
Quadratic?
Yeah.
Log.
It's a good think, but why
do you think it's log?
Ah-ha.
It's not a bad instinct, the
length is getting shorter each
time, but what's one of the
characteristics of a log algorithm?
It drops in half each time.

Korean: 
그러면 다시 돌아가고 다시 시작합니다. 그리고 같은 일을 반복하죠. 
네.
두 번째로 큰 원소는 2번째로 큰 자리에 놓여야 합니다. 
계속 그렇게 진행하게 되죠. 
좋습니다. 원소가 거품처럼 일어나기 때문에 
버블 정렬이라고 불리는 것입니다.  
자 
그렇다면 여기서 수행시간에 대한 성장차수는 무엇일까요? 
복잡도는 무엇일까요? 
사실 한동안 이 교실의 다른 쪽으론 
이야기를 하지 않았네요.
이 분이 저를 도와줬었죠. 
이번에는 다른 분들도 도와주시면 좋겠네요. 
여기서 복잡도는 무엇일까요? 
잘못된 안경을 쓴 것이 틀림없습니다. 
대답하려는 분이 아무도 없네요. 
로그? 
선형? 
지수? 
이차? 
예,  
로그. 
좋은 생각입니다. 그런데 왜 로그라고 생각하시나요? 
아하.
나쁘지 않지만, 매 시간 길이가 점점 짧아집니다. 
로그 알고리즘의 특징 중의 
하나는 무엇인가요? 
실행 될 때마다 매번 반으로 줄어듭니다. 

Korean: 
그래서 로그는 아니라고 할 수 있겠네요.  
좋습니다. 
답에 근접했어요. 
선형이 될 것이다? 그러나 이것을 
몇 번 살펴 보게 되죠? 
한번 실행해서 가장 큰 원소를 마지막에 
버블 정렬시키고, 또 한번 실행해서 
두 번째 큰 원소를 그 다음에 정렬 시킵니다. 
정렬을 시키기 위해서는 
매번 다른 실행을 거쳐야 하죠.
허.
몇 번의 선형 횟수를 시행 해야 
할 것처럼 들리네요. 
답은 이차(n^2)입니다.
맞나요?
좋습니다. 
다시 하나의 예를 봅시다. 
이것은 이차였습니다. 
그리고 이것을 써야 겠군요.
 O((ClogL)^2). 
우리가 측정한 것을 더 명확하게 보여주기 위해서입니다.  
좋아요.
더 좋게 할 수 있을까요?  
물론입니다.
사실 다음 시간에 여러분께 n log n 알고리즘을 보여드릴 것입니다. 
그러나 버블 정렬에서도 더 좋게 할 수 있습니다. 

English: 
So this isn't--
OK.
And you're also close.
It's going to be linear,
but how many times do
I go through this?
All right, I've got to do one
pass to bubble the last
element to the end.
I've got to do another pass to
bubble the second last element
to the end.
I've got to do another pass.
Huh.
Sounds like a linear number of
times I've got to do-- oh
fudge knuckle.
A linear number of things,
quadratic.
Right?
OK.
So this is again an example,
this was quadratic, and this
one was quadratic.
And I have this, to write it
out, this is order the length
of the list squared, OK?
Just to make it clear
what we're
actually measuring there.
All
right.
Could we do better?
Sure.
And in fact, next time we're
going to show you that n log n
algorithm, but even with bubble
sort, we can do better.

English: 
In a particular, if I look at
those traces, I can certainly
see cases where, man, I already
had the list sorted
much earlier on, and yet I
kept going back to see if
there was anything else
to bubble up.
How would I keep
track of that?
Could I take advantage of that?
Sure.
Why don't I just keep track
on each pass through the
algorithm whether I have
done any swaps?
All right?
Because if I don't do any swaps
on a pass through the
algorithm, then it
says everything's
in the right order.
And so, in fact, the version
that I commented out-- which
is also in your handout and I'm
now going to uncomment,
let's get that one out, get rid
of this one-- notice the
only change.
I'm going to keep track of a
little variable called swap,
it's initially true, and as long
as it's true, I'm going
to keep going, but inside of the
loop I'm going to set it
to false, and only if I do a
swap will I set it to true.
This says, if I go through an
entire pass through the list
and nothing gets changed,
I'm done.

Korean: 
특히, 저 결과들을 살펴보면 확실히 그 경우들을 
볼 수 있고, 제가 이미 전에 리스트들을 정렬해 놓았지만,
버블 정렬 되어야 할 것이  
더 있는지 계속 살펴보았습니다.
어떻게 계속 살펴볼 수 있을까요? 
그것을 이용할 수 있을까요? 
물론이죠.
제가 교환을 이미 끝낸 것인지 아닌지 
각각의 실행마다 살펴보면 어떨까요? 
맞나요?
왜냐하면 제가 바꾸지 않은 것이라면, 
이미 맞는 순서로 되어있다는 
것을 뜻하니까요. 
사실 제가 주석 처리한 것 - 여러분 교재에도 
있는 부분인데요. 주석처리해주시고, 
이 부분을 없애봅시다. 
- 변화를 알아차리셨을 겁니다.
swapped 이라고 불리는 작은 변수를 살펴보겠습니다.  
True 라고 초기화 되어 있고, 그것이 True인 한, 계속 진행하게 됩니다. 
그러나 루프의 안으로 들어가면 False 로 놓이게 되고,
True 일 때에만 교환할 수 있습니다.
만약 전체 리스트를 통과하면 어떠한 것도 
변하지 않는 다는 것을 말해줍니다. 끝난 거죠. 

English: 
And in fact if I do that, and
try test bubble sort, well, in
the first case, looks the same.
Ah.
On the second case, I
spot it right away.
On the third case, it takes me
the same amount of time.
And the fourth case, when
I set it up, I'm done.
OK.
So what's the lesson here?
I can be a little more careful
about keeping track of what
goes on inside of that loop.
If I don't have any more work
to do, let me just stop.
All right.
Nonetheless, even with this
change, what's the order
growth for bubble sort?
Still quadratic, right?
I'm looking for the worst case
behavior, it's still
quadratic, it's quadratic in the
length of the list, so I'm
sort of stuck with that.
Now.
Let me ask you one last
question, and then
we'll wrap this up.
Which of these algorithms
is better?
Insertion sort or bubble sort?
STUDENT: Bubble.
PROFESSOR ERIC GRIMSON:
Bubble.

Korean: 
버블 정렬을 테스트 해보겠습니다.  
첫 번째 경우에는 똑같아 보입니다.
아,     .
두 번째 경우에는. 딱 나왔네요.
세 번째 경우에는 같은 시간이 걸리고요.
네 번째 경우에는 이미 되어있네요. 끝났습니다.
좋습니다. 
그래서 여기서 교훈은 무엇일까요? 
루프 안에서 어떻게 진행되는지 
좀 더 주의 깊게 살펴보았습니다. 
더 할 일이 없으면 여기서 멈추도록 하겠습니다. 
좋습니다. 
그럼에도 불구하고, 버블 정렬의 수행시간에 
대한 성장차수 는 무엇일까요? 
여전히 이차이지요. 
그렇죠? 
제가 최악의 경우를 찾아도, 
그것은 여전히 이차입니다.  
이제,
마지막 질문을 드리겠습니다.  
그리고 수업을 마무리 짓도록 하겠습니다.
이 알고리즘들 중에서 무엇이 가장 나을까요?  
삽입 정렬일까요? 버블 정렬일까요?
학생들: 버블 정렬. 
교수 Eric Grimson: 버블 정렬. 

English: 
Bubble bubble toil
and trouble.
Who said bubble?
Why?
STUDENT: Well, the first
one was too inefficient
[UNINTELLIGIBLE] store and
compare each one, so
[UNINTELLIGIBLE]
PROFESSOR ERIC GRIMSON: It's
not a bad instinct.
Right.
So it-- so, your argument is,
bubble is better because it's
is essentially not doing all
these extra comparisons.
Another way of saying it is,
I can do this stop when
I don't need to.
All right?
OK.
Anybody have an opposing
opinion?
Wow, this sounds like a
presidential debate.
Sorry, I should reward you.
Thank you for that statement.
Anybody have an opposing
opinion?
Everybody's answering these
things and sitting
way up at the back.
Nice catch.
Yeah.
STUDENT: [INAUDIBLE]
PROFESSOR ERIC GRIMSON: I
don't think so, right?
I think selection sort, I
still have to go through

Korean: 
고난도 버블, 재앙도 버블('Double Double toil and trouble', 맥베스). 
누가 버블이라고 했죠? 
왜 그렇죠? 
학생: 음, 첫 번째 것은 너무 비효율 적이기 때문입니다. 
저장하고, 하나씩 비교하거나 
교수 Eric Grimson: 나쁘지 않은 생각입니다. 
좋아요. 
학생이 말하고자 하는 바는 그것이 기본적으로 이런 추가적인 비교들을 
하지 않기 때문에 버블이 더 좋다는 것입니다.  
다른 말로 하면, 필요 없으면 멈출 수 있다.
이거죠. 
맞나요?
네.
반대 의견을 가진 분 계신 가요? 
와우. 대선 토론 같네요. 
죄송합니다. 보상을 해야 하죠. 
의견을 말씀해 주셔서 감사합니다.  
다른 의견 가진 분 안 계신가요?
모두들 이것에 대해 답하고
뒤쪽에 앉아있네요
나이스 캐치! 
네.
교수 :전 그렇게 생각하지는 않습니다. 
제 생각에 선택 정렬은 여러 번 실행되어야 하고, 

English: 
multiple times, it was still
quadratic, OK, but I think
you're heading towards a
direction I want to get at, so
let me prime this
a little bit.
How many swaps do I do in
general in bubble sort,
compared to selection source?
God bless.
Oh, sorry, that wasn't a
sneeze, it was a two?
How many swaps do I
do in bubble sort?
A lot.
Right.
Potentially a lot because I'm
constantly doing that, that
says I'm running that inner loop
a whole bunch of times.
How many swaps do I do
in selection sort?
Once each time.
Right?
I only do one swap potentially,
it-- though not
one potentially, each
time at the end of
the loop I do a swap.
So this actually suggests again,
the orders of growth
are the same, but probably
selection sort is a more
efficient algorithm, because
I'm not doing that constant
amount of work every
time around.
And in fact, if you go look up,
you won't see bubble sort
used very much.
Most--
I shouldn't say most, many
computer scientists don't

Korean: 
여전히 이차여야 합니다. 그렇지만, 학생은 제가  
가고자 하는 방향으로 가고 있는 것 같군요. 
자, 그러면 제가 정보를 좀 더 드리죠.
일반적으로 선택 정렬과 비교해서 버블 정렬은 
몇 번을 교환하게 될까요? ?
오,
죄송합니다. 재채기를 한 게 아니었나요? 2었습니까?
버블 정렬에서 몇 번 교환하게 될까요? 
아주 많이 하겠죠. 
맞습니다. 
잠재적으로 아주 많죠. 왜냐하면 저는 그것을 계속 하게 될 테니까 말입니다. 
그 안쪽 루프에서 매우 여러 번 돌게 될 것입니다.  
선택 정렬에서는 몇 번 교환하게 될까요? 
한 번에 한 번씩입니다. 
맞나요?
잠재적으로 단지 한번 교환을 하게 되죠. 잠재적으로 1번은 아닐지라도,
루프의 끝에서 매번 교환하게 될 것입니다. 
그래서 이것은 사실 수행시간에 대한 성장차수가 같다는 것을 말해줍니다. 
그러나 아마도 선택 정렬은 더 효율적인 알고리즘 일 것입니다.
일정한 양만큼 계속해서 하지는 
않기 때문입니다. 
사실 찾아보면, 버블 정렬이 사용된 것을 
많이 보지 못할 것입니다. 
대부분. - 대부분이라고 말해서는 안 되지만 많은 컴퓨터 과학자들은 

English: 
think it should be taught,
because it's just so
inefficient.
I disagree, because it's a
clever idea, but it's still
something that we have
to keep track of.
All right.
We haven't gotten to our n log n
algorithm, we're going to do
that next time, but I want to
set the stage here by pulling
out one last piece.
OK.
Could we do better in
terms of sorting?
Again, remember what
our goal was.
If we could do sort, then we
saw, if we amortized the cost,
that searching is a lot more
efficient if we're searching a
sorted list.
How could we do better?
Let me set the stage.
I already said, back here, when
I used this board, that
this idea was really
important.
And that's because that is
a version of a divide and
conquer algorithm.
OK.
Binary search is perhaps the
simplest of the divide and
conquer algorithms, and
what does that mean?
It says, in order to solve a
problem, cut it down to a
smaller problem and try
and solve that one.

Korean: 
그것을 배워야 한다고 생각하지는 않습니다. 
왜냐하면 그것은 매우 비효율적이기 때문입니다. 
저는 동의하지는 않습니다. 이것은 영리한 아이디어이고, 
우리가 계속해서 살펴 보아야 할 것입니다.  
좋습니다.
오늘 n log n 알고리즘을 다루지는 않습니다. 다음 시간에 배우게 될 것입니다. 
그러나 n log n 에 대해서 조금 설명하면서 다음 시간에 
잘 이해할 수 있는 토대를 마련하도록 하겠습니다. 
좋습니다. 
우리는 정렬에 관해서 더 잘할 수 있을까요? 
다시, 우리의 목표가 무엇이었는지 기억 하시나요? 
만약 우리가 정렬할 수 있다면, 우리가 비용을 줄일 수 있다면, 
검색은 더 효율적으로 이루어 질 것입니다.  
즉, 우리가 정렬된 리스트를 검색한다면 말이죠. 
어떻게 더 잘 할 수 있을까요? 
다음 시간에 설명할 것에 대해 기본적인 것을 말씀 드리도록 하겠습니다. 
제가 이미 말씀 드렸듯이, 전으로 돌아가서, 이 칠판에 썼던 
아이디어는 정말 중요합니다. 
그것이 divide and conquer 알고리즘에 대한 
아이디어이기 때문입니다. 
네.
이진 탐색은 아마도 divide and conquer 알고리즘에서 가장 단순한  
것일지도 모릅니다. 그것은 무엇을 의미할까요?
즉, 문제를 풀기 위해서는 전체 문제를 작은 문제로 쪼개서 
문제를 해결하는 것을 의미합니다.  

English: 
So to just preface what we're
going to do next time, what
would happen if I wanted to do
sort, and rather than in
sorting the entire list at once,
I broke it into pieces,
and sorted the pieces, and then
just figured out a very
efficient way to bring those two
pieces and merge them back
together again?
Where those pieces, I would do
the same thing with, I would
divide them up into smaller
chunks, and sort those.
Is that going to give me a
more efficient algorithm?
And if you come back
on Thursday,
we'll answer that question.

Korean: 
이것이 다음 시간에 하게 될 내용의 
서문에 해당하는 것이지요. 
정렬이 어떻게 이루어질까요? 
전체 리스트를 한 번에 정렬하기 보다는 
조각으로 나누고 그 조각들을  
각각 정렬하고 다시 
가져와서 합칩니다.
같은 작업을 반복합니다.
이것은 더 효율적인 알고리즘이 될까요?
목요일에 오시면, 
답을 알려드리도록 하겠습니다.
