1
00:00:00,000 --> 00:00:12,350
>> [Музички]

2
00:00:12,350 --> 00:00:13,050
>> Роб BOWDEN: Здраво.

3
00:00:13,050 --> 00:00:13,640
Јас сум Роб.

4
00:00:13,640 --> 00:00:16,210
И ајде ова решение надвор.

5
00:00:16,210 --> 00:00:20,070
Па еве ние ќе се спроведе
општа маса.

6
00:00:20,070 --> 00:00:24,090
Можеме да видиме дека struct јазол на нашата
маса ќе изгледа вака.

7
00:00:24,090 --> 00:00:28,710
Па затоа се случува да имаат знак збор
низа од големината должина + 1.

8
00:00:28,710 --> 00:00:32,259
Не заборавајте + 1, со оглед на максимум
збор во речникот е 45

9
00:00:32,259 --> 00:00:33,130
карактери.

10
00:00:33,130 --> 00:00:37,070
А потоа ние ќе ви треба една дополнителна
карактер за обратна коса црта нула.

11
00:00:37,070 --> 00:00:40,870
>> А потоа нашите hashtable во секој
кофа ќе се складира

12
00:00:40,870 --> 00:00:42,320
поврзана листа на јазли.

13
00:00:42,320 --> 00:00:44,420
Ние не правиме линеарни љубопитство тука.

14
00:00:44,420 --> 00:00:48,430
И така со цел да се поврзат со следниот
елемент во кофа, потребен ни е

15
00:00:48,430 --> 00:00:50,390
struct јазол * следната.

16
00:00:50,390 --> 00:00:51,110
OK.

17
00:00:51,110 --> 00:00:53,090
Значи тоа е она што еден јазол изгледа.

18
00:00:53,090 --> 00:00:56,180
>> Сега тука е декларација
на нашите hashtable.

19
00:00:56,180 --> 00:00:59,640
Тоа се случува да имаат 16.834 кофи.

20
00:00:59,640 --> 00:01:01,910
Но тој број не е важно.

21
00:01:01,910 --> 00:01:05,450
И, конечно, ние ќе треба да имаат
глобалната променлива hashtable големина, што

22
00:01:05,450 --> 00:01:07,000
се случува да започнете како нула.

23
00:01:07,000 --> 00:01:10,760
И тоа се случува да ги пратите на тоа како
многу зборови се наоѓаат во нашата речникот.

24
00:01:10,760 --> 00:01:13,710
>> Па ајде да ги разгледаме во товарот.

25
00:01:13,710 --> 00:01:16,390
Забележите дека товарот, го враќа bool.

26
00:01:16,390 --> 00:01:20,530
Ќе се вратите точно ако тоа беше успешно
вчитан, и лажни поинаку.

27
00:01:20,530 --> 00:01:23,990
И е потребно const char * речник,
кој е речникот

28
00:01:23,990 --> 00:01:25,280
дека сакаме да се отвори.

29
00:01:25,280 --> 00:01:27,170
Па тоа е првото нешто
ние ќе се направи.

30
00:01:27,170 --> 00:01:29,500
>> Ние ќе fopen на
речник за читање.

31
00:01:29,500 --> 00:01:31,680
И ние ќе треба да се направи
сигурни дека тоа успеа.

32
00:01:31,680 --> 00:01:35,920
Значи, ако се врати NULL, тогаш ние не сме
успешно да се отвори во речникот.

33
00:01:35,920 --> 00:01:37,440
И ние треба да се врати лажни.

34
00:01:37,440 --> 00:01:41,580
Но претпоставувајќи дека тоа го правеше успешно
отвори, а потоа ние сакаме да го прочитате

35
00:01:41,580 --> 00:01:42,400
речникот.

36
00:01:42,400 --> 00:01:46,450
Значи имајте looping додека не се најде некој
причина да се пробие на овој циклус,

37
00:01:46,450 --> 00:01:47,570
кој ќе видиме.

38
00:01:47,570 --> 00:01:48,920
Значи имајте looping.

39
00:01:48,920 --> 00:01:51,780
>> И сега ние ќе треба да
Примерок еден јазол.

40
00:01:51,780 --> 00:01:54,020
И се разбира, ние треба
да воздух проверете повторно.

41
00:01:54,020 --> 00:01:58,680
Па ако mallocing не успее, тогаш
ние сакаме да се исклучи било кој јазол дека ние

42
00:01:58,680 --> 00:02:02,590
се случи со Примерок пред, во близина на
речник и да се врати лажни.

43
00:02:02,590 --> 00:02:06,830
Но игнорирањето тоа, претпоставувајќи дека
успеа, тогаш сакаме да се користи fscanf

44
00:02:06,830 --> 00:02:12,400
да се прочита еден збор од нашиот
речникот во нашите јазол.

45
00:02:12,400 --> 00:02:17,940
Па се сеќавам дека влез> збор е знак
Зборот тампон големина LENGHTH + 1

46
00:02:17,940 --> 00:02:20,300
дека ние ќе треба да се сместат на зборот внатре

