1
00:00:00,000 --> 00:00:04,419
>> [Música tocando]

2
00:00:04,419 --> 00:00:05,401

3
00:00:05,401 --> 00:00:08,460
>> DOUG LLOYD: OK, então uma mesclagem
tipo é mais um algoritmo

4
00:00:08,460 --> 00:00:11,200
que podemos usar para resolver
os elementos de uma matriz.

5
00:00:11,200 --> 00:00:14,480
Mas, como veremos, tem um
diferença muito fundamental

6
00:00:14,480 --> 00:00:17,850
de seleção tipo, bolha
tipo e ordenação por inserção

7
00:00:17,850 --> 00:00:20,280
que o tornam realmente muito inteligente.

8
00:00:20,280 --> 00:00:24,290
>> A idéia básica por trás de mesclagem
tipo é classificar matrizes menores

9
00:00:24,290 --> 00:00:27,430
e, em seguida, combinar essas matrizes
juntos, ou mesclar eles--

10
00:00:27,430 --> 00:00:31,440
daí o nome-- na ordem de classificação.

11
00:00:31,440 --> 00:00:34,230
A maneira que merge sort faz
isto é, aproveitando uma ferramenta

12
00:00:34,230 --> 00:00:37,290
chamado recursão, que é o que
nós vamos estar falando em breve,

13
00:00:37,290 --> 00:00:39,720
mas nós realmente não conversamos sobre isso ainda.

14
00:00:39,720 --> 00:00:43,010
>> Aqui é a idéia básica por trás merge sort.

15
00:00:43,010 --> 00:00:46,320
Classificar a metade esquerda da matriz,
assumindo que n é maior do que 1.

16
00:00:46,320 --> 00:00:49,980
E o que eu quero dizer quando digo
assumindo que n é maior do que 1 é,

17
00:00:49,980 --> 00:00:53,970
Eu acho que nós podemos concordar que se uma matriz
consiste somente de um único elemento,

18
00:00:53,970 --> 00:00:54,680
ele é classificado.

19
00:00:54,680 --> 00:00:56,560
Nós realmente não precisa
para fazer qualquer coisa para ele.

20
00:00:56,560 --> 00:00:58,059
Podemos apenas declará-lo para ser classificado.

21
00:00:58,059 --> 00:01:00,110
É apenas um único elemento.

22
00:01:00,110 --> 00:01:03,610
>> Assim, o pseudocódigo, novamente, é
ordenar a metade do lado esquerdo da matriz,

23
00:01:03,610 --> 00:01:08,590
em seguida, classificar a metade direita da matriz,
em seguida, mesclar as duas metades juntas.

24
00:01:08,590 --> 00:01:11,040
Agora, já que você pode ser
pensando, ele tipo de apenas

25
00:01:11,040 --> 00:01:14,080
Parece que você está adiando as--
você não está realmente fazendo alguma coisa.

26
00:01:14,080 --> 00:01:16,330
Você está dizendo classificar à esquerda
metade, ordenar a metade direita,

27
00:01:16,330 --> 00:01:19,335
mas você não está dizendo
me como você está fazendo isso.

28
00:01:19,335 --> 00:01:22,220
>> Mas lembre-se que, enquanto
uma matriz é um único elemento,

29
00:01:22,220 --> 00:01:23,705
podemos declará-la classificada.

30
00:01:23,705 --> 00:01:25,330
Então nós podemos apenas combiná-los juntos.

31
00:01:25,330 --> 00:01:27,788
E isso é realmente o
ideia fundamental por trás merge sort,

32
00:01:27,788 --> 00:01:31,150
é para quebrá-lo para baixo, de modo que
suas matrizes são de tamanho um.

33
00:01:31,150 --> 00:01:33,430
E então você reconstruir a partir daí.

34
00:01:33,430 --> 00:01:35,910
>> Merge sort é definitivamente
um algoritmo complicado.

35
00:01:35,910 --> 00:01:38,210
E é também um pouco
complicada para visualizar.

36
00:01:38,210 --> 00:01:41,870
Portanto, esperamos que, a visualização que eu
temos aqui vai ajudá-lo a seguir adiante.

37
00:01:41,870 --> 00:01:45,640
E eu vou tentar o meu melhor para narrar as coisas
e prosseguir com este um pouco mais

38
00:01:45,640 --> 00:01:49,180
lentamente do que os outros
apenas com a esperança de obter a sua cabeça

39
00:01:49,180 --> 00:01:51,800
em torno das idéias por trás merge sort.

