
English: 
Hi, I’m Carrie Anne, and welcome to CrashCourse
Computer Science!
Over the past two episodes, we got our first
taste of programming in a high-level language,
like Python or Java.
We talked about different types of programming
language statements – like assignments,
ifs, and loops – as well as putting statements
into functions that perform a computation,
like calculating an exponent.
Importantly, the function we wrote to calculate
exponents is only one possible solution.
There are other ways to write this function
– using different statements in different
orders – that achieve exactly the same numerical
result.
The difference between them is the algorithm,
that is the specific steps used to complete
the computation.
Some algorithms are better than others even
if they produce equal results.
Generally, the fewer steps it takes to compute,
the better it is, though sometimes we care
about other factors, like how much memory
it uses.
The term algorithm comes from Persian polymath
Muḥammad ibn Mūsā al-Khwārizmī who was
one of the fathers of algebra more than a
millennium ago.
The crafting of efficient algorithms – a
problem that existed long before modern computers

Korean: 
안녕하세요, 저는 Carrie Anne입니다.
컴퓨터 과학 특강에 오신 것을 환영합니다!
지난 두 편의 강의에서 파이썬이나 자바와 같은 높은 수준의 프로그래밍 언어를 처음 맛보았습니다.
지난 두 편의 강의에서 파이썬이나 자바와 같은 높은 수준의 프로그래밍 언어를 처음 맛보았습니다.
또한 할당문, If문, Loop와 같은 서로 다른 타입의 프로그래밍 언어 문장들을 살펴보았습니다.
그뿐 아니라 문장을 함수로 만들어 
지수 연산과 같은 계산을 수행하도록 하기도 했죠.
그뿐 아니라 문장을 함수로 만들어 
지수 연산과 같은 계산을 수행하도록 하기도 했죠.
중요한 것은, 우리가 지수를 계산하려고 쓴 함수는 
가능한 하나의 해결책 일뿐입니다.
다른 문장을 사용해서 이 함수를 작성하는
 또 다른 방법이 있습니다.
이 함수 역시 정확히 동일한 결과를 얻을 수 있습니다.
그들 사이의 차이점은 알고리즘이라고 하는,
계산을 완성하는데 사용되는 특정 단계 입니다.
그들 사이의 차이점은 알고리즘이라고 하는,
계산을 완성하는데 사용되는 특정 단계 입니다.
일부 알고리즘은 같은 결과를 생산해낼 지라도
 다른 알고리즘보다 우수합니다.
일반적으로 계산에 소요되는 단계가 줄어들수록 
더 좋은 결과를 얻을 수 있지만,
때로는 사용하는 메모리 양과 같은 
다른 요인들을 고려해야 하죠.
알고리즘이라는 용어는 페르시아의 천재였던 Muḥammad ibn Mūsā al-Khwārizmī
천년 전에 대수학의 아버지라 불리던 한 사람에게서 
비롯된 것입니다.
효율적인 알고리즘의 제작
 - 이것은 현대 컴퓨터 이전에 존재 했던 문제였습니다 -

Turkish: 
Merhaba, ben Carrie Anne ve CrashCourse'a hoş geldiniz.
Bilgisayar Bilimi!
Geçtiğimiz iki bölümde, biz ilk
yüksek düzeyde bir dilde programlama tadı,
Python veya Java gibi.
Farklı programlama türlerinden bahsettik
dil ifadeleri - ödevler gibi,
ifs ve loop - ifadeler koymanın yanı sıra
Hesaplama yapan fonksiyonlara
Bir üs hesaplamak gibi.
Önemli olarak, hesaplamak için yazdığımız işlevi
üstler olası bir çözümdür.
Bu işlevi yazmanın başka yolları da var
- farklı ifadeleri farklı kullanmak
emir - bu tamamen aynı sayısal olanı elde etmek
sonuç.
Aralarındaki fark algoritma,
bu, tamamlamak için kullanılan belirli adımlardır.
hesaplama.
Bazı algoritmalar diğerlerinden daha iyidir
eğer eşit sonuçlar üretirlerse.
Genel olarak, hesaplamak için daha az adım atması,
ne kadar iyiyse, bazen önemsiyoruz
diğer faktörler hakkında, ne kadar hafıza
kullanır.
Algoritma terimi Farsça polimattan geliyor
Muammad ibn Mūsā al-Khwārizmī
cebirden bir taneden fazla
bin yıl önce.
Verimli algoritmaların işlenmesi - a
modern bilgisayarlardan çok önce var olan problem

Chinese: 
嗨 我是Carrie Anne 欢迎收看10分钟速成课：计算机科学
在前两集中，我们第一次用高级语言编程
比如 Python 和 Java
我们讨论了几种语句 - 比如赋值语句，if 语句和循环语句
以及把语句放在函数里执行计算操作
比如计算指数
重要的是，我们写的函数只是所有解决方案中的一种
还有其它方案来解决问题
- 用不同的顺序写不同的语句 也能得到一样的结果
不同方案之间的区别是“算法”，算法是完成计算的具体步骤
即便结果一致，但有些算法会更好一些
一般来说，算法的步骤越少越好
虽然有时我们更关心其他因素，比如占多少内存
算法这个术语源于 波斯博识者 阿尔·花拉子密
他是 1000 多年前的代数之父之一
如何想出高效算法 - 是早在现代计算机出现前就存在的问题 -

English: 
– led to a whole science surrounding computation,
which evolved into the modern discipline of…
you guessed it!
Computer Science!
INTRO
One of the most storied algorithmic problems
in all of computer science is sorting… as
in sorting names or sorting numbers.
Computers sort all the time.
Looking for the cheapest airfare, arranging
your email by most recently sent, or scrolling
your contacts by last name -- those all require
sorting.
You might think “sorting isn’t so tough…
how many algorithms can there possibly be?”
The answer is: a lot.
Computer Scientists have spent decades inventing
algorithms for sorting, with cool names like
Bubble Sort and Spaghetti Sort.
Let’s try sorting!
Imagine we have a set of airfare prices to
Indianapolis.
We’ll talk about how data like this is represented
in memory next week, but for now, a series
of items like this is called an array.
Let’s take a look at these numbers to help
see how we might sort this programmatically.
We’ll start with a simple algorithm.
First, let’s scan down the array to find
the smallest number.
Starting at the top with 307.

Korean: 
- 현대 과학 분야로 진화 한 컴퓨팅을 
둘러 싼 전체 과학을 이끌어 냈습니다.
짐작 하시나요!?
컴퓨터 과학입니다!
 
컴퓨터 과학에서 가장 중요한 알고리즘 문제 중 하나는 '정렬'입니다.
이름을 정렬하거나 숫자를 정렬하는 것과 같은 것들이요.
컴퓨터는 항상 정렬합니다.
가장 저렴한 항공 요금을 찾고, 가장 최근에 받은 이메일을 정렬하거나
성씨 순서로 정렬된 연락처를 스크롤하는것 등 
모두 정렬이 필요합니다.
여러분은 "정렬이 그렇게 어렵지 않을 것 같은데,  얼마나 많은 알고리즘이 있을까요? 라고 생각할 수 있습니다.
답은 : 매우 많습니다.
컴퓨터 과학자들은 멋진 이름으로 정렬 알고리즘을 
수십 년 동안 발명해 왔습니다.
버블 정렬, 스파게티 정렬
한 번 정렬 해 봅시다.
인디애나폴리스를 가기 위한 항공 요금 한셋트를 가지고 있다고 상상해 봅시다.
다음주에 메모리 안에서 이러한 데이터들이 어떻게 나타나는지를 살펴볼 거지만, 이번 시간에는
이와 같은 일련의 항목을 배열이라고 합니다.
이 숫자들을 프로그래밍 방식으로 정렬하는 방법을 
살펴 보도록 하겠습니다.
우리는 간단한 알고리즘으로 시작할 것입니다.
먼저 배열을 훑어보며 가장 작은 숫자를 찾아 봅시다.
맨 위의 307부터 시작합니다.

