1
00:00:00,000 --> 00:00:09,700

2
00:00:09,700 --> 00:00:12,140
>> ZAMYLA Чан: Да се ​​направи
проверка на правопис.

3
00:00:12,140 --> 00:00:16,900
Ако отворите speller.c, тогаш ќе видите
дека повеќето од функционалност за

4
00:00:16,900 --> 00:00:20,810
проверка текстуална датотека против
речник е веќе направен за вас.

5
00:00:20,810 --> 00:00:26,330
. / Правопис, минувајќи во речник текст
датотека, и потоа друг текст фајл,

6
00:00:26,330 --> 00:00:28,960
ќе провери дека текстуална датотека
против речникот.

7
00:00:28,960 --> 00:00:34,160
>> Сега, речник текстуални датотеки ќе содржат
валидни зборови, по еден на линија.

8
00:00:34,160 --> 00:00:37,910
Тогаш speller.c ќе се јавите Вчитај
на речникот текст фајл.

9
00:00:37,910 --> 00:00:43,650
Тоа ќе се јавите на функција наречена Проверете на
секој збор во внесуваат текст фајл,

10
00:00:43,650 --> 00:00:46,460
печатење на сите погрешно напишани зборови.

11
00:00:46,460 --> 00:00:50,030
>> Speller.c, исто така, ќе се јавите Големина да
се утврди бројот на зборови во

12
00:00:50,030 --> 00:00:53,500
речник и повик Бриши
за да се ослободи меморија.

13
00:00:53,500 --> 00:00:57,600
speller.c, исто така, ќе ги пратите на тоа како
колку време се користи за да се спроведе на овие

14
00:00:57,600 --> 00:01:00,560
процеси, но ние ќе
добиете за таа подоцна.

15
00:01:00,560 --> 00:01:02,440
>> Значи она што ние треба да направам?

16
00:01:02,440 --> 00:01:05,110
Ние треба да се пополни во dictionary.c.

17
00:01:05,110 --> 00:01:09,940
Во dictionary.c, имаме помошник
функција оптоварување, кое го вчитува

18
00:01:09,940 --> 00:01:10,855
речникот.

19
00:01:10,855 --> 00:01:15,490
Функцијата Проверете, која проверува дали
даден збор е во речникот.

20
00:01:15,490 --> 00:01:19,150
Функцијата Големина враќа бројот
на зборови во речникот.

21
00:01:19,150 --> 00:01:24,870
И, конечно, имаме бриши, која
ослободува речникот од меморијата.

22
00:01:24,870 --> 00:01:27,070
>> Значи прво, да се справи со оптоварување.

23
00:01:27,070 --> 00:01:32,110
За секој збор во речникот текст
датотека, оптоварување ќе се сместат тие зборови во

24
00:01:32,110 --> 00:01:34,860
речникот податочна структура
на вашиот избор, или

25
00:01:34,860 --> 00:01:36,750
хеш табелата или TRIE.

26
00:01:36,750 --> 00:01:39,440
Јас ќе одам над двата во
оваа прошетка низ.

27
00:01:39,440 --> 00:01:43,150
>> Прво нека зборува за хеш табели.

28
00:01:43,150 --> 00:01:47,050
Велат дека имал 10 билијард топки и
ти сакаше да ги чува.

29
00:01:47,050 --> 00:01:50,420
Може да ги стави сите во кофа,
и кога ви се потребни специфични

30
00:01:50,420 --> 00:01:54,010
нумерирани топката, ќе се земе една
од кофата на време

31
00:01:54,010 --> 00:01:55,880
во потрага по таа топка.

32
00:01:55,880 --> 00:01:59,370
И со само 10 топки, треба да бидат
можат да се најдат на вашиот топката во разумен

33
00:01:59,370 --> 00:02:01,160
количина на време.

34
00:02:01,160 --> 00:02:03,180
>> Но, што ако сте имале 20 топки?

35
00:02:03,180 --> 00:02:05,480
Тоа би можело да потрае малку подолго, сега.

36
00:02:05,480 --> 00:02:06,180
Што е со 100?

37
00:02:06,180 --> 00:02:07,880
1000?

38
00:02:07,880 --> 00:02:11,590
Сега, тоа ќе биде многу полесно ако
сте имале повеќе кофи.

39
00:02:11,590 --> 00:02:15,890
Можеби една кофа за топки нумерирани нула
преку девет, друг корпата за

