1
00:00:02,160 --> 00:00:03,210
Ciao.

2
00:00:03,270 --> 00:00:04,440
Questo non voleva Lulu.

3
00:00:04,470 --> 00:00:05,580
E bentornato.

4
00:00:05,670 --> 00:00:12,300
Finora abbiamo esaminato un metodo per lavorare su un altro metodo per realizzare qualcosa.

5
00:00:12,300 --> 00:00:20,160
Ora diamo un'occhiata a un metodo che funziona da solo per ottenere qualcosa di non verificato come ricorsione

6
00:00:20,580 --> 00:00:25,500
che è una tecnica di programmazione interessante e non importante.

7
00:00:25,590 --> 00:00:31,770
Quindi il metodo che nel lavoro stesso viene anche definito un metodo ricorsivo e ci riferiamo a

8
00:00:31,920 --> 00:00:35,090
tale chiamata di invocazione come una chiamata ricorsiva.

9
00:00:35,190 --> 00:00:42,430
Quindi, quando un metodo si richiama, significa essenzialmente che il metodo è in esecuzione di nuovo.

10
00:00:42,720 --> 00:00:48,900
E durante quella fase di reintroduzione, potrebbe fare un'altra volta una chiamata ricorsiva su Saddam il

11
00:00:48,930 --> 00:00:50,100
terzo mondo.

12
00:00:50,160 --> 00:00:56,790
Quindi questo processo di rielaborazione del metodo eseguito di nuovo può accadere per un certo numero di

13
00:00:56,790 --> 00:01:02,040
volte fino a quando una condizione viene soddisfatta in una delle esecuzioni.

14
00:01:02,100 --> 00:01:09,820
Una delle esecuzioni del metodo sotto quella ricorsione si fermerebbe e con tale ricorsione ciò che otteniamo

15
00:01:09,820 --> 00:01:16,190
è un core compatto ed elegante che è un codice molto facile da capire.

16
00:01:16,550 --> 00:01:24,160
Non solo alcuni tipi di problemi possono essere implementati usando la ricorsione e questi tipi

17
00:01:24,250 --> 00:01:32,580
di problemi possono anche essere implementati usando un loop non ricorsivo molto simile, anche se non sono lontani.

18
00:01:32,590 --> 00:01:38,740
Questo perché con la ricorsione abbiamo lo script per fare invocazione del metodo in modo che la

19
00:01:38,740 --> 00:01:42,740
ripetitività possa anche essere simulata usando cicli come la forma d'arte.

20
00:01:43,390 --> 00:01:49,380
Ma quando implementato in modo non ricorsivo, ciò che otteniamo è un complesso chiamato.

21
00:01:49,560 --> 00:01:58,490
Quindi ciò che la ricorsione ci sta comprando è chiaramente espresso e vedremo che questo mi ha scioccato in una demo.

22
00:01:58,520 --> 00:02:07,120
Ora sappiamo che una chiamata al metodo risolverà qualche problema ma che la ricorsione quando un metodo invoca se

23
00:02:07,580 --> 00:02:13,570
stessa sarebbe indirizzare un sottotema che è un problema rimarrebbe lo stesso.

24
00:02:13,670 --> 00:02:22,730
Ma i dati di input per quella particolare istanza di esecuzione del metodo sarebbero in genere in sottoinsiemi più piccoli.

25
00:02:22,730 --> 00:02:30,050
Quindi con ogni invocazione ricorsiva il problema diventa sempre più piccolo finché non può essere reso più

26
00:02:30,050 --> 00:02:30,500
piccolo.

27
00:02:31,070 --> 00:02:35,620
A quel punto vediamo che abbiamo raggiunto un biscotto.

28
00:02:35,720 --> 00:02:41,860
Quindi questa è la condizione che soddisferebbe in una delle invocazioni del metodo.

29
00:02:41,870 --> 00:02:44,350
Questo è quello che menzionavo prima.

30
00:02:44,390 --> 00:02:52,180
Quindi, quando il caso migliore viene raggiunto, le interruzioni di ricorsione su fattoriali sono un tipico esempio che viene utilizzato quando si introduce

31
00:02:52,180 --> 00:02:53,170
la ricorsione.

32
00:02:53,230 --> 00:02:57,690
Qui abbiamo quattro fattoriali che sappiamo essere quattro volte tre volte due volte uno.

33
00:02:58,570 --> 00:03:06,130
E più generalmente avremmo questo quattro fattoriale sarebbe N volte e meno una volta e meno due e

34
00:03:06,130 --> 00:03:15,710
così via fino ad arrivare a 1 e questo può essere esposto noi e tempi e meno 1 fattoriale come puoi vedere

35
00:03:15,710 --> 00:03:23,520
abbiamo una rappresentazione ricorsiva ecco che quando n viene sostituito con N meno uno avremmo ottenuto e meno

36
00:03:23,790 --> 00:03:31,200
una volta e meno due fattoriali e dopo di essa e meno due fattoriali otterremmo e

37
00:03:31,230 --> 00:03:39,980
meno due volte e meno tre fattoriali e questo continuerebbe fino a quando non arriveremo a 1 volte 0 fattoriale.

38
00:03:39,980 --> 00:03:45,230
Ora andiamo avanti e implementiamo questa funzionalità fattoriale utilizzando la ricorsione per questa

39
00:03:47,920 --> 00:03:48,790
demo.

40
00:03:48,850 --> 00:03:55,180
Una nuova classe chiamata ricorsione è stata creata all'interno della directory di base in modo da poter andare avanti e