Turkish: 
- Hesaplamayı çevreleyen bütün bir bilime yol açtı,
modern disiplininin içine gelişti…
tahmin ettin!
Bilgisayar Bilimi!
GİRİŞ
En hikayeli algoritmik problemlerden biri
tüm bilgisayar bilimlerinde sıralama…
adları veya numaraları sıralamada.
Bilgisayarlar her zaman sıralar.
En ucuz uçak bileti aranıyor
e-postanızı en son gönderilenler veya kaydırma
Kişilerinizin soyadına göre
sıralama.
“Sıralama zor değil…” diye düşünebilirsiniz.
Kaç tane algoritma olabilir? ”
Cevap: çok fazla.
Bilgisayar Bilimcileri onlarca yılını icat ederek geçirdi
gibi serin isimler ile sıralama için algoritmalar,
Kabarcık Sırala ve Spagetti Sırala.
Sıralamayı deneyelim!
Bir dizi uçak bileti fiyatımız olduğunu hayal edin
Indianapolis.
Bunun gibi verilerin nasıl temsil edildiğinden bahsedeceğiz.
önümüzdeki hafta hafızada, ama şimdilik, bir dizi
Bunun gibi öğelere dizi denir.
Yardım etmek için bu numaralara bir göz atalım
Bunu programlı olarak nasıl sıralayabileceğimizi görün.
Basit bir algoritma ile başlayacağız.
İlk önce diziyi aşağıya tarayalım.
en küçük sayı.
307 ile zirveden başlayarak.

Chinese: 
导致了一个专门研究计算的领域，然后发展成某门现代学科
你猜对了！
计算机科学！
在各种算法中，被记载最多的是"排序"，
比如给名字、数字等东西排序
排序到处都是
找最便宜的机票
按时间排列邮件
按姓氏排列联系人
-这些都需要排序
你可能会想“排序好像不怎么难… 应该没几种算法吧”
答案是：超多
计算机科学家花了数十年发明各种排序算法
还起了酷酷的名字，“冒泡排序”“意面排序”
我们来试试排序！
试想我们有一堆机票价格，都是飞往  印第安纳波利斯 (美国地名)
我们下周再说这类数据怎么在内存中表示
但现在，这样一组数据叫“数组”（Array）
来看一下 我们有什么方法排序
我们先从简单的开始
首先，扫描这个数组找到最小的数，先从最上面的 307 开始

Korean: 
우리가 본 유일한 번호이기 때문에 
또한 가장 작은 수이기도 하죠.
다음은 239이며 307보다 작으므로 
새로운 가장 작은 숫자가됩니다.
다음은 214, 새로운 가장 작은 숫자가 되네요.
250은 가장 작은 숫자가 아니며 
384, 299, 223 또는 312도 아닙니다.
그래서 우리는 모든 숫자를 훑어 보았고 그 중 
214가 가장 작습니다.
이것을 오름차순으로 놓기 위해 우리는
214를 맨 위에있는 번호와 위치를 바꿉니다.
좋습니다.
우리는 하나의 숫자를 정렬했습니다!
이제 동일한 절차를 반복하지만 맨 위에부터 시작하는 
대신 한 칸 아래에서 시작합니다.
이제 동일한 절차를 반복하지만 맨 위에부터 시작하는 
대신 한 칸 아래에서 시작합니다.
먼저 우리의 새로운 가장 작은 숫자가 될 숫자 
239가 보입니다.
나머지 배열을 스캔하면 223이 두 번째 가장 작은 수이므로 2번째 자리에 있는 숫자와 자리를 바꿉니다.
나머지 배열을 스캔하면 223이 두 번째 가장 작은 수이므로 2번째 자리에 있는 숫자와 자리를 바꿉니다.
이제 우리는 세 번째부터 시작하여 다시 반복합니다.
이번에는 239와 307을 바꿉니다.
이 과정은 우리가 마지막 숫자에 도달할 때까지 계속됩니다. 그리고 짠!
배열이 정렬되었고 우리는 인디애나폴리스 행 항공편을 예약 할 준비가 되었습니다!

English: 
It’s the only number we’ve seen, so it’s
also the smallest.
The next is 239, that’s smaller than 307,
so it becomes our new smallest number.
Next is 214, our new smallest number.
250 is not, neither is 384, 299, 223 or 312.
So we’ve finished scanning all numbers,
and 214 is the smallest.
To put this into ascending order, we swap
214 with the number in the top location.
Great.
We sorted one number!
Now we repeat the same procedure, but instead
of starting at the top, we can start one spot
below.
First we see 239, which we save as our new
smallest number.
Scanning the rest of the array, we find 223
is the next smallest, so we swap this with
the number in the second spot.
Now we repeat again, starting from the third
number down.
This time, we swap 239 with 307.
This process continues until we get to the
very last number, and voila, the array is
sorted and you’re ready to book that flight
to Indianapolis!

Turkish: 
Gördüğümüz tek rakam bu, yani
ayrıca en küçük.
Sıradaki 239, bu 307'den küçük.
Böylece yeni en küçük sayımız olur.
Sıradaki 214, en küçük sayımız.
250, 384, 299, 223 veya 312 değildir.
Böylece tüm numaraları taramayı bitirdik.
214 en küçüğüdür.
Bunu artan düzene koymak için, takas ediyoruz
214 numara üst konumda.
Harika.
Bir numara sıraladık!
Şimdi aynı işlemi tekrarlıyoruz, ama bunun yerine
tepeden başlayarak, bir noktadan başlayabiliriz
altında.
İlk önce 239'u görüyoruz, ki yeni olanımız olarak
en küçük sayı
Dizinin geri kalanını tarayarak 223'ü bulduk
Bir sonraki en küçük, bu yüzden bunu takas ediyoruz
ikinci noktadaki sayı.
Şimdi tekrar başlıyoruz, üçüncü baştan
aşağı.
Bu sefer 239'u 307 ile değiştirdik.
Bu süreç biz elde edene kadar devam eder.
çok son sayı ve işte, dizi
sıralanmış ve o uçuş için rezervasyon yapmaya hazırsınız
Indianapolis'e!

Chinese: 
在目前所有"扫描"过数字里面，它最小
下一个是 239，比 307 小
所以目前的最小数是 239
下一个是 214 ，新的最小数
250 不是，384 、 299 、 223 、 312 都不是
所以我们扫描了所有的数字
而 214 是最小的
为了把数组按升序排列（小的在前，大的在后）
我们把 214 和最上面的数字交换
好
我们刚排序了一个数字！
现在重复同样的过程
这次不用从最上面开始，从第二位开始
首先我们看到 239，目前最小的数
扫描数组剩下的部分，我们发现 223 是最小的
所以把它和第 2 位的数字交换
我们继续重复这个过程，这次从第 3 位数字开始
这一次，我们让 239 和 307 互换位置
重复这个过程一直到最后一个数字
瞧，数字排好序了，你也准备好订机票啦

