1
00:00:00,000 --> 00:00:12,350
>> [მუსიკის დაკვრა]

2
00:00:12,350 --> 00:00:13,050
>> რობ Bowden: Hi.

3
00:00:13,050 --> 00:00:13,640
მე Rob.

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
ჩვენ ვხედავთ, რომ struct კვანძის ჩვენი
მაგიდა აპირებს გამოიყურებოდეს მოსწონს ეს.

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
და მაშინ ჩვენ ვაპირებთ გვჭირდება ერთი ზედმეტი
ხასიათი backslash ნულოვანი.

11
00:00:37,070 --> 00:00:40,870
>> და მაშინ ჩვენი hashtable თითოეულ
bucket აპირებს შესანახად

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
და რათა დააკავშიროს მომდევნო
ელემენტს bucket, ჩვენ გვჭირდება

15
00:00:48,430 --> 00:00:50,390
struct კვანძის * შემდეგი.

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
>> ახლა აქ არის დეკლარაცია
ჩვენი hashtable.

19
00:00:56,180 --> 00:00:59,640
ის აპირებს აქვს 16.834 თაიგულების.

20
00:00:59,640 --> 00:01:01,910
მაგრამ, რომ ნომერი ნამდვილად არ აქვს.

21
00:01:01,910 --> 00:01:05,450
და ბოლოს, ჩვენ ვაპირებთ აქვს
გლობალური ცვლადი hashtable ზომა, რომელიც

22
00:01:05,450 --> 00:01:07,000
აპირებს დაიწყოს off როგორც ნულოვანი.

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
თქვენ დაბრუნდება ნამდვილი, თუ ეს იყო წარმატებით
დატვირთული, და ცრუ სხვაგვარად.

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
და ჩვენ გვჭირდება დაბრუნების ცრუ.

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
გააგრძელეთ looping სანამ ჩვენ გამოძებნოს
მიზეზი შესვენება out ამ მარყუჟის,

37
00:01:46,450 --> 00:01:47,570
რომელიც ჩვენ დავინახავთ.

38
00:01:47,570 --> 00:01:48,920
გააგრძელეთ looping.

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 ადრე, დახუროს
ლექსიკონი და დაბრუნების ცრუ.

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
ასე მახსოვს, რომ entry> სიტყვა არის 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,
ჩვენ საბოლოოდ აპირებს დაარღვიოს out of

52
00:02:35,180 --> 00:02:37,280
ამ ხოლო loop.

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
და რეალურად ჩვენ უბრალოდ გამოყვანილია ამ hash
ფუნქციონირებს ინტერნეტში.

59
00:02:59,460 --> 00:03:04,010
ერთადერთი, რაც თქვენ უნდა აღიაროს არის
რომ ეს იღებს const char * სიტყვა.

60
00:03:04,010 --> 00:03:08,960
ამიტომ აღების სიმებიანი, როგორც შეყვანის და
დაბრუნების unsigned int როგორც გამომავალი.

61
00:03:08,960 --> 00:03:12,360
ასე რომ ყველა ქეშირების ფუნქცია, არის ის
იღებს შეყვანის და გაძლევთ

62
00:03:12,360 --> 00:03:14,490
ინდექსი შევიდა hashtable.

63
00:03:14,490 --> 00:03:18,530
>> გაითვალისწინეთ, რომ ჩვენ moding მიერ NUM_BUCKETS,
ასე რომ ღირებულება დაბრუნდა

64
00:03:18,530 --> 00:03:21,730
რეალურად არის ინდექსი შევიდა hashtable
და არ index მიღმა

65
00:03:21,730 --> 00:03:24,320
ფარგლებში მასივი.

66
00:03:24,320 --> 00:03:28,060
ასე რომ, თუ გავითვალისწინებთ, რომ ფუნქცია, ჩვენ ვაპირებთ
to hash სიტყვა, რომელიც ვკითხულობთ

67
00:03:28,060 --> 00:03:29,390
ლექსიკონი.

