1
00:00:00,000 --> 00:00:12,350
>> [संगीत खेल]

2
00:00:12,350 --> 00:00:13,050
>> आरओबी BOWDEN: हाय.

3
00:00:13,050 --> 00:00:13,640
मैं रोब हूँ.

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
हम देखते हैं कि हमारे की संरचना नोड
तालिका इस तरह लग रहा है.

7
00:00:24,090 --> 00:00:28,710
तो यह एक चार शब्द है जा रहा है
आकार लम्बाई 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
और फिर हम एक अतिरिक्त जरूरत जा रहे हैं
बैकस्लैश शून्य के लिए चरित्र.

11
00:00:37,070 --> 00:00:40,870
>> और तब प्रत्येक में हमारे Hashtable
बाल्टी स्टोर करने के लिए जा रहा है एक

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
और तो क्रम में अगले करने के लिए लिंक करने के लिए
बाल्टी में तत्व, हम एक की जरूरत

15
00:00:48,430 --> 00:00:50,390
संरचना नोड * अगले.

16
00:00:50,390 --> 00:00:51,110
ठीक है.

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
शून्य के रूप में शुरू करने जा रहा है.

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 चार * शब्दकोश लेता है
शब्दकोश है जो

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
यह शून्य लौट ऐसा है, तो हम नहीं था
सफलतापूर्वक शब्दकोश खुला.

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
हम कुछ पाते हैं तो जब तक पाशन रखना
इस पाश से बाहर तोड़ने के लिए कारण,

37
00:01:46,450 --> 00:01:47,570
हम देखेंगे जो.

38
00:01:47,570 --> 00:01:48,920
तो पाशन रखना.

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
तो उस प्रविष्टि> शब्द याद चार है
+ 1 आकार LENGHTH के शब्द बफर

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 वापस नहीं करता है, जो मामले में
हम अंत से बाहर तोड़ने के लिए जा रहे हैं

52
00:02:35,180 --> 00:02:37,280
इस समय पाश.

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
और वास्तव में हम सिर्फ इस हैश निकाला
इंटरनेट से कार्य करते हैं.

59
00:02:59,460 --> 00:03:04,010
आपको पहचानने की जरूरत है केवल एक चीज है
यह एक const चार * शब्द लेता है.

60
00:03:04,010 --> 00:03:08,960
इसलिए यह निवेश के रूप में एक स्ट्रिंग ले रही है, और है
आउटपुट के रूप में एक अहस्ताक्षरित 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
>> हम NUM_BUCKETS द्वारा moding रहे सूचना है कि,
इसलिए कि मूल्य लौटे

64
00:03:18,530 --> 00:03:21,730
वास्तव में Hashtable में एक सूचकांक है
और करता परे नहीं सूचकांक

65
00:03:21,730 --> 00:03:24,320
सरणी की सीमा.

66
00:03:24,320 --> 00:03:28,060
इसलिए कि समारोह, हम जा रहे हैं दी
हम पढ़ कि शब्द हैश करने के लिए

67
00:03:28,060 --> 00:03:29,390
शब्दकोश.

68
00:03:29,390 --> 00:03:31,700
और फिर हम प्रयोग करने जा रहे हैं
सम्मिलित करने के लिए कि हैश

69
00:03:31,700 --> 00:03:33,750
Hashtable में प्रवेश.

70
00:03:33,750 --> 00:03:38,520
>> अब Hashtable हैश वर्तमान है
तालिका में सूची जुड़े.

71
00:03:38,520 --> 00:03:41,410
और यह बहुत संभव है
यह सिर्फ रिक्त है कि.

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
हैश, वर्तमान प्रविष्टि.

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 कुछ लौटे

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
और हम सफलतापूर्वक पढ़ा नहीं था
में शब्दकोश से कुछ,

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
>> हम बाहर तोड़ एक बार जब हम देखने की जरूरत है, ठीक है,
हम क्योंकि वहाँ बाहर तोड़ा

89
00:04:32,750 --> 00:04:34,360
एक त्रुटि फ़ाइल से पढ़ रहा था?

90
00:04:34,360 --> 00:04:37,120
या हम बाहर तोड़ दिया क्योंकि हम
फ़ाइल के अंत तक?

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
फ़ाइल, और अंत में सच वापसी के बाद से हम
सफलतापूर्वक शब्दकोश भरा हुआ है.

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
* चार शब्द में, चाहे पारित किया
स्ट्रिंग में हमारे शब्दकोश में है.

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
>> इस शब्द में पारित देखते हुए, हम कर रहे हैं
शब्द हैश करने के लिए जा रहा है.

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
>> अब पाश के लिए यह जा रहा है
लिंक की गई सूची से पुनरावृति

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
हम जारी रखने के लिए जा रहे हैं
प्रवेश! = रिक्त है.

119
00:06:02,750 --> 00:06:07,770
और याद रखें कि सूचक को अद्यतन करने के
में अगले हमारे लिंक सूची प्रविष्टि = प्रविष्टि>.

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
वापसी सच.