40
00:02:15,890 --> 00:02:18,800
топки нумерирани од 10 до
19, и така натаму.

41
00:02:18,800 --> 00:02:22,330
>> Сега кога ви се потребни за да се погледне за специфични
топка, можете да автоматски

42
00:02:22,330 --> 00:02:26,320
одат на една специфична кофата и
пребарување низ кои кофа.

43
00:02:26,320 --> 00:02:29,840
И ако секоја канта има околу 10
топки, тогаш лесно може да пребарувате

44
00:02:29,840 --> 00:02:31,790
низ него.

45
00:02:31,790 --> 00:02:34,960
>> Сега, бидејќи ние сме се занимаваат со
речници, една кофа за

46
00:02:34,960 --> 00:02:41,970
сите зборови во речникот ќе
веројатно се премногу малку кофи.

47
00:02:41,970 --> 00:02:44,370
Па ајде да ги разгледаме во хеш табели.

48
00:02:44,370 --> 00:02:46,940
>> Сфатете го тоа како низа на кофи.

49
00:02:46,940 --> 00:02:50,370
И во овој случај, кофи
се нашите поврзани листи.

50
00:02:50,370 --> 00:02:54,770
И ние ќе го дистрибуирате сите наши зборови
меѓу овие повеќе поврзани листи во

51
00:02:54,770 --> 00:02:58,940
организиран начин си користење на хеш функција,
кои ќе ни каже кои

52
00:02:58,940 --> 00:03:03,720
кофа дадениот клуч, даден
збор, му припаѓа.

53
00:03:03,720 --> 00:03:05,960
>> Ајде да ја претставува оваа шематски.

54
00:03:05,960 --> 00:03:11,320
Сини кутии тука содржи вредности и
црвени кутии до друга точка вредност

55
00:03:11,320 --> 00:03:12,280
покажувачот пар.

56
00:03:12,280 --> 00:03:14,800
Ние ќе го нарекуваме овие парови јазли.

57
00:03:14,800 --> 00:03:18,260
Сега, секоја канта, како што реков
порано, е поврзана листа.

58
00:03:18,260 --> 00:03:21,820
Во поврзани листи, секој јазол има вредност,
како и покажувач на

59
00:03:21,820 --> 00:03:23,170
следната вредност.

60
00:03:23,170 --> 00:03:26,150
>> Сега, кои се занимаваат со поврзани листи,
тоа е многу важно што ќе

61
00:03:26,150 --> 00:03:28,120
не губат какви било врски.

62
00:03:28,120 --> 00:03:32,250
И уште еден факт да се запамети е дека
последните јазол, ако не се укаже на

63
00:03:32,250 --> 00:03:35,120
друг јазол, укажува на нула.

64
00:03:35,120 --> 00:03:37,970
>> Така како ние да ја претставува оваа во C?

65
00:03:37,970 --> 00:03:40,540
Ние се дефинираат нашите struct тука.

66
00:03:40,540 --> 00:03:44,850
И вредноста во овој случај е
на знак низа од должина.

67
00:03:44,850 --> 00:03:48,880
Должина плус 1, каде што должина е
Максималната должина на секој збор, плус 1 за

68
00:03:48,880 --> 00:03:50,380
нула терминатор.

69
00:03:50,380 --> 00:03:54,210
И тогаш имаме покажувач
друг јазол наречен Next.

70
00:03:54,210 --> 00:03:56,730
>> Па ајде направи мал поврзана листа.

71
00:03:56,730 --> 00:04:00,390
Прво, ќе сакате да го Примерок вашиот јазол,
кои создаваат простор во меморијата на

72
00:04:00,390 --> 00:04:04,010
големината на вашиот јазол тип.

73
00:04:04,010 --> 00:04:06,100
И направи уште еден јазол,
повторно mallocing.

74
00:04:06,100 --> 00:04:09,370

75
00:04:09,370 --> 00:04:14,340
>> Сега ако сакате да се додели вредност на
збор, тогаш може да се каже node1 стрелка

76
00:04:14,340 --> 00:04:18,820
Зборот е еднакво на "Здраво". Ова стрелките оператор
dereferences покажувачот и

77
00:04:18,820 --> 00:04:20,620
пристапи променливи на struct е.

78
00:04:20,620 --> 00:04:24,330
Овој начин, ние не треба да се користи и
точката и ѕвезда оператор.

