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

2
00:00:00,530 --> 00:00:03,070
>> დინამიკები 1: მოდით მივცეთ
ეს გამოსავალი ცდილობენ.

3
00:00:03,070 --> 00:00:07,130
მოდით შევხედოთ რა არის ჩვენი
Struct კვანძის ჰგავს.

4
00:00:07,130 --> 00:00:11,040
აქ ჩვენ ვხედავთ, ჩვენ ვაპირებთ აქვს
Bool Word და struct კვანძის ვარსკვლავი

5
00:00:11,040 --> 00:00:12,990
ბავშვები bracket ანბანი.

6
00:00:12,990 --> 00:00:18,720
ასე რომ, პირველი, რაც თქვენ შეიძლება გაინტერესებთ,
რატომ ანბანი hash განისაზღვრება, როგორც 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, ახლა, მახსოვს, როგორ
Trie რეალურად მუშაობს.

10
00:00:28,780 --> 00:00:33,420
ვთქვათ ჩვენ ინდექსირებას სიტყვა კატა,
შემდეგ კი root ჩვენი trie,

11
00:00:33,420 --> 00:00:36,670
ჩვენ ვაპირებთ შევხედოთ ბავშვები
მასივი, და ჩვენ ვაპირებთ შევხედოთ

12
00:00:36,670 --> 00:00:42,250
ინდექსი, რომელიც შეესაბამება წერილი
C. ასე რომ იქნებოდა ინდექსი ორი.

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

17
00:00:56,170 --> 00:01:01,240
ასე რომ მაშინ ჩვენ ვაპირებთ წასვლა რომ კვანძის,
და იმის გათვალისწინებით, რომ კვანძის, ჩვენ ვაპირებთ

18
00:01:01,240 --> 00:01:05,170
შევხედოთ ინდექსი, რომელიც შეესაბამება
თ და მოძრავი, რომ კვანძის,

19
00:01:05,170 --> 00:01:09,590
საბოლოოდ, ჩვენ მთლიანად ჩანდა
ჩვენი სიტყვა Cat, და ახლა bool

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
სიტყვა cat არ არის?

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

29
00:01:46,520 --> 00:01:48,370
მიუთითებს სიტყვა.

30
00:01:48,370 --> 00:01:52,920
>> ყველა უფლება, ასე რომ, ახლა, რომ ჩვენ ვიცით, თუ რა
Trie აპირებს გამოიყურებოდეს, მოდით შევხედოთ

31
00:01:52,920 --> 00:01:54,800
იმ Load ფუნქცია.

32
00:01:54,800 --> 00:01:58,670
ასე რომ Load დაბრუნებას აპირებს bool
განთავსების არა ჩვენ წარმატებულად

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

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

43
00:02:26,560 --> 00:02:30,250
ახლა, root იქნება კვანძის ვარსკვლავი.

44
00:02:30,250 --> 00:02:33,830
ის ზედა ჩვენი trie, რომ ჩვენ
იქნება iterating მეშვეობით.

45
00:02:33,830 --> 00:02:38,200
ასე რომ, პირველი, რაც ჩვენ ვაპირებთ მინდა
გავაკეთოთ არის გამოყოს მეხსიერება ჩვენი root.

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

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
ვარსკვლავი კურსორი iterate
ჩვენი trie.

58
00:03:14,340 --> 00:03:17,950
ასე რომ, ჩვენი root არასდროს შეიცვლება,
მაგრამ ჩვენ ვაპირებთ გამოვიყენოთ კურსორი

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
და ჩვენ გამოყენებით at fgetc.

62
00:03:26,965 --> 00:03:30,360
ასე რომ fgetc აპირებს დაიბრუნოს ერთი
ხასიათი ფაილი.

63
00:03:30,360 --> 00:03:33,430
ჩვენ ვაპირებთ გავაგრძელოთ grabbing
გმირები ჩვენ კი არ აღწევს

