1
00:00:00,000 --> 00:00:00,530

2
00:00:00,530 --> 00:00:03,070
>> ЗВУЧНИК 1: Да се ​​даде
ова решение, се обиде.

3
00:00:03,070 --> 00:00:07,130
Па ајде да ги разгледаме во она што нашите
Struct јазол ќе изгледа.

4
00:00:07,130 --> 00:00:11,040
Еве, гледаме дека се случува да имаат
Bool Word и еден јазол struct ѕвезда

5
00:00:11,040 --> 00:00:12,990
Деца заградата писмо.

6
00:00:12,990 --> 00:00:18,720
Па првото нешто може да се прашуваат,
зошто е азбука хаш дефинирана како 27?

7
00:00:18,720 --> 00:00:22,540
Добро, се сеќавам дека ние ќе треба
да се справува со апостроф, па

8
00:00:22,540 --> 00:00:25,610
тоа ќе биде нешто на некој посебен
случај во текот на оваа програма.

9
00:00:25,610 --> 00:00:28,780
>> Добро, сега, се сеќавам како
TRIE всушност работи.

10
00:00:28,780 --> 00:00:33,420
Да речеме дека ние сме индексирање зборот мачки,
потоа од коренот на нашите Trie,

11
00:00:33,420 --> 00:00:36,670
ние ќе се погледне на децата
низа, и ние ќе треба да се погледне на

12
00:00:36,670 --> 00:00:42,250
индекс, кој одговара на писмото
C. Значи тоа ќе биде индекс два.

13
00:00:42,250 --> 00:00:46,400
Па со оглед на тоа, дека ќе ни даде
нов јазол, а потоа ние ќе

14
00:00:46,400 --> 00:00:47,880
работат од тој јазол.

15
00:00:47,880 --> 00:00:51,830
>> Па со оглед на тоа јазол, ние сме уште еднаш
случува да се погледне во Детската низа,

16
00:00:51,830 --> 00:00:56,170
и ние ќе да се погледне во индекс нула
за да одговараат на А во мачка.

17
00:00:56,170 --> 00:01:01,240
Па тогаш ние ќе треба да одат на тој јазол,
и со оглед на тоа јазол, ние ќе

18
00:01:01,240 --> 00:01:05,170
да се погледне на индекс, кој одговара
со Т и премина на тој јазол,

19
00:01:05,170 --> 00:01:09,590
Конечно, имаме целосно погледна
преку нашето слово Мачка, и сега bool

20
00:01:09,590 --> 00:01:15,020
Зборот би требало да покажат дали
ова даден збор е всушност еден збор.

21
00:01:15,020 --> 00:01:17,530
>> Па зошто не ни треба тој посебен случај?

22
00:01:17,530 --> 00:01:21,680
Па, што ако катастрофа зборот
е во нашата речник, но

23
00:01:21,680 --> 00:01:24,120
зборот мачка не е?

24
00:01:24,120 --> 00:01:29,030
Па во потрага за да видите дали зборот мачка е
во нашата речник, ние ќе

25
00:01:29,030 --> 00:01:34,880
успешно се погледне преку индекси
Ц-А-Т и да го достигне еден јазол, но тоа е

26
00:01:34,880 --> 00:01:39,760
само затоа што катастрофа се случи со
создаде јазли на патот од Ц-А-Т ги сите

27
00:01:39,760 --> 00:01:41,250
начинот на кој на крајот на зборот.

28
00:01:41,250 --> 00:01:46,520
Па bool збор се користи покажат дали
овој одредена локација, всушност,

29
00:01:46,520 --> 00:01:48,370
укажува на зборот.

30
00:01:48,370 --> 00:01:52,920
>> Добро, па сега дека знаеме што е
TRIE се случува да изгледа, ајде да погледнеме

31
00:01:52,920 --> 00:01:54,800
на Вчитај функција.

32
00:01:54,800 --> 00:01:58,670
Па Вчитај ќе се врати bool
за тоа дали ние успешно или

33
00:01:58,670 --> 00:02:03,020
неуспешно натоварен речник и
ова ќе биде речникот

34
00:02:03,020 --> 00:02:04,520
дека сакаме да се вчита.

35
00:02:04,520 --> 00:02:08,310
Па првото нешто ние ќе треба да направите е да отворите
до кои речник за читање.

