1
00:00:00,000 --> 00:00:12,350
>> [MUZIK Bermain]

2
00:00:12,350 --> 00:00:13,050
>> ROB Bowden: Hi.

3
00:00:13,050 --> 00:00:13,640
Saya Rob.

4
00:00:13,640 --> 00:00:16,210
Dan mari kita penyelesaian ini keluar.

5
00:00:16,210 --> 00:00:20,070
Jadi di sini kita akan melaksanakan
jadual umum.

6
00:00:20,070 --> 00:00:24,090
Kita lihat bahawa nod struct yang kami
jadual akan kelihatan seperti ini.

7
00:00:24,090 --> 00:00:28,710
Jadi ia akan mempunyai perkataan char
pelbagai saiz PANJANG + 1.

8
00:00:28,710 --> 00:00:32,259
Jangan lupa + 1, sejak maksimum
perkataan dalam kamus ialah 45

9
00:00:32,259 --> 00:00:33,130
aksara.

10
00:00:33,130 --> 00:00:37,070
Dan kemudian kita akan memerlukan satu tambahan
watak untuk sifar garis sendeng terbalik itu.

11
00:00:37,070 --> 00:00:40,870
>> Dan kemudian hashtable kita dalam setiap
baldi akan menyimpan

12
00:00:40,870 --> 00:00:42,320
senarai bersambung nod.

13
00:00:42,320 --> 00:00:44,420
Kami tidak melakukan linear menyelesaikan sesuatu di sini.

14
00:00:44,420 --> 00:00:48,430
Dan sebagainya untuk pautan ke seterusnya
elemen dalam baldi, kita memerlukan

15
00:00:48,430 --> 00:00:50,390
nod struct * seterusnya.

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

17
00:00:51,110 --> 00:00:53,090
Jadi itulah yang nod kelihatan seperti.

18
00:00:53,090 --> 00:00:56,180
>> Sekarang di sini adalah pengakuan yang
daripada hashtable kami.

19
00:00:56,180 --> 00:00:59,640
Ia akan mempunyai 16.834 baldi.

20
00:00:59,640 --> 00:01:01,910
Tetapi jumlah itu tidak benar-benar perkara itu.

21
00:01:01,910 --> 00:01:05,450
Dan akhirnya, kita akan mempunyai
saiz hashtable pembolehubah global, yang

22
00:01:05,450 --> 00:01:07,000
akan bermula sebagai sifar.

23
00:01:07,000 --> 00:01:10,760
Dan ia akan menjejaki bagaimana
banyak perkataan dalam kamus kami.

24
00:01:10,760 --> 00:01:13,710
>> Jadi mari kita lihat beban.

25
00:01:13,710 --> 00:01:16,390
Notis beban itu, ia mengembalikan bool a.

26
00:01:16,390 --> 00:01:20,530
Anda kembali benar jika ia berjaya
dimuatkan, dan palsu sebaliknya.

27
00:01:20,530 --> 00:01:23,990
Dan ia mengambil char malar * kamus,
yang merupakan kamus

28
00:01:23,990 --> 00:01:25,280
yang kita mahu buka.

29
00:01:25,280 --> 00:01:27,170
Jadi itu perkara pertama
kita akan lakukan.

30
00:01:27,170 --> 00:01:29,500
>> Kami akan fopen yang
kamus untuk membaca.

31
00:01:29,500 --> 00:01:31,680
Dan kita akan perlu membuat
memastikan bahawa ia berjaya.

32
00:01:31,680 --> 00:01:35,920
Jadi, jika ia kembali NULL, maka kita tidak
berjaya membuka kamus.

33
00:01:35,920 --> 00:01:37,440
Dan kita perlu kembali palsu.

34
00:01:37,440 --> 00:01:41,580
Tetapi menganggap bahawa ia tidak berjaya
terbuka, maka kita mahu membaca

35
00:01:41,580 --> 00:01:42,400
kamus.

36
00:01:42,400 --> 00:01:46,450
Jadi menyimpan menggelung sehingga kita menemui beberapa
sebab untuk keluar daripada gelung ini,

37
00:01:46,450 --> 00:01:47,570
yang kita akan melihat.

38
00:01:47,570 --> 00:01:48,920
Jadi menyimpan menggelung.

39
00:01:48,920 --> 00:01:51,780
>> Dan sekarang kita akan
malloc nod tunggal.

40
00:01:51,780 --> 00:01:54,020
Dan sudah tentu kita perlu
untuk memeriksa udara lagi.

41
00:01:54,020 --> 00:01:58,680
Jadi jika mallocing tidak berjaya, maka
kita mahu memunggah mana-mana nod yang kita

42
00:01:58,680 --> 00:02:02,590
berlaku kepada malloc sebelum, tutup
kamus dan pulangan palsu.

43
00:02:02,590 --> 00:02:06,830
Tetapi mengabaikan itu, kami menganggap
berjaya, maka kita mahu menggunakan fscanf

44
00:02:06,830 --> 00:02:12,400
untuk membaca satu perkataan pun dari kami
kamus ke dalam nod kami.

45
00:02:12,400 --> 00:02:17,940
Jadi ingat bahawa kemasukan> perkataan char
penampan perkataan saiz LENGHTH + 1

46
00:02:17,940 --> 00:02:20,300
yang kita akan menyimpan perkataan masuk

47
00:02:20,300 --> 00:02:25,070
>> Jadi fscanf akan kembali 1, selagi
kerana ia mampu berjaya