68
00:03:29,390 --> 00:03:31,700
და მაშინ ჩვენ ვაპირებთ გამოვიყენოთ
რომ hash ჩასასმელად

69
00:03:31,700 --> 00:03:33,750
შესვლის hashtable.

70
00:03:33,750 --> 00:03:38,520
>> ახლა hashtable hash მიმდინარე
დაკავშირებული სიაში ცხრილში.

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
ასე რომ, ჩვენ ვაპირებთ, რომ ჩვენი დღევანდელი
შესვლის წერტილი რა hashtable

74
00:03:48,600 --> 00:03:50,380
ამჟამად მიუთითებს.

75
00:03:50,380 --> 00:03:53,310
და მაშინ ჩვენ ვაპირებთ შესანახად,
ამ hashtable ზე

76
00:03:53,310 --> 00:03:55,350
hash, მიმდინარე ჩანაწერი.

77
00:03:55,350 --> 00:03:59,320
ასე რომ, ეს ორი ხაზი წარმატებით ჩადეთ
შესვლის დასაწყისში

78
00:03:59,320 --> 00:04:02,260
უკავშირდება სია იმ ინდექსი
ამ hashtable.

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 at

82
00:04:13,960 --> 00:04:16,950
სადაც წერტილი გვახსოვდეს, რომ
ჩვენ უნდა გავათავისუფლოთ ჩანაწერი.

83
00:04:16,950 --> 00:04:19,459
ასე რომ, აქ ჩვენ malloced ჩანაწერი.

84
00:04:19,459 --> 00:04:21,329
და ჩვენ შევეცადეთ წავიკითხე რაღაც
საწყისი ლექსიკონი.

85
00:04:21,329 --> 00:04:23,910
და ჩვენ არ წარმატებით წაკითხული
რაღაც ლექსიკონი, in

86
00:04:23,910 --> 00:04:26,650
ასეთ შემთხვევაში, ჩვენ უნდა გავათავისუფლოთ შესვლის
რომ ჩვენ არასოდეს რეალურად ამოქმედებული

87
00:04:26,650 --> 00:04:29,140
hashtable, და საბოლოოდ დაარღვიოს.

88
00:04:29,140 --> 00:04:32,750
>> ერთხელ ჩვენ შესვენება out ჩვენ უნდა დაინახოს, ასევე,
არც ჩვენ შესვენება out რადგან იქ

89
00:04:32,750 --> 00:04:34,360
შეცდომა კითხულობს ფაილი?

90
00:04:34,360 --> 00:04:37,120
ან საერთოდ ჩვენ შესვენება out რადგან ჩვენ
მიაღწია ბოლოს ფაილი?

91
00:04:37,120 --> 00:04:39,480
იყო თუ არა შეცდომა, მაშინ
ჩვენ გვინდა, რომ დაბრუნების ცრუ.

92
00:04:39,480 --> 00:04:40,930
იმის გამო, რომ დატვირთვა არ გავიდა.

93
00:04:40,930 --> 00:04:43,890
და ამ პროცესში ჩვენ გვინდა, რომ განიტვირთოს
ყველა სიტყვა, რომ ვკითხულობთ და

94
00:04:43,890 --> 00:04:45,670
დახურვა ლექსიკონი ფაილი.

95
00:04:45,670 --> 00:04:48,740
>> ვთქვათ, ჩვენ არ გამოუვათ, მაშინ ჩვენ უბრალოდ
მაინც უნდა დახუროს ლექსიკონი

96
00:04:48,740 --> 00:04:53,040
ფაილი, და საბოლოოდ იქნება TRUE, რადგან ჩვენ
წარმატებით დატვირთული ლექსიკონი.

97
00:04:53,040 --> 00:04:54,420
და რომ ეს დატვირთვა.

98
00:04:54,420 --> 00:04:59,020
ახლა შევამოწმოთ, თუ გავითვალისწინებთ დატვირთული hashtable,
აპირებს გამოიყურებოდეს მოსწონს ეს.

99
00:04:59,020 --> 00:05:03,140
ასე რომ, შემოწმება, ის დააბრუნებს bool, რომელიც
აპირებს მიუთითებს თუ არა გავიდა