128
00:06:36,630 --> 00:06:39,590
हम सफलतापूर्वक पाया
हमारे Hashtable में शब्द.

129
00:06:39,590 --> 00:06:43,040
>> वहाँ एक मैच नहीं था, तो हम कर रहे हैं
फिर पाश के लिए जा रहा है और कम से देखो

130
00:06:43,040 --> 00:06:43,990
अगले प्रविष्टि.

131
00:06:43,990 --> 00:06:47,640
और जब तक हम वहाँ पाशन जारी रखेंगे
इस लिंक की गई सूची में प्रविष्टियों रहे हैं.

132
00:06:47,640 --> 00:06:50,160
हम तोड़ तो क्या होता
पाश के लिए इस से बाहर?

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
चूंकि प्रत्येक शब्द के लिए, भार में याद
हम हम एक वैश्विक वृद्धि, पाया

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
यहीं हम पर पाशन कर रहे हैं
हमारे टेबल के सभी बाल्टी.

145
00:07:30,440 --> 00:07:33,240
तो NUM_BUCKETS बाल्टी रहे हैं.

146
00:07:33,240 --> 00:07:37,410
और में प्रत्येक लिंक की गई सूची के लिए हमारी
Hashtable, हम पर पाश करने के लिए जा रहे हैं

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
हम तत्वों पाश वहाँ हूँ, जबकि
इस लिंक की गई सूची में.

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
तो चलो क्या हमारे पर एक नज़र
संरचना नोड की तरह दिखेगा.

166
00:08:33,070 --> 00:08:36,220
यहाँ हम हम एक bool लिए जा रहे हैं देखते हैं
शब्द और एक संरचना नोड * बच्चों

167
00:08:36,220 --> 00:08:37,470
ब्रैकेट वर्णमाला.

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

169
00:08:38,929 --> 00:08:42,020
आप हो सकता है तो पहली बात
सोच, क्यों अक्षर है

170
00:08:42,020 --> 00:08:44,660
एड 27 के रूप में परिभाषित किया गया?

171
00:08:44,660 --> 00:08:47,900
ठीक है, हम जरूरत जा रहे हैं कि याद
apostrophe निपटने होंगे.

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
पत्र से मेल खाती है कि सूचकांक
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
और हम सूचकांक शून्य को देखने के लिए जा रहे हैं
बिल्ली में एक के अनुरूप करने के लिए.

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
सफलतापूर्वक के माध्यम से देखने के लिए जा
क्षेत्र नोड में सूचकांक सी ए टी.

190
00:09:59,970 --> 00:10:04,290
लेकिन यह है कि केवल क्योंकि तबाही
रास्ते में नोड्स बनाने के लिए हुआ

191
00:10:04,290 --> 00:10:07,190
सी ए टी से, सभी तरह से करने के लिए
शब्द के अंत.

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
अशक्त, जो मामले में हम कर रहे हैं
झूठी वापस जाने के लिए जा रहा है.

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
वैश्विक चर जड़.

208
00:10:52,500 --> 00:10:56,190
अब रूट * एक नोड होने जा रहा है.

209
00:10:56,190 --> 00:10:59,760
यह हम कर रहे हैं कि हमारे Trie के ऊपर है
के माध्यम से पुनरावृति होने जा रहा.

210
00:10:59,760 --> 00:11:02,660
हम जा रहे हैं तो पहली बात
क्या करना चाहते करने के लिए आवंटित है

211
00:11:02,660 --> 00:11:04,140
हमारे रूट के लिए स्मृति.

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
पूरी तरह से बाहर चुना.

215
00:11:13,180 --> 00:11:17,290
हम malloc इस्तेमाल किया तो, अगर हम करने की आवश्यकता होगी
में संकेत के सभी के माध्यम से जाना हमारे

216
00:11:17,290 --> 00:11:20,160
नोड, और सुनिश्चित करें कि
वे सभी अशक्त हो.

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
इस अशक्त लौटे, तो हम
बंद करने या शब्दकोश करने की जरूरत है

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
हमारे 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
>> तो इस में पाश के लिए हम पढ़ रहे हैं
शब्दकोश फ़ाइल के माध्यम से.

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
हम हथियाने जारी रखने के लिए जा रहे हैं
संदेश तक पहुँच नहीं है, जबकि

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
सूचकांक हम में सूचकांक के लिए जा रहे हैं
बच्चों सरणी में कि

236
00:12:18,380 --> 00:12:19,810
हम पहले देखा.

237
00:12:19,810 --> 00:12:23,880
>> तो, जैसा मैंने पहले कहा, हम करने की आवश्यकता
विशेष मामला apostrophe.

238
00:12:23,880 --> 00:12:26,220
हम त्रिगुट का उपयोग कर रहे हैं नोटिस
यहाँ ऑपरेटर.

239
00:12:26,220 --> 00:12:29,580
तो हम हैं, के रूप में इस पढ़ने के लिए जा रहे हैं
हम में पढ़ा चरित्र एक था

