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

2
00:00:00,530 --> 00:00:03,070
>> スピーカ1：それでは挙げてみましょう
このソリューションTRY。

3
00:00:03,070 --> 00:00:07,130
それでは、どのような私たちを見てみましょう
構造ノードは、次のようになります。

4
00:00:07,130 --> 00:00:11,040
ここで、我々は持っているつもりです参照してください。
BOOL Wordや構造体節スター

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
>> [OK]を、今、どのように覚えている
トライは実際に動作します。

10
00:00:28,780 --> 00:00:33,420
それでは、単語猫をインデックス化しているとしましょう​​、
その後、私たちのトライのルートから、

11
00:00:33,420 --> 00:00:36,670
私たちは子供たちを見ていくつもりです
アレイと、私たちが見ていくつもりです

12
00:00:36,670 --> 00:00:42,250
文字に対応するインデックス
C.だから、インデックス2になります。

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

17
00:00:56,170 --> 00:01:01,240
それでは、私たちは、そのノードに行くつもりだ、
そのノードを考えると、我々は行っている

18
00:01:01,240 --> 00:01:05,170
対応しているインデックスを参照するため
Tに、そのノードに移動する、

19
00:01:05,170 --> 00:01:09,590
最後に、我々は完全に見てきました
私たちの言葉猫を通して、今ブール

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
首尾指標に目を通す
C-A-Tおよびノー​​ドに到達するが、それはです

26
00:01:34,880 --> 00:01:39,760
大惨事はに起こったという理由だけで
すべてのC-A-Tから途中でノードを作成

27
00:01:39,760 --> 00:01:41,250
単語の末尾への道。

28
00:01:41,250 --> 00:01:46,520
そうブールワードが使用されているかどうかを示す
この特定の場所に実際

29
00:01:46,520 --> 00:01:48,370
単語を示しています。

30
00:01:48,370 --> 00:01:52,920
>> 大丈夫、だから今我々が知っていることを何A
トライそれでは、見てみましょう、のように見えるために起こっている

31
00:01:52,920 --> 00:01:54,800
ロード機能で。

32
00:01:54,800 --> 00:01:58,670
だから、ロードブールを返すために起こっている
どうか、我々は成功したりするため

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
それは我々がしているという我々のトライのトップだ
繰り返し処理されようとして。

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

48
00:02:45,560 --> 00:02:47,240
完全にゼロ。

49
00:02:47,240 --> 00:02:51,350
我々はのmalloc使用のであれば、我々はする必要があります
私たちの内のポインタのすべてを行く

50
00:02:51,350 --> 00:02:54,220
ノードとことを確認してください
彼らはすべてのNULLだ。

51
00:02:54,220 --> 00:02:56,780
だから、callocは、私たちのためにそれを行うだろう。

52
00:02:56,780 --> 00:03:00,390
>> 今、ちょうどmallocのように、我々は確認する必要があり
割り当ては、実際のことを確認してください

53
00:03:00,390 --> 00:03:01,580
成功。

54
00:03:01,580 --> 00:03:04,060
これはnullを返した場合、我々は
私たちの辞書を閉じる必要が

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
反復するためにカーソルをスター
私たちのトライを通じて。

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
ファイルの終わりがあります。したがって
私たちが処理する必要が2例。

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
アルファベットマイナスに等しいインデックスを設定
指数26となります1。

74
00:04:11,740 --> 00:04:15,190
そうでなければ、それはアポストロフィでなかった場合には、
その後、我々は、インデックスを設定するつもりだ

75
00:04:15,190 --> 00:04:17,820
CマイナスAに等しい。

76
00:04:17,820 --> 00:04:23,090
だから、前のPセットから覚えて、
CマイナスAは私たちに与えるために起こっている

77
00:04:23,090 --> 00:04:27,470
もしそうであれば、Cのアルファベット順の位置、
Cは、文字A、この意志です

78
00:04:27,470 --> 00:04:28,770
私たちにインデックスゼロを与える。