79
00:04:24,330 --> 00:04:30,100
>> Па тогаш имам node2 стрелките збор еднаква на
"Свет". И таму, вредностите се

80
00:04:30,100 --> 00:04:33,110
населени во мојот јазли.

81
00:04:33,110 --> 00:04:38,780
Да се ​​направи линкови, јас ќе помине во node1
стрелката, пристап до тој јазол ѕвезда,

82
00:04:38,780 --> 00:04:44,160
тој јазол покажувач, е еднаква на node2,
покажувајќи node1 node2 да два.

83
00:04:44,160 --> 00:04:46,360
И таму имаме поврзана листа.

84
00:04:46,360 --> 00:04:51,480
>> Така што беше само еден поврзана листа, но
хаш табелата е цела низа на

85
00:04:51,480 --> 00:04:52,520
поврзани листи.

86
00:04:52,520 --> 00:04:55,920
Па, ќе го имаат истиот јазол
структура како порано.

87
00:04:55,920 --> 00:05:00,140
Но, ако сакавме вистински хаш табелата,
тогаш ние само може да се направи јазол покажувачот

88
00:05:00,140 --> 00:05:01,330
низа тука.

89
00:05:01,330 --> 00:05:04,940
На пример, големината 500.

90
00:05:04,940 --> 00:05:08,910
>> Сега најава, таму се случува да биде трговска
оф меѓу големината на вашиот

91
00:05:08,910 --> 00:05:11,280
хеш табелата и големината
на вашиот поврзани листи.

92
00:05:11,280 --> 00:05:15,640
Ако имате навистина голем број на
кофи, замислувајќи да се кандидира назад

93
00:05:15,640 --> 00:05:18,230
и назад на ред за да
најдете вашиот кофа.

94
00:05:18,230 --> 00:05:21,530
Но вие исто така не сакаат мал број
кофи, затоа што тогаш ние сме назад кон

95
00:05:21,530 --> 00:05:26,850
оригиналниот проблем за тоа како да се има
премногу топки во нашата кофа.

96
00:05:26,850 --> 00:05:30,480
>> Добро, но каде што нашата топката оди?

97
00:05:30,480 --> 00:05:33,150
Па, ние прво треба да се
имаат топката, нели?

98
00:05:33,150 --> 00:05:39,130
Па ајде Примерок јазол за секоја
нов збор што го имаме.

99
00:05:39,130 --> 00:05:42,900
јазол * new_node еднаквите
Примерок (sizeof (јазол)).

100
00:05:42,900 --> 00:05:46,760
>> Сега кога имаме оваа структура, ние
да ги скенирате во, со користење на функцијата

101
00:05:46,760 --> 00:05:51,850
fscanf, низа од нашите датотека, ако
тоа е речник датотека, во

102
00:05:51,850 --> 00:05:55,780
new_node стрелките збор, каде new_node
стрелките на зборот е нашата

103
00:05:55,780 --> 00:05:58,110
дестинација на тој збор.

104
00:05:58,110 --> 00:06:01,900
>> Следниот, ние ќе сакате да хаш дека
зборот со користење на хаш функција.

105
00:06:01,900 --> 00:06:05,860
Хеш функција зема низа
и се враќа на индекс.

106
00:06:05,860 --> 00:06:09,760
Во овој случај, индексот треба да
биде помал од бројот на

107
00:06:09,760 --> 00:06:11,440
кофи што го имате.

108
00:06:11,440 --> 00:06:14,600
>> Сега, хаш функции, кога ќе се обидуваш
да се најде еден и да се создаде една од

109
00:06:14,600 --> 00:06:17,890
свој, се сеќавам дека тие
мора да биде детерминистичка.

110
00:06:17,890 --> 00:06:22,420
Тоа значи дека со иста вредност треба да
мапа на истиот кофа во секое време

111
00:06:22,420 --> 00:06:23,800
дека ќе ја хаш.

112
00:06:23,800 --> 00:06:25,300
>> Тоа е вид на како библиотека.

113
00:06:25,300 --> 00:06:28,560
Кога ќе се земе книга, врз основа на
авторот, знаете што полица што треба

114
00:06:28,560 --> 00:06:31,890
одат за, без разлика дали тоа е полица број
еден, два или три.

115
00:06:31,890 --> 00:06:36,280
И таа книга секогаш ќе припаѓаат на
или полица еден, два или три.