Korean: 
우리가 살펴본 한 과정은 배열을 정렬하는 하나의 방법 
또는 하나의 알고리즘입니다.
우리가 살펴본 한 과정은 배열을 정렬하는 한가지 방법 또는 하나의 알고리즘입니다.
선택 정렬이라고 부르며 꽤 기본적인 것 입니다.
의사 코드를 살펴봅시다.
이 함수는 8, 80 또는 8천만개의 숫자를 정렬하는 데에 
사용할 수 있습니다.
또한 한번 함수를 쓰면 계속해서 다시 쓸 수 있습니다.
이 정렬 알고리즘으로 배열 안의 각 위치를 
맨 위부터 맨 아래까지 순환합니다.
그런 다음 각 위치에 대해 배열에서 위치를 바꿀 
가장 작은 수를 찾을때까지 반복실행 합니다.
그런 다음 각 위치에 대해 배열에서 위치를 바꿀 
가장 작은 수를 찾을때까지 반복실행 합니다.
이 코드에서 FOR 루프가 다른 FOR 루프 안에 포함되어 있는것을 볼 수 있습니다.
이것은 매우 간단히, 우리가 N개의 항목을 정렬하고 싶다면 N 번 반복해야 한다는 것을 의미합니다.
그 안에서 루프를 N번 반복하면 총합은 대략 N *N루프 
또는 N제곱이 됩니다.
그 안에서 루프를 N번 반복하면 총합은 대략 N *N루프 
또는 N제곱이 됩니다.
입력하는 수의 크기와 실행되는 단계 수 사이의 관계는 
선택 정렬 알고리즘의 복잡도를 특징화 합니다.
입력하는 수의 크기와 실행되는 단계 수 사이의 관계는 
선택 정렬 알고리즘의 복잡도를 특징화 합니다.
그것은 얼마나 빨리 또는 느리게 알고리즘이 실행될지 
근사치를 제공합니다.
컴퓨터 과학자들은 이러한 성장 순서를 
"큰 O 표기법" 으로 기록합니다. (농담 아니에요ㅎ)
컴퓨터 과학자들은 이러한 성장 순서를 
"큰 O 표기법" 으로 기록합니다. (농담 아니에요ㅎ)
N 제곱은 특별하게 효율적이지 않습니다.

Chinese: 
刚刚这种方法，或者说算法，
叫“选择排序”
-非常基础的一种算法
以下是“伪代码”
这个函数可以用来排序8个、80个甚至8千万个数字
一旦写好了就可以重复使用
在这个排序算法里，我们从头到尾循环一遍数组
对于每一个位置，都循环一遍数组，找到最小的数字然后互换位置
你可以在代码中看到这一点（一个 for 循环套在另一个 for 循环里）
这意味着
如果我们要为 N 项内容排序，我们就要循环 N 次
而在每一次循环中，我们也要再循环 N 次
总共有 N*N 次循环...
也就是 N ^ 2 次循环
算法的 输入大小 和 运行步骤 之间的关系
代表了算法的 复杂度
表示算法运行速度大致是个什么量级
计算机科学家们把算法复杂度叫
没开玩笑
“大 O 表示法”
算法复杂度为 O（N ^ 2）的算法，效率不高

English: 
The process we just walked through is one
way – or one algorithm – for sorting an
array.
It’s called Selection Sort -- and it’s
pretty basic.
Here’s the pseudo-code.
This function can be used to sort 8, 80, or
80 million numbers - and once you've written
the function, you can use it over and over
again.
With this sort algorithm, we loop through
each position in the array, from top to bottom,
and then for each of those positions, we have
to loop through the array to find the smallest
number to swap.
You can see this in the code, where one FOR
loop is nested inside of another FOR loop.
This means, very roughly, that if we want
to sort N items, we have to loop N times,
inside of which, we loop N times, for a grand
total of roughly N times N loops...
Or N squared.
This relationship of input size to the number
of steps the algorithm takes to run characterizes
the complexity of the Selection Sort algorithm.
It gives you an approximation of how fast,
or slow, an algorithm is going to be.
Computer Scientists write this order of growth
in something known as – no joke – “big
O notation”.
N squared is not particularly efficient.

Turkish: 
Daha yeni yürüdüğümüz süreç
yolu - veya bir algoritma - sıralamak için
dizi.
Buna Seçim Sıralama denir - ve
oldukça basit.
İşte sözde kodu.
Bu işlev 8, 80 veya
80 milyon numara - ve bir kere yazdın
fonksiyonu, tekrar tekrar kullanabilirsiniz.
tekrar.
Bu sıralama algoritması ile döngü boyunca ilerliyoruz
dizideki her konum, üstten alta,
ve sonra bu pozisyonların her biri için
en küçükleri bulmak için dizi içinde dolaşmak
değiştirilecek sayı.
Bunu kodun içinde görebilirsiniz.
döngü başka bir FOR döngüsünün içine yerleştirilir.
Bunun anlamı, kabaca, eğer istersen
N maddeyi sıralamak için N kere tekrar etmeliyiz.
bunun içinde N kez döngü yapıyoruz.
kabaca N kere toplam N döngü ...
Veya N kare.
Bu girdi büyüklüğü ile sayı arasındaki ilişki
algoritma karakteristiklerini çalıştırmak için gerekli adımların
Seçim Sıralama algoritmasının karmaşıklığı.
Size ne kadar hızlı olduğuna dair bir yaklaşım verir.
ya da yavaş, bir algoritma olacak.
Computer Scientists bu büyüme sırasını yazdı
bilinen bir şeyde - şaka yok - “büyük
O gösterimde ”.
N karesi özellikle verimli değil.

English: 
Our example array had n = 8 items, and 8 squared
is 64.
If we increase the size of our array from
8 items to 80, the running time is now 80
squared, which is 6,400.
So although our array only grew by 10 times
- from 8 to 80 – the running time increased
by 100 times – from 64 to 6,400!
This effect magnifies as the array gets larger.
That’s a big problem for a company like
Google, which has to sort arrays with millions
or billions of entries.
So, you might ask, as a burgeoning computer scientist, is there a more efficient sorting algorithm?
Let’s go back to our old, unsorted array
and try a different algorithm, merge sort.
The first thing merge sort does is check if
the size of the array is greater than 1.
If it is, it splits the array into two halves.
Since our array is size 8, it gets split into
two arrays of size 4.
These are still bigger than size 1, so they
get split again, into arrays of size 2, and
finally they split into 8 arrays with 1 item
in each.
Now we are ready to merge, which is how “merge
sort” gets its name.
Starting with the first two arrays, we read
the first – and only – value in them,

Turkish: 
Örnek dizimiz n = 8 öğe ve 8 kare idi
64.
Dizimizin boyutunu arttırırsak,
80'e 8 ürün, çalışma süresi şimdi 80
6.400 olan kare.
Bu yüzden dizimiz sadece 10 kat arttı
- 8'den 80'e kadar - çalışma süresi arttı
100 kez - 64 - 6,400!
Dizi büyüdükçe bu etki büyür.
Bu gibi bir şirket için büyük bir sorun
Milyonlarla dizileri sıralamak zorunda olan Google
veya milyarlarca giriş.
Öyleyse, gelişen bir bilgisayar bilimcisi olarak daha verimli bir sıralama algoritması olup olmadığını sorabilirsiniz.
Eski, sıralanmamış dizimize geri dönelim
ve farklı bir algoritma deneyin.
Birleştirme sıralama yapar ilk şey olup olmadığını kontrol etmektir
dizinin boyutu 1'den büyük.
Eğer öyleyse, diziyi iki yarıya böler.
Dizimizin boyutu 8 olduğundan, ayrılır
4 boyutlu iki dizi.
Bunlar hala 1 numaradan daha büyük, bu yüzden onlar
yeniden boyutlandırmak, boyut 2 dizileri içine ve
Sonunda 1 maddeyle 8 diziye ayrıldılar
her birinde.
Şimdi birleşmeye hazırız, bu nasıl “birleşiyor”
sort ”adını alır.
İlk iki diziden başlayarak, okuduk
bunlardaki ilk ve tek - değer,