41
00:03:55,180 --> 00:03:59,550
creare questa classe chiamata ricorsione all'interno della directory di base per questa demo.

42
00:03:59,560 --> 00:04:06,160
Lo mostrerò nel mio Eclipse Ed, quindi eseguirò questo programma da dentro eclipse.

43
00:04:06,160 --> 00:04:12,220
E se stai usando il normale tutor extra puoi compilarlo ed eseguirlo dal problema del comando.

44
00:04:12,850 --> 00:04:18,940
Quindi implementeremo fattoriali usando sia l'approccio non ricorsivo sia quello ricorsivo.

45
00:04:18,970 --> 00:04:24,280
In questo modo possiamo vedere come il codice sembra più leggibile utilizzando l'approccio ricorsivo.

46
00:04:24,670 --> 00:04:27,700
Quindi per entrambi abbiamo due metodi diversi.

47
00:04:27,700 --> 00:04:34,170
Per prima cosa esaminiamo l'approccio non ricorsivo e il metodo è stato chiamato come fattoriale e dove R

48
00:04:34,210 --> 00:04:35,920
sta per Non ricorsivo.

49
00:04:36,550 --> 00:04:38,060
E il metodo è implementato.

50
00:04:38,080 --> 00:04:39,480
Quindi ci limiteremo a guardarlo.

51
00:04:39,850 --> 00:04:47,740
Ma in seguito implementeremo l'approccio ricorsivo usando questo metodo chiamato fattoriale ora.

52
00:04:48,040 --> 00:04:53,720
Qui l'input è e il che significa che dobbiamo calcolare un fattoriale.

53
00:04:53,710 --> 00:05:00,090
Quindi questo approccio non ricorsivo usa un ciclo while per implementarlo qui.

54
00:05:00,190 --> 00:05:06,120
La prima cosa che stiamo facendo è controllare che l'input n sia 0 o 1.

55
00:05:06,130 --> 00:05:13,240
Se è 0 o 1, restituiremo il valore 1 perché 0 fattoriale o 1 fattoriale è 1.

56
00:05:14,170 --> 00:05:16,510
Ora se è qualcosa di diverso da quello.

57
00:05:16,690 --> 00:05:19,050
Va bene allora questa condizione fallirebbe.

58
00:05:19,120 --> 00:05:24,050
Ora l'assunto è che passeremo solo un valore positivo.

59
00:05:24,280 --> 00:05:29,700
Va bene quindi il valore deve essere zero o maggiore di zero per essere negativo.

60
00:05:30,310 --> 00:05:33,730
Quindi se è qualcosa di diverso da zero su uno allora lo siamo.

61
00:05:33,780 --> 00:05:41,350
Intendo qui e stiamo assegnando e a questa variabile temporanea chiamata fattoriale e il fattoriale questo calcolato

62
00:05:41,350 --> 00:05:42,280
qui.

63
00:05:42,280 --> 00:05:47,260
Quindi stiamo usando un ciclo while e la condizione è e maggiore o uguale a 2.

64
00:05:47,680 --> 00:05:52,820
E facciamo questa iterazione e ogni iterazione stiamo anche discriminando.

65
00:05:52,990 --> 00:05:55,790
E così lo facciamo fino e il più ricco 2.

66
00:05:56,020 --> 00:05:56,330
Va bene.

67
00:05:56,360 --> 00:06:04,450
Ed è per questo che lavoreremo, lo itereremo fino a quando diventerà 2 e in ogni iterazione stiamo calcolando il

68
00:06:04,450 --> 00:06:05,560
fattoriale qui.

69
00:06:05,560 --> 00:06:09,360
Stai dicendo tempi fattoriali e meno 1.

70
00:06:09,400 --> 00:06:12,310
Quindi è così che factorial sarà computer.

71
00:06:12,340 --> 00:06:15,960
Quindi se lo è, sarebbe quattro volte tre volte due volte uno.

72
00:06:16,500 --> 00:06:16,780
Destra.

73
00:06:17,230 --> 00:06:21,610
Quindi inizialmente facciamo solo un esempio e guardiamolo.

74
00:06:21,610 --> 00:06:25,620
Quindi, assumiamo che il valore passato sia 4.

75
00:06:25,630 --> 00:06:28,410
Va bene quindi dobbiamo calcolare per factorial con un 24.

76
00:06:28,960 --> 00:06:29,580
Ecco.

77
00:06:29,590 --> 00:06:35,490
E sarebbero quattro così fattoriali sarebbero quattro qui e all'interno del ciclo qui.

78
00:06:35,500 --> 00:06:38,230
Perché la condizione è vera per maggiore o uguale a 2.

79
00:06:38,380 --> 00:06:41,960
Quindi questo sarebbe quattro volte e meno uno.

80
00:06:42,010 --> 00:06:44,450
Quindi sarebbe quattro volte tre che è uguale a.

81
00:06:44,950 --> 00:06:46,170
E stiamo discriminando.

82
00:06:46,210 --> 00:06:47,860
E 2 3.

83
00:06:48,460 --> 00:06:52,440
Quindi il prossimo nella successiva iterazione 3 sarebbe maggiore o uguale a 2.

84
00:06:52,840 --> 00:06:53,090
Va bene.

85
00:06:53,170 --> 00:06:54,170
Che è vero.

86
00:06:54,280 --> 00:06:57,880
E qui anche l'attuale valore di factorial.

87
00:06:57,880 --> 00:07:02,470
Quindi ora sarebbe dodici volte tre meno 1 che è 2.

88
00:07:02,590 --> 00:07:03,270
E qui.