116
00:06:36,280 --> 00:06:39,460

117
00:06:39,460 --> 00:06:43,810
>> Значи, ако new_node стрелките збор има
збор од речникот, тогаш

118
00:06:43,810 --> 00:06:47,770
hashing new_node стрелките зборот ќе
ни даде индексот на

119
00:06:47,770 --> 00:06:49,370
кофа со хеш табелата.

120
00:06:49,370 --> 00:06:54,040
А потоа ние ќе вметнете дека во таа
специфични поврзана листа е наведено од страна на

121
00:06:54,040 --> 00:06:56,060
се врати вредноста на нашата хеш функција.

122
00:06:56,060 --> 00:06:59,070
>> Да ги погледнеме на пример на
вметнување на јазол во

123
00:06:59,070 --> 00:07:01,750
почетокот на поврзани листа.

124
00:07:01,750 --> 00:07:06,930
Ако главата е еден јазол покажувач кој покажува
на почетокот на поврзани

125
00:07:06,930 --> 00:07:12,420
листа, и new_node укажува на нови
јазол кој сакате да го внесете во, само

126
00:07:12,420 --> 00:07:17,340
доделување глава до new_node ќе го изгубат
врската со остатокот на листата.

127
00:07:17,340 --> 00:07:19,330
Па ние не сакаме да го направите тоа.

128
00:07:19,330 --> 00:07:22,160
>> Наместо тоа, ние сакаме да се осигураме
дека ние се држи до секој

129
00:07:22,160 --> 00:07:23,550
еден јазол во нашата програма.

130
00:07:23,550 --> 00:07:29,560
Па трчање new_node стрелката еднаквите
главата, а потоа главата еднаква new_node

131
00:07:29,560 --> 00:07:34,470
ќе ги зачува сите на
врски и да не губат било.

132
00:07:34,470 --> 00:07:39,330
>> Но што ако сакате вашата листа за да биде
подредени, бидејќи имаат сортирани поврзани

133
00:07:39,330 --> 00:07:42,910
листа може да биде полесно за
во потрага тоа подоцна?

134
00:07:42,910 --> 00:07:46,020
Па, за тоа, ќе треба да знаете
како да напречни поврзани листи.

135
00:07:46,020 --> 00:07:51,210
>> Да напречни поврзана листа, ајде да
јазол покажувач, јазол *, да дејствува како

136
00:07:51,210 --> 00:07:54,120
курсорот, што укажува кои
јазол сте во, почнувајќи

137
00:07:54,120 --> 00:07:55,460
на првиот елемент.

138
00:07:55,460 --> 00:08:01,070
Looping до курсорот е нула, можеме да
спроведе одредени процеси, а потоа

139
00:08:01,070 --> 00:08:04,330
унапредување на курсорот кога треба
користење на курсорот стрелка вредност.

140
00:08:04,330 --> 00:08:08,820
>> Запомнете, ова е истото како
велејќи ѕвезда курсорот, dereferencing

141
00:08:08,820 --> 00:08:13,480
курсорот, а потоа со помош на
точка оператор вредност.

142
00:08:13,480 --> 00:08:19,000
Значи ажурирање курсорот е со доделување
курсорот до курсорот стрелката.

143
00:08:19,000 --> 00:08:24,960
>> Велат дека се утврди дека Д станува во
помеѓу C и E. За да ја вметнете јазол,

144
00:08:24,960 --> 00:08:30,030
имаат new_node D точка на
јазол Е, кој е покажувачот следната.

145
00:08:30,030 --> 00:08:36,409
И потоа C, курсорот, тогаш може да укаже
да Д На тој начин, ќе се одржи на листата.

146
00:08:36,409 --> 00:08:41,080
Бидете внимателни да не да се изгуби вашиот линкови на
поместување на стрелките на покажувачот до Д

147
00:08:41,080 --> 00:08:43,929
веднаш.

148
00:08:43,929 --> 00:08:44,620
>> Во ред е.

149
00:08:44,620 --> 00:08:48,920
Па тоа е како може да се вметне јазли,
вчитување на нив во, оптоварување зборови во тие

150
00:08:48,920 --> 00:08:51,600
јазли, и да ги вметнете
во вашиот хаш табелата.

151
00:08:51,600 --> 00:08:53,580
Па сега ајде да погледнеме на обидува.