36
00:02:08,310 --> 00:02:12,060
Ние треба да бидете сигурни дека ние не успее,
па ако речникот не беше

37
00:02:12,060 --> 00:02:15,280
успешно отворен, ќе се врати
Не, во кој случај ние ќе

38
00:02:15,280 --> 00:02:16,340
враќање false.

39
00:02:16,340 --> 00:02:21,290
Но претпоставувајќи дека тоа успешно
отвори, тогаш ние всушност може да се прочита

40
00:02:21,290 --> 00:02:22,310
преку речникот.

41
00:02:22,310 --> 00:02:24,940
>> Па првото нешто ние ќе треба да
сакате да направите е да ја имаме оваа

42
00:02:24,940 --> 00:02:26,560
глобалната променлива корен.

43
00:02:26,560 --> 00:02:30,250
Сега, корен ќе биде еден јазол ѕвезда.

44
00:02:30,250 --> 00:02:33,830
Тоа е на врвот на нашата Trie дека ние сме
ќе треба да се процесирањето преку.

45
00:02:33,830 --> 00:02:38,200
Значи прво нешто што сте ќе сакате да се
направите е да алоцира меморија за нашиот корен.

46
00:02:38,200 --> 00:02:42,040
>> Забележете дека ние сме со користење на Calloc
функција, која е во основа иста

47
00:02:42,040 --> 00:02:45,560
како Примерок функција, освен тоа е
гарантирано да се вратат нешто што е

48
00:02:45,560 --> 00:02:47,240
целосно zeroed надвор.

49
00:02:47,240 --> 00:02:51,350
Значи, ако ние се користи Примерок, ние ќе треба да се
поминат низ сите покажувачи во нашата

50
00:02:51,350 --> 00:02:54,220
јазол и бидете сигурни дека
сите тие се ништовни.

51
00:02:54,220 --> 00:02:56,780
Па Calloc ќе го правам тоа за нас.

52
00:02:56,780 --> 00:03:00,390
>> Сега, само како Примерок, ние треба да се направи
сигурни дека распределбата е всушност

53
00:03:00,390 --> 00:03:01,580
успешна.

54
00:03:01,580 --> 00:03:04,060
Ако ова се врати на нула, тогаш ние
треба да ги затвориме нашите речник

55
00:03:04,060 --> 00:03:06,170
датотека и враќање false.

56
00:03:06,170 --> 00:03:11,040
Значи под претпоставка распределбата беше
успешна, ние ќе треба да се користи еден јазол

57
00:03:11,040 --> 00:03:14,340
ѕвезда покажувачот да iterate
преку нашата Trie.

58
00:03:14,340 --> 00:03:17,950
Значи нашиот корен никогаш не се случува да се промени,
но ние ќе се користи покажувачот за да

59
00:03:17,950 --> 00:03:20,770
всушност, оди од јазол да јазол.

60
00:03:20,770 --> 00:03:25,000
>> Добро, така што во овој За јамка, ние сме
читање преку речникот датотека,

61
00:03:25,000 --> 00:03:26,965
и ние сме со користење на fgetc.

62
00:03:26,965 --> 00:03:30,360
Па fgetc се случува да го зграби еден
карактер од датотеката.

63
00:03:30,360 --> 00:03:33,430
Ние ќе продолжиме грабање
карактери, додека ние не се постигне

64
00:03:33,430 --> 00:03:37,540
крајот на датотеката, па така постојат
два случаи ние треба да се справи.

65
00:03:37,540 --> 00:03:41,640
Прво, ако карактерот не беше
нова линија, за да знаеме дали тоа беше нов

66
00:03:41,640 --> 00:03:44,480
линија, тогаш ние сме за да
да се движи кон нов збор.

67
00:03:44,480 --> 00:03:49,300
Но под претпоставка дека тоа не е нова линија, а потоа
тука, ние сакаме да дознаам

68
00:03:49,300 --> 00:03:52,440
индекс ние ќе индекс во
во Детскиот низа што

69
00:03:52,440 --> 00:03:53,890
ние погледна порано.

70
00:03:53,890 --> 00:03:57,950
>> Значи како што реков претходно, ние треба да се
посебен случај на апостроф.

71
00:03:57,950 --> 00:04:01,040
Забележете ние сме со користење на тројна оператор
тука, па ние ќе го прочитате