100
00:05:03,140 --> 00:05:07,530
in char * სიტყვა, თუ არა გავიდა
in string არის ჩვენი ლექსიკონი.

101
00:05:07,530 --> 00:05:09,890
ასე რომ, თუ ეს ლექსიკონი,
თუ ეს არის ჩვენი hashtable,

102
00:05:09,890 --> 00:05:11,170
დავიბრუნებთ ჭეშმარიტი.

103
00:05:11,170 --> 00:05:13,380
და თუ ეს ასე არ არის, ჩვენ დაბრუნების ცრუ.

104
00:05:13,380 --> 00:05:17,740
>> აქედან გამომდინარე გავიდა სიტყვა, ჩვენ
ვაპირებ hash სიტყვა.

105
00:05:17,740 --> 00:05:22,110
ახლა მთავარია, რომ აღიარებენ,
რომ დატვირთვა ვიცოდით, რომ ყველა

106
00:05:22,110 --> 00:05:23,820
სიტყვა ჩვენ ვაპირებთ, რომ იყოს ქვედა შემთხვევაში.

107
00:05:23,820 --> 00:05:25,820
მაგრამ აქ ჩვენ არ ვარ დარწმუნებული.

108
00:05:25,820 --> 00:05:29,510
თუ ჩვენ შევხედოთ ჩვენი ქეშირების ფუნქცია,
ჩვენი ქეშირების ფუნქცია რეალურად

109
00:05:29,510 --> 00:05:32,700
ნაკლებია გარსაცმები თითოეული ხასიათი
სიტყვა.

110
00:05:32,700 --> 00:05:37,940
ასე რომ, მიუხედავად იმისა, კაპიტალიზაცია
სიტყვა, ჩვენი ქეშირების ფუნქცია არის დაბრუნების

111
00:05:37,940 --> 00:05:42,270
იგივე მაჩვენებელი, რასაც
კაპიტალიზაცია არის, როგორც ეს იქნებოდა

112
00:05:42,270 --> 00:05:45,280
დაბრუნდა სრულიად ამას
მობილური სიტყვას.

113
00:05:45,280 --> 00:05:46,600
კარგად.

114
00:05:46,600 --> 00:05:49,790
რომ ჩვენი ინდექსი შევიდა
hashtable ეს სიტყვა.

115
00:05:49,790 --> 00:05:52,940
>> ახლა ამ for loop აპირებს
iterate მეტი უკავშირდება სიაში

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
და გვახსოვდეს, რომ განახლება მაჩვენებელი
ჩვენს უკავშირდება სიაში შესვლის = entry> მომავალი.

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
იმიტომ, რომ კიდევ ერთხელ, ჩვენ გვინდა
გავაკეთოთ რამ შემთხვევაში insensitively.

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
ჩვენ წარმატებით ი
სიტყვა ჩვენს hashtable.

129
00:06:39,590 --> 00:06:43,040
>> იმ შემთხვევაში, თუ არ იყო მატჩი, მაშინ ჩვენ
აპირებს loop ერთხელ და შევხედოთ

130
00:06:43,040 --> 00:06:43,990
შემდეგი ჩანაწერი.

131
00:06:43,990 --> 00:06:47,640
და ჩვენ გავაგრძელებთ looping ხოლო არსებობს
არის მასალაა ამ უკავშირდება სიაში.

132
00:06:47,640 --> 00:06:50,160
რა მოხდება, თუ ჩვენ შესვენება
გარეთ ამ loop?

133
00:06:50,160 --> 00:06:55,110
ეს ნიშნავს, რომ ჩვენ ვერ ჩანაწერი, რომ
შესაბამისი სიტყვა, რომლის დროსაც

134
00:06:55,110 --> 00:07:00,220
ჩვენ დაბრუნების ცრუ მიუთითებს იმაზე, რომ ჩვენი
hashtable არ შეიცავს ამ სიტყვას.

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
მას შემდეგ, რაც მახსოვს დატვირთვა, თითოეული სიტყვა
ჩვენ აღმოვაჩინეთ, ჩვენ incremented გლობალურ