89
00:07:03,310 --> 00:07:05,180
E sarebbe dannoso per 2.

90
00:07:05,380 --> 00:07:06,910
E questo sarebbe 24 qui.

91
00:07:06,910 --> 00:07:12,730
Quindi fattoriale è venti per il valore corrente di fattoriale e 2 è maggiore o uguale a due che

92
00:07:12,730 --> 00:07:13,810
è anche vero.

93
00:07:13,840 --> 00:07:18,990
Quindi nella prossima iterazione sarebbe 24 volte 2 meno 1 che è 1.

94
00:07:19,000 --> 00:07:26,740
Quindi questo sarebbe 24 e diventerebbe 1 dopo che la condizione fallirebbe e avremmo accettato il ciclo e

95
00:07:27,100 --> 00:07:33,840
avremmo restituito il valore corrente di fattoriale con solo 24, quindi è fattoriale un'ora.

96
00:07:33,900 --> 00:07:44,890
Ora diamo un'occhiata alla versione ricorsiva in modo che sappiamo che deve essere e tempi fattoriali.

97
00:07:44,890 --> 00:07:48,880
Quindi questa è una chiamata ricorsiva e meno una.

98
00:07:48,970 --> 00:07:55,590
E diciamo solo ritorno e corriamo e vediamo cosa succede.

99
00:07:55,620 --> 00:08:01,080
Ora entrambi questi metodi sono invocati dal principale per primo permettimi di eseguire quell'esemplare un'ora.

100
00:08:01,400 --> 00:08:07,810
Va bene così questo fattoriale e su 4 è stato richiamato dall'interno della dichiarazione irlandese di stampa qui.

101
00:08:07,890 --> 00:08:14,410
Quindi lascia che esegua la chirurgia dance 24 o grand ed è uguale a quattro.

102
00:08:14,480 --> 00:08:21,830
Ora vediamo cosa succede se invochiamo la versione ricorsiva, come puoi vedere ricevendo un errore chiamato

103
00:08:22,070 --> 00:08:24,410
errore di overflow dello stack.

104
00:08:24,470 --> 00:08:28,460
Quindi questo è ciò che stiamo ottenendo quando invochiamo la versione ricorsiva.

105
00:08:28,460 --> 00:08:29,510
Questo ventiquattro qui.

106
00:08:29,510 --> 00:08:32,840
Per quanto riguarda la versione non ricorsiva, il valore restituito da quello.

107
00:08:33,080 --> 00:08:35,180
Quindi errore di overflow dello stack.

108
00:08:35,180 --> 00:08:39,450
Ora lasciatemi spiegare questo concetto chiamato stack e stack frame.

109
00:08:39,650 --> 00:08:44,930
Ma lo vedremo in dettaglio nella sezione interna della JVM.

110
00:08:44,930 --> 00:08:49,970
Quindi qui stiamo andando a discuterne molto brevemente solo per darti un'idea.

111
00:08:50,510 --> 00:08:55,920
Quindi, all'avvio di JVM, si ottiene un blocco di memoria dal sistema operativo.

112
00:08:56,060 --> 00:09:00,300
E parte di quella memoria è chiamata meno spazio Stack Stack.

113
00:09:00,380 --> 00:09:04,660
Ora lo spazio in pila ha una quantità limitata.

114
00:09:04,660 --> 00:09:06,800
Ora quando viene invocato un metodo come questo.

115
00:09:06,800 --> 00:09:13,790
Non così fattoriale di quattro quindi qualcosa chiamato stack frame frame dello stack è diverso dallo stack in modo da creare

116
00:09:13,790 --> 00:09:15,160
uno stack frame.

117
00:09:15,320 --> 00:09:17,170
E verrebbe memorizzato in STACK.

118
00:09:17,630 --> 00:09:19,930
OK stack frame entra in stack.

119
00:09:20,000 --> 00:09:23,010
Quindi verrebbero creati quattro frame fattoriali o quattro uno stack.

120
00:09:23,060 --> 00:09:25,250
E andrebbe in pila.

121
00:09:25,250 --> 00:09:33,900
Ora qui fattoriale OK sarebbe factorial o quattro e che a sua volta sta rendendo questa invocazione fattoriale di tre e

122
00:09:33,900 --> 00:09:37,880
quattro che un nuovo stack frame sarebbe stato creato.

123
00:09:38,000 --> 00:09:43,670
E questo verrebbe memorizzato in cima al precedente stack frame che è stato creato per davvero, naturalmente.

124
00:09:43,730 --> 00:09:45,630
È così fattoriale di tre.

125
00:09:45,810 --> 00:09:51,780
Quindi otteniamo un nuovo stack frame e quando una facoltà di tre viene eseguita nella rotazione successiva sarà

126
00:09:51,780 --> 00:09:52,930
un fattore due.

127
00:09:53,370 --> 00:09:59,040
E ciò risulterebbe nella creazione di un altro stack frame nello stack.

128
00:09:59,040 --> 00:09:59,400
OK.

129
00:09:59,670 --> 00:10:01,390
Quindi ora ci sono tre frame dello stack.

130
00:10:01,500 --> 00:10:05,870
Così fattoriale di due saprai che verrebbe invocato di nuovo.

131
00:10:06,210 --> 00:10:10,870
E questo si tradurrà in un paio di fattoriali di uno.

132
00:10:11,520 --> 00:10:15,780
E poi avremo fattoriale di 0 fattoriale di meno uno e che non si fermerà mai qui.

133
00:10:15,940 --> 00:10:16,510
OK.