72
00:04:01,040 --> 00:04:05,500
ова како ликот што читаме во било
апостроф, тогаш ние ќе треба да

73
00:04:05,500 --> 00:04:11,740
постави индекс еднаква на писмо минус
1, кој ќе биде индекс 26.

74
00:04:11,740 --> 00:04:15,190
Друго, ако не беше апостроф,
тогаш ние ќе треба да се постави на индекс

75
00:04:15,190 --> 00:04:17,820
еднаква на c минус.

76
00:04:17,820 --> 00:04:23,090
Значи се сеќавам назад од претходната стр сетови,
в минус се случува да ни даде

77
00:04:23,090 --> 00:04:27,470
азбучен позиција на в, па ако
в е буквата А, ова ќе

78
00:04:27,470 --> 00:04:28,770
ни даде индекс нула.

79
00:04:28,770 --> 00:04:32,180
За буквата Б, тоа ќе им даде
ни индекс 1, и така натаму.

80
00:04:32,180 --> 00:04:37,070
>> Па ова ни дава индекс во
Деца низа што сакаме.

81
00:04:37,070 --> 00:04:42,540
Сега, ако овој индекс е моментално null во
Детскиот низа, што значи дека

82
00:04:42,540 --> 00:04:47,470
еден јазол во моментов не постои од
тој пат, па ние треба да одвои

83
00:04:47,470 --> 00:04:49,220
јазол за тој пат.

84
00:04:49,220 --> 00:04:50,610
Тоа е она што го правиме тука.

85
00:04:50,610 --> 00:04:54,650
Па ние ќе се, повторно, користете Calloc
функција, така што ние немаме

86
00:04:54,650 --> 00:05:00,130
на нула од сите покажувачи, а ние,
повторно, треба да се провери дека Calloc

87
00:05:00,130 --> 00:05:01,300
не пропадне.

88
00:05:01,300 --> 00:05:04,760
Ако Calloc не успее, тогаш ние треба
да се исклучи сè, да ги затвориме

89
00:05:04,760 --> 00:05:06,880
речник, и да се врати лажни.

90
00:05:06,880 --> 00:05:14,110
>> Значи под претпоставка дека тоа не успее, тогаш
ова ќе се создаде нов дете за нас,

91
00:05:14,110 --> 00:05:16,000
и потоа ќе одат на тоа дете.

92
00:05:16,000 --> 00:05:19,030
Нашите курсорот ќе iterate
надолу за да тоа дете.

93
00:05:19,030 --> 00:05:23,390
Сега, ако ова не е нула за да започне со тоа,
тогаш покажувачот само да iterate

94
00:05:23,390 --> 00:05:26,650
надолу за да тоа дете без всушност
мора да се доделат ништо.

95
00:05:26,650 --> 00:05:30,790
Ова е случај каде што првпат се случи
за алоцирање на зборот мачка, и

96
00:05:30,790 --> 00:05:34,390
тоа значи дека кога одиме за алоцирање на
катастрофа, ние не треба да се создаде

97
00:05:34,390 --> 00:05:35,720
јазли за C-A-T повторно.

98
00:05:35,720 --> 00:05:37,620
Тие веќе постои.

99
00:05:37,620 --> 00:05:40,140
>> Добро, па што е ова на друго место?

100
00:05:40,140 --> 00:05:44,600
Ова е состојба каде што в беше
обратна коса црта n, каде в е нова линија.

101
00:05:44,600 --> 00:05:47,780
Ова значи дека имаме успешно
заврши збор.

102
00:05:47,780 --> 00:05:51,020
Сега, она што сакаме да правиме кога ќе
успешно заврши еден збор?

103
00:05:51,020 --> 00:05:55,250
Ние ќе се користи овој збор поле
внатрешноста на нашите struct јазол.

104
00:05:55,250 --> 00:06:00,570
>> Ние сакаме да го поставите тоа да Точно, така што
укажува на тоа дека јазол покажува

105
00:06:00,570 --> 00:06:03,320
успешна збор вистински збор.

106
00:06:03,320 --> 00:06:05,050
Сега, во собата дека на true.

107
00:06:05,050 --> 00:06:09,210
Ние сакаме да ги ресетирате нашите курсорот точка
на почетокот на Trie повторно.