139
00:07:11,080 --> 00:07:12,880
ცვლადი hashtable ზომა.

140
00:07:12,880 --> 00:07:16,480
ასე რომ ზომით ფუნქცია უბრალოდ აპირებს
დაბრუნებას გლობალური ცვლადი.

141
00:07:16,480 --> 00:07:18,150
და რომ არის ის.

142
00:07:18,150 --> 00:07:22,300
>> ახლა საბოლოოდ, ჩვენ უნდა განიტვირთოს
ლექსიკონი ერთხელ ყველაფერი კეთდება.

143
00:07:22,300 --> 00:07:25,340
ასე რომ, თუ ჩვენ ვაპირებთ, რომ გავაკეთოთ?

144
00:07:25,340 --> 00:07:30,440
აქ ჩვენ looping ზე
ყველა თაიგულების ჩვენს მაგიდასთან.

145
00:07:30,440 --> 00:07:33,240
ასე რომ, არსებობს NUM_BUCKETS თაიგულების.

146
00:07:33,240 --> 00:07:37,410
და თითოეული უკავშირდება სიაში ჩვენი
hashtable, ჩვენ ვაპირებთ loop მეტი

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
ჩვენ loop ხოლო არსებობს ელემენტები
ამ უკავშირდება სიაში.

159
00:08:12,800 --> 00:08:15,620
ჩვენ ყველაფერს გავაკეთებთ, რომ ყველა დაკავშირებული
სიების hashtable.

160
00:08:15,620 --> 00:08:19,460
და კიდევ ჩვენ გაკეთდეს, რომ ჩვენ
მთლიანად დაცალა hashtable და

161
00:08:19,460 --> 00:08:20,190
ჩვენ გავაკეთეთ.

162
00:08:20,190 --> 00:08:23,200
ასე რომ შეუძლებელია განიტვირთოს
ოდესმე დაბრუნების ცრუ.

163
00:08:23,200 --> 00:08:26,470
და როდესაც ჩვენ გავაკეთეთ, ჩვენ
უბრალოდ დააბრუნოს ჭეშმარიტი.

164
00:08:26,470 --> 00:08:29,000
>> მოდით მივცეთ ამ გადაწყვეტა ცდილობენ.

165
00:08:29,000 --> 00:08:33,070
მოდით შევხედოთ რა არის ჩვენი
struct კვანძის ჰგავს.

166
00:08:33,070 --> 00:08:36,220
აქ ჩვენ ვხედავთ, ჩვენ ვაპირებთ აქვს bool
სიტყვა და struct კვანძის * ბავშვები

167
00:08:36,220 --> 00:08:37,470
bracket ანბანი.

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

169
00:08:38,929 --> 00:08:42,020
ასე რომ პირველი რაც თქვენ შეიძლება
გაინტერესებთ, რატომ არის ALPHABET

170
00:08:42,020 --> 00:08:44,660
ed განისაზღვრება, როგორც 27?

171
00:08:44,660 --> 00:08:47,900
ისე, გვახსოვდეს, რომ ჩვენ ვაპირებთ გვჭირდება
უნდა გატარება აპოსტროფი.

172
00:08:47,900 --> 00:08:51,910
ასე რომ იქნება გარკვეულწილად
განსაკუთრებულ შემთხვევაში მთელი ამ პროგრამის.

173
00:08:51,910 --> 00:08:54,710
>> ახლა მახსოვს, როგორ trie
რეალურად მუშაობს.

174
00:08:54,710 --> 00:08:59,380
ვთქვათ ჩვენ ინდექსირებას სიტყვა
"კატა". შემდეგ ფესვი trie,

175
00:08:59,380 --> 00:09:02,610
ჩვენ ვაპირებთ შევხედოთ ბავშვები
მასივი, და ჩვენ ვაპირებთ შევხედოთ

