1
00:00:00,000 --> 00:00:12,350
>> [音楽再生]

2
00:00:12,350 --> 00:00:13,050
>> ROBボーデン：こんにちは。

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
だから、char型の言葉を持っているために起こっている
サイズ長さ+ 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
そして、我々は1が余分に必要になるだろう
バックスラッシュゼロの文字。

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
[OK]をクリックします。

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
これは、16834バケットを持つようになるだろう。

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
それはBOOLを返すと、その負荷に注意してください。

26
00:01:16,390 --> 00:01:20,530
それが成功した場合はtrueを返す
ロードされ、そうでない場合はfalse。

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
そして、我々はfalseを返す必要があります。

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
前のmallocに起こった、閉じ
辞書とfalseを返します。

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
だから、そのエントリを覚えている>言葉はCHARです
サイズ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
このwhileループ。

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
あなたが認識する必要がある唯一のものです
これはcon​​stのchar *文字の単語を取ること。

60
00:03:04,010 --> 00:03:08,960
だから、入力として文字列を取っている、と
出力として符号なし整数を返す。

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
>> 我々は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
だから、この2行は正常に挿入
の先頭にエントリー

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
だから、ここまで私たちは、エントリをmallocさ。

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
エラーが発生しました場合は、
私たちは、falseを返すようにしたい。

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
ファイル、および最終的にはtrueを返すため、我々
成功した辞書をロードしました。

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
そうである、それはBOOLを返す、確認
渡されたかどうかを示すために行く

100
00:05:03,140 --> 00:05:07,530
char *文字の単語で、かどうかを渡された
文字列に私たちの辞書にある。

101
00:05:07,530 --> 00:05:09,890
だから、辞書内にある場合、
それが私たちのハッシュテーブル内にある場合は、

102
00:05:09,890 --> 00:05:11,170
私たちは、trueを返します。

103
00:05:11,170 --> 00:05:13,380
そうでないならば、我々はfalseを返します。

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
完全に小文字に返さ
Wordのバージョン。

113
00:05:45,280 --> 00:05:46,600
大丈夫。

114
00:05:46,600 --> 00:05:49,790
それが私たちのインデックスはにあります
この単語のためのハッシュテーブル。

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
trueを返します。

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
私たちは壊れた場合はどうなります
forループこれのうち？

133
00:06:50,160 --> 00:06:55,110
それは我々がそのエントリを見つけられませんでした意味
その場合には、この言葉を一致

134
00:06:55,110 --> 00:07:00,220
私たちは、それを示すためにfalseを返す
ハッシュテーブルは、この単語が含まれていませんでした。

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
だから、size関数はちょうど起こっている
グローバル変数を返します。

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
だから、アンロードのために不可能だ
今までにfalseを返すように。

163
00:08:23,200 --> 00:08:26,470
そして、我々は、我々が完了したら
ただtrueを返す。

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
ここで我々はBOOLを持っているつもりです参照してください。
Wordや構造体ノード*子どもたち

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のように定義ED？

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
文字に対応するインデックス
C. SO 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
そして、我々は、インデックスをゼロに見ていくつもりです
猫のAに対応する。

181
00:09:22,110 --> 00:09:27,170
それでは、私たちは、そのノードに行くつもりだ、
そして我々が行っている、そのノードを与えられた

182
00:09:27,170 --> 00:09:31,090
最後に見て、それは相当だ
Tに、そのノードに移動する、

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
だから今我々はそれがトライが何であるかを知っていることを
のように見に行く、のを見てみましょう

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
ヌル、その場合、我々はしている
falseを返しに行く。

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
malloc関数として、それはある点を除く
何かを返すことが保証

214
00:11:11,500 --> 00:11:13,180
完全にゼロ。

215
00:11:13,180 --> 00:11:17,290
我々はmalloc関数を使用した場合ので、我々はする必要があります
私たちの内のポインタのすべてを行く