Korean: 
우리가 살펴본 예제 배열에는 n = 8 개 항목이 있으므로 
8의 제곱은 64 입니다.
배열의 크기를 8에서 80으로 늘이면, 
실행 시간은 이제 80의 제곱인
6400 입니다.
비록 우리의 배열은 단지 8에서 80으로 10 배 증가했지만 실행 시간은 100배 증가했습니다. 64에서 6400으로요!
비록 우리의 배열은 단지 8에서 80으로 10 배 증가했지만 실행 시간은 100배 증가했습니다. 64에서 6400으로요!
이것의 영향은 배열이 커질수록 확대됩니다.
Google과 같은 회사에게는 큰 문제죠. 그들은 수백만 개 또는 수십억 개의 항목으로 배열을 정렬해야합니다.
Google과 같은 회사에게는 큰 문제죠. 그들은 수백만 개 또는 수십억 개의 항목으로 배열을 정렬해야합니다.
아마, 여러분은 급성장하는 컴퓨터 과학자로서 더 효율적인 정렬 알고리즘이 있을지 질문 할 것입니다.
다시 예전의 분류되지 않은 배열로 돌아가서 
다른 알고리즘인 합병정렬을 해 봅시다.
합병정렬은 첫 번째 작업으로 
배열의 크기가 1보다 큰지 확인합니다.
1보다 큰 경우 배열을 두 개로 나눕니다.
배열의 크기가 8이므로 
크기가 4인 두개의 배열로 쪼개집니다.
이들은 크기 1보다 여전히 크기 때문에
다시 크기가 2 인 배열로 나눠집니다.
마지막에 각각 1개의 항목인 8 개의 배열로 분해됩니다.
이제 합병이라는 이름을 얻게 된 
합병정렬을 할 준비가되었습니다.
처음 두 배열을 시작으로 첫 번째 값이자 유일한 값인 
(이 경우 307과 239)를 읽습니다.

Chinese: 
假设数组有 8 个元素（n = 8），而 8 ^ 2 是 64
如果我们将大小从 8 个增加到 80 个
运行时间就变成了 80 ^ 2 = 6400
虽然我们的数组大小只增长了 10 倍（从 8 到 80 ）
但运行时间却增加了 100 倍！（从 64 到 6400 ）
随着数组增大，对算法运行效率的影响会越变越大
这对“谷歌”这样的公司来说是个大问题
他们要对数百万乃至数十亿条目进行排序
作为未来的计算机科学家你可能会问：有没有更高效的排序算法？
让我们回到那个未排序的数组
试一下另一个算法，“归并排序”
“归并排序”做的第一件事是 检查数组大小是否大于 1
如果是，它会把数组分成两半
由于我们的数组大小是 8
它被分成两个大小为 4 的数组
但它们仍然大于 1
所以它们再次分成大小为 2 的数组
最后变成 8 个数组，每个数组的大小为 1
现在我们准备好合并了，这就是“归并排序”名字的由来
从前两个数组开始，我们读取它们的第一个（也是唯一的）值

English: 
in this case, 307 and 239.
239 is smaller, so we take that value first.
The only number left is 307, so we put that
value second.
We’ve successfully merged two arrays.
We now repeat this process for the remaining
pairs, putting them each in sorted order.
Then the merge process repeats.
Again, we take the first two arrays, and we
compare the first numbers in them.
This time its 239 and 214.
214 is lowest, so we take that number first.
Now we look again at the first two numbers
in both arrays: 239 and 250.
239 is lower, so we take that number next.
Now we look at the next two numbers: 307 and
250.
250 is lower, so we take that.
Finally, we’re left with just 307, so that
gets added last.
In every case, we start with two arrays, each
individually sorted, and merge them into a
larger sorted array.
We repeat the exact same merging process for
the two remaining arrays of size two.
Now we have two sorted arrays of size 4.

Korean: 
처음 두 배열을 시작으로 첫 번째 값이자 유일한 값인 
(이 경우 307과 239)를 읽습니다.
239는 더 작으므로 먼저 그 값을 가져옵니다.
남은 번호는 307 뿐이므로 두번째 값으로 집어넣습니다.
두 개의 배열을 성공적으로 병합했습니다.
이제 남겨진 쌍들에 대해서 이 과정을 반복하며 
그들을 정렬된 순서로 놓습니다.
그런 다음 합병 과정이 반복됩니다.
다시, 첫 번째 두 배열을 취해서
그 안에 있는 첫 번째 숫자를 비교하십시오.
이번에는 239 와 214입니다.
214가 제일 작기 때문에 번호를 첫 번째로 가져옵니다.
이제 두 배열에서 처음 두 숫자를 다시 살펴 봅니다.
239와 250죠.
239가 더 작으므로 그 숫자를 다음으로 가져옵니다.
다음 두 숫자를 봅시다. 307과 250.
250이 더 작으니 이걸 가져갑니다.
마지막으로 307만 남았으므로
끝부분에 추가하면 됩니다.
모든 경우에서 두 개의 배열로 시작합니다.
개별적으로 정렬하고 이들을 합병하여
더 크게 정렬된 배열로 만듭니다.
크기가 2인 남아있는 배열들에 대하여 
똑같은 합병 과정을 반복합니다.
이제 크기가 4인 두 개의 정렬 된 배열이 있습니다.

Turkish: 
bu durumda, 307 ve 239.
239 daha küçük, bu yüzden ilk önce bu değeri alıyoruz.
Geriye kalan tek sayı 307, bu yüzden koyduk
ikinci değer.
İki diziyi başarıyla birleştirdik.
Şimdi bu süreci kalanlar için tekrarlıyoruz.
çiftler, her birini sırayla dizmek
Sonra birleştirme işlemi tekrarlar.
Yine ilk iki diziyi alıyoruz ve
İçlerindeki ilk sayıları karşılaştırır.
Bu sefer 239 ve 214.
214 en düşük olduğu için ilk önce bu sayıyı alıyoruz.
Şimdi ilk iki sayıya tekrar bakıyoruz
her iki dizide: 239 ve 250.
239 daha düşük, o zaman bir sonraki sayıyı alıyoruz.
Şimdi sonraki iki sayıya bakalım: 307 ve
250.
250 daha düşük, bunu alıyoruz.
Sonunda sadece 307 ile ayrıldık.
en son eklenir.
Her durumda, her biri iki dizi ile başlıyoruz.
tek tek sıralanmış ve bunları bir
büyük sıralama dizisi.
İçin aynı birleştirme işlemini tekrarlıyoruz.
iki boyutta kalan iki dizi.
Şimdi 4 boyutunda iki sıralama dizisine sahibiz.