47
00:02:20,300 --> 00:02:25,070
>> Па fscanf се случува да се врати 1, се додека
како што беше во состојба успешно да

48
00:02:25,070 --> 00:02:26,750
чита зборот од датотеката.

49
00:02:26,750 --> 00:02:30,460
Ако било грешка се случува, или ние
стигнат до крајот на датотеката, таа

50
00:02:30,460 --> 00:02:31,950
нема да се врати 1.

51
00:02:31,950 --> 00:02:35,180
Во кој случај не го врати 1,
ние сме конечно ќе излезат од

52
00:02:35,180 --> 00:02:37,280
ова додека јамка.

53
00:02:37,280 --> 00:02:42,770
Така можеме да видиме дека еднаш имаме успешно
чита збор во

54
00:02:42,770 --> 00:02:48,270
влез> зборот, тогаш ние ќе треба да дека
Зборот за користење на нашата хеш функција.

55
00:02:48,270 --> 00:02:49,580
>> Ајде да ги разгледаме во
хаш функција.

56
00:02:49,580 --> 00:02:52,430

57
00:02:52,430 --> 00:02:55,610
Така да навистина не треба
да се разбере ова.

58
00:02:55,610 --> 00:02:59,460
А всушност ние само се повлече овој хаш
функционира од интернет.

59
00:02:59,460 --> 00:03:04,010
Единственото нешто што треба да се признае е
дека ова се const char * збор.

60
00:03:04,010 --> 00:03:08,960
Па тоа е преземање на низа како влез, и
враќање на непотпишана int како излез.

61
00:03:08,960 --> 00:03:12,360
Па тоа е сите хеш функција е, тоа е
зема во влез и ви дава

62
00:03:12,360 --> 00:03:14,490
индекс во hashtable.

63
00:03:14,490 --> 00:03:18,530
>> Забележете дека ние сме moding од NUM_BUCKETS,
така што вредност врати

64
00:03:18,530 --> 00:03:21,730
всушност е индекс во hashtable
и не индекс надвор од

65
00:03:21,730 --> 00:03:24,320
границите на низата.

66
00:03:24,320 --> 00:03:28,060
Па со оглед на тоа функционира, ние ќе
да хаш зборот што го читаме

67
00:03:28,060 --> 00:03:29,390
речникот.

68
00:03:29,390 --> 00:03:31,700
А потоа ние ќе го користите
дека хаш да го вметнете

69
00:03:31,700 --> 00:03:33,750
влез во hashtable.

70
00:03:33,750 --> 00:03:38,520
>> Сега hashtable хаш е моменталниот
поврзана листа во табелата.

71
00:03:38,520 --> 00:03:41,410
И тоа е многу можно
дека тоа е само NULL.

72
00:03:41,410 --> 00:03:44,960
Ние сакаме да го внесете нашиот влез на
почетокот на овој поврзана листа.

73
00:03:44,960 --> 00:03:48,600
И така ние си оди за да имаат нашите сегашни
влезна точка на она што hashtable

74
00:03:48,600 --> 00:03:50,380
во моментов посочува.

75
00:03:50,380 --> 00:03:53,310
И тогаш ние ќе ги чувате,
во hashtable во

76
00:03:53,310 --> 00:03:55,350
хаш, сегашниот влез.

77
00:03:55,350 --> 00:03:59,320
Значи овие две линии успешно вметнете
влез на почетокот на

78
00:03:59,320 --> 00:04:02,260
поврзана листа на тој индекс
во hashtable.

79
00:04:02,260 --> 00:04:04,900
>> Откако ќе завршиш со тоа, знаеме
кои ние откривме друг збор во

80
00:04:04,900 --> 00:04:07,790
речник, и ние прираст повторно.

81
00:04:07,790 --> 00:04:13,960
Па ние го задржи тоа го прават додека fscanf
конечно се врати нешто не-1 на

82
00:04:13,960 --> 00:04:16,950
која точка да се запамети дека
ние треба да се ослободи влез.

83
00:04:16,950 --> 00:04:19,459
Значи тука имаме malloced запис.

84
00:04:19,459 --> 00:04:21,329
И се обидовме да прочитате нешто
од речникот.

85
00:04:21,329 --> 00:04:23,910
И ние не успешно го прочитате
нешто од речникот, во

86
00:04:23,910 --> 00:04:26,650
кој случај ние треба да се ослободи влезот
дека ние всушност никогаш не се стави во

87
00:04:26,650 --> 00:04:29,140
hashtable, и конечно се скрши.

88
00:04:29,140 --> 00:04:32,750
>> Откако ќе се пробие ние треба да се види, добро,
не ни се пробие затоа што има

89
00:04:32,750 --> 00:04:34,360
Се појави грешка при читањето од датотеката?

90
00:04:34,360 --> 00:04:37,120
Или не ние се пробие, бидејќи ние
до крајот на датотеката?

91
00:04:37,120 --> 00:04:39,480
Ако има грешка, тогаш
ние сакаме да се врати лажни.

92
00:04:39,480 --> 00:04:40,930
Бидејќи товарот не успее.