40
00:01:51,800 --> 00:01:54,680
>> Portanto, temos a mesma matriz como a
outras algoritmo de classificação vídeos

41
00:01:54,680 --> 00:01:57,120
se você já viu eles--
uma matriz de seis elementos.

42
00:01:57,120 --> 00:02:02,110
E o nosso código pseudocode aqui é classificar
a metade esquerda, ordenar a metade direita,

43
00:02:02,110 --> 00:02:03,890
mesclar as duas metades juntas.

44
00:02:03,890 --> 00:02:09,770
Então, vamos dar este tijolo vermelho muito escuro
array e classificar a metade esquerda do mesmo.

45
00:02:09,770 --> 00:02:13,380
>> Então, por enquanto, vamos
a ignorar as coisas à direita.

46
00:02:13,380 --> 00:02:15,740
É lá, mas estamos
não naquele passo ainda.

47
00:02:15,740 --> 00:02:18,220
Nós não somos a espécie a
metade direita da matriz.

48
00:02:18,220 --> 00:02:21,037
Estamos em espécie à esquerda
metade da matriz.

49
00:02:21,037 --> 00:02:22,870
E apenas por uma questão
de ser um pouco mais

50
00:02:22,870 --> 00:02:26,480
claro, para que eu possa consultar
para o passo que estamos no,

51
00:02:26,480 --> 00:02:29,800
Eu vou mudar o
cor deste conjunto de laranja.

52
00:02:29,800 --> 00:02:33,190
Agora, nós ainda estamos falando sobre o
mesma metade esquerda da matriz original.

53
00:02:33,190 --> 00:02:38,520
Mas eu estou esperando que por ser capaz de
referem-se às cores de vários itens,

54
00:02:38,520 --> 00:02:40,900
ele vai torná-lo um pouco mais
claro o que está acontecendo aqui.

55
00:02:40,900 --> 00:02:43,270
>> OK, então agora temos um
três matriz elemento.

56
00:02:43,270 --> 00:02:46,420
Como podemos classificar a metade esquerda deste
matriz, o que é ainda neste passo?

57
00:02:46,420 --> 00:02:49,400
Nós estamos tentando classificar a esquerda
metade do tijolo vermelho array--

58
00:02:49,400 --> 00:02:52,410
a metade esquerda das quais
Eu tenho agora de cor laranja.

59
00:02:52,410 --> 00:02:54,840
>> Bem, nós poderíamos tentar
repetir esse processo novamente.

60
00:02:54,840 --> 00:02:56,756
Então, nós ainda estamos no
meio tentando classificar

61
00:02:56,756 --> 00:02:58,700
a metade esquerda da matriz completa.

62
00:02:58,700 --> 00:03:00,450
A metade esquerda do
array, eu só vou

63
00:03:00,450 --> 00:03:03,910
para decidir arbitrariamente que a metade esquerda
será menor do que a metade direita,

64
00:03:03,910 --> 00:03:06,550
porque isto acontece a
composto por três elementos.

65
00:03:06,550 --> 00:03:11,260
>> E assim eu vou dizer que o
metade esquerda da metade esquerda da matriz

66
00:03:11,260 --> 00:03:14,050
é apenas o elemento cinco.

67
00:03:14,050 --> 00:03:18,360
Cinco, sendo um único elemento
array, nós sabemos como resolver isso.

68
00:03:18,360 --> 00:03:21,615
E assim cinco está classificada.

69
00:03:21,615 --> 00:03:22,990
Nós apenas estamos indo para declarar isso.

70
00:03:22,990 --> 00:03:24,890
É uma única matriz elemento.

71
00:03:24,890 --> 00:03:29,015
>> Então, nós temos agora classificados o
metade esquerda da esquerda half--

72
00:03:29,015 --> 00:03:33,190
ou melhor, temos classificados o
metade esquerda da laranja.

73
00:03:33,190 --> 00:03:37,970
Então, agora, a fim de ainda completa
metade esquerda da matriz total,

74
00:03:37,970 --> 00:03:43,481
precisamos classificar a metade direita
da laranja, ou essas coisas.

75
00:03:43,481 --> 00:03:44,230
Como fazemos isso?

76
00:03:44,230 --> 00:03:45,930
Bem, nós temos um array com dois elementos.

77
00:03:45,930 --> 00:03:50,470
Assim, podemos classificar a metade esquerda
da matriz, que é dois.

78
00:03:50,470 --> 00:03:52,090
Dois é um único elemento.