240
00:12:29,580 --> 00:12:35,330
apostrophe, तो हम स्थापित करने के लिए जा रहे हैं
सूचकांक = "वर्णमाला" -1, जो होगा

241
00:12:35,330 --> 00:12:37,680
सूचकांक 26 हो.

242
00:12:37,680 --> 00:12:41,130
>> वरना, यह एक apostrophe नहीं था, तो वहाँ
हम सूचकांक सेट करने के लिए जा रहे हैं

243
00:12:41,130 --> 00:12:43,760
सी के बराबर - एक.

244
00:12:43,760 --> 00:12:49,030
तो वापस पहले पी सेट से याद है,
सी - एक हमें देने जा रहा है

245
00:12:49,030 --> 00:12:53,410
सी. की वर्णमाला स्थिति तो अगर
सी यह, पत्र एक है

246
00:12:53,410 --> 00:12:54,700
हमें सूचकांक शून्य दे.

247
00:12:54,700 --> 00:12:58,120
पत्र बी के लिए यह दे देंगे
इतने पर हमें सूचकांक 1, और.

248
00:12:58,120 --> 00:13:03,010
>> तो यह हमारे में सूचकांक देता है
हम चाहते हैं कि बच्चों सरणी.

249
00:13:03,010 --> 00:13:08,890
अब इस सूचकांक में फिलहाल शून्य है
बच्चों, इसका मतलब है कि एक नोड

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
सभी संकेत बाहर शून्य.

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
हमारे कर्सर पुनरावृति होगी
उस बच्चे को नीचे.

261
00:13:44,960 --> 00:13:49,330
>> अब इस के साथ शुरू करने के लिए अशक्त नहीं था,
तब कर्सर बस पुनरावृति कर सकते हैं

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
फिर सी ए टी के लिए नोड्स.

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
यह सी थी जहां हालत है
सी एक नई लाइन थी जहां बैकस्लैश एन,.

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
हम इस शब्द के क्षेत्र का उपयोग करने के लिए जा रहे हैं
हमारे संरचना नोड के अंदर.

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
हम अंत में सी तक पहुँचने! = EOF, जिसमें
मामले में हम फाइल से बाहर तोड़.

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
>> हम यहाँ देखते हैं, पहले की तरह,
हम पुनरावृति करने के लिए कर्सर का उपयोग करने के लिए जा रहे हैं

294
00:15:40,190 --> 00:15:41,970
हमारे Trie के माध्यम से.

295
00:15:41,970 --> 00:15:46,600
अब यहाँ हम पुनरावृति करने के लिए जा रहे हैं
हमारे पूरे शब्द पर.

296
00:15:46,600 --> 00:15:50,620
तो, हम पिछले रहे हैं शब्द पर iterating
हम यह निर्धारित करने के लिए जा रहे हैं

297
00:15:50,620 --> 00:15:56,400
सूचकांक बच्चों सरणी में कि
शब्द ब्रैकेट मैं से मेल खाती है तो यह

298
00:15:56,400 --> 00:15:59,670
बिल्कुल वैसा ही लग रहा है
लोड, जहां अगर शब्द [मैं]

299
00:15:59,670 --> 00:16:03,310
एक apostrophe, तो हम चाहते है
सूचकांक "वर्णमाला" का उपयोग करने के लिए - 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
>> वरना हम दो कम शब्द का प्रयोग करने जा रहे हैं
ब्रैकेट मैं तो उस शब्द को याद कर सकते हैं

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
>> और अब अगर बच्चों में है कि सूचकांक
सरणी रिक्त है, कि हम का मतलब

309
00:16:32,420 --> 00:16:34,990
अब कोई पुनरावृति को जारी रख सकते हैं
हमारे 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
और तुम अशक्त मुठभेड़ कभी नहीं होगा.

314
00:16:45,290 --> 00:16:47,850
तो अशक्त सामना, हम वापसी झूठी.

315
00:16:47,850 --> 00:16:49,840
शब्द शब्दकोश में नहीं है.

316
00:16:49,840 --> 00:16:53,660
यह रिक्त नहीं थे, तो हम कर रहे हैं
पुनरावृति को जारी रखने के लिए जा रहा है.

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
हम अशक्त कभी नहीं मारा.

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
शब्दकोश आकार incrementing
हम मुठभेड़ कि प्रत्येक शब्द.

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 जा रहा है यहाँ देख
बच्चों के सभी पर अधिक पुनरावृति

342
00:18:06,580 --> 00:18:08,410
इस विशेष नोड.

343
00:18:08,410 --> 00:18:11,750
और बच्चे के नोड नहीं है अगर
अशक्त, तो हम करने जा रहे हैं

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
तो एक बार हम मुक्त कराने के काम हो गया
सब कुछ, सच वापसी.

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
और इस स्पेलर था.

356
00:18:42,426 --> 00:18:47,830
>> [संगीत खेल]