48
00:02:25,070 --> 00:02:26,750
membaca perkataan dari fail.

49
00:02:26,750 --> 00:02:30,460
Jika sama ada kesilapan berlaku, atau kita
sampai ke akhir fail tersebut, ia

50
00:02:30,460 --> 00:02:31,950
tidak akan kembali 1.

51
00:02:31,950 --> 00:02:35,180
Di mana ia tidak kembali 1,
kita akhirnya akan keluar daripada

52
00:02:35,180 --> 00:02:37,280
ini gelung sementara.

53
00:02:37,280 --> 00:02:42,770
Jadi kita lihat bahawa sebaik sahaja kami telah berjaya
membaca perkataan ke dalam

54
00:02:42,770 --> 00:02:48,270
kemasukan> perkataan, maka kita akan dengan
perkataan menggunakan fungsi hash kami.

55
00:02:48,270 --> 00:02:49,580
>> Mari kita lihat
fungsi hash.

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

57
00:02:52,430 --> 00:02:55,610
Jadi anda tidak benar-benar memerlukan
untuk memahami perkara ini.

58
00:02:55,610 --> 00:02:59,460
Dan sebenarnya kita hanya ditarik hash ini
berfungsi dari internet.

59
00:02:59,460 --> 00:03:04,010
Satu-satunya perkara yang anda perlu menyedari adalah
bahawa ini mengambil char malar * perkataan.

60
00:03:04,010 --> 00:03:08,960
Jadi ia mengambil rentetan sebagai input, dan
kembali satu int tidak ditandatangani sebagai output.

61
00:03:08,960 --> 00:03:12,360
Jadi itu sahaja fungsi hash adalah, adakah ia
mengambil masa dalam input dan memberi anda

62
00:03:12,360 --> 00:03:14,490
indeks ke hashtable itu.

63
00:03:14,490 --> 00:03:18,530
>> Perhatikan bahawa kita moding oleh NUM_BUCKETS,
jadi nilai yang dikembalikan

64
00:03:18,530 --> 00:03:21,730
sebenarnya ialah indeks ke hashtable yang
dan tidak indeks di luar

65
00:03:21,730 --> 00:03:24,320
batas array.

66
00:03:24,320 --> 00:03:28,060
Jadi diberikan fungsi itu, kita akan
untuk hash perkataan yang kita membaca

67
00:03:28,060 --> 00:03:29,390
kamus.

68
00:03:29,390 --> 00:03:31,700
Dan kemudian kita akan menggunakan
bahawa hash untuk memasukkan

69
00:03:31,700 --> 00:03:33,750
masuk ke hashtable itu.

70
00:03:33,750 --> 00:03:38,520
>> Hash Sekarang hashtable adalah semasa
senarai dikaitkan dalam jadual.

71
00:03:38,520 --> 00:03:41,410
Dan ia sangat mungkin
bahawa ia hanya NULL.

72
00:03:41,410 --> 00:03:44,960
Kami mahu memasukkan kemasukan kami di
permulaan senarai ini dikaitkan.

73
00:03:44,960 --> 00:03:48,600
Dan dengan itu kita akan perlu semasa kami
pintu masuk kepada apa yang hashtable

74
00:03:48,600 --> 00:03:50,380
kini menunjuk ke.

75
00:03:50,380 --> 00:03:53,310
Dan kemudian kita akan menyimpan,
dalam hashtable di

76
00:03:53,310 --> 00:03:55,350
hash, masuk semasa.

77
00:03:55,350 --> 00:03:59,320
Jadi kedua-dua baris berjaya memasukkan
penyertaan di permulaan

78
00:03:59,320 --> 00:04:02,260
senarai bersambung pada indeks yang
dalam hashtable itu.

79
00:04:02,260 --> 00:04:04,900
>> Setelah kami selesai dengan itu, kita tahu
yang kami dapati perkataan lain dalam

80
00:04:04,900 --> 00:04:07,790
kamus, dan kami kenaikan lagi.

81
00:04:07,790 --> 00:04:13,960
Oleh itu, kita terus melakukan sehingga fscanf
akhirnya kembali sesuatu bukan 1 pada

82
00:04:13,960 --> 00:04:16,950
mana titik ingat bahawa
kita perlu untuk membebaskan masuk.

83
00:04:16,950 --> 00:04:19,459
Jadi di sini kita malloced entri.

84
00:04:19,459 --> 00:04:21,329
Dan kami cuba untuk membaca sesuatu
daripada kamus.

85
00:04:21,329 --> 00:04:23,910
Dan kita tidak berjaya membaca
sesuatu daripada kamus, dalam

86
00:04:23,910 --> 00:04:26,650
mana kita perlu untuk membebaskan masuk
yang kita tidak benar-benar meletakkan ke dalam

87
00:04:26,650 --> 00:04:29,140
hashtable, dan akhirnya pecah.

88
00:04:29,140 --> 00:04:32,750
>> Apabila kita keluar kita perlu melihat, baik,
yang kita keluar kerana ada

89
00:04:32,750 --> 00:04:34,360
telah kesilapan membaca dari fail?

90
00:04:34,360 --> 00:04:37,120
Atau adakah kita keluar kerana kita
sampai ke penghujung fail?

91
00:04:37,120 --> 00:04:39,480
Jika terdapat kesilapan,
kita mahu kembali palsu.

92
00:04:39,480 --> 00:04:40,930
Kerana beban tidak berjaya.

