1
00:00:00,000 --> 00:00:12,350
>> [Музыка играет]

2
00:00:12,350 --> 00:00:13,050
>> ROB 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
Мы видим, что структура узел Наши
таблица будет выглядеть следующим образом.

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
>> А потом наш хеш в каждом
ведро собирается хранить

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
структура узла * следующий.

16
00:00:50,390 --> 00:00:51,110
ОК.

17
00:00:51,110 --> 00:00:53,090
Так вот что узел выглядит.

18
00:00:53,090 --> 00:00:56,180
>> Теперь вот декларация
нашей хэш-таблице.

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
И, наконец, мы собираемся иметь
глобальная переменная размер хеш, который

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
Обратите внимание, что нагрузки, она возвращает логическое значение.

26
00:01:16,390 --> 00:01:20,530
Вы возвращаетесь верно, если это было успешно
загружены, и в противном случае.

27
00:01:20,530 --> 00:01:23,990
И это занимает константный символ * словарь,
который является словарь

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
>> Мы собираемся открыть поток,
словарь для чтения.

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
Так что держите цикл, пока не найдем некоторые
Причина, чтобы вырваться из этого цикла,

37
00:01:46,450 --> 00:01:47,570
которые мы увидим.

38
00:01:47,570 --> 00:01:48,920
Так что держите цикла.

39
00:01:48,920 --> 00:01:51,780
>> И теперь мы собираемся
Malloc один узел.

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
Единственное, что вы должны признать это
что это занимает константный символ * слово.

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
индекс в хэш-таблице.

63
00:03:14,490 --> 00:03:18,530
>> Обратите внимание, что мы Moding по NUM_BUCKETS,
так что значение, возвращенное

64
00:03:18,530 --> 00:03:21,730
на самом деле является индексом в хэш-таблице
и не индексирует за

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
вступление в хэш-таблице.

70
00:03:33,750 --> 00:03:38,520
>> Теперь хеш хэш текущий
связано список в таблице.

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
И таким образом мы будем иметь нашу ток
Точка входа к тому, что хеш-таблица

74
00:03:48,600 --> 00:03:50,380
В настоящее время указывает.

75
00:03:50,380 --> 00:03:53,310
А потом мы собираемся хранить,
в хэш-таблице на

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
Связанный список по этому индексу
в хэш-таблице.

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
хеш, и, наконец, сломать.

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
Так что теперь проверить, учитывая загруженный хеш,
будет выглядеть следующим образом.

99
00:04:59,020 --> 00:05:03,140
Поэтому проверить, она возвращает логическое значение, которое
собирается указать, является ли прошло

100
00:05:03,140 --> 00:05:07,530
в символ * слова, будь то прошло
в строке находится в нашем словаре.

101
00:05:07,530 --> 00:05:09,890
Так что, если он находится в словаре,
если он находится в нашей хэш-таблице,

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
Поэтому, независимо от капитализации
Слово, наш хэш-функция является возвращение

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
>> Теперь это цикл собирается
перебора связанного списка

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
И помните, что обновление указатель
в наш связанный список запись = запись> следующая.

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
Мы успешно нашли
Слово в нашей хэш-таблице.

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
И мы будем продолжать зацикливание в то время как есть
являются записи в этой связанного списка.

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
мы вернуться ложным, чтобы указать, что наш
хеш не содержат это слово.

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
переменный размер хеш.

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
Прямо здесь мы пробегаем по
все ведра нашем столе.

145
00:07:30,440 --> 00:07:33,240
Таким образом, есть NUM_BUCKETS ведра.

146
00:07:33,240 --> 00:07:37,410
И для каждого связанного списка в нашем
хеш, мы собираемся цикла по

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
Мы сделаем это для всех связан
Списки в хэш-таблице.

160
00:08:15,620 --> 00:08:19,460
И как только мы закончим с этим, мы
полностью разгрузили хеш-таблицу, и

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
Итак, давайте посмотрим, что наш
структура узел будет выглядеть.

166
00:08:33,070 --> 00:08:36,220
Здесь мы видим, что мы собираемся иметь логическое значение
слово и структура узла * дети

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
Поэтому первое, что вы могли бы быть
интересно, почему АЛФАВИТ

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
>> Теперь вспомните, как синтаксического дерева
на самом деле работает.

174
00:08:54,710 --> 00:08:59,380
Скажем мы индексации слово
"кошки". Тогда из корня синтаксического дерева,