93
00:04:40,930 --> 00:04:43,890
И во процесот ние сакаме да се исклучи
сите зборови, што читаме во, и

94
00:04:43,890 --> 00:04:45,670
затвори речникот.

95
00:04:45,670 --> 00:04:48,740
>> Претпоставувајќи ние не успее, тогаш ние само
уште треба да се затвори речникот

96
00:04:48,740 --> 00:04:53,040
поднесе, и конечно враќање вистина, бидејќи ние
успешно вчитан речникот.

97
00:04:53,040 --> 00:04:54,420
И тоа е тоа за товарот.

98
00:04:54,420 --> 00:04:59,020
Па сега провери, со оглед натоварени hashtable,
ќе изгледа вака.

99
00:04:59,020 --> 00:05:03,140
Па провери, го враќа bool, што е
ќе покаже дали помина

100
00:05:03,140 --> 00:05:07,530
во char * збор, дали помина
во стринг е во нашата речникот.

101
00:05:07,530 --> 00:05:09,890
Значи, ако тоа е во речникот,
ако тоа е во нашата hashtable,

102
00:05:09,890 --> 00:05:11,170
ние ќе се врати вистина.

103
00:05:11,170 --> 00:05:13,380
И ако тоа не е, ние ќе се врати лажни.

104
00:05:13,380 --> 00:05:17,740
>> Имајќи го предвид ова донесен во збор, ние сме
ќе хаш на зборот.

105
00:05:17,740 --> 00:05:22,110
Сега важна работа да се признае е
дека во товарот знаевме дека сите

106
00:05:22,110 --> 00:05:23,820
зборови ние ќе биде помал случај.

107
00:05:23,820 --> 00:05:25,820
Но тука ние не сме толку сигурни.

108
00:05:25,820 --> 00:05:29,510
Доколку ги разгледаме во нашата хеш функција,
нашите хаш функција, всушност,

109
00:05:29,510 --> 00:05:32,700
е помал обвивка секој карактер
на зборот.

110
00:05:32,700 --> 00:05:37,940
Значи без оглед на капитализација на
збор, нашата hash функција е враќање

111
00:05:37,940 --> 00:05:42,270
истиот индекс за без оглед на
капитализација е, како што ќе има

112
00:05:42,270 --> 00:05:45,280
врати за сосема мали
верзија на зборот.

113
00:05:45,280 --> 00:05:46,600
Во ред.

114
00:05:46,600 --> 00:05:49,790
Тоа е нашиот индекс е во
Hashtable за овој збор.

115
00:05:49,790 --> 00:05:52,940
>> Сега ова за телефонска линија ќе
iterate преку поврзана листа

116
00:05:52,940 --> 00:05:55,000
кој беше во тој индекс.

117
00:05:55,000 --> 00:05:59,610
Така забележите ние сме иницијализацијата влез
да се укаже на тој индекс.

118
00:05:59,610 --> 00:06:02,750
Ние ќе продолжиме
додека влез! = NULL.

119
00:06:02,750 --> 00:06:07,770
И се сеќавам дека ажурирање на покажувачот
во нашата поврзана листа влез = влез> Next.

120
00:06:07,770 --> 00:06:14,400
Па имаат нашите сегашни влезна точка за да
следната точка во поврзана листа.

121
00:06:14,400 --> 00:06:19,250
>> Значи за секој влез во поврзана листа,
ние ќе го користите strcasecmp.

122
00:06:19,250 --> 00:06:20,330
Тоа не е strcomp.

123
00:06:20,330 --> 00:06:23,780
Бидејќи уште еднаш, ние сакаме да
се прават работите случај буквите.

124
00:06:23,780 --> 00:06:27,870
Па ние ги користиме strcasecmp да се споредат
збор кој беше донесен во текот на овој

125
00:06:27,870 --> 00:06:31,860
функција против зборот
што е во овој запис.

126
00:06:31,860 --> 00:06:35,570
Ако го враќа нула, што значи дека имаше
еден натпревар, во кој случај ние сакаме да

127
00:06:35,570 --> 00:06:36,630
врати вистина.

128
00:06:36,630 --> 00:06:39,590
Ние успешно се најде на
збор во нашите hashtable.

129
00:06:39,590 --> 00:06:43,040
>> Ако не беше еден натпревар, тогаш ние сме
ќе јамка повторно и се погледне на

130
00:06:43,040 --> 00:06:43,990
Следниот влез.

131
00:06:43,990 --> 00:06:47,640
И ние ќе продолжиме looping додека постојат
се записи во оваа поврзани листа.

132
00:06:47,640 --> 00:06:50,160
Што се случува ако ние се скрши
надвор од овој за телефонска линија?

133
00:06:50,160 --> 00:06:55,110
Тоа значи дека ние не најде запис дека
одговараше овој збор, во кој случај

134
00:06:55,110 --> 00:07:00,220
ние се врати лажни за да се покаже дека нашите
hashtable не содржи овој збор.

135
00:07:00,220 --> 00:07:02,540
И тоа е чек.