Chinese: 
也就是 307 和 239
239 更小，所以我们把这个值放前面
而剩下的唯一数字是 307 ，所以把这个值放在第二位
我们成功合并了两个数组
现在对剩下的数组重复这个过程，将它们按序排列
然后再重复合并的过程
同样，取前两个数组，比较第一个数
这次是 239 和 214
214 更小，所以放前面
再看两个数组中前两个数：239 和 250
239 更小，所以放下一位
现在来看剩下的两个数字：307 和 250
250 更小，所以放到下一位
最后只剩下 307 ，所以放最后
每个循环开始时，取两个数组排序
然后合并成一个更大的有序数组
我们对剩下两个大小为 2 的数组重复这个过程
现在有两个大小为 4 的有序数组

Korean: 
이전과 마찬가지로 합병하여 각 배열의 첫째 두개의 숫자를 비교하여 더 낮은 수를 가져옵니다.
이전과 마찬가지로 합병하여 각 배열의 첫째 두개의 숫자를 비교하여 더 낮은 수를 가져옵니다.
모든 숫자가 합병될 때까지 이 작업을 반복합니다. 
배열은 완전히 다시 정렬됩니다!
나쁜 소식은 몇 번을 정렬하든 여러분은 인디애나 폴리스에 가려면 여전히 $214를 지불해야 한다는 것입니다.
나쁜 소식은 몇 번을 정렬하든 여러분은 인디애나 폴리스에 가려면 여전히 $214를 지불해야 한다는 것입니다.
어쨌든 "Big O" 합병 정렬의 계산 복잡도는
N*logN 입니다.
N은 비교하고 합병하는 데에 필요한 횟수만큼 발생합니다.
이 횟수는 정렬 안의 배열 항목 수와 직접 비례합니다.
로그 N은 병합 단계의 수에서 나옵니다.
이 예에서는 8개의 항목인 배열을 4개로, 2개로, 1개로 
쪼개었습니다.
3번을 쪼갰습니다.
이런 식으로 반으로 나누는 것은 항목 수 사이에 
로그관계를 가지고 있습니다.
절 믿으세요!
2를 밑수로 하는 Log 8은 3 과 같습니다.
항렬의 크기를 두배인 16으로 하면 정렬할 항목 수는 
두 배가 늘어납니다.
2를 밑수로 하는 Log 16은 4 이므로,  분할 단계 횟수는 1이 증가합니다.
배열의 크기를 8에서 1,000배인 8000으로 늘려도 
분할 단계 수는 꽤 낮습니다.
배열의 크기를 8에서 1,000배인 8000으로 늘려도 
분할 단계 수는 꽤 낮습니다.
2를 밑수로 하는 로그 8000은 대략 13 이죠.

English: 
Just as before, we merge, comparing the first
two numbers in each array, and taking the
lowest.
We repeat this until all the numbers are merged,
and then our array is fully sorted again!
The bad news is: no matter how many times
we sort these, you’re still going to have
to pay $214 to get to Indianapolis.
Anyway, the “Big O” computational complexity
of merge sort is N times the Log of N.
The N comes from the number of times we need
to compare and merge items, which is directly
proportional to the number of items in the
array.
The Log N comes from the number of merge steps.
In our example, we broke our array of 8 items
into 4, then 2, and finally 1.
That’s 3 splits.
Splitting in half repeatedly like this has
a logarithmic relationship with the number
of items - trust me!
Log base 2 of 8 equals 3 splits.
If we double the size of our array to 16 – that's
twice as many items to sort – it only increases
the number of split steps by 1 since log base
2 of 16 equals 4.
Even if we increase the size of the array
more than a thousand times, from 8 items to
8000 items, the number of split steps stays
pretty low.
Log base 2 of 8000 is roughly 13.

Chinese: 
像以前一样，我们比较每个数组中的前两个数字，然后取最小的数字
重复这个过程直到所有数字合并在一起
这样数组就排好序啦！
但坏消息是：
无论我们排序多少次
你还是要付 214 美元才能到达 印第安纳波利斯
总之，“归并排序”的算法复杂度是 O（N * Log(N)）
“N” 是我们要 比较元素+合并元素 的次数
这和数组元素数量成正比
“log(N)”是合并步骤的数量
在我们的例子中，我们把大小为 8 的数组分成4个数组
然后分成 2 个，最后再分成 1 个
这样就分了 3 次
重复对半分割的操作 与 元素数量 成对数关系
相信我！
log(8) = 3
如果我们将数组大小变成 16
- 之前的两倍
也只需要多 1 次分割
因为 log(16) = 4
即使把数组大小扩大一千多倍
从8个元素到8000个元素，分割步骤的数量也不会增大多少
log(8000) 大约为 13

Turkish: 
Tıpkı eskisi gibi, ilkini karşılaştırarak birleşiyoruz
Her dizideki iki sayı ve
en düşük.
Tüm sayılar birleştirilene kadar bunu tekrarlıyoruz,
ve sonra dizimiz tekrar tam olarak dizildi!
Kötü haber şudur: kaç kere olursa olsun
Bunları sıralarız, sen hala sahip olacaksın
Indianapolis’e gitmek için 214 dolar ödemek.
Her neyse, “Büyük O” hesaplama karmaşıklığı
birleştirme sıralaması N'nin logosunun N katıdır.
N, ihtiyacımız olan sayıdan geliyor.
doğrudan olan öğeleri karşılaştırmak ve birleştirmek için
içindeki öğelerin sayısıyla orantılı
dizi.
Günlük N, birleştirme adımlarının sayısından gelir.
Örneğimizde 8 maddeden oluşan dizimizi kırdık
4'e, sonra 2'ye ve sonunda 1'e.
3 bölme var.
Bu gibi tekrar tekrar ikiye bölme
sayı ile logaritmik bir ilişki
Eşyaların - güven bana!
Log bankası 2/8, 3 bölmeye eşittir.
Dizimizin boyutunu 16'ya çıkarsak - bu
sıralamak için iki kat daha fazla öğe - yalnızca artar
log tabanından beri adım adım 1'e bölünme sayısı
16'nın 2'si 4'e eşittir.
Dizinin boyutunu arttırsak bile
8 maddeden bine fazla
8000 ürün, bölünmüş adım sayısı kalır
oldukça düşük.
Kütük kaidesi 8000/8, kabaca 13'tür.

Turkish: 
Bu fazla, ama 3'ten fazla değil - hakkında
dört kat daha büyük - ve yine de sıralama yapıyoruz
çok daha fazla numara.
Bu nedenle, birleştirme sıralama çok daha verimli
seçim sırasından daha.
Ve şimdi seramik kedi koleksiyonumu koyabilirim
adına sırayla daha hızlı!
Kelimenin tam anlamıyla onlarca sıralama algoritması var
inceleyebiliriz ama bunun yerine taşımak istiyorum
benim favori klasik kategorimde
algoritmik problemler: grafik araması!
Grafik, birbirine bağlı bir düğüm ağıdır.
çizgiler.
Şehirleri ile bir harita gibi düşünebilirsiniz
ve onları birbirine bağlayan yollar.
Bu şehirler arasındaki yollar farklı
zaman miktarları.
Her satırı, adlandırılmış olanla etiketleyebiliriz.
bir maliyet veya ağırlık.
Bu durumda, seyahat haftaları.
Şimdi en hızlıyı bulmak istediğimizi varsayalım.
ulaşmak için Highgarden'daki bir ordunun güzergahı
Winterfell adlı kalede.
En basit yaklaşım sadece denemek olacaktır
Her bir yol ayrıntılı olarak hesaplanır ve hesaplanır
her birinin toplam maliyeti.
Bu kaba kuvvet yaklaşımı.
Bir kaba kuvvet yaklaşımı kullanabilirdik
sıralamada, her birini sistematik olarak deneyerek
dizinin permütasyonu olup olmadığını kontrol etmek
sıralanmış.
Bu bir N faktöriyel karmaşıklığa sahip olacaktı
- bu düğüm sayısıdır, çarpı bir kez,
ondan bir kez daha az, vb.
1.