93
00:04:40,930 --> 00:04:43,890
Dan dalam proses itu kita mahu memunggah
semua perkataan yang kita baca dalam, dan

94
00:04:43,890 --> 00:04:45,670
menutup fail kamus.

95
00:04:45,670 --> 00:04:48,740
>> Andai kata kita tidak berjaya, maka kita hanya
masih perlu menutup kamus

96
00:04:48,740 --> 00:04:53,040
fail, dan akhirnya kembali benar kerana kita
berjaya dimuatkan kamus.

97
00:04:53,040 --> 00:04:54,420
Dan itu sahaja untuk beban.

98
00:04:54,420 --> 00:04:59,020
Jadi sekarang cek, diberi hashtable dimuatkan,
akan kelihatan seperti ini.

99
00:04:59,020 --> 00:05:03,140
Jadi lihat, ia kembali bool, yang merupakan
akan menunjukkan sama ada diluluskan

100
00:05:03,140 --> 00:05:07,530
dalam char * perkataan, sama ada diluluskan
dalam rentetan di dalam kamus kami.

101
00:05:07,530 --> 00:05:09,890
Jadi, jika ia ada di dalam kamus,
jika ia di hashtable kami,

102
00:05:09,890 --> 00:05:11,170
kita akan kembali benar.

103
00:05:11,170 --> 00:05:13,380
Dan jika tidak, kita akan kembali palsu.

104
00:05:13,380 --> 00:05:17,740
>> Memandangkan ini diluluskan pada perkataan, kita
akan hash perkataan.

105
00:05:17,740 --> 00:05:22,110
Sekarang satu perkara yang penting untuk menyedari adalah
bahawa dalam beban kami tahu bahawa semua

106
00:05:22,110 --> 00:05:23,820
kata-kata kita akan menjadi kes yang lebih rendah.

107
00:05:23,820 --> 00:05:25,820
Tetapi di sini kita tidak begitu pasti.

108
00:05:25,820 --> 00:05:29,510
Jika kita lihat fungsi hash kami,
fungsi hash kita sebenarnya

109
00:05:29,510 --> 00:05:32,700
adalah selongsong yang lebih rendah setiap aksara
perkataan.

110
00:05:32,700 --> 00:05:37,940
Jadi, tanpa mengira permodalan
perkataan, fungsi hash kami adalah kembali

111
00:05:37,940 --> 00:05:42,270
indeks yang sama untuk apa jua
permodalan adalah, kerana ia akan

112
00:05:42,270 --> 00:05:45,280
kembali untuk yang sama sekali huruf kecil
versi perkataan.

113
00:05:45,280 --> 00:05:46,600
Baiklah.

114
00:05:46,600 --> 00:05:49,790
Itulah indeks kami adalah ke dalam
hashtable untuk perkataan ini.

115
00:05:49,790 --> 00:05:52,940
>> Sekarang ini untuk gelung akan
melelar ke senarai dikaitkan

116
00:05:52,940 --> 00:05:55,000
yang pada indeks itu.

117
00:05:55,000 --> 00:05:59,610
Jadi notis kita Memulakan masuk
untuk menunjukkan kepada indeks itu.

118
00:05:59,610 --> 00:06:02,750
Kami akan terus
manakala kemasukan! = NULL.

119
00:06:02,750 --> 00:06:07,770
Dan ingat bahawa mengemaskini penuding
dalam kemasukan kami dikaitkan senarai = entry> seterusnya.

120
00:06:07,770 --> 00:06:14,400
Jadi mempunyai pintu masuk semasa kami untuk
item seterusnya dalam senarai yang dipautkan.

121
00:06:14,400 --> 00:06:19,250
>> Jadi bagi setiap penyertaan dalam senarai yang dihubungkan,
kita akan menggunakan strcasecmp.

122
00:06:19,250 --> 00:06:20,330
Ia bukan strcomp.

123
00:06:20,330 --> 00:06:23,780
Kerana sekali lagi, kita mahu
melakukan perkara-perkara kes insensitively.

124
00:06:23,780 --> 00:06:27,870
Oleh itu, kita menggunakan strcasecmp untuk membandingkan
perkataan yang telah diluluskan melalui ini

125
00:06:27,870 --> 00:06:31,860
fungsi terhadap perkataan
yang ada di entri ini.

126
00:06:31,860 --> 00:06:35,570
Jika ia kembali sifar, ini bermakna terdapat
perlawanan, di mana kita mahu

127
00:06:35,570 --> 00:06:36,630
kembali benar.

128
00:06:36,630 --> 00:06:39,590
Kami berjaya menemui
perkataan dalam hashtable kami.

129
00:06:39,590 --> 00:06:43,040
>> Jika tidak ada perlawanan, maka kami
akan gelung lagi dan melihat

130
00:06:43,040 --> 00:06:43,990
kemasukan yang berikutnya.

131
00:06:43,990 --> 00:06:47,640
Dan kami akan terus gelung sementara ada
entri di senarai ini dikaitkan.

132
00:06:47,640 --> 00:06:50,160
Apakah yang akan berlaku jika kita memecahkan
daripada ini untuk gelung?

133
00:06:50,160 --> 00:06:55,110
Ini bermakna kita tidak mencari penyertaan yang
dipadankan perkataan ini, di mana

134
00:06:55,110 --> 00:07:00,220
kita kembali palsu untuk menunjukkan bahawa kami
hashtable tidak mengandungi perkataan ini.

135
00:07:00,220 --> 00:07:02,540
Dan itu cek.