176
00:09:02,610 --> 00:09:08,090
ინდექსი, რომელიც შეესაბამება წერილი
C. ასე რომ იქნება ინდექსირებული 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
და ჩვენ ვაპირებთ შევხედოთ მაჩვენებელი ნულოვანი
შეესაბამება in კატა.

181
00:09:22,110 --> 00:09:27,170
ასე რომ მაშინ ჩვენ ვაპირებთ წასვლა რომ კვანძის,
და იმის გათვალისწინებით, რომ კვანძის ჩვენ ვაპირებთ

182
00:09:27,170 --> 00:09:31,090
შევხედოთ ბოლომდე ეს შეესაბამება
თ და მოძრავი, რომ კვანძის,

183
00:09:31,090 --> 00:09:35,530
საბოლოოდ, ჩვენ მთლიანად ჩანდა
ჩვენი სიტყვა "კატა". და ახლა 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
ახლა რომ ჩვენ ვიცით, რა trie არის
აპირებს გამოიყურებოდეს, მოდით შევხედოთ

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
null, ამ შემთხვევაში ჩვენ
დაბრუნებას აპირებს ყალბი.

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
გლობალური ცვლადი root.

208
00:10:52,500 --> 00:10:56,190
ახლა root იქნება კვანძის *.

209
00:10:56,190 --> 00:10:59,760
ის ზედა ჩვენი trie, რომ ჩვენ
იქნება iterating მეშვეობით.

210
00:10:59,760 --> 00:11:02,660
ასე რომ, პირველი, რაც ჩვენ ვაპირებთ
გსურთ არის გამოუყოფს

211
00:11:02,660 --> 00:11:04,140
მეხსიერების ჩვენი root.

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
სრულიად zeroed out.

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
ფაილი და დაბრუნების ცრუ.

222
00:11:32,100 --> 00:11:36,835
ასე რომ, ვთქვათ, რომ გამოყოფის იყო
წარმატებული, ჩვენ ვაპირებთ გამოვიყენოთ კვანძის *

223
00:11:36,835 --> 00:11:40,270
კურსორი iterate ჩვენი trie.

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
>> ასე რომ, ამ for loop ჩვენ კითხულობს
მეშვეობით ლექსიკონი ფაილი.

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
ჩვენ ვაპირებთ გავაგრძელოთ grabbing
გმირები ჩვენ კი არ აღწევს

230
00:11:59,370 --> 00:12:01,570
ფაილის ბოლოში.

231
00:12:01,570 --> 00:12:03,480
>> არსებობს ორი შემთხვევა ჩვენ უნდა გაუმკლავდეს.

232
00:12:03,480 --> 00:12:06,610
პირველი, თუ ხასიათი
არ იყო ახალი ხაზი.

233
00:12:06,610 --> 00:12:10,450
ასე რომ, ჩვენ ვიცით, თუ ეს იყო ახალი ხაზი, მაშინ
ჩვენ შესახებ გადაადგილება ახალი სიტყვა.

234
00:12:10,450 --> 00:12:15,240
მაგრამ ვთქვათ, რომ ეს არ იყო ახალი ხაზი, მაშინ
აქ ჩვენ გვინდა გაერკვნენ

235
00:12:15,240 --> 00:12:18,380
index ჩვენ ვაპირებთ ინდექსი შევიდა
ბავშვების მასივი,

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
გაითვალისწინეთ, ჩვენ გამოყენებით ternary
ოპერატორი აქ.

239
00:12:26,220 --> 00:12:29,580
ამიტომ, ჩვენ ვაპირებთ, რომ წაიკითხონ ეს, თუ
ხასიათი ვკითხულობთ იყო

240
00:12:29,580 --> 00:12:35,330
აპოსტროფი, მაშინ ჩვენ ვაპირებთ მითითებული
index = "ანბანი" -1, რომელიც

241
00:12:35,330 --> 00:12:37,680
იყოს ინდექსი 26.

242
00:12:37,680 --> 00:12:41,130
>> სხვაგან, თუ ეს არ იყო აპოსტროფი, არსებობს
ჩვენ ვაპირებთ, რომ შექმნას ინდექსი