Korean: 
그 이상이지만, 3보다 훨씬 크진 않은데요, 
약 4배정도가 커졌습니다.
그럼에도 불구하고 우리는 더 많은 숫자를 정렬합니다.
이러한 이유로 병합 정렬이 
선택 정렬보다 훨씬 효율적입니다.
그리고 이제는 세라믹 고양이 컬렉션을 이름 순서대로 
더 빨리 정렬할 수 있습니다.
정말, 함께 살펴볼 수 있는 수십 개의 
정렬 알고리즘이 있지만 그 대신에,
제가 가장 좋아하는 고전 알고리즘 분야의 문제인 그래픽 탐색을 함께 해보길 원합니다.
그래프는에 의해 선으로 연결된 노드 네트워크입니다.
도시와 그들을 연결하는 도로로 된 지도와 비슷하다고 
생각해도 무관합니다.
도시들 간의 경로는 각각 다른 시간이 걸립니다.
비용이나 무게로 각각의 선을 이름붙일 수 있습니다.
이 경우에, 여행하는 데 걸리는 주입니다.
이제 Highgarden에 있는 군대가 Winterfell의 성까지 가장 빠른 경로를 찾고 싶다고 가정해 봅시다.
이제 Highgarden에 있는 군대가 Winterfell의 성까지 가장 빠른 경로를 찾고 싶다고 가정해 봅시다.
가장 간단한 방법은 모든 단일 경로를 철저히 조사하고 
각각의 총 비용을 계산하는 것 입니다.
가장 간단한 방법은 모든 단일 경로를 철저히 조사하고 
각각의 총 비용을 계산하는 것 입니다.
이것은 무차별적 접근이라고 합니다.
체계적으로 모든 순열을 검사하여 정렬 여부를 확인함으로써 무차별적 접근 방식을 사용할 수도 있습니다.
체계적으로 모든 순열을 검사하여 정렬 여부를 확인함으로써 무차별적 접근 방식을 사용할 수도 있습니다.
이것은 N  팩토리얼의 복잡성을 가질 것입니다.
N팩토리얼이란 노드의 수인 N부터 시작해서 N보다1작은수, 그보다 1작은수, 계속해서 1까지 곱한 수를 말합니다.

English: 
That's more, but not much more than 3 -- about
four times larger – and yet we’re sorting
a lot more numbers.
For this reason, merge sort is much more efficient
than selection sort.
And now I can put my ceramic cat collection
in name order MUCH faster!
There are literally dozens of sorting algorithms
we could review, but instead, I want to move
on to my other favorite category of classic
algorithmic problems: graph search!
A graph is a network of nodes connected by
lines.
You can think of it like a map, with cities
and roads connecting them.
Routes between these cities take different
amounts of time.
We can label each line with what is called
a cost or weight.
In this case, it’s weeks of travel.
Now let’s say we want to find the fastest
route for an army at Highgarden to reach the
castle at Winterfell.
The simplest approach would just be to try
every single path exhaustively and calculate
the total cost of each.
That’s a brute force approach.
We could have used a brute force approach
in sorting, by systematically trying every
permutation of the array to check if it’s
sorted.
This would have an N factorial complexity
- that is the number of nodes, times one less,
times one less than that, and so on until
1.

Chinese: 
之前8个元素3步，现在8000个元素13步，只是4倍多一点
然而我们排序的元素多得多
因此“归并排序”比“选择排序”更有效率
这下我把陶瓷猫根据名字排列的速度就更快了！
我们可以讲好几十种排序算法，但没那个时间
我想谈谈我最喜欢的经典算法问题：
“图搜索”
“图”是用线连起来的一堆“节点”
你可以想成地图，每个节点是一个城市，节点间的线是公路
从一个城市到另一个城市，每条线需要的时间不同
我们可以用“成本(cost)”或“权重(weight)”来称呼。
在这个例子里，数字代表需要几个星期能到。
假设我们想找从“高庭”到“凛冬城”的最快路线
最简单的方法是尝试每一条路
计算每种选择的总成本
这是种蛮力方法
假设我们用蛮力方法来排序数组
尝试每一种排列组合，看是否排好了序
这样做的时间复杂度是 O( N! )
N 是图里节点的数量，N! 代表 N 乘以 N-1 , 然后乘 N-2 ... 一直乘到 1

Korean: 
N 제곱보다 더 나쁜 방법이네요.
그러나 우리는 더 영리 하게 할 수 있습니다.
이 그래픽 문제의 고전적인 알고리즘 해법은 컴퓨터 과학의 실습 및 이론에서 가장 위대한 지성인 중 한명이었던
Edsger Dijkstra가 발명해냈습니다
그래서 적당히 Dijkstra의 알고리즘이라
 이름 붙여졌습니다.
먼저 Highgarden에서 0의 값으로 시작하는 것을 
노드 안에 표시를 하겠습니다.
지금은 다른 모든 도시는 물음표가 표시되어 있는데,
우리는 아직 그 곳들로의 도착 값을 알지 못합니다.
지금은 다른 모든 도시는 물음표가 표시되어 있는데,
우리는 아직 그 곳들로의 도착 값을 알지 못합니다.
Dijkstra의 알고리즘은 항상 
값이 가장 낮은 노드에서 시작합니다.
이 경우에는 하나의 노드에 대해서만 알고 있으므로, Highgarden에서 시작합니다.
해당 노드에 한 단계 떨어져서 연결되어 있는 모든 노드로의 길을 하나씩 따라 가며
각 노드에 도달하기 위한 값을 기록합니다.
알고리즘의 한 단계가 완료됩니다.
아직 Winterfell에 도착하지 못했으므로, 
Dijkstra의 알고리즘을 반복 실행합니다.
Highgarden을 이미 확인한 상태에서, 다음
최저 값 노드는 King 's Landing입니다.
이전과 마찬가지로, 모든 방문하지 않은
연결된 도시로 따라갑니다.
The Trident 선의 값은 5입니다.
그러나 우리는 Highgarden에서부터 드는 
값을 보기 때문에 총 값을 계산합니다.
The Trident 는 8+5로 13주 입니다.

English: 
Which is way worse than even N squared.
But, we can be way more clever!
The classic algorithmic solution to this graph
problem was invented by one of the greatest
minds in computer science practice and theory,
Edsger Dijkstra, so it’s appropriately named
Dijkstra's algorithm.
We start in Highgarden with a cost of 0, which
we mark inside the node.
For now, we mark all other cities with question
marks - we don’t know the cost of getting
to them yet.
Dijkstra's algorithm always starts with the
node with lowest cost.
In this case, it only knows about one node,
Highgarden, so it starts there.
It follows all paths from that node to all
connecting nodes that are one step away, and
records the cost to get to each of them.
That completes one round of the algorithm.
We haven’t encountered Winterfell yet, so
we loop and run Dijkstra's algorithm again.
With Highgarden already checked, the next
lowest cost node is King's Landing.
Just as before, we follow every unvisited
line to any connecting cities.
The line to The Trident has a cost of 5.
However, we want to keep a running cost from
Highgarden, so the total cost of getting to
The Trident is 8 plus 5, which is 13 weeks.