216
00:11:17,290 --> 00:11:20,160
ノード、およびことを確認してください
彼らはすべてのNULLだ。

217
00:11:20,160 --> 00:11:22,710
だから、callocは、私たちのためにそれを行うだろう。

218
00:11:22,710 --> 00:11:26,330
>> 今だけのmallocと同じように、我々は確認する必要があり
割り当てが実際にあったことを確認してください

219
00:11:26,330 --> 00:11:27,520
成功。

220
00:11:27,520 --> 00:11:29,990
これはnullを返した場合、我々は
閉じたり、辞書必要がある

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
私たちのトライを反復処理するためにカーソル。

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
>> 私たちが処理する必要がある2つのケースがあります。

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
だから我々は、IF、としてこれを読んでするつもりだ
我々が読み取った文字だった

240
00:12:29,580 --> 00:12:35,330
アポストロフィ、その後、我々は設定しようとしている
インデックス= "ALPHABET" -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に等しい。

244
00:12:43,760 --> 00:12:49,030
だから、戻って、以前のP-セットから覚えて、
C  -  Aは、私たちに与えるために起こっている

245
00:12:49,030 --> 00:12:53,410
もしそうであればCのアルファベットの位置
Cは、この意志文字Aである

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
今、このインデックスは、現在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
辞書、falseを返します。

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
>> さて、これはそもそもNULLでなかった場合には、
カーソルだけ繰り返すことができます

262
00:13:49,330 --> 00:13:52,590
実際にすることなく、その子まで
何を配分すること。

263
00:13:52,590 --> 00:13:56,730
これは、我々が最初に起こったケースで​​ある
単語割り当てる「CAT」をと

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
これはCだった条件である
Cは新しいラインだったバックスラッシュ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
我々は、このWordのフィールドを使用するつもりだ
当社の構造ノードの内部。

272
00:14:21,100 --> 00:14:23,390
私たちは、trueにそれを設定したい。

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
>> 今trueにそれを設定します。

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
>> 今2例は下がある
私たちは、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
ファイルは、その場合、我々は、閉じ
我々以来提出し、trueを返す

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
チェック機能を見ると、我々が表示さ
そのチェックは、BOOLを返すために起こっている。

290
00:15:25,156 --> 00:15:29,680
この言葉は、それがだとした場合にはtrueを返します
私たちのトライである渡される。

291
00:15:29,680 --> 00:15:32,110
それは、そうでない場合はfalseを返します。

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
正確に見えるようになるだろう
負荷、単語であれば[I]

299
00:15:59,670 --> 00:16:03,310
アポストロフィは、その後、我々は欲しいさ
1  - インデックス "ALPHABET"を使用する。

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
>> 他に我々は2つ​​の下位ワードを使用するつもりだ
ブラケット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
だから、Googleのインデックスになるだろう
子配列に変換する。

308
00:16:27,680 --> 00:16:32,420
>> そして今、子どもたちにそのインデックスの場合
配列がnullの場合、それは我々を意味します

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
だから、ヌルに遭遇、我々はfalseを返します。

315
00:16:47,850 --> 00:16:49,840
言葉は辞書にありません。

316
00:16:49,840 --> 00:16:53,660
それがnullでないならば、我々はしている
反復を継​​続する予定。

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
我々はNULLを打つことはありません。

321
00:17:03,950 --> 00:17:07,220
それは我々が通り抜けることができたことを意味
単語全体、検索

322
00:17:07,220 --> 00:17:08,920
私たちのTRY内のノード。

323
00:17:08,920 --> 00:17:10,770
しかし、我々は非常にまだ終わっていない。

324
00:17:10,770 --> 00:17:12,290
>> 我々だけtrueを返すようにしたくない。

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
および子ノードではない場合
NULLの場合、我々はするつもりだ

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
して、設定が完了する、
我々だけtrueを返すことができます。

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
だから我々は解放終わったら
すべては、trueを返します。

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
>> [音楽再生]