243
00:12:41,130 --> 00:12:43,760
ტოლი გ - ს.

244
00:12:43,760 --> 00:12:49,030
ასე მახსოვს უკან ადრე P-კომპლექტი,
c - აპირებს მოგვცეს

245
00:12:49,030 --> 00:12:53,410
ანბანური პოზიცია C. ასე რომ, თუ
C არის წერილი, ეს იქნება

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 in
ბავშვებს, ეს ნიშნავს, რომ კვანძის

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
ნულოვანი out ყველა მითითებას.

255
00:13:22,880 --> 00:13:27,240
და ჩვენ კვლავ უნდა შეამოწმოს
რომ calloc არ ჩავარდება.

256
00:13:27,240 --> 00:13:30,700
იმ შემთხვევაში, თუ calloc არ ვერ, მაშინ ჩვენ უნდა
განიტვირთოს ყველაფერი, დავხუჭავთ

257
00:13:30,700 --> 00:13:32,820
ლექსიკონი, და დაბრუნების ცრუ.

258
00:13:32,820 --> 00:13:40,050
ასე რომ, ვთქვათ, რომ ეს არ ვერ, მაშინ
ეს იქნება შექმნათ ახალი ბავშვი ჩვენთვის.

259
00:13:40,050 --> 00:13:41,930
და მაშინ ჩვენ წასვლა რომ ბავშვი.

260
00:13:41,930 --> 00:13:44,960
ჩვენი კურსორი iterate
ქვემოთ რომ ბავშვი.

261
00:13:44,960 --> 00:13:49,330
>> ახლა, თუ ეს არ იყო null დაიწყოს,
მაშინ კურსორი შეგიძლიათ უბრალოდ iterate

262
00:13:49,330 --> 00:13:52,590
ქვემოთ რომ ბავშვის გარეშე, ფაქტობრივად,
მქონე გამოყოფას არაფერი.

263
00:13:52,590 --> 00:13:56,730
ეს არის საქმე, სადაც ჩვენ პირველად მოხდა
გამოყოფს სიტყვა "კატა". და

264
00:13:56,730 --> 00:14:00,330
ეს ნიშნავს, რომ როდესაც ჩვენ მივდივართ გამოუყოს
"კატასტროფის" ჩვენ არ უნდა შევქმნათ

265
00:14:00,330 --> 00:14:01,680
კვანძების C-A-T ერთხელ.

266
00:14:01,680 --> 00:14:04,830
ისინი უკვე არსებობს.

267
00:14:04,830 --> 00:14:06,080
>> რა არის ეს სხვა?

268
00:14:06,080 --> 00:14:10,480
ეს არის მდგომარეობა, სადაც c იყო
backslash N, სადაც c იყო ახალი ხაზი.

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
ჩვენ ვაპირებთ გამოვიყენოთ ეს სიტყვა ველი
შიგნით ჩვენი struct კვანძში.

272
00:14:21,100 --> 00:14:23,390
ჩვენ გვინდა, რომ მითითებული, რომ ასეა.

273
00:14:23,390 --> 00:14:27,150
ასე რომ, იმაზე მიუთითებს, რომ ამ კვანძის
მიუთითებს, რომ წარმატებული

274
00:14:27,150 --> 00:14:29,250
სიტყვა, ფაქტობრივი სიტყვა.

275
00:14:29,250 --> 00:14:30,940
>> არის მითითებული, რომ ასეა.

276
00:14:30,940 --> 00:14:35,150
ჩვენ გვინდა, რომ აღადგინოთ ჩვენი კურსორი წერტილი
დასაწყისში trie ერთხელ.

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
აშენებს ახალ კვანძების ჩვენი trie და
თითოეული სიტყვა ლექსიკონი, სანამ

280
00:14:49,150 --> 00:14:54,020
ჩვენ საბოლოოდ მიაღწიოს C! = EOF, რომელშიც
თუ ჩვენ შესვენება out of ფაილი.