136
00:07:02,540 --> 00:07:04,790
>> Па ајде да ги разгледаме во големина.

137
00:07:04,790 --> 00:07:06,970
Сега големина ќе биде прилично едноставна.

138
00:07:06,970 --> 00:07:11,080
Од сеќавам во оптоварување, за секој збор
најдовме, ние зголемува глобалната

139
00:07:11,080 --> 00:07:12,880
променлива големина hashtable.

140
00:07:12,880 --> 00:07:16,480
Па големината функција е само ќе
да се вратат глобалната променлива.

141
00:07:16,480 --> 00:07:18,150
И тоа е тоа.

142
00:07:18,150 --> 00:07:22,300
>> Сега, конечно, ние треба да се вчита на
речник еднаш сè е направено.

143
00:07:22,300 --> 00:07:25,340
Па, како ќе се дојде да го направите тоа?

144
00:07:25,340 --> 00:07:30,440
Токму тука ние сме looping преку
сите кофи со нашата маса.

145
00:07:30,440 --> 00:07:33,240
Па така постојат NUM_BUCKETS кофи.

146
00:07:33,240 --> 00:07:37,410
И за секоја поврзана листа во нашата
hashtable, ние ќе треба да прават јамки низ

147
00:07:37,410 --> 00:07:41,070
интегритет на поврзаните листа,
ослободување секој елемент.

148
00:07:41,070 --> 00:07:42,900
>> Сега ние треба да се биде внимателен.

149
00:07:42,900 --> 00:07:47,910
Значи тука имаме привремена променлива
тоа е чување на покажувачот на следната

150
00:07:47,910 --> 00:07:49,730
елемент во поврзана листа.

151
00:07:49,730 --> 00:07:52,140
А потоа ние ќе слободен
тековниот елемент.

152
00:07:52,140 --> 00:07:55,990
Ние треба да бидеме сигурни дека ние го правиме ова, бидејќи ние
не може само слободен тековниот елемент

153
00:07:55,990 --> 00:07:59,180
а потоа се обиде да пристапи на следната покажувач,
бидејќи еднаш ние сме го ослободија,

154
00:07:59,180 --> 00:08:00,870
меморија станува неважечка.

155
00:08:00,870 --> 00:08:04,990
>> Значи ние треба да се задржи околу покажувачот на
следниот елемент, тогаш можеме да го ослободи

156
00:08:04,990 --> 00:08:08,360
тековниот елемент, а потоа можеме да се ажурира
нашите сегашни елемент да се укаже на

157
00:08:08,360 --> 00:08:09,550
следниот елемент.

158
00:08:09,550 --> 00:08:12,800
Ќе јамка додека постојат елементи
во овој поврзана листа.

159
00:08:12,800 --> 00:08:15,620
Ние ќе го направи тоа за сите поврзани
листи во hashtable.

160
00:08:15,620 --> 00:08:19,460
И штом ќе завршиш со тоа, ние сме
целосно истоваруваат hashtable, и

161
00:08:19,460 --> 00:08:20,190
ние сме направиле.

162
00:08:20,190 --> 00:08:23,200
Така што е невозможно за бриши
да некогаш се врати лажни.

163
00:08:23,200 --> 00:08:26,470
И кога ќе завршиш, ние
само врати вистина.

164
00:08:26,470 --> 00:08:29,000
>> Ајде да им даде на ова решение, се обиде.

165
00:08:29,000 --> 00:08:33,070
Па ајде да ги разгледаме во она што нашите
struct јазол ќе изгледа.

166
00:08:33,070 --> 00:08:36,220
Овде можеме да видиме ние ќе имаат bool
збор и struct јазол * деца

167
00:08:36,220 --> 00:08:37,470
заградата писмо.

168
00:08:37,470 --> 00:08:38,929

169
00:08:38,929 --> 00:08:42,020
Така првото нешто што може да биде
се прашувам, зошто е ALPHABET

170
00:08:42,020 --> 00:08:44,660
ед дефинирана како 27?

171
00:08:44,660 --> 00:08:47,900
Добро, се сеќавам дека ние ќе треба
да се справува со апостроф.

172
00:08:47,900 --> 00:08:51,910
Така што нема да биде нешто на некој
посебен случај во текот на оваа програма.

173
00:08:51,910 --> 00:08:54,710
>> Сега се сеќавам како TRIE
всушност работи.

174
00:08:54,710 --> 00:08:59,380
Да речеме дека ние сме индексирање зборот
"Мачки". Потоа од коренот на TRIE,

175
00:08:59,380 --> 00:09:02,610
ние ќе се погледне на деца
низа, и ние ќе треба да се погледне на

176
00:09:02,610 --> 00:09:08,090
индекс, кој одговара на писмото
C. Значи дека ќе бидат индексирани 2.

177
00:09:08,090 --> 00:09:11,530
Па со оглед на тоа, дека ќе
ни даде нов јазол.

178
00:09:11,530 --> 00:09:13,820
А потоа ние ќе работат од тој јазол.

179
00:09:13,820 --> 00:09:17,770
>> Па со оглед на тоа јазол, ние сме уште еднаш
ќе се погледне на децата низа.