152
00:08:53,580 --> 00:08:58,540
>> Во TRIE, секој јазол ќе содржи
спектар на јазол покажувачи, по една за секој

153
00:08:58,540 --> 00:09:02,260
буква во азбуката
плус апостроф.

154
00:09:02,260 --> 00:09:06,150
И секој елемент во низата
ќе точка за друг јазол.

155
00:09:06,150 --> 00:09:10,130
Ако тој јазол е нула, тогаш тоа писмо
нема да биде следната буква од

156
00:09:10,130 --> 00:09:15,690
секој збор во низа, бидејќи секој
Зборот означува дали тоа е последната

157
00:09:15,690 --> 00:09:18,160
карактер на зборот или не.

158
00:09:18,160 --> 00:09:19,750
>> Да ги погледнеме на дијаграм.

159
00:09:19,750 --> 00:09:22,260
Се надевам дека работите ќе се
да биде малку појасна.

160
00:09:22,260 --> 00:09:27,210
Во овој дијаграм, гледаме дека само
одредени букви и некои поднизи

161
00:09:27,210 --> 00:09:28,190
се наведени надвор.

162
00:09:28,190 --> 00:09:32,500
Па можете да следат одредени патеки, и
сите оние патеки ќе ве доведе до

163
00:09:32,500 --> 00:09:34,020
различни зборови.

164
00:09:34,020 --> 00:09:37,630
>> Така како ние да ја претставува оваа во C?

165
00:09:37,630 --> 00:09:41,910
Па, секој јазол сега се случува да имаат
Булова вредност означува дали

166
00:09:41,910 --> 00:09:46,580
тој јазол е на крајот на
даден збор или не.

167
00:09:46,580 --> 00:09:50,690
А потоа, исто така, ќе имаат низа на
јазол совети наречена деца, и

168
00:09:50,690 --> 00:09:53,440
таму се случува да биде 27 од нив.

169
00:09:53,440 --> 00:09:56,510
И запомнете, исто така, ќе сакате да го
ги пратите на вашиот прв јазол.

170
00:09:56,510 --> 00:09:59,830
Ние ќе се јавам дека корен.

171
00:09:59,830 --> 00:10:01,690
>> Па тоа е структурата на TRIE.

172
00:10:01,690 --> 00:10:05,630
Како да ја претставуваат оваа
како речник?

173
00:10:05,630 --> 00:10:09,890
Добро, да се вчита зборови во, за секој
речникот збор, ви се случува да сакаат

174
00:10:09,890 --> 00:10:11,960
да iterate преку TRIE.

175
00:10:11,960 --> 00:10:16,170
И секој елемент кај децата
одговара на различни букви.

176
00:10:16,170 --> 00:10:21,660
>> Па проверка на вредноста на деца
индексот i, каде што ја претставува

177
00:10:21,660 --> 00:10:24,840
специфични индексот на писмото што
ти се обидуваш да го внесете.

178
00:10:24,840 --> 00:10:28,980
Па, ако тоа е нула, тогаш ќе сакате да го
Примерок нов јазол и имаат деца

179
00:10:28,980 --> 00:10:31,110
јас укажуваат на тој јазол.

180
00:10:31,110 --> 00:10:35,630
>> Ако не е нула, тогаш тоа значи дека
дека со оглед гранка, што им беше дадена

181
00:10:35,630 --> 00:10:37,350
подниза, веќе постои.

182
00:10:37,350 --> 00:10:40,160
Па тогаш само ќе се преселат во таа
нов јазол и да се продолжи.

183
00:10:40,160 --> 00:10:43,220
Ако сте на крајот на зборот што
ти се обидуваш да се вчита во

184
00:10:43,220 --> 00:10:48,120
речник, а потоа можете да го поставите кои
тековната јазол дека сте за да се обистини.

185
00:10:48,120 --> 00:10:51,550
>> Па ајде да погледнеме еден пример на вметнување
зборот "лисица" во нашите

186
00:10:51,550 --> 00:10:53,070
речникот.

187
00:10:53,070 --> 00:10:56,110
Преправам почнеме со
празен речник.

188
00:10:56,110 --> 00:11:01,610
На првата буква, F, ќе се наоѓа
кај децата индекс пет од корените

189
00:11:01,610 --> 00:11:03,700
деца низа.

190
00:11:03,700 --> 00:11:05,430
Па ние се вметне дека внатре