108
00:06:09,210 --> 00:06:13,510
И конечно, прираст нашите речник
големината, бидејќи ние се најде друг збор.

109
00:06:13,510 --> 00:06:16,450
>> Добро, па ние ќе да го задржи тоа
дека, читање карактер од страна на

110
00:06:16,450 --> 00:06:21,960
карактер, изградба на нови јазли во
нашите Trie и за секој збор во

111
00:06:21,960 --> 00:06:26,810
речник, додека ние конечно достигне в
еднакво EOF, во кој случај, ние се пробие

112
00:06:26,810 --> 00:06:28,100
од датотеката.

113
00:06:28,100 --> 00:06:31,110
Сега, постојат два случаи под
кои би можеле да имаат хит EOF.

114
00:06:31,110 --> 00:06:35,680
Првиот е ако имало грешка
читање од датотека, па ако има

115
00:06:35,680 --> 00:06:39,280
грешка, ние треба да направите типичен
бриши сето она, во близина на датотеката,

116
00:06:39,280 --> 00:06:40,520
враќање false.

117
00:06:40,520 --> 00:06:43,870
Под претпоставка дека не беше грешка, дека
само значи дека ние всушност хит на крајот на

118
00:06:43,870 --> 00:06:47,820
на датотеката, во кој случај, ние затвори
поднесе и да се вратат Точно, бидејќи ние

119
00:06:47,820 --> 00:06:51,010
успешно вчитан речникот
во нашите Trie.

120
00:06:51,010 --> 00:06:54,240
>> Добро, па сега ајде да
проверете Провери.

121
00:06:54,240 --> 00:06:58,780
Гледање на Проверете функција, гледаме
дека Проверете нема да се врати bool.

122
00:06:58,780 --> 00:07:03,740
Тоа Враќа true ако овој збор дека тоа е
се пренесува е во наши Trie.

123
00:07:03,740 --> 00:07:06,170
Го враќа false.

124
00:07:06,170 --> 00:07:10,110
>> Па, како ќе се дојде да се утврди дали
овој збор е во наши Trie?

125
00:07:10,110 --> 00:07:14,270
Гледаме дека овде, исто како и пред тоа,
ние ќе се користи покажувачот да iterate

126
00:07:14,270 --> 00:07:16,010
преку нашата Trie.

127
00:07:16,010 --> 00:07:20,650
Сега, тука, ние ќе iterate
над целата наша збор.

128
00:07:20,650 --> 00:07:24,680
Па процесирањето над зборот ние сме
помина, ние ќе треба да се одреди

129
00:07:24,680 --> 00:07:29,280
индекс во Детскиот низа што
одговара на зборот заградата јас.

130
00:07:29,280 --> 00:07:34,150
Значи ова се случува да изгледаат точно како
Оптоварување, каде што ако зборот заградата i е

131
00:07:34,150 --> 00:07:38,110
апостроф, тогаш ние сакаме да се користи индекс
азбука минус 1, бидејќи ние утврдени

132
00:07:38,110 --> 00:07:41,160
дека е местото каде што ние ќе
за да ја запази апострофи.

133
00:07:41,160 --> 00:07:44,440
>> Друг ние ќе го користите tolower
Зборот заградата јас.

134
00:07:44,440 --> 00:07:48,270
Значи се сеќавам тој збор може да има произволен
капитализација, и така ние

135
00:07:48,270 --> 00:07:51,590
сакате да бидете сигурни дека ние сме користење
мали букви верзија на нештата.

136
00:07:51,590 --> 00:07:55,300
А потоа одземе од тоа мали
А до, уште еднаш, да ни даде на

137
00:07:55,300 --> 00:07:57,940
азбучен позиција
од овој карактер.

138
00:07:57,940 --> 00:08:01,740
Така што ќе биде нашиот индекс
во Детскиот низа.

139
00:08:01,740 --> 00:08:06,480
>> И сега, ако тој индекс во Детската
низа е нула, тоа значи дека ние

140
00:08:06,480 --> 00:08:09,050
не може да продолжи процесирањето
одредување на нашите Trie.

141
00:08:09,050 --> 00:08:13,320
Ако тоа е случај, овој збор не може
можност да биде во нашите Trie, бидејќи ако тоа