180
00:09:17,770 --> 00:09:22,110
И ние ќе да се погледне во индекс нула
за да одговараат на А во мачка.

181
00:09:22,110 --> 00:09:27,170
Па тогаш ние ќе треба да одат на тој јазол,
и со оглед на тоа јазол ние ќе

182
00:09:27,170 --> 00:09:31,090
да се погледне на крајот тоа е одговара
со Т и премина на тој јазол,

183
00:09:31,090 --> 00:09:35,530
Конечно, имаме целосно погледна
преку нашето слово "мачка". И сега bool

184
00:09:35,530 --> 00:09:40,960
зборот би требало да покажат дали
ова даден збор е всушност еден збор.

185
00:09:40,960 --> 00:09:43,470
>> Па зошто не ни треба тој посебен случај?

186
00:09:43,470 --> 00:09:47,700
Па, она што на зборот "катастрофа"
е во нашата речник, но

187
00:09:47,700 --> 00:09:50,150
Зборот "мачка" не е?

188
00:09:50,150 --> 00:09:54,580
Па и бара да се види дали зборот "мачка"
е во нашата речник, ние сме

189
00:09:54,580 --> 00:09:59,970
ќе успешно се погледне преку
индексите C-A-T во регионот јазол.

190
00:09:59,970 --> 00:10:04,290
Но, тоа е само затоа што катастрофа
се случи да се создаде јазли на пат

191
00:10:04,290 --> 00:10:07,190
од C-A-T, сите на начин да
на крајот на збор.

192
00:10:07,190 --> 00:10:12,020
Па bool збор се користи за да се покаже дали
овој одредена локација

193
00:10:12,020 --> 00:10:14,310
всушност укажува на зборот.

194
00:10:14,310 --> 00:10:15,140
>> Во ред е.

195
00:10:15,140 --> 00:10:19,310
Па сега дека знаеме што TRIE е
ќе изгледа, ајде да се погледне на

196
00:10:19,310 --> 00:10:20,730
вчитување функција.

197
00:10:20,730 --> 00:10:24,610
Значи оптоварување се случува да се врати bool
за тоа дали ние успешно или

198
00:10:24,610 --> 00:10:26,720
неуспешно натоварен речникот.

199
00:10:26,720 --> 00:10:30,460
И ова ќе биде речникот
дека сакаме да се вчита.

200
00:10:30,460 --> 00:10:33,930
>> Па првото нешто сакаме да направите е да отворите
до кои речник за читање.

201
00:10:33,930 --> 00:10:36,160
И ние треба да бидете сигурни дека
ние не успеваат.

202
00:10:36,160 --> 00:10:39,580
Па ако речникот не беше
успешно отворен, ќе се врати

203
00:10:39,580 --> 00:10:42,400
нула, во кој случај ние сме
ќе се врати лажни.

204
00:10:42,400 --> 00:10:47,230
Но претпоставувајќи дека тоа успешно
отвори, тогаш ние всушност може да се прочита

205
00:10:47,230 --> 00:10:48,220
преку речникот.

206
00:10:48,220 --> 00:10:50,880
>> Па првото нешто ние ќе треба да
сакате да направите е да ја имаме оваа

207
00:10:50,880 --> 00:10:52,500
глобалната променлива корен.

208
00:10:52,500 --> 00:10:56,190
Сега корен ќе биде еден јазол *.

209
00:10:56,190 --> 00:10:59,760
Тоа е на врвот на нашата TRIE дека ние сме
ќе треба да се процесирањето преку.

210
00:10:59,760 --> 00:11:02,660
Така првото нешто што ние ќе
да сакаат да направите е да се доделат

211
00:11:02,660 --> 00:11:04,140
меморија за нашиот корен.

212
00:11:04,140 --> 00:11:07,980
Забележете дека ние сме со користење на calloc
функција, која е во основа иста

213
00:11:07,980 --> 00:11:11,500
како Примерок функција, освен тоа е
гарантирано да се вратат нешто што е

214
00:11:11,500 --> 00:11:13,180
целосно zeroed надвор.

215
00:11:13,180 --> 00:11:17,290
Значи, ако ние се користи Примерок, ние ќе треба да се
поминат низ сите покажувачи во нашата

216
00:11:17,290 --> 00:11:20,160
јазол, и бидете сигурни дека
сите тие се ништовни.

217
00:11:20,160 --> 00:11:22,710
Па calloc ќе го правам тоа за нас.

218
00:11:22,710 --> 00:11:26,330
>> Сега само како Примерок, ние треба да се направи
сигурни дека распределбата беше, всушност,

219
00:11:26,330 --> 00:11:27,520
успешна.

220
00:11:27,520 --> 00:11:29,990
Ако ова се врати на нула, тогаш ние
треба да се затвори или речник

221
00:11:29,990 --> 00:11:32,100
датотека и враќање false.

222
00:11:32,100 --> 00:11:36,835
Значи под претпоставка дека распределбата беше
успешна, ние ќе треба да се користи еден јазол *

