1
00:00:00,000 --> 00:00:09,560

2
00:00:09,560 --> 00:00:13,120
>> ZAMYLA CHAN: La prima cosa che si potrebbe
avviso sul ritrovamento è che abbiamo già

3
00:00:13,120 --> 00:00:14,520
hanno il codice scritto per noi.

4
00:00:14,520 --> 00:00:16,219
Questo è chiamato codice di distribuzione.

5
00:00:16,219 --> 00:00:19,060
Quindi non stiamo solo scrivendo il nostro
codice da zero più.

6
00:00:19,060 --> 00:00:23,870
Piuttosto, stiamo riempiendo i vuoti
in qualche codice preesistente.

7
00:00:23,870 --> 00:00:28,860
>> Il programma find.c richiede numeri
per riempire il pagliaio, cerca l'

8
00:00:28,860 --> 00:00:33,260
mucchio di fieno per un ago inseriti dall'utente,
e lo fa chiamando ordinamento e

9
00:00:33,260 --> 00:00:36,660
ricerca, funzioni definite
in helpers.c.

10
00:00:36,660 --> 00:00:38,740
Così find.c è scritto già.

11
00:00:38,740 --> 00:00:41,840
Il vostro compito è quello di scrivere aiutanti.

12
00:00:41,840 --> 00:00:42,940
>> Allora, cosa stiamo facendo?

13
00:00:42,940 --> 00:00:45,270
Stiamo implementando due funzioni.

14
00:00:45,270 --> 00:00:50,110
Ricerca, che restituisce true se un valore
si trova nel pagliaio, di ritorno

15
00:00:50,110 --> 00:00:52,430
false se il valore è
non nel pagliaio.

16
00:00:52,430 --> 00:00:59,060
E poi stiamo attuazione anche sort,
che ordina l'array chiamato valori.

17
00:00:59,060 --> 00:01:01,120
Quindi cerchiamo di affrontare la ricerca.

18
00:01:01,120 --> 00:01:04,550
>> Ricerca è attualmente implementato
come una ricerca lineare.

19
00:01:04,550 --> 00:01:06,620
Ma si può fare molto meglio di così.

20
00:01:06,620 --> 00:01:11,610
Ricerca lineare è implementato in O di n
tempo, che è piuttosto lento, sebbene

21
00:01:11,610 --> 00:01:14,920
Puoi cercare qualsiasi lista data ad essa.

22
00:01:14,920 --> 00:01:21,190
Il vostro compito è quello di implementare la ricerca binaria,
che ha tempo di esecuzione O di log n.

23
00:01:21,190 --> 00:01:22,200
Questo è abbastanza veloce.

24
00:01:22,200 --> 00:01:24,240
>> Ma c'è una clausola.

25
00:01:24,240 --> 00:01:28,910
La ricerca binaria può cercare solo
attraverso liste pre-ordinati.

26
00:01:28,910 --> 00:01:31,450
Perché è così?

27
00:01:31,450 --> 00:01:33,690
Bene, diamo un'occhiata a un esempio.

28
00:01:33,690 --> 00:01:37,350
Dato un array di valori, pagliaio,
stiamo andando a guardare

29
00:01:37,350 --> 00:01:41,510
un ago, e in questo
, il numero intero 3.

30
00:01:41,510 --> 00:01:45,220
>> Il modo in cui ricerca binaria funziona è che
confrontiamo il valore medio di

31
00:01:45,220 --> 00:01:49,430
la matrice all'ago, molto simile a come
abbiamo aperto una rubrica a metà

32
00:01:49,430 --> 00:01:51,720
la pagina in settimana 0.

33
00:01:51,720 --> 00:01:55,710
Così, dopo aver confrontato il valore medio di
l'ago, si può scartare sia l'

34
00:01:55,710 --> 00:01:59,620
sinistra oa destra della matrice
stringendo i vostri limiti.

35
00:01:59,620 --> 00:02:04,450
In questo caso, poiché 3, la nostra ago, è
inferiore a 10, il valore medio, la

36
00:02:04,450 --> 00:02:07,060
proprio limite può diminuire.

37
00:02:07,060 --> 00:02:09,470
>> Ma cercare di rendere i vostri limiti
il più stretto possibile.

38
00:02:09,470 --> 00:02:12,690
Se il valore medio non è l'ago,
poi si sa che non c'è bisogno di

39
00:02:12,690 --> 00:02:14,070
includere nella ricerca.

40
00:02:14,070 --> 00:02:18,390
Così il vostro limite destro può stringere la
limiti della ricerca in un pochino di più,

41
00:02:18,390 --> 00:02:22,840
e così via e così via, fino
a trovare l'ago.

42
00:02:22,840 --> 00:02:24,580
>> Quindi cosa fa il pseudo
codice assomiglia?

43
00:02:24,580 --> 00:02:28,980
Ebbene, mentre stiamo ancora guardando attraverso
l'elenco e ancora

44
00:02:28,980 --> 00:02:33,540
elementi da cercare in, prendiamo la metà
della lista e confrontare tale

45
00:02:33,540 --> 00:02:36,020
valore centrale per il nostro ago.

46
00:02:36,020 --> 00:02:38,380
Se sono uguali, allora significa che abbiamo
trovato l'ago, e possiamo

47
00:02:38,380 --> 00:02:40,160
return true.

48
00:02:40,160 --> 00:02:43,940
>> Altrimenti, se l'ago è inferiore
il valore medio, allora questo significa che

49
00:02:43,940 --> 00:02:48,350
può scartare la metà destra e giusto
verificare il lato sinistro della matrice.

50
00:02:48,350 --> 00:02:51,860
In caso contrario, ci cerchiamo l'
lato destro della matrice.

51
00:02:51,860 --> 00:02:55,470
E alla fine, se non si dispone di alcun
più elementi lasciati a cercare, ma voi

52
00:02:55,470 --> 00:02:58,030
non hanno ancora trovato l'ago,
poi si torna falso.

53
00:02:58,030 --> 00:03:02,960
Poiché l'ago sicuramente
non è nel pagliaio.

54
00:03:02,960 --> 00:03:06,200
>> Ora, una cosa semplice di questa pseudo
codice binario di ricerca è che può

55
00:03:06,200 --> 00:03:11,000
essere interpretato sia come iterativo
o implementazione ricorsiva.

56
00:03:11,000 --> 00:03:14,900
Quindi sarebbe ricorsiva se si chiama
la funzione di ricerca all'interno della ricerca

57
00:03:14,900 --> 00:03:18,400
funzionamento su entrambi metà dell'array.

58
00:03:18,400 --> 00:03:20,750
Parleremo ricorsione un po '
più avanti nel corso.

59
00:03:20,750 --> 00:03:23,210
Ma non sanno che si tratta di un'opzione
se vuoi provare.

60
00:03:23,210 --> 00:03:24,460