79
00:03:52,090 --> 00:03:55,890
Por isso é classificado por padrão.
Então, podemos classificar a metade direita

80
00:03:55,890 --> 00:03:58,530
de que a porção de matriz, a uma.

81
00:03:58,530 --> 00:04:00,210
Isso é tipo de por padrão.

82
00:04:00,210 --> 00:04:03,610
>> Isto é agora pela primeira vez
chegamos a um passo de mesclagem.

83
00:04:03,610 --> 00:04:06,135
Nós completamos, embora
agora estamos tipo de aninhados down--

84
00:04:06,135 --> 00:04:08,420
e que é uma espécie de complicado
coisa com recursividade é,

85
00:04:08,420 --> 00:04:10,930
você precisa para manter seu
cabeça sobre onde nós estamos.

86
00:04:10,930 --> 00:04:15,560
Então, nós tipo de esquerda
metade da porção de laranja.

87
00:04:15,560 --> 00:04:21,280
>> E agora, nós estamos no meio de triagem
a metade direita da porção de laranja.

88
00:04:21,280 --> 00:04:25,320
E, nesse processo, estamos
agora prestes a ser no degrau,

89
00:04:25,320 --> 00:04:27,850
mesclar as duas metades juntas.

90
00:04:27,850 --> 00:04:31,700
Quando olhamos para as duas metades
da matriz, vemos dois e um.

91
00:04:31,700 --> 00:04:33,880
Elemento que é menor?

92
00:04:33,880 --> 00:04:35,160
Uma.

93
00:04:35,160 --> 00:04:36,760
>> Em seguida, o qual elemento é menor?

94
00:04:36,760 --> 00:04:38,300
Bem, é duas ou nada.

95
00:04:38,300 --> 00:04:39,910
Portanto, é dois.

96
00:04:39,910 --> 00:04:43,690
Então, agora, só para enquadrar novamente
onde estamos no contexto,

97
00:04:43,690 --> 00:04:48,230
nós ter resolvido o
metade esquerda da laranja

98
00:04:48,230 --> 00:04:49,886
e a metade direita da origem.

99
00:04:49,886 --> 00:04:52,510
Eu sei que eu mudei as cores
de novo, mas que é onde estávamos.

100
00:04:52,510 --> 00:04:54,676
E a razão pela qual eu fiz isso
é porque este processo é

101
00:04:54,676 --> 00:04:57,870
vai continuar, a iteração para baixo.

102
00:04:57,870 --> 00:05:00,500
Temos classificados esquerda
a metade da laranja ex

103
00:05:00,500 --> 00:05:02,590
e a metade direita do ex-laranja.

104
00:05:02,590 --> 00:05:05,620
>> Agora, precisamos mesclar aqueles
duas metades juntos também.

105
00:05:05,620 --> 00:05:07,730
Essa é a etapa em que estamos.

106
00:05:07,730 --> 00:05:11,440
Portanto, considerar todas as
elementos que são agora verde,

107
00:05:11,440 --> 00:05:12,972
a metade esquerda da matriz original.

108
00:05:12,972 --> 00:05:14,680
E nós mesclar aqueles
utilizando o mesmo processo de

109
00:05:14,680 --> 00:05:18,660
fizemos para mesclar dois
e um apenas um momento atrás.

110
00:05:18,660 --> 00:05:23,080
>> A metade da esquerda, a menor
elemento na metade esquerda é cinco.

111
00:05:23,080 --> 00:05:25,620
O elemento mais pequeno
a metade direita é um deles.

112
00:05:25,620 --> 00:05:27,370
Qual dessas é menor?

113
00:05:27,370 --> 00:05:29,260
Uma.

114
00:05:29,260 --> 00:05:32,250
>> O elemento mais pequeno
a metade esquerda é cinco.

115
00:05:32,250 --> 00:05:35,540
O elemento mais pequeno
a metade direita é dois.

116
00:05:35,540 --> 00:05:36,970
Qual é o menor?

117
00:05:36,970 --> 00:05:38,160
Dois.

118
00:05:38,160 --> 00:05:41,540
E por último, em seguida, cinco e
nada, podemos dizer cinco.

119
00:05:41,540 --> 00:05:43,935
>> OK, portanto, grande figura, vamos
fazer uma pausa por um segundo

120
00:05:43,935 --> 00:05:46,080
e descobrir onde estamos.

121
00:05:46,080 --> 00:05:48,580
Se começássemos a partir de
o início, nós