Turkish: 
N kareden bile daha kötü.
Ancak, daha akıllı olabiliriz!
Bu grafiğe klasik algoritmik çözüm
sorun en büyüklerinden biri tarafından icat edildi
bilgisayar bilimleri pratiğinde ve teoride beyinler,
Edsger Dijkstra, bu yüzden uygun şekilde adlandırılmış
Dijkstra'nın algoritması.
Highgarden'da 0 ile başlıyoruz.
düğümün içini işaretleriz.
Şimdilik, diğer bütün şehirleri soruyla işaretledik
işaretleri - almanın maliyetini bilmiyoruz
onlara henüz.
Dijkstra'nın algoritması her zaman ile başlar
en düşük maliyetli düğüm.
Bu durumda, sadece bir düğümü bilir,
Highgarden, o yüzden orada başlar.
Bu düğümden herkese giden tüm yolları izler
bir adım ötedeki bağlantı düğümlerini ve
her birine alma maliyetini kaydeder.
Bu algoritmanın bir turunu tamamlar.
Winterfell ile henüz karşılaşmadık.
Dijkstra'nın algoritmasını tekrar tekrar kullanıyoruz.
Highgarden daha önceden kontrol edilmişken
en düşük maliyetli düğüm King's Landing'dir.
Tıpkı eskisi gibi, ziyaret etmeyenleri takip ediyoruz
herhangi bir bağlı şehirlere
The Trident hattının maliyeti 5.
Bununla birlikte, işletme maliyetini bir değerden korumak istiyoruz.
Highgarden, bu yüzden toplam maliyet
Trident 8 artı 5'tir, 13 haftadır.

Chinese: 
这种方法比 O( N ^ 2 ) 还要糟糕得多
但我们可以更聪明些！
解决这个问题的经典算法是由
理论计算机科学中最伟大的头脑之一
Edsger Dijkstra 发明的
所以这个算法叫 “Dijkstra 算法”
我们从“高庭”开始，此时成本为0，我们将 0 标记在节点里
同时把其他城市节点标为问号，因为我们不知道到达这些城市的成本
“Dijkstra 算法”始终以成本最低的节点开始
这种情况下，它只知道一个节点
“高庭”，所以从那里开始
算法记录起点到所有相邻节点的成本
这就完成了一轮算法
但是我们还没到“凛冬城”
所以再次运行“Dijkstra 算法”
“高庭”已经检查过了
下一个最低成本节点是“君临城” （King's Landing）
像之前一样，记录所有临近节点的成本
到达“三叉戟河”的成本为 5
我们想记录从“高庭”到这里的成本
所以“三叉戟河”的总成本是 8+5 = 13 周
现在走另一条路到“奔流城”

English: 
Now we follow the offroad path to Riverrun,
which has a high cost of 25, for a total of 33.
But we can see inside of Riverrun that we’ve
already found a path with a lower cost of
just 10.
So we disregard our new path, and stick with
the previous, better path.
We’ve now explored every line from King's
Landing and didn’t find Winterfell, so we
move on.
The next lowest cost node is Riverrun, at
10 weeks.
First we check the path to The Trident, which
has a total cost of 10 plus 2, or 12.
That’s slightly better than the previous
path we found, which had a cost of 13, so
we update the path and cost to The Trident.
There is also a line from Riverrun to Pyke
with a cost of 3.
10 plus 3 is 13, which beats the previous
cost of 14, and so we update Pyke's path and
cost as well.
That’s all paths from Riverrun checked...
so... you guessed it, Dijkstra's algorithm
loops again.
The node with the next lowest cost is The
Trident and the only line from The Trident
that we haven’t checked is a path to Winterfell!
It has a cost of 10, plus we need to add in
the cost of 12 it takes to get to The Trident,
for a grand total cost of 22.
We check our last path, from Pyke to Winterfell,
which sums to 31.

Chinese: 
这条路的成本高达 25 ，总成本为 33
但是我们已经在“奔流城”存了最低成本 10
所以无视新路线
用以前成本更低的路
现在已经遍历了“君临城”的每一条路线，但还是没到“凛冬城”
所以我们继续
下一个最低成本节点是“奔流城”，需要 10 周
首先我们检查到“三叉戟河”的成本为 10+2 = 12
比之前成本 13 的路稍好
所以更新“三叉戟河”的成本
从“奔流城”到“派克城”也有一条路，成本为3
10+3 = 13 ，而以前的成本是 14
所以我们更新“派克城”的成本
从“奔流城”出发的所有路径都走遍了，但还是没到“凛冬城”
你猜对了“Dijkstra 算法”会再循环一遍
现在成本最低的节点是“三叉戟河”
而从“三叉戟河”出发的，我们唯一没检查过的路，通往“凛冬城”！
它的成本是 10
再加上到“三叉戟河”的成本 12
总成本为 22
我们再检查最后一条路，“派克城”到“凛冬城”，成本 31

Korean: 
이제 우리는 Riverrun으로 가는 오프로드 경로를 따라가 봅니다. 25의 높은 값을 가지고 있으며 총합은 33입니다.
그러나 우리는 Riverrun 안에 10밖에 안 되는 
더 작은 값을 가진 경로를 발견했음을 알 수 있습니다.
그러나 우리는 Riverrun 안에 10밖에 안 되는 
더 작은 값을 가진 경로를 발견했음을 알 수 있습니다.
그래서 우리는 새로운 길을 무시하고
이전의 더 나은 길을 지키도록 하죠.
이제 King's Landing의 모든 길을 살펴 보았고, 
Winterfell에 도착하지 못했습니다.
계속 진행하도록 하겠습니다.
다음으로 가장 수가 작은 노드는 Riverrun의 10주입니다.
먼저 우리는 The Trident로의 경로를 확인합니다.
10 + 2, 또는 12의 값을 갖습니다.
이전에 발견했던 13의 값보다 약간 나아졌으므로,
The Trident에 대한 경로와 비용을 업데이트합니다.
Riverrun에서 Pyke으로의 선의 값은 3입니다.
10 + 3은 13이며 이전의 값은 14이므로 
Pyke의 경로와 값을 업데이트 합니다.
10 + 3은 13이며 이전의 값은 14이므로 
Pyke의 경로와 값을 업데이트 합니다.
여기까지가 Riverrun에서 확인한 모든 경로입니다. 
그 다음은, 짐작하시겠지만
Dijkstra의 알고리즘 루프가 다시 반복됩니다.
다음으로 비용이 가장 낮은 노드는 The Trident이며, 우리가 아직 확인하지 않은 The Trident의 경로는 유일하게
Winterfell로 가는 길입니다!
그것은 10의 값을 갖고 있고 The Trident에 도착하는 데 드는 비용인 12를 더해야 합니다.
총 값은 22입니다.
Pyke에서 Winterfell까지 마지막 경로를 확인하면 
합은 31입니다.