79
00:04:28,770 --> 00:04:32,180
文字Bは、それが与えるであろう
私たちのインデックス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
辞書、およびfalseを返します。

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
当社のカーソルが繰り返されます
その子まで。

93
00:05:19,030 --> 00:05:23,390
さて、これはそもそもNULLでなかった場合には、
カーソルだけ繰り返すことができます

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
>> [OK]を、ので、このほかには何ですか？

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

104
00:05:55,250 --> 00:06:00,570
>> 我々はそのように、Trueにそれを設定したい
このノードが示していることを示し

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
我々はポイントに私たちのカーソルをリセットしたい
もう一度トライの先頭に。

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
文字に新しいノードを構築する
私たちのトライと内の各単語のための

111
00:06:21,960 --> 00:06:26,810
辞書、我々は最終的にCに到達するまで
、我々は壊れ、その場合、EOFに等しい

112
00:06:26,810 --> 00:06:28,100
ファイルが不足しています。

113
00:06:28,100 --> 00:06:31,110
今、2例が下にあります
私たちは、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
ファイルは、その場合、我々は、閉じ
我々以来提出し、Trueを返します

119
00:06:47,820 --> 00:06:51,010
成功した辞書をロード
私たちのトライへ。

120
00:06:51,010 --> 00:06:54,240
>> 大丈夫、だから今みましょう
チェックアウトチェック。

121
00:06:54,240 --> 00:06:58,780
チェック機能を見ると、我々が表示さ
ていることを確認し、ブール型にを返すために起こっている。

122
00:06:58,780 --> 00:07:03,740
この言葉は、それがだとした場合にはTrueを返します
私たちのトライである渡される。

123
00:07:03,740 --> 00:07:06,170
それは、それ以外の場合はFalseを返します。

124
00:07:06,170 --> 00:07:10,110
>> では、どのようにするかどうかを判断しようとしている
この言葉は、私たちのトライである？

125
00:07:10,110 --> 00:07:14,270
我々は、その直前のようにここを参照してください、
私たちは、反復するために、カーソルを使用するつもりだ

126
00:07:14,270 --> 00:07:16,010
私たちのトライを通じて。

127
00:07:16,010 --> 00:07:20,650
さて、ここでは、繰り返し処理をするつもりだ
私達の全体の単語の上に。

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を使用するつもりだ
単語ブラケットI。

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
だから、Googleのインデックスになるだろう
子ども配列に。

139
00:08:01,740 --> 00:08:06,480
>> そして今、子供にそのインデックスの場合
配列がnullの場合、それは我々を意味します

140
00:08:06,480 --> 00:08:09,050
もはや反復を継続することはできません
私たちのトライダウン。

141
00:08:09,050 --> 00:08:13,320
その場合は、この言葉ができない
おそらく、我々のトライになるので、どうか

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

145
00:08:21,910 --> 00:08:23,810
言葉は辞書にありません。

146
00:08:23,810 --> 00:08:28,200
それがnullでないならば、我々はするつもりだ
反復を継​​続し、私たちはなるだろう

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
世界と私たちのトライのノードを見つけ、
しかし、我々は非常にまだ終わっていない。

151
00:08:44,840 --> 00:08:46,350
我々だけtrueを返すようにしたくない。

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
私たちのために仕事なので、私たちの関数の
アンローダーと呼ばれようとしている。

164
00:09:33,390 --> 00:09:35,830
何アンローダは何をするつもりですか？

165
00:09:35,830 --> 00:09:40,640
私たちは、アンローダーをしようとしていることがわかり
でも子供のすべてを反復

166
00:09:40,640 --> 00:09:45,810
この特定のノード、もし子供
ノードがnullでない場合、我々はするつもりだ

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
だから、これは再帰的にアンロードされます
全体トライしてから、それはだ、一度

172
00:10:04,550 --> 00:10:06,910
行って、私たちはtrueを返すことができます。

173
00:10:06,910 --> 00:10:09,770
アンは、私たちがしている、失敗することはできません
物事を解放。

174
00:10:09,770 --> 00:10:12,985
だから我々は解放終わったら
すべては、Trueを返します。

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