134
00:10:16,590 --> 00:10:20,970
Quindi è come un'invocazione finita ad un certo punto.

135
00:10:20,970 --> 00:10:27,960
Quindi tutti questi stack stack vengono impilati nello stack e lo stack ha una memoria limitata.

136
00:10:28,020 --> 00:10:34,380
E avevamo esaurito lo spazio e alla fine avremmo ricevuto questo errore chiamato errore di overflow dello stack perché

137
00:10:34,830 --> 00:10:36,520
lo stack stava diventando overflow.

138
00:10:37,170 --> 00:10:39,910
Quindi il problema qui è che non esiste una condizione di base.

139
00:10:40,280 --> 00:10:40,600
OK.

140
00:10:40,620 --> 00:10:44,570
Quindi dobbiamo mettere una condizione base in modo che la ricorsione si fermi.

141
00:10:44,820 --> 00:10:50,460
E nel nostro caso la condizione di base sarebbe ed è uguale a zero in quel punto.

142
00:10:50,460 --> 00:10:53,590
Sarebbe zero fattoriale e vorremmo restituirne uno.

143
00:10:54,150 --> 00:10:56,070
Quindi questo è ciò che è guadagnato.

144
00:10:56,370 --> 00:11:00,120
Ora ci sarebbe una chiusura ad esso.

145
00:11:00,130 --> 00:11:01,170
E quindi se ci sei.

146
00:11:01,240 --> 00:11:02,360
Quindi prendiamo 24.

147
00:11:03,010 --> 00:11:03,220
OK.

148
00:11:03,220 --> 00:11:05,140
Quindi guardiamo questo.

149
00:11:05,140 --> 00:11:08,430
Quindi diciamo inizialmente ed è uguale a quattro.

150
00:11:08,440 --> 00:11:15,090
Così sarebbe e tempi fattoriali fuori e meno uno.

151
00:11:15,120 --> 00:11:15,360
Destra.

152
00:11:15,360 --> 00:11:20,980
Potrebbero essere tre o quattro scusate quattro volte fattoriali di Quattro meno uno con la strada.

153
00:11:21,180 --> 00:11:23,780
In effetti a questo punto viene invocato un totale di tre.

154
00:11:24,080 --> 00:11:24,690
OK.

155
00:11:24,840 --> 00:11:27,650
Quindi niente viene restituito qui.

156
00:11:27,690 --> 00:11:30,510
È solo che il ritorno è lì ma lo è.

157
00:11:30,600 --> 00:11:32,210
Times fattoriale di tre.

158
00:11:32,250 --> 00:11:34,270
Quindi nel qual caso il controllo.

159
00:11:34,580 --> 00:11:41,970
Quindi c'è una chiamata ricorsiva e il metodo dovrebbe essere eseguito ancora una volta con questo albero dei valori.

160
00:11:42,000 --> 00:11:44,190
Quindi con questo il metodo viene eseguito nuovamente.

161
00:11:44,500 --> 00:11:53,000
E così saremmo venuti qui e sarebbe stato tre volte fattoriale di due OK.

162
00:11:53,070 --> 00:12:03,950
E questo lavoro corrisponde a due volte fattoriale di uno sul ciclo successivo.

163
00:12:03,980 --> 00:12:14,890
Sarebbe una volta fattoriale di 0 su 1 fattoriale di zero viene invocato e sarà zero.

164
00:12:14,890 --> 00:12:19,010
E il caso base sarebbe vero e nessuno sarebbe scritto.

165
00:12:19,050 --> 00:12:19,350
OK.

166
00:12:19,380 --> 00:12:26,280
Quindi, quando uno ha scritto che OK, la struttura di zero ne restituisce una.

167
00:12:26,290 --> 00:12:28,460
Quindi ne avremmo uno qui.

168
00:12:28,550 --> 00:12:31,900
E quindi questo è uno e questo è il ritorno qui.

169
00:12:31,900 --> 00:12:32,950
Destra.

170
00:12:33,040 --> 00:12:36,320
Quindi significa essenzialmente fattoriale di 1.

171
00:12:36,370 --> 00:12:38,560
Quindi questo non è altro che fattoriale di uno.

172
00:12:38,560 --> 00:12:40,170
Questo è ciò che sta accadendo.

173
00:12:40,300 --> 00:12:45,220
Quindi stiamo dicendo che nella prossima dichiarazione avremmo scritto due in uno.

174
00:12:45,220 --> 00:12:51,580
Quindi, quando viene restituito, sostituisce fattoriale di 2 con il valore scritto con 2.

175
00:12:51,730 --> 00:12:58,730
E questo corrisponderebbe a 6 ora e 6 verrebbero restituiti il che significa che il fattoriale di 3

176
00:12:58,930 --> 00:13:01,020
sarebbe stato sostituito con 6.

177
00:13:01,150 --> 00:13:04,900
E ora siamo nella prima invocazione.

178
00:13:05,200 --> 00:13:09,040
E quello sarebbe 24 e infine 24 sarebbero scritti.

179
00:13:09,040 --> 00:13:13,070
Quindi con ogni invocazione il metodo viene richiamato.

180
00:13:13,180 --> 00:13:20,410
Infine, quando viene raggiunta la base quando viene raggiunto il caso base, l'intero processo andrà indietro

181
00:13:20,800 --> 00:13:28,480
finché non raggiungiamo la prima chiamata e quindi restituiremo quel valore e il metodo si arresta e

182
00:13:28,480 --> 00:13:31,760
il metodo completa la sua esecuzione okay.