136
00:07:02,540 --> 00:07:04,790
>> Jadi mari kita lihat pada saiz.

137
00:07:04,790 --> 00:07:06,970
Saiz sekarang akan menjadi agak mudah.

138
00:07:06,970 --> 00:07:11,080
Sejak ingat dalam beban bagi setiap perkataan
kami dapati, kita incremented global

139
00:07:11,080 --> 00:07:12,880
saiz hashtable berubah-ubah.

140
00:07:12,880 --> 00:07:16,480
Jadi fungsi saiz hanya akan
untuk kembali berubah-ubah global.

141
00:07:16,480 --> 00:07:18,150
Dan itu sahaja.

142
00:07:18,150 --> 00:07:22,300
>> Kini akhirnya, kita perlu memunggah
kamus sekali semuanya dilakukan.

143
00:07:22,300 --> 00:07:25,340
Jadi bagaimana kita boleh berbuat demikian?

144
00:07:25,340 --> 00:07:30,440
Di sini kami menggelung lebih
semua baldi meja kami.

145
00:07:30,440 --> 00:07:33,240
Jadi, terdapat NUM_BUCKETS baldi.

146
00:07:33,240 --> 00:07:37,410
Dan bagi setiap senarai dikaitkan dalam kami
hashtable, kita akan lebih gelung

147
00:07:37,410 --> 00:07:41,070
keseluruhan daripada senarai yang dihubungkan,
membebaskan setiap elemen.

148
00:07:41,070 --> 00:07:42,900
>> Sekarang kita perlu berhati-hati.

149
00:07:42,900 --> 00:07:47,910
Jadi di sini kita mempunyai pembolehubah sementara
yang yang menyimpan penunjuk ke depan

150
00:07:47,910 --> 00:07:49,730
elemen dalam senarai berkaitan.

151
00:07:49,730 --> 00:07:52,140
Dan kemudian kita akan bebas
elemen semasa.

152
00:07:52,140 --> 00:07:55,990
Kita perlu pastikan kita melakukan ini kerana kita
tidak boleh hanya membebaskan elemen semasa

153
00:07:55,990 --> 00:07:59,180
dan kemudian cuba untuk mengakses penunjuk akan datang,
sejak setelah kami dibebaskan ia,

154
00:07:59,180 --> 00:08:00,870
memori menjadi tidak sah.

155
00:08:00,870 --> 00:08:04,990
>> Oleh itu, kita perlu menjaga seluruh penunjuk kepada
elemen yang akan datang, maka kita boleh membebaskan

156
00:08:04,990 --> 00:08:08,360
elemen semasa, dan kemudian kita boleh mengemas kini
elemen semasa kami untuk menunjukkan

157
00:08:08,360 --> 00:08:09,550
elemen seterusnya.

158
00:08:09,550 --> 00:08:12,800
Kami akan gelung manakala terdapat unsur-unsur
dalam senarai ini dikaitkan.

159
00:08:12,800 --> 00:08:15,620
Kami akan melakukannya untuk semua berkait
senarai di hashtable itu.

160
00:08:15,620 --> 00:08:19,460
Dan sebaik sahaja kami selesai dengan itu, kita kena
sepenuhnya dipunggah hashtable, dan

161
00:08:19,460 --> 00:08:20,190
kita selesai.

162
00:08:20,190 --> 00:08:23,200
Jadi ia adalah mustahil untuk memunggah
yang pernah pulangan palsu.

163
00:08:23,200 --> 00:08:26,470
Dan apabila kita selesai, kita
hanya kembali benar.

164
00:08:26,470 --> 00:08:29,000
>> Mari kita memberi penyelesaian ini cuba.

165
00:08:29,000 --> 00:08:33,070
Jadi mari kita lihat apa yang kami
nod struct akan kelihatan seperti.

166
00:08:33,070 --> 00:08:36,220
Di sini kita lihat kita akan mempunyai satu bool
perkataan dan nod struct * kanak-kanak

167
00:08:36,220 --> 00:08:37,470
kurungan abjad.

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

169
00:08:38,929 --> 00:08:42,020
Jadi perkara pertama yang anda mungkin
tertanya-tanya, mengapa abjad

170
00:08:42,020 --> 00:08:44,660
ed ditakrifkan sebagai 27?

171
00:08:44,660 --> 00:08:47,900
Nah, ingat bahawa kita akan perlu
yang akan mengendalikan koma atas itu.

172
00:08:47,900 --> 00:08:51,910
Supaya akan menjadi sebahagian dari
kes khas sepanjang program ini.

173
00:08:51,910 --> 00:08:54,710
>> Sekarang ingat bagaimana indone yang
sebenarnya berfungsi.

174
00:08:54,710 --> 00:08:59,380
Katakan kita mengindeks perkataan
"Kucing." Kemudian dari akar indone,

175
00:08:59,380 --> 00:09:02,610
kita akan melihat anak-anak
pelbagai, dan kita akan melihat

176
00:09:02,610 --> 00:09:08,090
indeks yang sepadan dengan huruf
C. Jadi yang akan diindeks 2.

177
00:09:08,090 --> 00:09:11,530
Jadi memandangkan, kehendak yang
memberi kita nod baru.

178
00:09:11,530 --> 00:09:13,820
Dan kemudian kita akan bekerja dari nod itu.

179
00:09:13,820 --> 00:09:17,770
>> Jadi diberikan nod itu, kami sekali lagi
akan melihat pelbagai kanak-kanak itu.