281
00:14:54,020 --> 00:14:57,050
>> ახლა არსებობს ორი შემთხვევა ქვეშ
რომელიც ჩვენ შეიძლება არ მოხვდა EOF.

282
00:14:57,050 --> 00:15:00,980
პირველი არის ის, იყო თუ არა შეცდომა
კითხულობს ფაილი.

283
00:15:00,980 --> 00:15:03,470
ასე რომ, თუ იყო შეცდომა, ჩვენ
უნდა გავაკეთოთ დამახასიათებელი.

284
00:15:03,470 --> 00:15:06,460
განიტვირთოს ყველაფერი, ახლო
ფაილი, დაბრუნების ცრუ.

285
00:15:06,460 --> 00:15:09,810
ვთქვათ, არ იყო შეცდომა, რომელიც
მხოლოდ იმას ნიშნავს, ჩვენ რეალურად მოხვდა ბოლოს

286
00:15:09,810 --> 00:15:13,750
ფაილი, ამ შემთხვევაში, ჩვენ დახურვა
ფაილი და დააბრუნოს ჭეშმარიტი, რადგან ჩვენ

287
00:15:13,750 --> 00:15:17,330
წარმატებით დატვირთული ლექსიკონი
ჩვენს trie.

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
ის ბრუნდება ნამდვილი, თუ ეს სიტყვა, რომ
მიმდინარეობს გავიდა ჩვენს trie.

291
00:15:29,680 --> 00:15:32,110
ის დააბრუნებს ცრუ სხვაგვარად.

292
00:15:32,110 --> 00:15:36,050
ასე რომ, თუ თქვენ თუ არა
ეს სიტყვა არის ჩვენი trie?

293
00:15:36,050 --> 00:15:40,190
>> ჩვენ ვხედავთ, რომ აქ, ისევე, როგორც ადრე,
ჩვენ ვაპირებთ გამოვიყენოთ კურსორი iterate

294
00:15:40,190 --> 00:15:41,970
ჩვენი trie.

295
00:15:41,970 --> 00:15:46,600
ახლა აქ ჩვენ ვაპირებთ iterate
მეტი ჩვენი მთელი სიტყვა.

296
00:15:46,600 --> 00:15:50,620
ასე რომ iterating მეტი სიტყვა ვართ წარსულში,
ჩვენ ვაპირებთ, რათა დადგინდეს

297
00:15:50,620 --> 00:15:56,400
ინდექსი შევიდა ბავშვები მასივი,
შეესაბამება სიტყვა bracket I. ასე რომ, ეს

298
00:15:56,400 --> 00:15:59,670
აპირებს გამოიყურებოდეს ზუსტად ისევე,
დატვირთვის, სადაც თუ სიტყვა [i]

299
00:15:59,670 --> 00:16:03,310
არის აპოსტროფი, მაშინ ჩვენ გვინდა
გამოყენება ინდექსი "ანბანი" - 1.

300
00:16:03,310 --> 00:16:05,350
იმიტომ, რომ ჩვენ განისაზღვრა, რომ
არის, სადაც ჩვენ ვაპირებთ შესანახად

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

302
00:16:07,100 --> 00:16:11,780
>> Else ჩვენ ვაპირებთ გამოვიყენოთ ორი ქვედა სიტყვა
bracket 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
ასე რომ იქნება ჩვენი ინდექსი
შევიდა ბავშვები მასივი.

308
00:16:27,680 --> 00:16:32,420
>> და ახლა, თუ ეს ინდექსი შევიდა ბავშვები
მასივი null, ეს ნიშნავს, რომ ჩვენ

309
00:16:32,420 --> 00:16:34,990
ვეღარ გააგრძელებს iterating
ქვემოთ ჩვენი trie.

310
00:16:34,990 --> 00:16:38,870
თუ ეს საქმე, ეს სიტყვა არ შეიძლება
შესაძლოა იყოს ჩვენი trie.

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
და თქვენ არასოდეს ექმნებათ null.

314
00:16:45,290 --> 00:16:47,850
ასე რომ, შესახებ, null, ვბრუნდებით ყალბი.