183
00:13:31,780 --> 00:13:39,940
Quindi questo è il record, quindi chiama e, come puoi vedere, il tribunale è molto più pulito.

184
00:13:39,940 --> 00:13:46,240
Quindi, se osservate entrambe queste implementazioni, la versione ricorsiva è molto più pulita di quanto possiamo

185
00:13:46,240 --> 00:13:50,720
vedere chiaramente mentre la versione non ricorsiva ha tutto questo.

186
00:13:50,740 --> 00:13:57,700
Quindi con la ricorsione ciò che otteniamo è un codice più pulito otteniamo un codice più pulito, ma sarebbe

187
00:13:58,030 --> 00:14:04,480
leggermente più lento perché abbiamo come tutti questi con ogni chiamata in cui viene creato uno stock.

188
00:14:04,690 --> 00:14:10,840
E questo richiederebbe un po 'di tempo e occuperebbe anche un po' di spazio per ogni invocazione e lo

189
00:14:10,840 --> 00:14:16,890
stack frame verrà creato in modo tale che la parola coinvolga sia il tempo sia la base in

190
00:14:16,910 --> 00:14:25,440
modo un po 'inefficiente, ma il codice è molto più più pulito ora e molto più chiaro ora e questo è ciò di cui abbiamo bisogno.

191
00:14:25,450 --> 00:14:32,740
A volte possiamo compromettere l'efficienza se il codice è molto più leggibile e questo è ciò che

192
00:14:32,740 --> 00:14:34,260
otteniamo dalla ricorsione.

193
00:14:34,360 --> 00:14:36,280
Okay, questo è tutto.

194
00:14:36,340 --> 00:14:42,930
Quindi la prossima domanda è: quando usiamo la ricorsione, la ricorsione non può essere usata per tutti i tipi di problemi.

195
00:14:43,030 --> 00:14:46,500
Entra in gioco solo se il problema può essere risolto.

196
00:14:46,510 --> 00:14:47,910
Siamo simili.

197
00:14:47,920 --> 00:14:56,320
Alcuni problemi come in questo caso in cui ogni invocazione in cui c'è questo problema in cui dobbiamo trovare factorial fuori

198
00:14:56,320 --> 00:15:02,250
dalla fine, ma che può essere affrontato via fattoriale e meno uno va bene.

199
00:15:02,260 --> 00:15:07,990
Questo è un problema che può essere a sua volta indirizzato usando Rudolph e meno 2.

200
00:15:08,020 --> 00:15:12,950
Quindi se questo è il tipo di problema con cui abbiamo a che fare allora possiamo usare la ricorsione.

201
00:15:12,980 --> 00:15:19,210
E qui ci sono alcuni esempi di problemi che richiedono la ricorsione e ce ne sono molti altri ma questi sono alcuni

202
00:15:19,210 --> 00:15:21,850
semplici esempi di cui potresti essere a conoscenza.

203
00:15:21,850 --> 00:15:28,730
Uno è la ricerca binaria che riguarda la ricerca di un elemento in una lista di elementi e le Nexus

204
00:15:28,840 --> 00:15:30,070
Towers di Hanoi.

205
00:15:30,220 --> 00:15:34,810
Quindi, se si dispone di uno sfondo informatico, potrebbe essersi imbattuto in questo nella

206
00:15:34,810 --> 00:15:40,270
classe delle strutture dati che può anche essere risolta ricorrendo alla ricorsione e successivamente alla frequenza delle parole.

207
00:15:40,480 --> 00:15:46,930
Quindi se hai un documento e se vuoi cercare una parola particolare e poi vuoi cercare

208
00:15:46,930 --> 00:15:50,260
quante volte quella parola appare nel documento.

209
00:15:50,260 --> 00:15:52,940
Quindi può essere implementato in ogni modo immaginabile.

210
00:15:53,590 --> 00:15:55,700
Quindi abbiamo guardato fattoriale.

211
00:15:55,720 --> 00:16:02,570
Ora esaminiamo anche la ricerca binaria rapidamente perché la ricerca binaria è un problema di intervista di base.

212
00:16:02,710 --> 00:16:10,630
Inoltre, se guardiamo anche a questo, ti daremo una migliore comprensione della ricorsione, quindi con la ricerca binaria

213
00:16:10,630 --> 00:16:14,480
cercheremo un elemento tra una lista di elementi.

214
00:16:14,500 --> 00:16:19,990
Diciamo che abbiamo questi elementi qui e ci sono tutte e quattro le ricerche binarie.

215
00:16:19,990 --> 00:16:23,340
Il requisito è che gli elementi debbano essere ordinati per primi.

216
00:16:23,440 --> 00:16:24,270
Così.

217
00:16:24,460 --> 00:16:26,560
Il che significa che devono essere in ordine crescente.

218
00:16:26,560 --> 00:16:29,200
In questo caso sono tutti in ordine crescente.

219
00:16:29,200 --> 00:16:30,500
Quindi questo è il requisito.

220
00:16:30,550 --> 00:16:38,260
Ora, se non usiamo la ricerca binaria, c'è un modo per implementarlo usando una ricerca lineare che significa che

221
00:16:38,260 --> 00:16:44,890
dovresti cercare ognuno di questi elementi e controllare se l'elemento che stai cercando appare in qualsiasi

222
00:16:44,920 --> 00:16:45,790
punto dell'elenco.

223
00:16:45,940 --> 00:16:48,210
Quindi dovresti esaminare l'intera lista.

224
00:16:48,210 --> 00:16:53,570
Ora se hai un milione di elementi scansionerai il milione di elementi nel peggiore dei casi.