122
00:05:48,580 --> 00:05:51,640
agora completou para
a matriz global apenas

123
00:05:51,640 --> 00:05:53,810
um passo do código pseudocode aqui.

124
00:05:53,810 --> 00:05:56,645
Nós ter resolvido o
metade esquerda da matriz.

125
00:05:56,645 --> 00:05:59,490
>> Lembre-se que o original
ordem era cinco, dois, um.

126
00:05:59,490 --> 00:06:02,570
Ao passar por este processo
e nidificação para baixo e repetir,

127
00:06:02,570 --> 00:06:05,990
continuando a quebrar o problema
em partes cada vez menores,

128
00:06:05,990 --> 00:06:09,670
temos agora concluída
um passo do pseudocode

129
00:06:09,670 --> 00:06:13,940
para toda a matriz de partida.

130
00:06:13,940 --> 00:06:16,670
Nós ter resolvido sua meia esquerda.

131
00:06:16,670 --> 00:06:18,670
>> Então agora vamos congelar lá.

132
00:06:18,670 --> 00:06:23,087
E agora vamos classificar a direita
metade da matriz original.

133
00:06:23,087 --> 00:06:25,670
E vamos fazer isso por
passando pela mesma iterativo

134
00:06:25,670 --> 00:06:30,630
processo de quebrar as coisas
e, em seguida, mesclando-los juntos.

135
00:06:30,630 --> 00:06:34,290
>> Assim, a metade esquerda da
vermelho, ou a metade esquerda

136
00:06:34,290 --> 00:06:38,830
da metade direita do original
array, eu vou dizer é três.

137
00:06:38,830 --> 00:06:40,312
Mais uma vez, eu estou sendo consistente aqui.

138
00:06:40,312 --> 00:06:42,020
Se você tem um estranho
número de elementos, ela

139
00:06:42,020 --> 00:06:44,478
Não importa realmente se
você faz o esquerdo menor

140
00:06:44,478 --> 00:06:45,620
ou o direito de um menor.

141
00:06:45,620 --> 00:06:49,230
>> O que importa é que sempre que você
deparar com este problema na condução

142
00:06:49,230 --> 00:06:51,422
uma mala, você precisa ser consistente.

143
00:06:51,422 --> 00:06:53,505
Você quer sempre precisa
fazer um lado esquerdo menor

144
00:06:53,505 --> 00:06:55,421
ou sempre precisa fazer
o lado direito menor.

145
00:06:55,421 --> 00:06:57,720
Aqui, eu escolhi para sempre
fazer o lado esquerdo menor

146
00:06:57,720 --> 00:07:04,380
quando minha matriz, ou o meu
sub-array, é de uma dimensão ímpar.

147
00:07:04,380 --> 00:07:07,420
>> Três é um único elemento,
e por isso é ordenada.

148
00:07:07,420 --> 00:07:10,860
Temos aproveitado essa suposição
em todo o nosso processo até agora.

149
00:07:10,860 --> 00:07:15,020
Então agora vamos classificar a direita
metade da metade direita,

150
00:07:15,020 --> 00:07:18,210
ou a metade direita do vermelho.

151
00:07:18,210 --> 00:07:20,390
>> Mais uma vez, temos de dividir isso para baixo.

152
00:07:20,390 --> 00:07:21,910
Este não é um único elemento de matriz.

153
00:07:21,910 --> 00:07:23,970
Não podemos declará-la classificada.

154
00:07:23,970 --> 00:07:27,060
E assim em primeiro lugar, vamos
para classificar a metade esquerda.

155
00:07:27,060 --> 00:07:31,620
>> A metade da esquerda é um único elemento,
por isso é tipo de por padrão.

156
00:07:31,620 --> 00:07:34,840
Então vamos classificar a direita
metade, que é um único elemento.

157
00:07:34,840 --> 00:07:41,250
É classificado por padrão. E agora,
que pode mesclar os dois juntos.

158
00:07:41,250 --> 00:07:45,820
Quatro é menor, e
em seguida, seis é menor.

159
00:07:45,820 --> 00:07:48,870
>> Mais uma vez, o que temos feito neste momento?

160
00:07:48,870 --> 00:07:52,512
Temos classificados esquerda
metade da metade direita.

161
00:07:52,512 --> 00:07:54,720
Ou voltar para o original
cores que estavam lá,

162
00:07:54,720 --> 00:07:57,875
temos ordenados esquerda
metade do vermelho mais suave.