64
00:03:33,430 --> 00:03:37,540
ფაილის ბოლოში, ასე რომ
ორ შემთხვევაში ჩვენ უნდა გაუმკლავდეს.

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
index ჩვენ ვაპირებთ ინდექსი შევიდა
ბავშვთა მასივი,

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

72
00:04:01,040 --> 00:04:05,500
ეს თითქოს ხასიათი ვკითხულობთ იყო
აპოსტროფი, მაშინ ჩვენ ვაპირებთ

73
00:04:05,500 --> 00:04:11,740
მითითებული მაჩვენებელში ანბანი minus
1, რომელიც იქნება ინდექსი 26.

74
00:04:11,740 --> 00:04:15,190
სხვაგან, თუ ეს არ იყო აპოსტროფი,
მაშინ ჩვენ ვაპირებთ მითითებული ინდექსი

75
00:04:15,190 --> 00:04:17,820
ტოლი გ მინუს.

76
00:04:17,820 --> 00:04:23,090
ასე გვახსოვს უკან წინა p კომპლექტი,
გ მინუს აპირებს მოგვცეს

77
00:04:23,090 --> 00:04:27,470
ანბანური პოზიცია c ასე რომ, თუ
გ არის წერილი, ეს იქნება

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

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
ნულოვანი out ყველა პოინტერები, და ჩვენ,
ერთხელ, უნდა შეამოწმოთ, რომ 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
ჩვენი კურსორი iterate
ქვემოთ რომ ბავშვი.

93
00:05:19,030 --> 00:05:23,390
ახლა, თუ ეს არ იყო null დაიწყოს,
მაშინ კურსორი შეგიძლიათ უბრალოდ iterate

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 იყო
backslash N, სადაც c იყო ახალი ხაზი.

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

104
00:05:55,250 --> 00:06:00,570
>> ჩვენ გვინდა, რომ მითითებული, რომ მართალია, ისე, რომ
მიუთითებს იმაზე, რომ ამ კვანძის მიუთითებს

105
00:06:00,570 --> 00:06:03,320
წარმატებული სიტყვა ფაქტობრივი სიტყვა.

106
00:06:03,320 --> 00:06:05,050
ახლა მითითებული, რომ ასეა.

107
00:06:05,050 --> 00:06:09,210
ჩვენ გვინდა, რომ აღადგინოთ ჩვენი კურსორი წერტილი
დასაწყისში trie ერთხელ.

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

111
00:06:21,960 --> 00:06:26,810
ლექსიკონი, სანამ ჩვენ საბოლოოდ მიაღწიოს გ
შეადგენს EOF, ამ შემთხვევაში, ჩვენ შესვენება

112
00:06:26,810 --> 00:06:28,100
out of ფაილი.

113
00:06:28,100 --> 00:06:31,110
ახლა, არსებობს ორი გათვალისწინებულ შემთხვევაში
რომელიც ჩვენ შეიძლება არ მოხვდა 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
დაბრუნების ცრუ.

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

120
00:06:51,010 --> 00:06:54,240
>> ყველა უფლება, ასე რომ, ახლა მოდით
შეამოწმეთ შემოწმება.

121
00:06:54,240 --> 00:06:58,780
ეძებს Check ფუნქცია, ჩვენ ვხედავთ
რომ Check დაბრუნებას აპირებს bool.

122
00:06:58,780 --> 00:07:03,740
ის დააბრუნებს True, თუ ეს სიტყვა, რომ
მიმდინარეობს გავიდა ჩვენს trie.

123
00:07:03,740 --> 00:07:06,170
ის დააბრუნებს False მიიღო.

124
00:07:06,170 --> 00:07:10,110
>> ასე რომ, როგორ მივდივართ თუ არა
ეს სიტყვა არის ჩვენი trie?

125
00:07:10,110 --> 00:07:14,270
ჩვენ ვხედავთ, რომ აქ, ისევე, როგორც ადრე,
ჩვენ ვაპირებთ გამოვიყენოთ კურსორი iterate

126
00:07:14,270 --> 00:07:16,010
ჩვენი trie.