142
00:08:13,320 --> 00:08:18,000
беа, тоа би значело дека ќе биде
патот надолу до тој збор, и ќе

143
00:08:18,000 --> 00:08:19,350
никогаш не се судрите со нула.

144
00:08:19,350 --> 00:08:21,910
Така наиде на нула, ќе се вратиме лажно.

145
00:08:21,910 --> 00:08:23,810
Зборот не е во речникот.

146
00:08:23,810 --> 00:08:28,200
Ако не беше нула, тогаш ние ќе треба да
продолжи процесирањето, па ние ќе

147
00:08:28,200 --> 00:08:33,150
за да обновите нашата курсорот да се укаже дека
особено јазол на тој индекс.

148
00:08:33,150 --> 00:08:36,659
>> Па ние го задржи тоа го прават во текот на
целиот збор.

149
00:08:36,659 --> 00:08:40,630
Претпоставувајќи дека никогаш не удрил нула, тоа значи дека
бевме во можност да се добие во текот на целиот

150
00:08:40,630 --> 00:08:44,840
свет и да се најде еден јазол во нашата Trie,
но ние не сме сосема направиле досега.

151
00:08:44,840 --> 00:08:46,350
Ние не сакаме само да се вратат Точно.

152
00:08:46,350 --> 00:08:51,400
Ние сакаме да се врати курсорот грешка збор
бидејќи, се сеќавам еднаш, ако мачка не е

153
00:08:51,400 --> 00:08:55,140
во нашата речник и катастрофа е,
тогаш ние успешно ќе добие преку

154
00:08:55,140 --> 00:08:59,810
зборот мачка, но курсорот збор
ќе бидат лажни и не е точно.

155
00:08:59,810 --> 00:09:04,990
Па ние се врати курсорот збор за да се покаже
дали овој јазол е всушност еден збор,

156
00:09:04,990 --> 00:09:06,530
и тоа е тоа за чек.

157
00:09:06,530 --> 00:09:08,310
>> Па ајде проверете големина.

158
00:09:08,310 --> 00:09:11,410
Па Големина ќе биде прилично лесно
бидејќи, се сеќавам во оптоварување, ние сме

159
00:09:11,410 --> 00:09:15,480
зголемување, Речник големина за
секој збор што се сретнуваме.

160
00:09:15,480 --> 00:09:20,820
Па Големина е само ќе се врати
речник големина, и тоа е тоа.

161
00:09:20,820 --> 00:09:24,650
>> Сите во право, па на крај, ние имаме се исклучи.

162
00:09:24,650 --> 00:09:29,050
Па бриши, ние ќе треба да се користи
рекурзивен функција да всушност прават сите

163
00:09:29,050 --> 00:09:33,390
на работа за нас, така што нашите функција
се случува да се нарече Unloader.

164
00:09:33,390 --> 00:09:35,830
Што Unloader случува да се направи?

165
00:09:35,830 --> 00:09:40,640
Гледаме дека овде Unloader се случува да се
iterate во текот на сите деца во

166
00:09:40,640 --> 00:09:45,810
ова особено јазол, и ако детето
јазол не е нула, тогаш ние ќе треба да

167
00:09:45,810 --> 00:09:47,760
бриши јазол.

168
00:09:47,760 --> 00:09:52,070
>> Значи ова се случува да рекурзивно
бриши сите наши деца.

169
00:09:52,070 --> 00:09:55,140
Еднаш ние сме сигурни дека сите наши деца
се растоварува, тогаш ние

170
00:09:55,140 --> 00:09:58,830
може да се ослободиме, па исклучи себе.

171
00:09:58,830 --> 00:10:04,550
Значи ова рекурзивно ќе бриши
целата Trie, а потоа еднаш тоа е

172
00:10:04,550 --> 00:10:06,910
направи, ние само може да се врати Точно.

173
00:10:06,910 --> 00:10:09,770
Бриши не може да пропадне, ние сме
само што си заштедувате работи.

174
00:10:09,770 --> 00:10:12,985
Значи еднаш сме завршиш ослободување
сè, се врати Точно.

175
00:10:12,985 --> 00:10:14,380
И тоа е тоа.

176
00:10:14,380 --> 00:10:16,792
Моето име е Роб, и ова
беше [нечујни].

177
00:10:16,792 --> 00:10:21,888