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
यह कहा जाता है एक समारोह पर जाँच बुलाता हूँ
inputted पाठ फ़ाइल में हर शब्द,

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
>> तो हम कैसे सी में इस का प्रतिनिधित्व करते हैं?

65
00:03:37,970 --> 00:03:40,540
हम यहाँ हमारी संरचना को परिभाषित.

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
और फिर हम करने के लिए एक सूचक है
अगला नामक एक और नोड.

70
00:03:54,210 --> 00:03:56,730
>> तो चलो एक छोटा सा लिंक सूची बनाते हैं.

71
00:03:56,730 --> 00:04:00,390
सबसे पहले, आप अपने नोड malloc के लिए चाहता हूँ,
स्मृति में स्थान बनाने के जो

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
संरचना के चर तक पहुँचता है.

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 के बराबर होती है,
दो Node2 को Node1 ओर इशारा करते हुए.

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
तो चलो हर के लिए एक नोड malloc जाने
हम हैं कि नए शब्द.

99
00:05:39,130 --> 00:05:42,900
नोड * new_node बराबरी
malloc (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
कर्सर जब तक पाशन हम कर सकते हैं, अशक्त है
फिर कुछ प्रक्रियाओं और आचरण

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
>> आप डी में हो जाता है कि निर्धारित कहो
सी और ई नोड सम्मिलित करने के बीच,

144
00:08:24,960 --> 00:08:30,030
को new_node डी बिंदु है
अगले कर्सर है जो नोड ई,.

145
00:08:30,030 --> 00:08:36,409
और फिर सी, कर्सर, तो बात कर सकते हैं
डी. कि जिस तरह से करने के लिए, आप एक सूची बनाए.

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
वर्णमाला में अक्षर
प्लस एक apostrophe.

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
इस चित्र में, हम देखते हैं कि केवल
कुछ पत्र और कुछ substrings

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
>> तो हम कैसे सी में इस का प्रतिनिधित्व करते हैं?

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
Trie के माध्यम से पुनरावृति करने के लिए.

175
00:10:11,960 --> 00:10:16,170
और बच्चों में प्रत्येक तत्व
एक अलग पत्र से मेल खाती है.

176
00:10:16,170 --> 00:10:21,660
>> इसलिए बच्चों पर मूल्य की जाँच
मैं प्रतिनिधित्व करता है जहां सूचकांक मैं,

177
00:10:21,660 --> 00:10:24,840
पत्र के विशिष्ट सूचकांक कि
आप सम्मिलित करने के लिए कोशिश कर रहे हैं.

178
00:10:24,840 --> 00:10:28,980
खैर, यह शून्य है, तो आप के लिए चाहता हूँ
एक नए नोड malloc और बच्चे हैं

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
substring, पहले से मौजूद है.

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
पहले अक्षर, एफ, स्थित हो जाएगा
बच्चों के सूचकांक में जड़ों के पांच

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, और एक्स

192
00:11:14,610 --> 00:11:20,180
शाखाओं में बंटी, यह भी है कि नीचे हो जाएगा
हे के बच्चों से दूर.

193
00:11:20,180 --> 00:11:24,120
और फिर एक्स आखिरी खत है क्योंकि
शब्द का "फॉक्स," तो मैं करने जा रहा हूँ

194
00:11:24,120 --> 00:11:27,210
इंगित करने के लिए कि हरे रंग कि
यह शब्द के अंत में है.

195
00:11:27,210 --> 00:11:32,880
सी में, यह है कि स्थापित हो जाएगा
शब्द सच मान पर बूलियन.

196
00:11:32,880 --> 00:11:36,780
>> अब क्या हुआ अगर आप कर रहे हैं कि अगले शब्द
में लोड करने के लिए शब्द "foo" है?

197
00:11:36,780 --> 00:11:41,490
वैसे, अगर आप किसी भी अधिक malloc की जरूरत नहीं है
एफ के लिए या ओ के लिए अंतरिक्ष, क्योंकि

198
00:11:41,490 --> 00:11:42,990
उन पहले से मौजूद हैं.

199
00:11:42,990 --> 00:11:45,910
लेकिन foo में पिछले हे?

200
00:11:45,910 --> 00:11:47,320
एक है कि आप malloc के लिए होगा.

201
00:11:47,320 --> 00:11:52,390
सेटिंग, उस के लिए एक नया नोड बनाओ
सच है पद बूलियन.

202
00:11:52,390 --> 00:11:57,340
>> तो अब सम्मिलित करते हैं "कुत्ता." डॉग होगा
जड़ों के सूचकांक तीन के साथ शुरू

203
00:11:57,340 --> 00:12:00,520
बच्चों, डी नहीं है क्योंकि
अभी तक नहीं बनाया गया.

204
00:12:00,520 --> 00:12:04,990
और हम एक ऐसी प्रक्रिया के रूप में पालन करेंगे
इससे पहले, substring कुत्ते बनाने,

205
00:12:04,990 --> 00:12:10,400
जहां जी हरी क्योंकि रंग का है
कि एक शब्द के अंत में है.

206
00:12:10,400 --> 00:12:13,160
>> अब, हम "नहीं" सम्मिलित करने के लिए क्या चाहते हैं?

207
00:12:13,160 --> 00:12:17,150
खैर, इस कुत्ते का एक substring है, तो
हम अब और malloc की जरूरत नहीं है.

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
वर्ण या apostrophes.

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
क्रमबद्ध लिंक सूचियों या unsorted वाले.

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

235
00:14:00,390 --> 00:14:03,280
बच्चों में तत्व इसी.

236
00:14:03,280 --> 00:14:07,770
>> उस तत्व रिक्त है, तो इसका मतलब है कि
कोई substrings कर रहे हैं कि

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
लेकिन अगर नहीं, कि भले ही substring
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
बच्चों सरणियों की, जब तक
आप अपने शीर्ष रूट नोड मारा.

277
00:16:15,610 --> 00:16:18,920
यहाँ है जहां Recursion
काम में आ जाएगा.

278
00:16:18,920 --> 00:16:22,780
>> सुनिश्चित करें कि आप शायद मुक्त कर दिया गया है कि बनाने के लिए
आप malloced दिया है कि सब कुछ,

279
00:16:22,780 --> 00:16:24,400
आप वेलग्रिंड उपयोग कर सकते हैं.

280
00:16:24,400 --> 00:16:28,640
वेलग्रिंड रनिंग अपने कार्यक्रम चलेंगे
स्मृति के कितने बाइट्स गिनती

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
वेलग्रिंड आपको बताता है तो एक बार उस चलाने और
और तुम तो, आगे बढ़ो देता है

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