225
00:16:53,660 --> 00:16:54,280
Va bene.

226
00:16:54,430 --> 00:16:59,230
Nel caso peggiore dovresti scansionare tutti i milioni di elementi e non troverai il tuo elemento.

227
00:16:59,230 --> 00:17:07,300
In questo modo la chiamiamo ricerca lineare e l'efficienza dell'algoritmo per quella sarebbe spenta e diciamo

228
00:17:07,300 --> 00:17:08,870
che è lineare.

229
00:17:09,090 --> 00:17:14,570
Ora con la ricerca binaria sarà molto più efficiente a causa dell'algoritmo stesso.

230
00:17:14,680 --> 00:17:20,770
E là l'efficienza l'efficienza dell'algoritmo diciamo che è logaritmica quindi sarà grande o

231
00:17:20,920 --> 00:17:22,030
log n.

232
00:17:22,140 --> 00:17:22,500
OK.

233
00:17:22,550 --> 00:17:26,480
Quindi la ricerca binaria è più efficiente della ricerca lineare.

234
00:17:26,930 --> 00:17:29,070
E vediamo come funziona.

235
00:17:29,080 --> 00:17:31,160
Quindi qui abbiamo otto elementi.

236
00:17:31,180 --> 00:17:38,470
Diciamo che la prima invocazione è che questa ricerca binaria non è altro che la matrice e zero non

237
00:17:38,470 --> 00:17:43,310
è altro che lo zero con indice e otto è l'ultimo indice.

238
00:17:43,330 --> 00:17:47,470
Quindi ci sono nove elementi che stiamo passando otto e questo è l'elemento che deve essere cercato.

239
00:17:47,840 --> 00:17:48,510
Va bene.

240
00:17:48,610 --> 00:17:54,670
E la ricerca binaria ritornerebbe se l'elemento è presente ovunque qui in questo caso è presente

241
00:17:54,670 --> 00:17:55,270
qui.

242
00:17:55,390 --> 00:17:59,290
Quindi restituirebbe la posizione dell'indice di quell'elemento.

243
00:17:59,650 --> 00:18:02,760
Quindi questo sarebbe 5 0 1 2 3 4 e 5.

244
00:18:03,280 --> 00:18:06,240
Ma se l'elemento non è formato allora ritornerebbe a meno 1.

245
00:18:06,590 --> 00:18:06,930
Va bene.

246
00:18:06,970 --> 00:18:09,730
Quindi restituirà il valore dell'indice qui.

247
00:18:09,730 --> 00:18:18,790
E in sostanza ciò che fa la ricerca binaria non è la scansione dell'intero array in modo che scansiona solo

248
00:18:18,790 --> 00:18:20,500
alcune aree dell'array.

249
00:18:20,710 --> 00:18:27,970
Ed è per questo che è molto più efficiente e il modo in cui lo fa è che una volta

250
00:18:28,000 --> 00:18:35,650
che lo invochi, la prima cosa che fa è calcolare il centro dell'array che non è altro che 0 più 8 byte 2.

251
00:18:36,330 --> 00:18:36,650
Va bene.

252
00:18:36,670 --> 00:18:38,300
A cui non ha nulla in cambio.

253
00:18:38,320 --> 00:18:46,090
Quindi, vieni ad usare il valore fatto per così zero è l'indice inferiore dell'elemento inferiore su 8 è il più alto indicizzato, quindi non

254
00:18:46,450 --> 00:18:48,950
più tardi andremo a riempire questo metodo.

255
00:18:49,060 --> 00:18:51,120
Quindi la firma del metodo è anche qui.

256
00:18:51,310 --> 00:18:52,820
Il primo elemento è 8.

257
00:18:52,840 --> 00:18:56,940
Il secondo è indice più alto indice più basso sulla chiave per tale.

258
00:18:56,960 --> 00:19:02,920
Va bene quindi sarà un vantaggio di due per zero più 8 per 2 che è per quello.

259
00:19:02,950 --> 00:19:10,630
Quindi controlleremo se questo è l'elemento in questo indice, indipendentemente dal fatto che sia la chiave.

260
00:19:11,290 --> 00:19:17,070
Quindi l'elemento in 4 posizioni per è 55 che non è uguale a 65.

261
00:19:17,280 --> 00:19:23,620
Se fosse stato lo stesso elemento se questo fosse sessantacinque, il metodo sarebbe tornato.

262
00:19:23,620 --> 00:19:26,440
Questo indice particolare come output.

263
00:19:27,130 --> 00:19:36,160
Ma poiché non è il caso dopo controllerà se la P è maggiore o minore di 55.

264
00:19:36,280 --> 00:19:42,670
In questo caso, sessantacinque, la nostra chiave che stiamo cercando è superiore a 55, il che significa che deve

265
00:19:42,670 --> 00:19:50,270
apparire su di me e su questa parte della matrice in modo da poter ignorare tutti gli elementi che sono apparsi prima dei cinquantacinque.

266
00:19:50,740 --> 00:19:53,220
E questo è ciò che ci dà l'efficienza.

267
00:19:53,220 --> 00:19:56,400
Questo è ciò che rende la ricerca binaria più veloce.

268
00:19:56,530 --> 00:20:03,540
Quindi stiamo saltando tutti questi elementi e ci stiamo concentrando solo su questa parte, il che

269
00:20:03,540 --> 00:20:10,290
significa che ora possiamo fare una chiamata ricorsiva e dire semplicemente la ricerca binaria OK.

270
00:20:10,320 --> 00:20:17,480
E abbiamo bisogno di passare la matrice e abbiamo bisogno di passare in ordine gli indici.