223
00:11:36,835 --> 00:11:40,270
курсорот да iterate преку нашата TRIE.

224
00:11:40,270 --> 00:11:43,890
Па нашите корени никогаш нема да се промени,
но ние ќе се користи покажувачот

225
00:11:43,890 --> 00:11:47,875
всушност, оди од јазол да јазол.

226
00:11:47,875 --> 00:11:50,940
>> Така што во овој за телефонска линија читаме
преку речникот.

227
00:11:50,940 --> 00:11:53,670
И ние сме со користење fgetc.

228
00:11:53,670 --> 00:11:56,290
Fgetc се случува да го зграби еден
карактер од датотеката.

229
00:11:56,290 --> 00:11:59,370
Ние ќе продолжиме грабање
карактери, додека ние не се постигне

230
00:11:59,370 --> 00:12:01,570
крајот на датотеката.

231
00:12:01,570 --> 00:12:03,480
>> Постојат два случаи ние треба да се справи.

232
00:12:03,480 --> 00:12:06,610
Прво, ако карактерот
не е нова линија.

233
00:12:06,610 --> 00:12:10,450
Па знаеме дали тоа беше нова линија, а потоа
ние сме за да се движи кон нов збор.

234
00:12:10,450 --> 00:12:15,240
Но под претпоставка дека тоа не е нова линија, а потоа
Еве ние сакаме да дознаам

235
00:12:15,240 --> 00:12:18,380
индекс ние ќе индекс во
кај децата низа што

236
00:12:18,380 --> 00:12:19,810
ние погледна порано.

237
00:12:19,810 --> 00:12:23,880
>> Значи, како што реков претходно, ние треба да се
посебен случај на апостроф.

238
00:12:23,880 --> 00:12:26,220
Забележете ние сме со користење на тројна
оператор тука.

239
00:12:26,220 --> 00:12:29,580
Па ние ќе го прочитате овој пример, ако
ликот што читаме во беше

240
00:12:29,580 --> 00:12:35,330
апостроф, тогаш ние ќе треба да се постави
индекс = "азбука", која -1 ќе

241
00:12:35,330 --> 00:12:37,680
биде индекс 26.

242
00:12:37,680 --> 00:12:41,130
>> Друго, ако не беше апостроф, има
ние ќе се постави на индекс

243
00:12:41,130 --> 00:12:43,760
еднаква на c - a.

244
00:12:43,760 --> 00:12:49,030
Значи се сеќавам назад од претходно п-сетови,
в - а се случува да ни даде

245
00:12:49,030 --> 00:12:53,410
азбучен позиција на C. Значи, ако
C е буквата А, ова ќе

246
00:12:53,410 --> 00:12:54,700
ни даде индекс нула.

247
00:12:54,700 --> 00:12:58,120
За буквата Б, тоа ќе им даде
ни индекс 1, и така натаму.

248
00:12:58,120 --> 00:13:03,010
>> Па ова ни дава индекс во
деца низа што сакаме.

249
00:13:03,010 --> 00:13:08,890
Сега, ако овој индекс е моментално null во
децата, што значи дека еден јазол

250
00:13:08,890 --> 00:13:11,830
во моментов не постојат
од тој пат.

251
00:13:11,830 --> 00:13:15,160
Значи ние треба да ги распредели
јазол за тој пат.

252
00:13:15,160 --> 00:13:16,550
Тоа е она што ние ќе направиме тука.

253
00:13:16,550 --> 00:13:20,690
>> Па ние ќе повторно да ги користите calloc
функција, така што ние не треба да се

254
00:13:20,690 --> 00:13:22,880
нула надвор сите покажувачи.

255
00:13:22,880 --> 00:13:27,240
И повторно треба да се провери
дека calloc не пропадне.

256
00:13:27,240 --> 00:13:30,700
Ако calloc не успее, тогаш ние треба
да се исклучи сè, да ги затвориме

257
00:13:30,700 --> 00:13:32,820
речник, и да се врати лажни.

258
00:13:32,820 --> 00:13:40,050
Значи под претпоставка дека тоа не успее, тогаш
ова ќе се создаде нов дете за нас.

259
00:13:40,050 --> 00:13:41,930
И потоа ќе одат на тоа дете.

260
00:13:41,930 --> 00:13:44,960
Нашите курсорот ќе iterate
надолу за да тоа дете.

261
00:13:44,960 --> 00:13:49,330
>> Сега, ако ова не е нула за да започне со тоа,
тогаш покажувачот само да iterate

262
00:13:49,330 --> 00:13:52,590
надолу за да тоа дете без всушност
мора да се доделат ништо.

263
00:13:52,590 --> 00:13:56,730
Ова е случај каде што првпат се случи
распредели на зборот "мачка". И

264
00:13:56,730 --> 00:14:00,330
тоа значи дека кога одиме за алоцирање на
"Катастрофа", ние не треба да се создаде

265
00:14:00,330 --> 00:14:01,680
јазли за C-A-T повторно.

266
00:14:01,680 --> 00:14:04,830
Тие веќе постои.