191
00:11:05,430 --> 00:11:14,610
>> Буквата О, тогаш ќе биде кај децата
индекс 15, после тоа Ф И тогаш X

192
00:11:14,610 --> 00:11:20,180
ќе биде уште под тоа, разгранување
исклучување на децата на O.

193
00:11:20,180 --> 00:11:24,120
, А потоа поради X е последната буква
на зборот "лисица", а потоа јас ќе одам да

194
00:11:24,120 --> 00:11:27,210
боја која зелена за да се покаже дека
тоа е крајот на зборот.

195
00:11:27,210 --> 00:11:32,880
Во C, кој ќе биде поставување на Е
Зборот Булова на вредноста вистина.

196
00:11:32,880 --> 00:11:36,780
>> Сега што ако следниот збор што сте
вчитување на е зборот "foo"?

197
00:11:36,780 --> 00:11:41,490
Добро, вие не треба да Примерок повеќе
простор за F или O, бидејќи

198
00:11:41,490 --> 00:11:42,990
оние кои се веќе постои.

199
00:11:42,990 --> 00:11:45,910
Но последната O во foo?

200
00:11:45,910 --> 00:11:47,320
Оној, ќе мора да Примерок.

201
00:11:47,320 --> 00:11:52,390
Направи нов јазол за тоа, поставување
на е зборот Булова на true.

202
00:11:52,390 --> 00:11:57,340
>> Па сега ајде да се вметне "куче". Кучето ќе
започне со индекс три од корените

203
00:11:57,340 --> 00:12:00,520
деца, бидејќи D го нема
уште не е создадена.

204
00:12:00,520 --> 00:12:04,990
И ние ќе го следат сличен процес како
пред, создавајќи подниза куче,

205
00:12:04,990 --> 00:12:10,400
каде е G е обоена со зелена боја, бидејќи
тоа е крајот на зборот.

206
00:12:10,400 --> 00:12:13,160
>> Сега, што ако сакаме да внесете "не"?

207
00:12:13,160 --> 00:12:17,150
Па, ова е подниза на куче, па
ние не треба да Примерок повеќе.

208
00:12:17,150 --> 00:12:20,800
Но, ние треба да се посочи каде ние сме
до крајот на тој збор.

209
00:12:20,800 --> 00:12:24,020
Па О ќе биде обоена со зелена боја.

210
00:12:24,020 --> 00:12:27,810
Продолжување на тој процес за секоја
збор во речникот, сте

211
00:12:27,810 --> 00:12:32,120
натоварен нив во во или вашиот
хеш табелата или вашиот TRIE.

212
00:12:32,120 --> 00:12:37,530
>> speller.c ќе помине во жици за
dictionary.c да ги провери.

213
00:12:37,530 --> 00:12:41,140
Сега, проверката функција треба да работат
под случај нечувствителност.

214
00:12:41,140 --> 00:12:45,980
Тоа значи дека големи букви и
мали букви и мешавина на двете

215
00:12:45,980 --> 00:12:50,670
сите треба да се изедначува со точно ако било
комбинација на тоа е во

216
00:12:50,670 --> 00:12:51,880
речникот.

217
00:12:51,880 --> 00:12:55,580
Можете исто така да се претпостави дека конците се
само ќе содржат азбучен

218
00:12:55,580 --> 00:12:58,200
карактери или апострофи.

219
00:12:58,200 --> 00:13:02,490
>> Па ајде да погледнеме како може да се провери
со хеш табелата структура.

220
00:13:02,490 --> 00:13:07,330
Па, ако зборот постои, тогаш тоа
може да се најде во хеш табелата.

221
00:13:07,330 --> 00:13:12,240
Па тогаш може да се обидете да се најде дека
збор во релевантните кофа.

222
00:13:12,240 --> 00:13:14,480
>> Така што кофата ќе тој збор да биде во?

223
00:13:14,480 --> 00:13:20,060
Па, ќе го добиете бројот, тој индекс
на корпата, со hashing тој збор

224
00:13:20,060 --> 00:13:23,690
а потоа бараат во што поврзана листа,
traversing преку целата

225
00:13:23,690 --> 00:13:28,060
поврзана листа, со користење на Стринг
Споредете функција.

226
00:13:28,060 --> 00:13:31,940
>> Ако на крајот на поврзани листа е
постигнат, што значи дека вашиот курсорот