163
00:07:57,875 --> 00:08:00,416
Ele foi originalmente um tijolo escuro
vermelho e agora é um vermelho mais suave,

164
00:08:00,416 --> 00:08:02,350
ou um vermelho foi mais suave.

165
00:08:02,350 --> 00:08:05,145
>> E então temos o classificado
metade direita do vermelho mais suave.

166
00:08:05,145 --> 00:08:08,270
Agora, bem, eles são verde novamente, apenas
porque estamos passando por um processo.

167
00:08:08,270 --> 00:08:10,720
E nós temos que repetir
isso mais e mais.

168
00:08:10,720 --> 00:08:14,695
>> Então agora podemos mesclar aqueles
duas metades juntas.

169
00:08:14,695 --> 00:08:15,820
E isso é o que fazemos aqui.

170
00:08:15,820 --> 00:08:17,653
Assim, a linha preta apenas
dividido a metade esquerda

171
00:08:17,653 --> 00:08:19,690
ea metade direita da parte tipo.

172
00:08:19,690 --> 00:08:24,310
>> Nós comparamos o menor valor
no lado esquerdo da array--

173
00:08:24,310 --> 00:08:26,710
ou me desculpar, o menor
valor da metade esquerda

174
00:08:26,710 --> 00:08:30,790
para o valor menor da direita
metade e descobrir que três é menor.

175
00:08:30,790 --> 00:08:32,530
E agora um pouco de uma otimização, certo?

176
00:08:32,530 --> 00:08:35,175
Há realmente nada
esquerda, no lado esquerdo.

177
00:08:35,175 --> 00:08:37,440
>> Não há nada restante
do lado esquerdo,

178
00:08:37,440 --> 00:08:40,877
para que possamos eficientemente
apenas move-- podemos declarar

179
00:08:40,877 --> 00:08:42,960
o resto é, na verdade,
classificadas e apenas pregá-la

180
00:08:42,960 --> 00:08:45,126
sobre, porque não há nada
outra para comparação.

181
00:08:45,126 --> 00:08:49,140
E nós sabemos que o lado direito
do lado direito está classificada.

182
00:08:49,140 --> 00:08:52,770
>> OK, então agora vamos congelar novamente e
descobrir onde estamos na história.

183
00:08:52,770 --> 00:08:56,120
Em geral a matriz,
o que temos feito?

184
00:08:56,120 --> 00:08:58,790
Nós realmente realizar
Agora as etapas um e dois etapa.

185
00:08:58,790 --> 00:09:03,300
Separamos a metade esquerda, e
nós ordenamos a metade direita.

186
00:09:03,300 --> 00:09:08,210
>> Então, agora, tudo o que resta é para nós
para mesclar essas duas metades juntas.

187
00:09:08,210 --> 00:09:11,670
Então, nós comparamos o menor valorizado
elemento de cada metade da matriz

188
00:09:11,670 --> 00:09:13,510
por sua vez, e prossiga.

189
00:09:13,510 --> 00:09:16,535
Um é inferior a três, para que se passa.

190
00:09:16,535 --> 00:09:19,770
>> Dois é inferior a três, assim que dois vai.

191
00:09:19,770 --> 00:09:22,740
Três é inferior a 5, de modo que três tentativas.

192
00:09:22,740 --> 00:09:25,820
Quatro é inferior a 5, de modo que vai de quatro.

193
00:09:25,820 --> 00:09:30,210
Em seguida, cinco é menos de seis,
e seis é tudo o que resta.

194
00:09:30,210 --> 00:09:31,820
>> Agora, eu sei, isso foi uma série de etapas.

195
00:09:31,820 --> 00:09:33,636
E nós deixamos muito
de memória em nossa esteira.

196
00:09:33,636 --> 00:09:35,260
E é isso que esses são quadrados cinza.

197
00:09:35,260 --> 00:09:40,540
E provavelmente me senti como que teve um
muito mais do que a ordenação por inserção, bolha

198
00:09:40,540 --> 00:09:42,660
sort, ou ordenação por seleção.

199
00:09:42,660 --> 00:09:45,330
>> Mas, na realidade, porque um
muitos destes processos

200
00:09:45,330 --> 00:09:48,260
estão acontecendo ao mesmo tempo--
que é algo que vai, mais uma vez,

201
00:09:48,260 --> 00:09:51,100
falar quando falamos de
recursão em um futuro video--

202
00:09:51,100 --> 00:09:53,799
este algoritmo efectivamente
claramente é fundamentalmente