180
00:09:17,770 --> 00:09:22,110
Dan kita akan melihat indeks sifar
untuk sesuai dengan A dalam kucing.

181
00:09:22,110 --> 00:09:27,170
Demikian maka kita akan pergi dengan node itu,
dan diberikan nod bahawa kita akan

182
00:09:27,170 --> 00:09:31,090
untuk melihat akhirnya ia adalah sepadan
T. Dan beralih dengan node itu,

183
00:09:31,090 --> 00:09:35,530
akhirnya, kita telah benar-benar kelihatan
melalui perkataan kita "kucing." Dan kini bool

184
00:09:35,530 --> 00:09:40,960
perkataan sepatutnya untuk menunjukkan sama ada
perkataan ini diberikan sebenarnya perkataan.

185
00:09:40,960 --> 00:09:43,470
>> Jadi mengapa kita perlu bahawa kes khas?

186
00:09:43,470 --> 00:09:47,700
Akan apa perkataan "bencana"
di dalam kamus kita, tetapi

187
00:09:47,700 --> 00:09:50,150
perkataan "kucing" tidak?

188
00:09:50,150 --> 00:09:54,580
Jadi dan ingin melihat jika perkataan "kucing"
adalah di dalam kamus kita, kita

189
00:09:54,580 --> 00:09:59,970
akan berjaya melihat melalui
indeks C-A-T dalam nod wilayah.

190
00:09:59,970 --> 00:10:04,290
Tetapi itu hanya kerana malapetaka
berlaku untuk mewujudkan nod dalam perjalanan

191
00:10:04,290 --> 00:10:07,190
daripada C-A-T, sepanjang jalan ke
akhir perkataan.

192
00:10:07,190 --> 00:10:12,020
Jadi perkataan bool digunakan untuk menunjukkan sama ada
lokasi ini tertentu

193
00:10:12,020 --> 00:10:14,310
sebenarnya menunjukkan perkataan.

194
00:10:14,310 --> 00:10:15,140
>> Baiklah.

195
00:10:15,140 --> 00:10:19,310
Jadi sekarang kita tahu apa yang indone adalah
akan kelihatan seperti, mari kita lihat di

196
00:10:19,310 --> 00:10:20,730
memuatkan fungsi.

197
00:10:20,730 --> 00:10:24,610
Jadi beban akan kembali bool yang
untuk sama ada kita berjaya atau

198
00:10:24,610 --> 00:10:26,720
tidak berjaya dimuatkan kamus.

199
00:10:26,720 --> 00:10:30,460
Dan ini akan menjadi kamus
yang kita mahu untuk beban.

200
00:10:30,460 --> 00:10:33,930
>> Perkara oleh itu kita lakukan adalah terbuka
up yang kamus untuk membaca.

201
00:10:33,930 --> 00:10:36,160
Dan kita perlu memastikan
kami tidak gagal.

202
00:10:36,160 --> 00:10:39,580
Jadi jika kamus itu tidak
berjaya dibuka, ia akan kembali

203
00:10:39,580 --> 00:10:42,400
batal, di mana kami
akan kembali palsu.

204
00:10:42,400 --> 00:10:47,230
Tetapi menganggap bahawa ia berjaya
dibuka, maka kita sebenarnya boleh membaca

205
00:10:47,230 --> 00:10:48,220
melalui kamus.

206
00:10:48,220 --> 00:10:50,880
>> Perkara itu kita akan
mahu lakukan adalah kita mempunyai ini

207
00:10:50,880 --> 00:10:52,500
akar ubah global.

208
00:10:52,500 --> 00:10:56,190
Sekarang akar akan menjadi nod *.

209
00:10:56,190 --> 00:10:59,760
Ia bahagian atas indone kita bahawa kita
akan iterating melalui.

210
00:10:59,760 --> 00:11:02,660
Jadi perkara pertama yang kita akan
mahu lakukan adalah memperuntukkan

211
00:11:02,660 --> 00:11:04,140
memori untuk akar kami.

212
00:11:04,140 --> 00:11:07,980
Perhatikan bahawa kita menggunakan calloc yang
fungsi, yang pada dasarnya yang sama

213
00:11:07,980 --> 00:11:11,500
sebagai fungsi malloc, kecuali ia
dijamin untuk kembali sesuatu yang

214
00:11:11,500 --> 00:11:13,180
sepenuhnya menumpukan perhatian di luar.

215
00:11:13,180 --> 00:11:17,290
Jadi, jika kita digunakan malloc, kita perlu
pergi melalui semua petunjuk dalam kita

216
00:11:17,290 --> 00:11:20,160
nod, dan memastikan bahawa
mereka semua null.

217
00:11:20,160 --> 00:11:22,710
Jadi calloc akan melakukannya untuk kita.

218
00:11:22,710 --> 00:11:26,330
>> Sekarang seperti malloc, kita perlu membuat
memastikan bahawa peruntukan itu sebenarnya

219
00:11:26,330 --> 00:11:27,520
berjaya.

220
00:11:27,520 --> 00:11:29,990
Jika ini kembali batal, maka kita
perlu untuk menutup atau kamus

221
00:11:29,990 --> 00:11:32,100
memfailkan dan pulangan palsu.

222
00:11:32,100 --> 00:11:36,835
Jadi menganggap peruntukan yang
berjaya, kita akan menggunakan nod *

223
00:11:36,835 --> 00:11:40,270
kursor untuk melelar melalui indone kami.