271
00:20:17,480 --> 00:20:19,390
Quindi il mezzo era per qui.

272
00:20:19,400 --> 00:20:25,340
Questo era il Met ma dal momento che l'elemento è più grande di questo deve essere da qui.

273
00:20:25,340 --> 00:20:30,460
Quindi per il minimo passeremo metà più 1 e molto più in alto.

274
00:20:30,500 --> 00:20:37,420
Passeremo semplicemente tutto ciò che abbiamo qui, che è 8 e l'elemento sarà passato di nuovo.

275
00:20:37,460 --> 00:20:39,890
Quindi questo med plus 1 non è altro che 5.

276
00:20:40,340 --> 00:20:46,290
Quindi questa è la prossima chiamata ricorsiva e per questo calcoleremo ancora una volta il risultato.

277
00:20:46,370 --> 00:20:51,330
Quindi sarebbero cinque più otto 13 per 2, che sarebbero 6.

278
00:20:51,450 --> 00:20:51,750
OK.

279
00:20:51,780 --> 00:20:54,380
Sarebbe il sei punto cinque ma troncato a sei.

280
00:20:54,380 --> 00:21:02,240
Quindi la vedremo di 6, che non è altro che questo settantuno e lo paragoniamo

281
00:21:02,240 --> 00:21:06,130
a sessantacinque e sessantacinque come meno.

282
00:21:06,200 --> 00:21:10,230
Quindi, questo significa che dobbiamo guardare solo a quest'area.

283
00:21:10,740 --> 00:21:11,030
OK.

284
00:21:11,060 --> 00:21:18,740
Quindi in precedenza sai che abbiamo limitato il nostro io a questa parte, ma ora che questa invocazione dal 65 è

285
00:21:18,800 --> 00:21:22,440
inferiore a settantuno non può far parte di questo.

286
00:21:22,460 --> 00:21:31,310
OK, quindi deve essere solo in quest'area, il che significa che la nostra prossima chiamata sarà qualcosa

287
00:21:31,310 --> 00:21:38,280
come questa ricerca binaria di ae deve essere la parte più a sinistra.

288
00:21:38,750 --> 00:21:41,690
Quindi in questo caso si vedrebbe la legge.

289
00:21:41,720 --> 00:21:46,120
Quindi avremo ancora cinque sulla parte superiore sarebbe reso meno uno.

290
00:21:46,130 --> 00:21:49,580
Quindi prima Matt era qui, quindi sarebbe diventato meno uno.

291
00:21:50,210 --> 00:21:53,940
OK, così Matt aveva sei anni, quindi meno uno sarà cinque.

292
00:21:54,680 --> 00:21:56,470
E avremo anche sessantacinque.

293
00:21:56,480 --> 00:21:57,910
Ora ancora una volta.

294
00:21:58,060 --> 00:22:04,240
Quindi questo è ciò che abbiamo ora che questa invocazione sia inferiore che superiore sono uguali.

295
00:22:04,400 --> 00:22:12,200
E questo sarebbe il nostro caso base se si vedesse sempre più in basso, allora dovremo interrompere la nostra ricorsione

296
00:22:12,200 --> 00:22:17,290
e controlleremo se l'elemento in questa posizione va bene se è sessantacinque.

297
00:22:17,820 --> 00:22:18,110
OK.

298
00:22:18,110 --> 00:22:23,700
E nel nostro caso alla elementare 60 se il file di posizione è effettivamente sessantacinque.

299
00:22:23,900 --> 00:22:26,600
Quindi vorremmo restituire quel particolare valore.

300
00:22:26,600 --> 00:22:28,160
Ecco cosa sta succedendo.

301
00:22:28,250 --> 00:22:29,630
E quando torniamo.

302
00:22:29,750 --> 00:22:31,660
Quindi dovremmo restituire il file di valori.

303
00:22:32,420 --> 00:22:36,560
Quindi, se non fosse stato 65, sarebbe ritornato meno uno.

304
00:22:37,250 --> 00:22:39,950
Ecco come funziona l'algoritmo.

305
00:22:39,950 --> 00:22:45,170
Ora andiamo avanti e rapidamente raggiunto questo, quindi dovrebbe essere interessante.

306
00:22:45,170 --> 00:22:47,560
Quindi abbiamo il metodo qui.

307
00:22:47,720 --> 00:22:56,820
Abbiamo solo bisogno di riempire questo in modo che questo avrebbe un'efficienza logaritmica e quindi la glassatura è proviamo il

308
00:22:56,850 --> 00:22:57,830
caso base.

309
00:22:57,930 --> 00:23:00,330
Così abbiamo come Alan Edge in questo.

310
00:23:00,540 --> 00:23:05,930
Quindi controlleremo se è uguale a bordo se questo è il caso.

311
00:23:05,970 --> 00:23:06,210
OK.

312
00:23:06,240 --> 00:23:13,270
Quindi dobbiamo verificare se la nostra chiave è una chiamata a una disattivazione.

313
00:23:13,680 --> 00:23:16,780
Ecco come El o off.

314
00:23:16,910 --> 00:23:18,420
Non importa.

315
00:23:18,780 --> 00:23:22,420
Se è lo stesso, dobbiamo restituire l'indice.

316
00:23:22,780 --> 00:23:23,160
Destra.

317
00:23:23,180 --> 00:23:29,260
Perché abbiamo trovato il nostro elemento come vorremmo restituire meno 1.

318
00:23:29,360 --> 00:23:36,350
Ora se questo non è il caso, significa che dovremmo fare una chiamata ricorsiva prima di tutto, dobbiamo