227
00:13:31,940 --> 00:13:36,030
достигне нула, тогаш зборот не е
да се најде во речникот.

228
00:13:36,030 --> 00:13:39,090
Тоа нема да биде во било која друга кофа.

229
00:13:39,090 --> 00:13:43,020
Па овде, можеби ќе се види како таму би можеле да
биде трампа помеѓу имаат или

230
00:13:43,020 --> 00:13:46,280
подредени поврзани листи или вон оние.

231
00:13:46,280 --> 00:13:51,180
Или ќе биде потребно повеќе време во текот на
оптоварување или повеќе време при проверка.

232
00:13:51,180 --> 00:13:53,560
>> Како што може да се провери во
на TRIE структура?

233
00:13:53,560 --> 00:13:56,370
Ние ќе се патува надолу
во TRIE.

234
00:13:56,370 --> 00:14:00,390
За секоја буква во внесуваат збор
дека ние сме проверка, ќе одиме на тоа

235
00:14:00,390 --> 00:14:03,280
соодветните елемент во деца.

236
00:14:03,280 --> 00:14:07,770
>> Ако тој елемент е нула, тогаш тоа значи дека
дека не постојат поднизи

237
00:14:07,770 --> 00:14:11,110
кои содржат нашите влез збор, па
зборот е погрешно напишан.

238
00:14:11,110 --> 00:14:15,140
Ако не е нула, ние може да се движи кон
следната буква од зборот, дека ние сме

239
00:14:15,140 --> 00:14:18,850
проверка и продолжи овој процес
додека не ги добиеме на крајот

240
00:14:18,850 --> 00:14:20,350
на влез збор.

241
00:14:20,350 --> 00:14:23,330
А потоа може да се провери
ако е зборот е вистина.

242
00:14:23,330 --> 00:14:24,610
Ако е така, тогаш одлично.

243
00:14:24,610 --> 00:14:25,590
Зборот е точно.

244
00:14:25,590 --> 00:14:30,890
Но ако не, и покрај тоа што подниза
постои во TRIE, зборот е

245
00:14:30,890 --> 00:14:32,250
погрешно напишани.

246
00:14:32,250 --> 00:14:36,590
>> Кога функцијата Големина се нарекува, големина
треба да се врати на број на зборови кои

247
00:14:36,590 --> 00:14:39,110
се во вашиот дадена речник
податочна структура.

248
00:14:39,110 --> 00:14:42,780
Значи, ако сте со користење на хаш табелата, можете
или да одат низ секој

249
00:14:42,780 --> 00:14:45,860
поврзана листа во секој
кофа пребројување на бројот

250
00:14:45,860 --> 00:14:47,130
на зборовите се таму.

251
00:14:47,130 --> 00:14:49,940
Ако сте со користење на TRIE, можете да
поминат низ секој не нула

252
00:14:49,940 --> 00:14:52,030
пат во вашиот TRIE.

253
00:14:52,030 --> 00:14:56,420
Или додека сте вчитување речникот
во, можеби може да ги пратите на тоа како

254
00:14:56,420 --> 00:14:58,760
многу зборови сте вчитување внатре

255
00:14:58,760 --> 00:15:03,180
>> Откако speller.c завршува проверка на
текстуална датотека против речник, потоа

256
00:15:03,180 --> 00:15:08,010
тоа е направено и така го нарекува бриши, каде
вашата работа е да се ослободи ништо

257
00:15:08,010 --> 00:15:09,500
дека сте malloced.

258
00:15:09,500 --> 00:15:14,420
Значи, ако имате потреба при користење на хаш табелата, тогаш ќе
треба да бидат особено внимателни за да се избегне

259
00:15:14,420 --> 00:15:18,830
меморија протекување со тоа што не си заштедувате ништо
предвреме и задржување на секој

260
00:15:18,830 --> 00:15:20,780
еден линк, пред да бесплатно.

261
00:15:20,780 --> 00:15:24,680

262
00:15:24,680 --> 00:15:30,100
>> Значи за секој елемент во хеш табелата
и за секој јазол во поврзана листа,

263
00:15:30,100 --> 00:15:32,370
ќе сакате да се ослободи тој јазол.

264
00:15:32,370 --> 00:15:34,970
Како да одите за ослободување
поврзан листа?