224
00:11:40,270 --> 00:11:43,890
Jadi akar kita tidak pernah akan berubah,
tetapi kita akan menggunakan kursor untuk

225
00:11:43,890 --> 00:11:47,875
sebenarnya pergi dari nod ke nod.

226
00:11:47,875 --> 00:11:50,940
>> Jadi dalam ini untuk gelung kita membaca
melalui fail kamus.

227
00:11:50,940 --> 00:11:53,670
Dan kita menggunakan fgetc.

228
00:11:53,670 --> 00:11:56,290
Fgetc akan merebut satu
watak dari fail.

229
00:11:56,290 --> 00:11:59,370
Kami akan terus meraih
aksara manakala kita tidak sampai ke

230
00:11:59,370 --> 00:12:01,570
akhir fail.

231
00:12:01,570 --> 00:12:03,480
>> Terdapat dua kes kita perlu untuk mengendalikan.

232
00:12:03,480 --> 00:12:06,610
Yang pertama, jika watak
bukan satu barisan baru.

233
00:12:06,610 --> 00:12:10,450
Oleh itu, kita tahu jika ia adalah barisan baru, maka
kita kira-kira untuk bergerak ke satu perkataan baru.

234
00:12:10,450 --> 00:12:15,240
Tetapi menganggap ia bukan satu talian baru, maka
di sini kita mahu memikirkan

235
00:12:15,240 --> 00:12:18,380
indeks kita akan indeks ke dalam
dalam pelbagai kanak-kanak yang

236
00:12:18,380 --> 00:12:19,810
kita melihat sebelum ini.

237
00:12:19,810 --> 00:12:23,880
>> Jadi, seperti yang saya katakan sebelum ini, kita perlu
kes khas koma atas itu.

238
00:12:23,880 --> 00:12:26,220
Notis yang kita gunakan pertigaan yang
operator di sini.

239
00:12:26,220 --> 00:12:29,580
Jadi, kita akan membaca ini kerana, jika
watak kita baca dalam merupakan

240
00:12:29,580 --> 00:12:35,330
koma atas, maka kita akan menetapkan
index = "abjad" -1, yang akan

241
00:12:35,330 --> 00:12:37,680
menjadi indeks 26.

242
00:12:37,680 --> 00:12:41,130
>> Lagi, jika ia tidak apostrofe, terdapat
kami akan menetapkan indeks

243
00:12:41,130 --> 00:12:43,760
sama dengan c - a.

244
00:12:43,760 --> 00:12:49,030
Jadi ingat kembali dari sebelum ini p-set,
c - a akan memberi kita

245
00:12:49,030 --> 00:12:53,410
kedudukan abjad C. Jadi, jika
C adalah huruf A, ini akan

246
00:12:53,410 --> 00:12:54,700
memberikan kita indeks sifar.

247
00:12:54,700 --> 00:12:58,120
Untuk surat B, ia akan memberikan
kami indeks 1, dan sebagainya.

248
00:12:58,120 --> 00:13:03,010
>> Jadi ini memberikan kita indeks ke dalam
kanak-kanak array yang kita mahu.

249
00:13:03,010 --> 00:13:08,890
Sekarang jika indeks ini kini null dalam
kanak-kanak, ini bermakna bahawa nod

250
00:13:08,890 --> 00:13:11,830
buat masa ini tidak wujud
dari jalan itu.

251
00:13:11,830 --> 00:13:15,160
Oleh itu, kita perlu memperuntukkan
nod untuk jalan itu.

252
00:13:15,160 --> 00:13:16,550
Itulah apa yang kita akan lakukan di sini.

253
00:13:16,550 --> 00:13:20,690
>> Jadi, kita akan sekali lagi menggunakan calloc yang
fungsi, supaya kita tidak perlu

254
00:13:20,690 --> 00:13:22,880
sifar segala petunjuk.

255
00:13:22,880 --> 00:13:27,240
Dan kami sekali lagi perlu menyemak
calloc yang tidak gagal.

256
00:13:27,240 --> 00:13:30,700
Jika calloc tidak gagal, maka kita perlu
untuk memunggah segala-galanya, kita menutup

257
00:13:30,700 --> 00:13:32,820
kamus, dan pulangan palsu.

258
00:13:32,820 --> 00:13:40,050
Jadi menganggap bahawa ia tidak gagal, maka
ini akan mewujudkan anak yang baru untuk kita.

259
00:13:40,050 --> 00:13:41,930
Dan kemudian kita akan pergi kepada anak itu.

260
00:13:41,930 --> 00:13:44,960
Kursor kami akan melelar
turun kepada anak itu.

261
00:13:44,960 --> 00:13:49,330
>> Sekarang jika ini tidak batal untuk memulakan dengan,
maka kursor hanya boleh melelar

262
00:13:49,330 --> 00:13:52,590
ke kanak-kanak yang tanpa sebenarnya
perlu memperuntukkan apa-apa.

263
00:13:52,590 --> 00:13:56,730
Ini adalah kes di mana kita mula-mula berlaku
memperuntukkan perkataan "kucing." Dan

264
00:13:56,730 --> 00:14:00,330
ini bermakna apabila kita pergi untuk memperuntukkan
"Bencana," kita tidak perlu membuat

265
00:14:00,330 --> 00:14:01,680
nod untuk C-A-T lagi.

266
00:14:01,680 --> 00:14:04,830
Mereka sudah wujud.

267
00:14:04,830 --> 00:14:06,080
>> Apakah ini yang berlainan?