127
00:07:16,010 --> 00:07:20,650
ახლა, აქ, ჩვენ ვაპირებთ iterate
მეტი ჩვენი მთელი სიტყვა.

128
00:07:20,650 --> 00:07:24,680
ასე რომ iterating მეტი სიტყვა ვართ
გავიდა, ჩვენ ვაპირებთ, რათა დადგინდეს

129
00:07:24,680 --> 00:07:29,280
ინდექსი შევიდა ბავშვები მასივი,
შეესაბამება სიტყვა bracket i.

130
00:07:29,280 --> 00:07:34,150
ასე რომ, ეს აპირებს გამოიყურებოდეს ზუსტად ისევე,
დატვირთვის, სადაც თუ სიტყვა bracket i არის

131
00:07:34,150 --> 00:07:38,110
აპოსტროფი, მაშინ ჩვენ გვინდა გამოვიყენოთ ინდექსი
ანბანი მინუს 1 რადგან ჩვენ გადაწყვეტილი

132
00:07:38,110 --> 00:07:41,160
რომ არის, სადაც ჩვენ ვაპირებთ
შესანახად apostrophes.

133
00:07:41,160 --> 00:07:44,440
>> Else ჩვენ ვაპირებთ გამოვიყენოთ tolower
სიტყვა bracket 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
ასე რომ იქნება ჩვენი ინდექსი
შევიდა ბავშვები მასივი.

139
00:08:01,740 --> 00:08:06,480
>> და ახლა, თუ ეს ინდექსი შევიდა ბავშვები
მასივი null, ეს ნიშნავს, რომ ჩვენ

140
00:08:06,480 --> 00:08:09,050
ვეღარ გააგრძელებს iterating
ქვემოთ ჩვენი trie.

141
00:08:09,050 --> 00:08:13,320
თუ ეს საქმე, ეს სიტყვა არ შეიძლება
შესაძლოა იყოს ჩვენი trie, რადგან თუ იგი

142
00:08:13,320 --> 00:08:18,000
იყო, ეს იმას ნიშნავს, იქ იქნება
გზა ქვემოთ რომ სიტყვა და თქვენ

143
00:08:18,000 --> 00:08:19,350
არასდროს ექმნებათ null.

144
00:08:19,350 --> 00:08:21,910
ასე რომ, შესახებ, null, ვბრუნდებით ყალბი.

145
00:08:21,910 --> 00:08:23,810
სიტყვა არ არის ლექსიკონში.

146
00:08:23,810 --> 00:08:28,200
თუ ეს არ იყო null, მაშინ ჩვენ ვაპირებთ
გაგრძელდება iterating, ამიტომ ჩვენ ვაპირებთ

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
ვთქვათ, ჩვენ არ მოხვდა null, ანუ
ჩვენ შევძელით, რომ მიიღოთ მთელი

150
00:08:40,630 --> 00:08:44,840
მსოფლიოში და იპოვოს კვანძის ჩვენს trie,
მაგრამ ჩვენ არ საკმაოდ გაკეთდეს არავის გაუკეთებია.

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
ასე რომ ზომა იქნება საკმაოდ ადვილი
მას შემდეგ, მახსოვს Load, ჩვენ

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
მუშაობა ჩვენთვის, ისე ჩვენი ფუნქცია
აპირებს ეწოდოს Unloader.

164
00:09:33,390 --> 00:09:35,830
რა არის Unloader აპირებს?

165
00:09:35,830 --> 00:09:40,640
ჩვენ ვხედავთ, აქ რომ Unloader აპირებს
iterate მეტი ყველა ბავშვები

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

171
00:09:58,830 --> 00:10:04,550
ასე რომ, ეს იქნება რეკურსიული განიტვირთოს
მთელი trie, და შემდეგ კიდევ, რომ ის,

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

175
00:10:12,985 --> 00:10:14,380
და რომ არის ის.

176
00:10:14,380 --> 00:10:16,792
ჩემი სახელი არის რობ, და ამ
იყო [INAUDIBLE].

177
00:10:16,792 --> 00:10:21,888