203
00:09:53,799 --> 00:09:55,590
diferente de tudo
temos visto antes

204
00:09:55,590 --> 00:09:58,820
mas também é significativamente
mais eficiente.

205
00:09:58,820 --> 00:09:59,532
>> Por que é que?

206
00:09:59,532 --> 00:10:01,240
Bem, na pior
cenário, temos

207
00:10:01,240 --> 00:10:04,830
para dividir n elementos up
e em seguida recombinam-los.

208
00:10:04,830 --> 00:10:06,680
Mas quando nós recombinar
los, o que estamos fazendo

209
00:10:06,680 --> 00:10:11,110
é basicamente dobrando o
tamanho das matrizes menores.

210
00:10:11,110 --> 00:10:14,260
Temos um monte de um elemento
matrizes que efectivamente

211
00:10:14,260 --> 00:10:16,290
combinar em duas matrizes de elementos.

212
00:10:16,290 --> 00:10:18,590
E, em seguida, tomamos aqueles
duas matrizes elemento

213
00:10:18,590 --> 00:10:21,890
e combiná-los em
quatro matrizes de elementos, e assim por diante,

214
00:10:21,890 --> 00:10:26,130
e assim por diante, e assim por diante, até que
tem uma única matriz elemento n.

215
00:10:26,130 --> 00:10:29,910
>> Mas quantas duplicações
que é preciso para chegar ao n?

216
00:10:29,910 --> 00:10:31,460
Pense de volta para o exemplo do livro de telefone.

217
00:10:31,460 --> 00:10:34,490
Quantas vezes temos de rasgar
o livro de telefone pela metade, quantos mais

218
00:10:34,490 --> 00:10:38,370
vezes temos de rasgar o livro de telefone
em metade, se o tamanho do livro de telefone

219
00:10:38,370 --> 00:10:39,680
duplicou?

220
00:10:39,680 --> 00:10:41,960
Há apenas um, certo?

221
00:10:41,960 --> 00:10:45,360
>> Portanto, há algum tipo de
elemento logarítmica aqui.

222
00:10:45,360 --> 00:10:48,590
Mas nós também ainda temos que, pelo menos,
olhar para todos os n elementos.

223
00:10:48,590 --> 00:10:53,860
Assim, no pior dos casos,
merge sort é executado em log n n.

224
00:10:53,860 --> 00:10:56,160
Temos de olhar para
todos os n elementos,

225
00:10:56,160 --> 00:11:02,915
e nós temos que combiná-los
em conjunto em N log N conjuntos de passos.

226
00:11:02,915 --> 00:11:05,290
Na melhor das hipóteses,
a matriz é perfeitamente ordenadas.

227
00:11:05,290 --> 00:11:06,300
Isso é ótimo.

228
00:11:06,300 --> 00:11:09,980
Mas baseado no algoritmo que temos aqui,
ainda temos de dividir e recombinar.

229
00:11:09,980 --> 00:11:13,290
Embora, neste caso, o
recombinação é uma espécie de ineficaz.

230
00:11:13,290 --> 00:11:14,720
Isto não é necessário.

231
00:11:14,720 --> 00:11:17,580
Mas nós ainda passar por
todo o processo de qualquer maneira.

232
00:11:17,580 --> 00:11:21,290
>> Assim, na melhor das hipóteses
e, no pior caso,

233
00:11:21,290 --> 00:11:24,970
este algoritmo é executado em log n n tempo.

234
00:11:24,970 --> 00:11:29,130
Merge sort é definitivamente um pouco mais complicado
do que os outros principais algoritmos de ordenação

235
00:11:29,130 --> 00:11:33,470
nós já conversamos sobre CS50, mas é
substancialmente mais poderoso.

236
00:11:33,470 --> 00:11:35,400
>> E por isso, se você alguma vez encontrar-
ocasião para precisar dele

237
00:11:35,400 --> 00:11:38,480
ou usá-lo para classificar uma
grande conjunto de dados, obtendo

238
00:11:38,480 --> 00:11:41,940
sua cabeça em torno da idéia de recursão
vai ser realmente poderoso.

239
00:11:41,940 --> 00:11:45,270
E ele vai fazer o seu
programas realmente muito mais eficiente

240
00:11:45,270 --> 00:11:48,700
usando merge sort contra qualquer outra coisa.

241
00:11:48,700 --> 00:11:49,640
Eu sou Doug Lloyd.

242
00:11:49,640 --> 00:11:51,970
Este é CS50.

243
00:11:51,970 --> 00:11:53,826