268
00:14:06,080 --> 00:14:10,480
Ini adalah keadaan di mana c adalah
garis sendeng terbalik n, di mana c adalah barisan baru.

269
00:14:10,480 --> 00:14:13,710
Ini bermakna bahawa kita telah berjaya
selesai satu perkataan.

270
00:14:13,710 --> 00:14:16,860
Sekarang apa yang kita mahu lakukan apabila kita
berjaya menamatkan satu perkataan?

271
00:14:16,860 --> 00:14:21,100
Kami akan menggunakan bidang perkataan ini
di dalam nod struct kami.

272
00:14:21,100 --> 00:14:23,390
Kami mahu menetapkan bahawa untuk benar.

273
00:14:23,390 --> 00:14:27,150
Jadi yang menunjukkan bahawa nod ini
menunjukkan yang berjaya

274
00:14:27,150 --> 00:14:29,250
perkataan, perkataan yang sebenar.

275
00:14:29,250 --> 00:14:30,940
>> Kini bersedia untuk yang benar.

276
00:14:30,940 --> 00:14:35,150
Kami mahu menetapkan semula kursor menjelaskan fakta
ke permulaan indone lagi.

277
00:14:35,150 --> 00:14:40,160
Dan akhirnya, kenaikan kamus kami
saiz, kerana kita mendapati kerja lain.

278
00:14:40,160 --> 00:14:43,230
Jadi, kita akan terus melakukan itu,
membaca dalam watak oleh watak,

279
00:14:43,230 --> 00:14:49,150
membina nod baru di indone dan
bagi setiap perkataan dalam kamus, sehingga

280
00:14:49,150 --> 00:14:54,020
kami akhirnya mencapai C! = EOF, di mana
kes kita keluar daripada fail.

281
00:14:54,020 --> 00:14:57,050
>> Sekarang terdapat dua kes di bawah
yang kita mungkin telah melanda EOF.

282
00:14:57,050 --> 00:15:00,980
Yang pertama adalah jika terdapat ralat
membaca dari fail.

283
00:15:00,980 --> 00:15:03,470
Jadi, jika ada ralat, kami
perlu melakukan perkara yang biasa.

284
00:15:03,470 --> 00:15:06,460
Memunggah segala-galanya, berhampiran
fail, pulangan palsu.

285
00:15:06,460 --> 00:15:09,810
Dengan menganggap tidak ada kesilapan, yang
hanya bermakna kita sebenarnya melanda akhir

286
00:15:09,810 --> 00:15:13,750
fail, di mana, kita menutup
memfailkan dan kembali benar kerana kita

287
00:15:13,750 --> 00:15:17,330
kamus berjaya dimuatkan
ke indone kami.

288
00:15:17,330 --> 00:15:20,170
>> Jadi sekarang mari kita lihat cek.

289
00:15:20,170 --> 00:15:25,156
Melihat fungsi cek, kita lihat
cek yang akan kembali bool a.

290
00:15:25,156 --> 00:15:29,680
Ia akan kembali benar jika perkataan ini bahawa itu
yang diluluskan adalah di indone kami.

291
00:15:29,680 --> 00:15:32,110
Ia akan kembali palsu sebaliknya.

292
00:15:32,110 --> 00:15:36,050
Jadi bagaimana anda menentukan sama ada
perkataan ini adalah di indone kita?

293
00:15:36,050 --> 00:15:40,190
>> Kita lihat di sini bahawa, sama seperti sebelum ini,
kita akan menggunakan kursor untuk melelar

294
00:15:40,190 --> 00:15:41,970
melalui indone kami.

295
00:15:41,970 --> 00:15:46,600
Sekarang di sini kita akan melelar
atas seluruh perkataan kami.

296
00:15:46,600 --> 00:15:50,620
Jadi iterating lebih perkataan kami yang lepas,
kita akan menentukan

297
00:15:50,620 --> 00:15:56,400
indeks ke dalam pelbagai kanak-kanak yang
sepadan dengan kurungan perkataan I. Jadi ini

298
00:15:56,400 --> 00:15:59,670
akan kelihatan betul-betul seperti
beban, di mana jika perkataan [i]

299
00:15:59,670 --> 00:16:03,310
adalah apostrofe, maka kita mahu
menggunakan index "abjad" - 1.

300
00:16:03,310 --> 00:16:05,350
Kerana kita menetapkan bahawa yang
adalah di mana kita akan menyimpan

301
00:16:05,350 --> 00:16:07,100
apostrofi.

302
00:16:07,100 --> 00:16:11,780
>> Yang lain kita akan menggunakan dua perkataan yang lebih rendah
kurungan I. Jadi ingat perkataan yang boleh

303
00:16:11,780 --> 00:16:13,920
mempunyai permodalan sewenang-wenangnya.

304
00:16:13,920 --> 00:16:17,540
Dan jadi kita ingin memastikan bahawa kita
menggunakan versi huruf kecil perkara.

305
00:16:17,540 --> 00:16:21,920
Dan kemudian tolak dari yang 'a' untuk sekali
sekali lagi memberi kita abjad yang

306
00:16:21,920 --> 00:16:23,880
kedudukan watak itu.

307
00:16:23,880 --> 00:16:27,680
Supaya akan menjadi indeks kami
ke dalam pelbagai kanak-kanak itu.

308
00:16:27,680 --> 00:16:32,420
>> Dan kini jika indeks itu ke dalam kanak-kanak
array adalah batal, ini bermakna kita