Turkish: 
Şimdi Riverrun'a giden offroad yolunu takip ediyoruz.
toplam maliyeti 25 olan yüksek bir bedeli var.
Ama Riverrun’un içinde olduğumuzu görebiliriz.
zaten daha düşük maliyetli bir yol bulmuş
sadece 10.
Bu yüzden yeni yolumuzu göz ardı ediyoruz ve buna bağlı kalıyoruz
önceki, daha iyi yol.
King'in her hattını şimdi araştırdık
İniş ve Winterfell'i bulamadık.
Devam et.
Bir sonraki en düşük maliyet düğümü, Riverrun’da
10 hafta
İlk önce The Trident’e giden yolu kontrol ediyoruz.
toplam maliyeti 10 artı 2 veya 12'dir.
Bu öncekinden biraz daha iyi
bulduğumuz yol, ki bunun maliyeti 13 oldu, yani
yolu ve maliyeti The Trident olarak güncelleriz.
Riverrun'dan Pyke'ye bir hat var.
3 maliyeti ile.
10 artı 3 13 olur, bu önceki sayıyı yener
maliyeti 14 ve bu yüzden Pyke'nin yolunu güncelledik ve
aynı zamanda maliyet.
Riverrun'dan bütün yollar kontrol edildi ...
Yani ... tahmin ettin, Dijkstra'nın algoritması.
tekrar döngüler.
Bir sonraki en düşük maliyetli düğüm:
Trident ve The Trident'ten tek hat
biz kontrol etmedik ki Winterfell'e giden yol!
10'a mal oluyor, artı eklememiz gerek
The Trident'e ulaşmak için gereken 12 maliyet,
22 toplam maliyeti için.
Pyke'den Winterfell'e kadar son yolumuzu kontrol ediyoruz.
31'e karşılık geliyor.

English: 
Now we know the lowest total cost, and also
the fastest route for the army to get there,
which avoids King’s Landing!
Dijkstra's original algorithm, conceived in
1956, had a complexity of the number of nodes
in the graph squared.
And squared, as we already discussed, is never
great, because it means the algorithm can’t
scale to big problems - like the entire road
map of the United States.
Fortunately, Dijkstra's algorithm was improved
a few years later to take the number of nodes
in the graph, times the log of the number
of nodes, PLUS the number of lines.
Although this looks more complicated, it’s
actually quite a bit faster.
Plugging in our example graph, with 6 cities
and 9 lines, proves it.
Our algorithm drops from 36 loops to around 14.
As with sorting, there are innumerable graph search algorithms, with different pros and cons.
Every time you use a service like Google Maps
to find directions, an algorithm much like
Dijkstra's is running on servers to figure
out the best route for you.
Algorithms are everywhere and the modern world
would not be possible without them.
We touched only the very tip of the algorithmic
iceberg in this episode, but a central part

Turkish: 
Şimdi en düşük toplam maliyeti biliyoruz ve
ordunun oraya ulaşması için en hızlı yol,
hangi Kralın İnişini önler!
Dijkstra'nın özgün algoritması, tasarlanan
1956, düğüm sayısının karmaşıklığına sahipti.
grafikte kare.
Ve daha önce tartıştığımız gibi, kare asla
harika, çünkü algoritma yapamaz
büyük sorunlara ölçeklendirme - tüm yol gibi
Amerika Birleşik Devletleri Haritası.
Neyse ki, Dijkstra'nın algoritması geliştirildi
birkaç yıl sonra düğüm sayısını almak
Grafikte, sayının günlüğünü
düğümlerin, PLUS satır sayısını.
Bu daha karmaşık görünse de,
aslında biraz daha hızlı.
Örnek grafiğimizi 6 şehirle beraber takarak
ve 9 satır, kanıtlıyor.
Algoritmamız 36 döngüden 14'e düşüyor.
Sıralamada olduğu gibi, farklı avantaj ve dezavantajları olan sayısız grafik arama algoritması vardır.
Google Haritalar gibi bir servisi her kullanışınızda
Yön bulmak için, benzer bir algoritma
Dijkstra'nın anlamaya sunucuları sunucular üzerinde çalışıyor
Sizin için en iyi rotayı seçin.
Algoritmalar her yerde ve modern dünya
onlarsız mümkün olmazdı.
Algoritmikliğin yalnızca en ucuna dokunduk
bu bölümde buzdağı, ancak merkezi bir parçası

Chinese: 
现在我们知道了最低成本，也就是军队到达的最快路线
而且绕过了“君临城”！
“Dijkstra 算法”的原始版本，在 1956 年构思
算法复杂度为 O(N ^ 2)
我们之前说过 O(N ^ 2) 的效率不够好
意味着算法的输入不可以很大
比如美国的完整路线图
幸运的是，“Dijkstra 算法”几年后得到改进
算法复杂度变成了 O( N * log(N) + L ) （N为节点数，L 为道路数）
虽然看起来更复杂，
但实际上更快一些
用之前的例子来算（6 个节点和 9 条路）可以证明它更快。
算法从 36 个循环减少到 14 个左右
就像排序一样，图搜索算法也有很多很多，每个有不同的优缺点
每次用“谷歌地图”找路时
类似 “Dijkstra 算法”的算法就在服务器上运行，帮你找出最佳路线
算法无处不在
现代世界离不开它们
这一集中，我们只触及了算法的冰山一角
但成为一名计算机科学家的核心

Korean: 
우리는 가장 작은 값을 가지면서 군대가 가장 빨리 도착할 수 있는 길을 알아냈습니다.
이제 King 's Landing을 피할 수 있습니다!
Dijkstra의 원조 알고리즘은 1956년에 구상되었고, 
그래프 안의 노드 수의 제곱만큼의 복잡도를 지녔습니다.
Dijkstra의 원조 알고리즘은 1956년에 구상되었고, 
그래프 안의 노드 수의 제곱만큼의 복잡도를 지녔습니다.
그리고 이미 논의한 것처럼 제곱 된
알고리즘은 절대 좋지 않습니다.
미국 전체의 도로지도과 같은 커다란 범위의 
알고리즘 문제를 해결할 수 없기 때문입니다.
다행히, 몇 년 뒤 Dijkstra의 알고리즘이 개선되었습니다.
그래프 안의 노드 수를 로그(노드 수)와 곱하고 
라인의 수를 더하는 방법으로요.
이것이 더 복잡해 보이지만, 실제로는 꽤 빠릅니다.
예제 그래프에 적용해 보겠습니다. 
6개의 도시와 9개의 행. 증명해내네요.
우리의 알고리즘은 36개의 루프에서 
약 14개의 알고리즘으로 떨어집니다.
정렬과 마찬가지로, 수많은 장단점을 가진 무수한 그래프 검색 알고리즘이 있습니다.
여러분이 Google 지도로 길을 찾는것과 같은 서비스를 
사용할 때 마다 Dijkstra의 알고리즘은 서버에서 실행되어
여러분을 위한 최고의 길을 알아내줍니다.
알고리즘은 어디에나 있으며 
현대 세상은 알고리즘 없이는 불가능합니다.
우리는 알고리즘의 빙산의 일각만을 다루었지만, 
컴퓨터 과학자가 되는 핵심 부분은

Turkish: 
bilgisayar uzmanı olmanın kaldıraç
var olan algoritmalar ve ne zaman yenilerini yazmak
gerekli ve umarım bu küçük lezzet ilgisini çekmiştir
daha fazla ARAMA.
Gelecek hafta görüşürüz.

Korean: 
기존 알고리즘을 사용해서 필요에 따라 
새로운 알고리즘을 작성하는 데에 있습니다.
그리고 저는 여러분이 이 작은 경험이 여러분에게 더 찾고자 함에 흥미를 불러 일으켰길 바랍니다.
다음 주에 봐요.

Chinese: 
是根据情况，选用现有算法或者写新算法
我希望这集的小例子能让你体会到这一点。
我们下周见

English: 
of being a computer scientist is leveraging
existing algorithms and writing new ones when
needed, and I hope this little taste has intrigued
you to SEARCH further.
I’ll see you next week.