315
00:16:47,850 --> 00:16:49,840
სიტყვა არ არის ლექსიკონში.

316
00:16:49,840 --> 00:16:53,660
თუ ეს არ იყო null, მაშინ ჩვენ
გავაგრძელებთ iterating.

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
კვანძის ჩვენს ცდილობენ.

323
00:17:08,920 --> 00:17:10,770
მაგრამ ჩვენ არ საკმაოდ გაკეთდეს არავის გაუკეთებია.

324
00:17:10,770 --> 00:17:12,290
>> ჩვენ არ გვინდა, რომ უბრალოდ დააბრუნოს ჭეშმარიტი.

325
00:17:12,290 --> 00:17:14,770
ჩვენ გვინდა დაბრუნდეს კურსორი> სიტყვა.

326
00:17:14,770 --> 00:17:18,980
მას შემდეგ, რაც მახსოვს, ერთხელ, "კატა" არ არის
ჩვენი ლექსიკონი, და "კატასტროფა"

327
00:17:18,980 --> 00:17:22,935
არის, მაშინ ჩვენ წარმატებით მივიღებთ
მეშვეობით სიტყვა "კატა". მაგრამ კურსორი

328
00:17:22,935 --> 00:17:25,760
სიტყვა იქნება ყალბი და არ შეესაბამება სიმართლეს.

329
00:17:25,760 --> 00:17:30,930
ასე რომ, ჩვენ დაბრუნდება კურსორი სიტყვა მიუთითოს
თუ არა ამ კვანძის რეალურად სიტყვა.

330
00:17:30,930 --> 00:17:32,470
და რომ ეს შემოწმება.

331
00:17:32,470 --> 00:17:34,250
>> მოდით შეამოწმეთ ზომა.

332
00:17:34,250 --> 00:17:37,350
ასე რომ ზომა იქნება საკმაოდ ადვილი
რადგან, გახსოვდეთ, დატვირთვის, ჩვენ

333
00:17:37,350 --> 00:17:41,430
დამატება ლექსიკონი ზომა
თითოეული სიტყვა, რომ ჩვენ ვაწყდებით.

334
00:17:41,430 --> 00:17:45,350
ასე რომ ზომით უბრალოდ აპირებს
დაბრუნებას ლექსიკონი ზომა.

335
00:17:45,350 --> 00:17:47,390
და რომ არის ის.

336
00:17:47,390 --> 00:17:50,590
>> ასე რომ, ბოლოს ჩვენ განიტვირთოს.

337
00:17:50,590 --> 00:17:55,100
ასე რომ განიტვირთოს, ჩვენ ვაპირებთ გამოვიყენოთ
რეკურსიული ფუნქცია რეალურად ყველაფერი

338
00:17:55,100 --> 00:17:56,530
მუშაობა ჩვენთვის.

339
00:17:56,530 --> 00:17:59,340
ასე რომ, ჩვენი ფუნქცია აპირებს
მოეთხოვოს unloader.

340
00:17:59,340 --> 00:18:01,650
რა არის unloader აპირებს?

341
00:18:01,650 --> 00:18:06,580
ჩვენ ვხედავთ, აქ რომ unloader აპირებს
iterate მეტი ყველა ბავშვები

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
ეს იმუშავებს რეკურსიული
განიტვირთოს მთელი trie.

349
00:18:29,460 --> 00:18:32,850
და მერე კიდევ რომ კეთდება,
ჩვენ შეგვიძლია უბრალოდ დააბრუნოს ჭეშმარიტი.

350
00:18:32,850 --> 00:18:34,210
განიტვირთოს ვერ ჩავარდება.

351
00:18:34,210 --> 00:18:35,710
ჩვენ უბრალოდ გამონთავისუფლების რამ.

352
00:18:35,710 --> 00:18:38,870
ასე რომ ერთხელ ჩვენ გავაკეთეთ ათავისუფლებს
ყველაფერი, 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
და ეს იყო speller.

356
00:18:42,426 --> 00:18:47,830
>> [მუსიკის დაკვრა]