265
00:15:34,970 --> 00:15:38,570
Поставување на вашиот јазол покажувачот на курсорот до
на главата, на почетокот на

266
00:15:38,570 --> 00:15:43,100
поврзана листа, а потоа додека курсорот
не е нула, можете да поставите привремена

267
00:15:43,100 --> 00:15:45,610
јазол покажувач на курсорот.

268
00:15:45,610 --> 00:15:48,370
Тогаш напредуваат на курсорот.

269
00:15:48,370 --> 00:15:52,950
А потоа можете да слободното дека привремено
вредност, додека сеуште држи за да

270
00:15:52,950 --> 00:15:55,650
сè што после тоа.

271
00:15:55,650 --> 00:15:57,800
>> Што ако сте со користење на TRIE?

272
00:15:57,800 --> 00:16:00,410
Тогаш најдобар начин да го направите ова
е да се исклучи од самиот

273
00:16:00,410 --> 00:16:02,290
дното до врвот.

274
00:16:02,290 --> 00:16:06,920
Патувајќи до најниска можна
јазол, можете да ги ослободи сите покажувачи во

275
00:16:06,920 --> 00:16:11,430
дека децата, а потоа одјавување
нагоре, ослободувајќи сите елементи во сите

276
00:16:11,430 --> 00:16:15,610
на децата низи, додека
ќе погоди вашиот топ root јазол.

277
00:16:15,610 --> 00:16:18,920
Тука е местото каде рекурзијата
ќе ни се најде.

278
00:16:18,920 --> 00:16:22,780
>> Да бидете сигурни дека сте веројатно ослободени
сè што сте malloced,

279
00:16:22,780 --> 00:16:24,400
можете да го користите Valgrind.

280
00:16:24,400 --> 00:16:28,640
Вклучување Valgrind ќе се кандидира на вашиот програма
броење колку бајти меморија

281
00:16:28,640 --> 00:16:32,440
сте користење и правење на сигурни дека сте
ослободени сите нив, ти го кажувам

282
00:16:32,440 --> 00:16:34,530
каде што би можеле да имаат
заборавил да бесплатно.

283
00:16:34,530 --> 00:16:38,390
Така да работи таа и уште Valgrind ви кажува
и ти дава зелено светло, тогаш

284
00:16:38,390 --> 00:16:41,160
ќе завршите со бриши.

285
00:16:41,160 --> 00:16:44,420
>> Сега, неколку совети пред да одите
и да почне спроведувањето на вашиот

286
00:16:44,420 --> 00:16:46,260
речникот.

287
00:16:46,260 --> 00:16:49,650
Јас му препорачувам да помине во помал
речник кога ќе се обидуваш да се тестираат

288
00:16:49,650 --> 00:16:52,620
работи надвор и дебагирање со БДП.

289
00:16:52,620 --> 00:16:58,550
Користење на правопис е. / Правопис, на
изборен речник, а потоа и текстот.

290
00:16:58,550 --> 00:17:01,550
>> По дифолт, го товари во
големите речникот.

291
00:17:01,550 --> 00:17:06,670
Па можеби ќе сакате да се помине во мали
речник, или можеби дури и го направи вашиот

292
00:17:06,670 --> 00:17:11,819
сопствена земја, со измената на вашиот речник
и вашиот текст фајл.

293
00:17:11,819 --> 00:17:15,950
>> А потоа конечно, би, исто така, препорачуваме
да земе пенкало и хартија и да подготви

294
00:17:15,950 --> 00:17:20,490
работи надвор пред, за време и по
што сум напишал на сите ваши код.

295
00:17:20,490 --> 00:17:24,170
Само бидете сигурни дека имате
оние совети само десно.

296
00:17:24,170 --> 00:17:26,480
>> Ви посакувам најдоброто од среќа.

297
00:17:26,480 --> 00:17:29,690
И штом еднаш ќе завршите, ако сакате
да се спротивстават на голема табла и

298
00:17:29,690 --> 00:17:34,390
види колку брзо вашата програма е во споредба со
своите соученици, тогаш јас ве охрабруваме

299
00:17:34,390 --> 00:17:35,960
да се провери тоа.

300
00:17:35,960 --> 00:17:39,220
>> Со тоа, ќе завршите со
на правопис PSet.

301
00:17:39,220 --> 00:17:41,800
Моето име е Zamyla, а тоа е CS50.

302
00:17:41,800 --> 00:17:49,504