309
00:16:32,420 --> 00:16:34,990
tidak lagi boleh terus iterating
turun indone kami.

310
00:16:34,990 --> 00:16:38,870
Jika itu berlaku, perkataan ini tidak boleh
mungkin berada dalam indone kami.

311
00:16:38,870 --> 00:16:42,340
Kerana jika ia, yang akan
bermakna akan ada jalan yang

312
00:16:42,340 --> 00:16:43,510
ke perkataan itu.

313
00:16:43,510 --> 00:16:45,290
Dan anda tidak akan menghadapi null.

314
00:16:45,290 --> 00:16:47,850
Jadi menghadapi batal, kita kembali palsu.

315
00:16:47,850 --> 00:16:49,840
Perkataan itu tidak ada di dalam kamus.

316
00:16:49,840 --> 00:16:53,660
Jika tidak batal, maka kami
akan terus iterating.

317
00:16:53,660 --> 00:16:57,220
>> Jadi, kita akan di luar sana kursor
untuk menunjukkan bahawa tertentu

318
00:16:57,220 --> 00:16:59,760
nod di indeks itu.

319
00:16:59,760 --> 00:17:03,150
Kami terus melakukan bahawa sepanjang
perkataan keseluruhan, dengan andaian

320
00:17:03,150 --> 00:17:03,950
kita tidak pernah memukul null.

321
00:17:03,950 --> 00:17:07,220
Ini bermakna kita dapat melalui
perkataan keseluruhan dan mencari

322
00:17:07,220 --> 00:17:08,920
nod dalam cuba kami.

323
00:17:08,920 --> 00:17:10,770
Tetapi kita tidak cukup dilakukan lagi.

324
00:17:10,770 --> 00:17:12,290
>> Kami tidak mahu hanya kembali benar.

325
00:17:12,290 --> 00:17:14,770
Kami mahu kembali kursor> perkataan.

326
00:17:14,770 --> 00:17:18,980
Sejak ingat lagi, adalah "kucing" tidak
di dalam kamus kita, dan "bencana"

327
00:17:18,980 --> 00:17:22,935
adalah, maka kita akan berjaya kita
melalui perkataan "kucing." Tetapi kursor

328
00:17:22,935 --> 00:17:25,760
perkataan akan menjadi palsu dan tidak benar.

329
00:17:25,760 --> 00:17:30,930
Oleh itu, kita kembali perkataan kursor untuk menunjukkan
sama ada nod ini sebenarnya perkataan.

330
00:17:30,930 --> 00:17:32,470
Dan itu sahaja untuk cek.

331
00:17:32,470 --> 00:17:34,250
>> Jadi mari kita lihat saiz.

332
00:17:34,250 --> 00:17:37,350
Jadi saiz akan menjadi agak mudah
sejak, ingat dalam beban, kami

333
00:17:37,350 --> 00:17:41,430
menokok saiz kamus untuk
setiap perkataan yang kita hadapi.

334
00:17:41,430 --> 00:17:45,350
Jadi saiz hanya akan
kembali saiz kamus.

335
00:17:45,350 --> 00:17:47,390
Dan itu sahaja.

336
00:17:47,390 --> 00:17:50,590
>> Jadi akhir sekali kita telah memunggah.

337
00:17:50,590 --> 00:17:55,100
Jadi memunggah, kita akan menggunakan
fungsi rekursi untuk benar-benar melakukan semua

338
00:17:55,100 --> 00:17:56,530
kerja untuk kita.

339
00:17:56,530 --> 00:17:59,340
Jadi fungsi kita akan
dipanggil pada-beban.

340
00:17:59,340 --> 00:18:01,650
Apa yang pengurang beban akan lakukan?

341
00:18:01,650 --> 00:18:06,580
Kita lihat di sini-beban yang akan
melelar atas semua kanak-kanak di

342
00:18:06,580 --> 00:18:08,410
ini nod tertentu.

343
00:18:08,410 --> 00:18:11,750
Dan jika nod kanak-kanak tidak
batal, maka kita akan

344
00:18:11,750 --> 00:18:13,730
memunggah nod kanak-kanak.

345
00:18:13,730 --> 00:18:18,010
>> Jadi ini adalah anda secara rekursif memunggah
semua anak-anak kita.

346
00:18:18,010 --> 00:18:21,080
Apabila kita pasti bahawa semua anak-anak kita
telah dipunggah, maka kita

347
00:18:21,080 --> 00:18:25,210
boleh membebaskan diri kita, jadi
memunggah diri kita sendiri.

348
00:18:25,210 --> 00:18:29,460
Ini akan bekerja secara rekursif
memunggah keseluruhan indone itu.

349
00:18:29,460 --> 00:18:32,850
Dan kemudian sekali itu dilakukan,
kita hanya boleh kembali benar.

350
00:18:32,850 --> 00:18:34,210
Memunggah tidak boleh gagal.

351
00:18:34,210 --> 00:18:35,710
Kami hanya membebaskan sesuatu.

352
00:18:35,710 --> 00:18:38,870
Jadi sebaik sahaja kami selesai membebaskan
segala-galanya, kembali benar.

353
00:18:38,870 --> 00:18:40,320
Dan itu sahaja.

354
00:18:40,320 --> 00:18:41,080
Nama saya Rob.

355
00:18:41,080 --> 00:18:42,426
Dan ini adalah buku ejaan.

356
00:18:42,426 --> 00:18:47,830
>> [MUZIK Bermain]