175
00:08:59,380 --> 00:09:02,610
мы будем смотреть на детей
Массив, и мы будем смотреть на

176
00:09:02,610 --> 00:09:08,090
индекс, который соответствует букве
С. Так что будет индексироваться 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
наконец, мы полностью посмотрел
через наше слово "кот". А теперь Ьоо

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
собирается успешно просматривать
индексы С-А-Т в области узла.

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

191
00:10:04,290 --> 00:10:07,190
от С-А-Т, вплоть до
конец слова.

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
Так что теперь мы знаем, что это синтаксического дерева является
будет выглядеть, давайте посмотрим на

196
00:10:19,310 --> 00:10:20,730
загрузить функцию.

197
00:10:20,730 --> 00:10:24,610
Так нагрузка будет возвращать логическое значение
для того мы успешно или

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
Это вершина нашего синтаксического дерева, что мы
будет итерации.

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
полностью обнуляется.

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
файл и вернуться ложным.

222
00:11:32,100 --> 00:11:36,835
Так, предполагая, что распределение было
успешно, мы собираемся использовать узел *

223
00:11:36,835 --> 00:11:40,270
курсор для перебора нашего синтаксического дерева.

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
равна с -.

244
00:12:43,760 --> 00:12:49,030
Так что помните сравнению с ранее р-наборов,
с - а будет давать нам

245
00:12:49,030 --> 00:12:53,410
алфавитный позиция С. Так что если
С буква А, это будет

246
00:12:53,410 --> 00:12:54,700
дать нам нулевой индекс.

247
00:12:54,700 --> 00:12:58,120
Для письма B, это даст
нам индекс 1, и так далее.

248
00:12:58,120 --> 00:13:03,010
>> Так что это дает нам индекс в
дети массив, который мы хотим.

249
00:13:03,010 --> 00:13:08,890
Теперь, если этот показатель в настоящее время нулевой в
дети, это означает, что узел

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
Наша курсор итерации
до этого ребенка.

261
00:13:44,960 --> 00:13:49,330
>> Теперь, если это не было пустой для начала,
то курсор можно просто перебрать

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
Это состояние, при котором кондиционер был
косая черта п, где кондиционер был новая линия.

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
Мы собираемся использовать это поле слово
внутри нашего структуры узла.

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
Мы хотим, чтобы сбросить нашу курсор к точке
в начале синтаксического дерева снова.

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
построения новых узлов в нашей синтаксического дерева и
для каждого слова в словаре, до

280
00:14:49,150 --> 00:14:54,020
мы, наконец, достичь C! = 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
Выгрузка все, близко
файл, возвращение ложным.

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
успешно загружен словарь
в нашей синтаксического дерева.

288
00:15:17,330 --> 00:15:20,170
>> Так что теперь давайте проверим чек.

289
00:15:20,170 --> 00:15:25,156
Глядя на функции проверки, мы видим,
, что регистрация будет возвращать логическое значение.

290
00:15:25,156 --> 00:15:29,680
Это возвращает истину, если это слово, что это
передается в нашей синтаксического дерева.

291
00:15:29,680 --> 00:15:32,110
Это возвращает ложь в противном случае.

292
00:15:32,110 --> 00:15:36,050
Так как же определить, является ли
это слово в нашем синтаксического дерева?

293
00:15:36,050 --> 00:15:40,190
>> Мы видим здесь, что, как и раньше,
мы собираемся использовать курсор для перебора

294
00:15:40,190 --> 00:15:41,970
через нашу синтаксического дерева.

295
00:15:41,970 --> 00:15:46,600
Теперь вот мы собираемся итерации
над всем нашим словом.

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
будет выглядеть так же, как
нагрузка, где, если слово [я]

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
>> Остальное мы собираемся использовать два нижних слово
Кронштейн И. Так что помните, что слово может

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
больше не может продолжать итерации
вниз нашего синтаксического дерева.

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

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
Таким образом, наша функция будет
быть вызван разгрузки.

340
00:17:59,340 --> 00:18:01,650
Что разгрузочное собираетесь делать?

341
00:18:01,650 --> 00:18:06,580
Мы видим здесь, что разгрузочная собирается
перебора всех детей в

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
Это будет работать рекурсивно
выгрузить весь синтаксического дерева.

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
>> [Музыка играет]