267
00:14:04,830 --> 00:14:06,080
>> Што е ова на друго место?

268
00:14:06,080 --> 00:14:10,480
Ова е состојба каде што в беше
обратна коса црта n, каде в е нова линија.

269
00:14:10,480 --> 00:14:13,710
Ова значи дека имаме успешно
заврши збор.

270
00:14:13,710 --> 00:14:16,860
Сега што сакаме да правиме кога ќе
успешно заврши еден збор?

271
00:14:16,860 --> 00:14:21,100
Ние ќе се користи овој збор поле
внатрешноста на нашите struct јазол.

272
00:14:21,100 --> 00:14:23,390
Ние сакаме да го поставите тоа да се оствари.

273
00:14:23,390 --> 00:14:27,150
Така што укажува на тоа дека овој јазол
покажува успешна

274
00:14:27,150 --> 00:14:29,250
збор, вистински збор.

275
00:14:29,250 --> 00:14:30,940
>> Сега го поставите тоа да се оствари.

276
00:14:30,940 --> 00:14:35,150
Ние сакаме да ги ресетирате нашите курсорот точка
на почетокот на TRIE повторно.

277
00:14:35,150 --> 00:14:40,160
И конечно, прираст нашите речник
големина, бидејќи ние се најде друга работа.

278
00:14:40,160 --> 00:14:43,230
Па ние ќе да се задржи тоа го прават,
читање во знак по знак,

279
00:14:43,230 --> 00:14:49,150
изградба на нови јазли во нашата TRIE и
за секој збор во речникот, додека

280
00:14:49,150 --> 00:14:54,020
ние конечно се постигне Ц! = EOF, во која
случај ние се пробие на датотеката.

281
00:14:54,020 --> 00:14:57,050
>> Сега постојат два случаи под
кои би можеле да имаат хит EOF.

282
00:14:57,050 --> 00:15:00,980
Првиот е ако имало грешка
читање од датотеката.

283
00:15:00,980 --> 00:15:03,470
Значи, ако имало грешка, ние
треба да се направи типичен.

284
00:15:03,470 --> 00:15:06,460
Бриши сè, во близина
датотеката, враќање false.

285
00:15:06,460 --> 00:15:09,810
Под претпоставка дека не беше грешка, дека
само значи дека ние всушност хит на крајот на

286
00:15:09,810 --> 00:15:13,750
на датотеката, во кој случај, ние затвори
датотека и враќање вистина, бидејќи ние

287
00:15:13,750 --> 00:15:17,330
успешно вчитан речник
во нашите TRIE.

288
00:15:17,330 --> 00:15:20,170
>> Па сега нека проверат чек.

289
00:15:20,170 --> 00:15:25,156
Гледање на проверка функција, гледаме
таа опција ќе се врати bool.

290
00:15:25,156 --> 00:15:29,680
Тоа враќа true ако овој збор дека тоа е
се пренесува е во наши TRIE.

291
00:15:29,680 --> 00:15:32,110
Го враќа false.

292
00:15:32,110 --> 00:15:36,050
Па како ви се утврди дали
овој збор е во наши TRIE?

293
00:15:36,050 --> 00:15:40,190
>> Гледаме дека овде, исто како и пред тоа,
ние ќе се користи покажувачот да iterate

294
00:15:40,190 --> 00:15:41,970
преку нашата TRIE.

295
00:15:41,970 --> 00:15:46,600
Сега тука ние ќе iterate
над целата наша збор.

296
00:15:46,600 --> 00:15:50,620
Па процесирањето над зборот ние сме минато,
ние ќе утврди

297
00:15:50,620 --> 00:15:56,400
индекс во низа деца кои
одговара на зборот заградата I. Значи ова

298
00:15:56,400 --> 00:15:59,670
се случува да изгледаат точно како
оптоварување, каде што ако зборот [i]

299
00:15:59,670 --> 00:16:03,310
е апостроф, тогаш сакаме
да се користи индекс "азбука" - 1.

300
00:16:03,310 --> 00:16:05,350
Бидејќи ние утврди дека
е местото каде што ние ќе треба да се сместат

301
00:16:05,350 --> 00:16:07,100
апострофи.

302
00:16:07,100 --> 00:16:11,780
>> Друг ние ќе користат две пониски збор
заградата I. Значи се сеќавам тој збор може да

303
00:16:11,780 --> 00:16:13,920
имаат произволен капитализација.

304
00:16:13,920 --> 00:16:17,540
И затоа сакаме да бидете сигурни дека ние сме
користење на мали верзија на нештата.

305
00:16:17,540 --> 00:16:21,920
А потоа одземе од тоа "а" уште
повторно ни даде азбучен

306
00:16:21,920 --> 00:16:23,880
позиција на таа карактер.

307
00:16:23,880 --> 00:16:27,680
Така што ќе биде нашиот индекс
во децата низа.

308
00:16:27,680 --> 00:16:32,420
>> И сега, ако тој индекс во децата
низа е нула, тоа значи дека ние