319
00:23:36,770 --> 00:23:44,120
calcolare l'elemento metallico che verrebbe aggiunto più incisione per assicurarsi che le parentesi siano lì perché altrimenti senza le

320
00:23:44,120 --> 00:23:46,900
parentesi questo otterrebbe una precedenza più alta.

321
00:23:46,910 --> 00:23:49,730
Sarebbe inciso per 2 e poi verrà aggiunto all'errore.

322
00:23:50,420 --> 00:23:52,330
Quindi abbiamo bisogno della parentesi qui.

323
00:23:52,460 --> 00:24:11,490
Ora controlleremo fa se la nostra chiave è uguale alla e della metà del nostro ritorno, e se è maggiore di lui, possiamo saltare la parte

324
00:24:11,490 --> 00:24:23,120
sinistra del giorno e possiamo solo cercare la parte superiore di la matrice che viene dal

325
00:24:23,120 --> 00:24:26,050
MIT più uno.

326
00:24:26,090 --> 00:24:30,180
Quindi diremmo la ricerca binaria eh.

327
00:24:30,380 --> 00:24:34,820
Quindi nella nuova invocazione l'elemento inferiore deve essere fatto più uno.

328
00:24:34,820 --> 00:24:38,840
Quindi dobbiamo passare il MIT più 1 e più alto sarebbe lo stesso.

329
00:24:38,840 --> 00:24:44,880
Quindi trimestre come noi come indice superiore più alto passiamo semplicemente lo stesso.

330
00:24:44,990 --> 00:24:49,690
E abbiamo anche passato la chiave.

331
00:24:49,870 --> 00:24:57,310
Ora l'ultimo è se anche questo fallisce, il che significa che la chiave è inferiore a metà di quella di B.

332
00:24:57,310 --> 00:25:00,310
Dobbiamo scansionare solo la parte inferiore della destra.

333
00:25:00,570 --> 00:25:01,260
Tutto ok.

334
00:25:01,300 --> 00:25:02,490
Quindi dovremmo

335
00:25:05,290 --> 00:25:13,150
separare e una parte inferiore dell'array per la parte inferiore l'indice più basso sarebbe lo stesso indice di come.

336
00:25:13,200 --> 00:25:13,980
Va bene.

337
00:25:14,350 --> 00:25:19,730
E l'indice più alto nella prossima iterazione sarebbe reso meno 1.

338
00:25:19,840 --> 00:25:20,890
E sarebbe la chiave.

339
00:25:21,160 --> 00:25:21,300
Va bene.

340
00:25:21,490 --> 00:25:22,630
Quindi questo è quello che abbiamo.

341
00:25:23,530 --> 00:25:24,700
Quindi questo è l'impostazione predefinita.

342
00:25:24,940 --> 00:25:31,090
Quindi se entrambi falliscono, allora arriviamo a quello di default dove key è inferiore a e off.

343
00:25:31,810 --> 00:25:33,100
Quindi questo è quello che abbiamo.

344
00:25:33,100 --> 00:25:35,330
Andiamo avanti ed eseguiamolo.

345
00:25:35,350 --> 00:25:39,150
Quindi lascia che copi tutto questo nella questione principale.

346
00:25:41,120 --> 00:25:43,130
E questo restituisce l'indice.

347
00:25:43,160 --> 00:25:45,650
Quindi fammi vedere l'indice equivale a questo X

348
00:25:49,380 --> 00:25:49,780
..

349
00:25:49,800 --> 00:25:51,800
Quindi lasciami correre.

350
00:25:51,930 --> 00:25:55,210
Quindi deve stampare bene quel valore dell'indice.

351
00:25:55,400 --> 00:26:03,600
Ora se passiamo diciamo trentaquattro qui ne stamperebbe tre perché 30 40 appare nella terza

352
00:26:03,600 --> 00:26:04,730
posizione.

353
00:26:04,770 --> 00:26:07,480
Allo stesso modo se passi cento che non c'è.

354
00:26:08,120 --> 00:26:09,880
Deve tornare meno uno.

355
00:26:09,880 --> 00:26:11,740
Quindi meno uno è stato scritto.

356
00:26:11,850 --> 00:26:14,700
Quindi questo è tutto quello che c'è nella ricerca binaria.

357
00:26:14,700 --> 00:26:18,300
Quindi è molto più efficiente e comparato a fattoriale.

358
00:26:18,300 --> 00:26:24,690
Qui ne abbiamo due in posizione ma solo in una determinata esecuzione del metodo solo uno di essi

359
00:26:24,690 --> 00:26:25,440
verrebbe invocato.

360
00:26:26,070 --> 00:26:28,950
Quindi è leggermente diverso qui ma dentro

361
00:26:29,040 --> 00:26:36,120
Ad esempio per noi stessi e io faremo anche in luoghi simili a questo, ma non

362
00:26:36,120 --> 00:26:38,990
avremmo una condizione di questo tipo.

363
00:26:39,030 --> 00:26:44,580
Quindi entrambe le invocazioni sarebbero eseguite e come funzionerebbe in un modo leggermente diverso.

364
00:26:45,390 --> 00:26:54,350
OK così detto e quindi sappiamo come una buona idea su come la ricorsione funzionerebbe.

365
00:26:54,640 --> 00:26:55,620
E questo è tutto.

366
00:26:55,650 --> 00:26:58,740
E questo codice sarà disponibile nella sezione risorse.

367
00:26:58,740 --> 00:27:00,450
Grazie e buon codice.