309
00:16:32,420 --> 00:16:34,990
не може да продолжи процесирањето
одредување на нашите TRIE.

310
00:16:34,990 --> 00:16:38,870
Ако тоа е случај, овој збор не може
можност да биде во нашите TRIE.

311
00:16:38,870 --> 00:16:42,340
Бидејќи ако тоа се, кои би
значи дека ќе биде патеката

312
00:16:42,340 --> 00:16:43,510
одредување на тој збор.

313
00:16:43,510 --> 00:16:45,290
И никогаш не би се судрите со нула.

314
00:16:45,290 --> 00:16:47,850
Така наиде на нула, ќе се вратиме лажни.

315
00:16:47,850 --> 00:16:49,840
Зборот не е во речникот.

316
00:16:49,840 --> 00:16:53,660
Ако не беше нула, тогаш ние сме
ќе процесирањето продолжи.

317
00:16:53,660 --> 00:16:57,220
>> Па ние ќе таму курсорот
да се укаже на тоа особено

318
00:16:57,220 --> 00:16:59,760
јазол на тој индекс.

319
00:16:59,760 --> 00:17:03,150
Ние го задржи тоа дека во текот на
целиот збор, претпоставувајќи

320
00:17:03,150 --> 00:17:03,950
ние никогаш не го погоди нула.

321
00:17:03,950 --> 00:17:07,220
Тоа значи дека бевме во можност да се добие преку
целиот збор и да се најде

322
00:17:07,220 --> 00:17:08,920
јазол во нашата проба.

323
00:17:08,920 --> 00:17:10,770
Но, ние не сме сосема направиле досега.

324
00:17:10,770 --> 00:17:12,290
>> Ние не сакаме само да се врати вистина.

325
00:17:12,290 --> 00:17:14,770
Ние сакаме да се врати курсорот> зборот.

326
00:17:14,770 --> 00:17:18,980
Од сеќавам еднаш, е "мачка" не е
во нашата речник, и "катастрофа"

327
00:17:18,980 --> 00:17:22,935
е, тогаш ние ќе успешно ќе го добиеме
преку зборот "мачка". Но курсорот

328
00:17:22,935 --> 00:17:25,760
Зборот ќе биде лажен и не е точно.

329
00:17:25,760 --> 00:17:30,930
Па ние се врати курсорот збор за да се покаже
дали овој јазол е всушност еден збор.

330
00:17:30,930 --> 00:17:32,470
И тоа е тоа за чек.

331
00:17:32,470 --> 00:17:34,250
>> Па ајде проверете големина.

332
00:17:34,250 --> 00:17:37,350
Па големината ќе биде прилично лесно
бидејќи, се сеќавам во оптоварување, ние сме

333
00:17:37,350 --> 00:17:41,430
зголемување, Речник големина за
секој збор што се сретнуваме.

334
00:17:41,430 --> 00:17:45,350
Па големината е само ќе
врати речник големина.

335
00:17:45,350 --> 00:17:47,390
И тоа е тоа.

336
00:17:47,390 --> 00:17:50,590
>> Па на крај имаме исклучи.

337
00:17:50,590 --> 00:17:55,100
Па бриши, ние ќе треба да се користи
рекурзивен функција да всушност прават сите

338
00:17:55,100 --> 00:17:56,530
на работа за нас.

339
00:17:56,530 --> 00:17:59,340
Значи, нашата функција ќе
бидат повикани unloader.

340
00:17:59,340 --> 00:18:01,650
Што unloader случува да се направи?

341
00:18:01,650 --> 00:18:06,580
Гледаме дека овде unloader се случува да се
iterate во текот на сите деца во

342
00:18:06,580 --> 00:18:08,410
ова особено јазол.

343
00:18:08,410 --> 00:18:11,750
И ако јазол не е
нула, тогаш ние ќе треба да

344
00:18:11,750 --> 00:18:13,730
бриши јазол.

345
00:18:13,730 --> 00:18:18,010
>> Значи ова е дека рекурзивно бриши
сите на нашите деца.

346
00:18:18,010 --> 00:18:21,080
Еднаш ние сме сигурни дека сите наши деца
се растоварува, тогаш ние

347
00:18:21,080 --> 00:18:25,210
може да се ослободиме, па
бриши нас самите.

348
00:18:25,210 --> 00:18:29,460
Ова ќе работи рекурзивно
бриши целиот TRIE.

349
00:18:29,460 --> 00:18:32,850
А потоа, откако тоа е направено,
ние само може да се врати вистина.

350
00:18:32,850 --> 00:18:34,210
Бриши не може да пропадне.

351
00:18:34,210 --> 00:18:35,710
Ние сме само што си заштедувате работи.

352
00:18:35,710 --> 00:18:38,870
Значи еднаш сме завршиш ослободување
сè, се врати вистина.

353
00:18:38,870 --> 00:18:40,320
И тоа е тоа.

354
00:18:40,320 --> 00:18:41,080
Моето име е Роб.

355
00:18:41,080 --> 00:18:42,426
И тоа беше правопис.

356
00:18:42,426 --> 00:18:47,830
>> [Музички]