>> [संगीत खेल]
>> आरओबी BOWDEN: हाय.
मैं रोब हूँ.
और हम इस समाधान करते हैं.
तो यहाँ हम लागू करने के लिए जा रहे हैं एक सामान्य तालिका.
हम देखते हैं कि हमारे की संरचना नोड तालिका इस तरह लग रहा है.
तो यह एक चार शब्द है जा रहा है आकार लम्बाई 1 की सरणी.
, + 1 मत भूलना के बाद से अधिकतम शब्दकोश में शब्द 45
अक्षर.
और फिर हम एक अतिरिक्त जरूरत जा रहे हैं बैकस्लैश शून्य के लिए चरित्र.
>> और तब प्रत्येक में हमारे Hashtable बाल्टी स्टोर करने के लिए जा रहा है एक
नोड्स के लिंक की गई सूची.
हम यहाँ की जांच कर रही रैखिक नहीं कर रहे हैं.
और तो क्रम में अगले करने के लिए लिंक करने के लिए बाल्टी में तत्व, हम एक की जरूरत
संरचना नोड * अगले.
ठीक है.
तो यह है कि एक नोड की तरह लग रहा है.
>> अब यहाँ घोषणा है हमारे Hashtable की.
यह 16,834 बाल्टी किया जा रहा है.
लेकिन यह संख्या वास्तव में कोई फर्क नहीं पड़ता.
और अंत में, हम करने के लिए जा रहे हैं वैश्विक चर Hashtable आकार, जो
शून्य के रूप में शुरू करने जा रहा है.
और यह कैसे का ट्रैक रखने के लिए जा रहा है कई शब्द हमारे शब्दकोश में हैं.
>> तो चलो लोड पर एक नजर डालते हैं.
लोड नोटिस, यह एक bool देता है.
यह सफलतापूर्वक किया गया था अगर तुम सच वापसी भरी हुई है, और झूठी अन्यथा.
और यह एक const चार * शब्दकोश लेता है शब्दकोश है जो
हम खोलना चाहते हैं.
तो पहली बात कि है हम क्या करने जा रहे हैं.
>> हम fopen के लिए जा रहे हैं पढ़ने के लिए शब्दकोश.
और हम बनाने के लिए किया जा रहे हैं यह सफल रहा है सुनिश्चित करें.
यह शून्य लौट ऐसा है, तो हम नहीं था सफलतापूर्वक शब्दकोश खुला.
और हम झूठे वापसी की जरूरत है.
लेकिन यह सफलतापूर्वक किया था यह सोचते हैं कि खुला, तो हम पढ़ना चाहते हैं
शब्दकोश.
हम कुछ पाते हैं तो जब तक पाशन रखना इस पाश से बाहर तोड़ने के लिए कारण,
हम देखेंगे जो.
तो पाशन रखना.
>> और अब हम जा रहे हैं एक नोड malloc.
और हां हम जरूरत हवा करने के लिए फिर से जाँच करें.
तो mallocing सफल नहीं हुए, तो फिर हम चाहते हैं कि हम किसी भी नोड अनलोड करना चाहते हैं
पहले malloc के लिए हुआ है, बंद शब्दकोश और झूठी वापसी.
लेकिन उस की अनदेखी, यह सोचते हैं हम सफल रहा, तो हम fscanf उपयोग करना चाहते हैं
से एक भी शब्द पढ़ने के लिए हमारे हमारे नोड में शब्दकोश.
तो उस प्रविष्टि> शब्द याद चार है + 1 आकार LENGHTH के शब्द बफर
हम अंदर शब्द स्टोर करने के लिए जा रहे हैं कि
>> तो fscanf के रूप में लंबे, 1 वापस जाने के लिए जा रहा है यह सक्षम करने के लिए सफलतापूर्वक किया गया था के रूप में
फाइल से एक शब्द पढ़ें.
एक त्रुटि या तो होता है, या हम फ़ाइल के अंत तक पहुँचते हैं, यह
1 वापस नहीं होगा.
यह 1 वापस नहीं करता है, जो मामले में हम अंत से बाहर तोड़ने के लिए जा रहे हैं
इस समय पाश.
तो हम देखते हैं कि हम सफलतापूर्वक एक बार में एक शब्द पढ़
प्रवेश> शब्द है, तो हम उस के लिए जा रहे हैं हमारे हैश समारोह का उपयोग कर शब्द.
>> पर एक नज़र रखना हैश समारोह.
तो क्या आप वास्तव में जरूरत नहीं है यह समझने के लिए.
और वास्तव में हम सिर्फ इस हैश निकाला इंटरनेट से कार्य करते हैं.
आपको पहचानने की जरूरत है केवल एक चीज है यह एक const चार * शब्द लेता है.
इसलिए यह निवेश के रूप में एक स्ट्रिंग ले रही है, और है आउटपुट के रूप में एक अहस्ताक्षरित int लौटने.
ताकि सभी एक हैश समारोह है, यह है एक निवेश के रूप में लेता है और आप एक देता है
Hashtable में सूचकांक.
>> हम NUM_BUCKETS द्वारा moding रहे सूचना है कि, इसलिए कि मूल्य लौटे
वास्तव में Hashtable में एक सूचकांक है और करता परे नहीं सूचकांक
सरणी की सीमा.
इसलिए कि समारोह, हम जा रहे हैं दी हम पढ़ कि शब्द हैश करने के लिए
शब्दकोश.
और फिर हम प्रयोग करने जा रहे हैं सम्मिलित करने के लिए कि हैश
Hashtable में प्रवेश.
>> अब Hashtable हैश वर्तमान है तालिका में सूची जुड़े.
और यह बहुत संभव है यह सिर्फ रिक्त है कि.
हम पर हमारे प्रविष्टि सम्मिलित करना चाहते हैं इस लिंक की गई सूची की शुरुआत.
और इसलिए हम अपने मौजूदा लिए जा रहे हैं क्या Hashtable करने के लिए प्रवेश बिंदु
वर्तमान में अंक.
और फिर हम, स्टोर करने के लिए जा रहे हैं पर Hashtable में
हैश, वर्तमान प्रविष्टि.
तो इन दो लाइनों को सफलतापूर्वक सम्मिलित की शुरुआत में प्रवेश
कि सूचकांक में लिंक की गई सूची Hashtable में.
>> हम उस के साथ काम हो जाने के बाद, हम जानते हैं हम में एक और शब्द पाया कि
शब्दकोश, और हम फिर से वेतन वृद्धि.
तो हम क्या कर रखना कि fscanf तक अंत में गैर 1 कुछ लौटे
जो बात है कि याद हम प्रवेश नि: शुल्क करने की जरूरत है.
तो यहाँ हम एक प्रवेश malloced.
और हम कुछ पढ़ने की कोशिश की शब्दकोश से.
और हम सफलतापूर्वक पढ़ा नहीं था में शब्दकोश से कुछ,
हम प्रवेश नि: शुल्क करने की जरूरत है, जो मामले हम वास्तव में कभी नहीं लगा कि
Hashtable, और अंत में टूट गया.
>> हम बाहर तोड़ एक बार जब हम देखने की जरूरत है, ठीक है, हम क्योंकि वहाँ बाहर तोड़ा
एक त्रुटि फ़ाइल से पढ़ रहा था?
या हम बाहर तोड़ दिया क्योंकि हम फ़ाइल के अंत तक?
एक त्रुटि तो, अगर वहाँ था हम झूठे वापसी करना चाहते हैं.
लोड सफल नहीं हुआ है.
और इस प्रक्रिया में हम अनलोड करना चाहते हैं सब हम में पढ़ा है कि शब्द, और
शब्दकोश फ़ाइल को बंद करें.
>> हम सफल नहीं मान लें, तो हम बस अभी शब्दकोश को बंद करने की जरूरत है
फ़ाइल, और अंत में सच वापसी के बाद से हम सफलतापूर्वक शब्दकोश भरा हुआ है.
और है कि लोड के लिए है.
तो अब, एक भरी हुई Hashtable दिया, जाँच इस तरह लग रहा है.
तो है, जो इसे एक bool रिटर्न की जांच पारित कर दिया है कि क्या इंगित करने के लिए जा रहा
* चार शब्द में, चाहे पारित किया स्ट्रिंग में हमारे शब्दकोश में है.
, यह शब्दकोश में है तो अगर यह हमारे Hashtable में है,
हम सच में वापस आ जाएगी.
ऐसा नहीं है, तो हम झूठे वापसी करेंगे.
>> इस शब्द में पारित देखते हुए, हम कर रहे हैं शब्द हैश करने के लिए जा रहा है.
अब पहचान करने के लिए एक महत्वपूर्ण बात है लोड में हमें पता था कि उस का सब
हम कम मामले होने जा रहे शब्द.
लेकिन यहाँ हम इतना यकीन नहीं कर रहे हैं.
हम अपने हैश समारोह पर एक नज़र रखना, वास्तव में हमारे हैश समारोह
कम आवरण प्रत्येक चरित्र है शब्द की.
इसलिए चाहे पूंजीकरण के शब्द, हमारे हैश समारोह वापसी है
जो कुछ के लिए एक ही सूचकांक पूंजीकरण यह होता है, है
एक पूरी तरह से लोअरकेस के लिए लौटे शब्द का संस्करण.
ठीक है.
यही कारण है कि हमारी अनुक्रमणिका में है इस शब्द के लिए Hashtable.
>> अब पाश के लिए यह जा रहा है लिंक की गई सूची से पुनरावृति
कि कि सूचकांक पर था.
इसलिए हम प्रवेश आरंभ कर रहे हैं नोटिस कि सूचकांक को इंगित करने के लिए.
हम जारी रखने के लिए जा रहे हैं प्रवेश! = रिक्त है.
और याद रखें कि सूचक को अद्यतन करने के में अगले हमारे लिंक सूची प्रविष्टि = प्रविष्टि>.
इसलिए हमारे वर्तमान प्रवेश बिंदु करने के लिए है लिंक की गई सूची में अगले आइटम.
>> तो लिंक की गई सूची में प्रत्येक प्रविष्टि के लिए, हम strcasecmp उपयोग करने के लिए जा रहे हैं.
यह StrComp नहीं है.
एक बार फिर, हम चाहते हैं क्योंकि insensitively बातें मामला नहीं है.
इसलिए हम तुलना करने के लिए strcasecmp उपयोग इस के माध्यम से पारित किया गया था कि शब्द
शब्द के खिलाफ समारोह कि इस प्रविष्टि में है.
यह शून्य देता है, तो वहाँ था कि इसका मतलब हम चाहते हैं, जो मामले में एक मैच,
वापसी सच.
हम सफलतापूर्वक पाया हमारे Hashtable में शब्द.
>> वहाँ एक मैच नहीं था, तो हम कर रहे हैं फिर पाश के लिए जा रहा है और कम से देखो
अगले प्रविष्टि.
और जब तक हम वहाँ पाशन जारी रखेंगे इस लिंक की गई सूची में प्रविष्टियों रहे हैं.
हम तोड़ तो क्या होता पाश के लिए इस से बाहर?
यही कारण है कि हम एक प्रवेश नहीं मिल रहा था इसका मतलब है कि जो मामले में, इस शब्द का मिलान नहीं हुआ
हम इंगित करने के लिए वापसी झूठी कि हमारी Hashtable इस शब्द शामिल नहीं किया था.
और कहा कि एक जांच है.
>> तो चलो आकार पर एक नज़र रखना.
अब आकार बहुत आसान होने जा रहा है.
चूंकि प्रत्येक शब्द के लिए, भार में याद हम हम एक वैश्विक वृद्धि, पाया
चर Hashtable आकार.
तो आकार समारोह बस जा रहा है वैश्विक चर वापस जाने के लिए.
और यह बात है.
>> अब अंत में, हम अनलोड करने के लिए की जरूरत शब्दकोश सब कुछ हो चुका है एक बार.
तो कैसे हम ऐसा करने जा रहे हैं?
यहीं हम पर पाशन कर रहे हैं हमारे टेबल के सभी बाल्टी.
तो NUM_BUCKETS बाल्टी रहे हैं.
और में प्रत्येक लिंक की गई सूची के लिए हमारी Hashtable, हम पर पाश करने के लिए जा रहे हैं
लिंक की गई सूची की सम्पूर्णता, प्रत्येक तत्व मुक्त.
>> अब हम सावधान रहने की जरूरत है.
तो यहाँ हम एक अस्थायी चर है कि अगले करने के लिए सूचक के भंडारण है
लिंक की गई सूची में तत्व.
और फिर हम मुक्त करने के लिए जा रहे हैं वर्तमान तत्व.
हम हम हम के बाद से ऐसा सुनिश्चित करने की आवश्यकता अभी वर्तमान तत्व मुक्त नहीं कर सकते
और फिर अगले सूचक तक पहुँचने का प्रयास, एक बार के बाद से हम इसे मुक्त कर दिया गया है,
स्मृति अमान्य हो जाता है.
>> तो हम करने के लिए एक सूचक के आसपास रखने की जरूरत अगले तत्व है, तो हम मुक्त कर सकते हैं
वर्तमान तत्व, और फिर हम अपडेट कर सकते हैं करने के लिए बात करने के लिए हमारे वर्तमान तत्व
अगले तत्व.
हम तत्वों पाश वहाँ हूँ, जबकि इस लिंक की गई सूची में.
हम सभी जुड़े के लिए कि क्या करेंगे Hashtable में सूचियों.
हम उस के साथ कर रहे हैं और एक बार, हम है पूरी तरह से Hashtable उतार दिया, और
हम कर रहे हैं.
तो यह अनलोड करने के लिए असंभव है कभी झूठी वापस जाने के लिए.
और हम कर रहे हैं, हम सिर्फ सच वापसी.
>> चलो इस समाधान एक कोशिश दे.
तो चलो क्या हमारे पर एक नज़र संरचना नोड की तरह दिखेगा.
यहाँ हम हम एक bool लिए जा रहे हैं देखते हैं शब्द और एक संरचना नोड * बच्चों
ब्रैकेट वर्णमाला.
आप हो सकता है तो पहली बात सोच, क्यों अक्षर है
एड 27 के रूप में परिभाषित किया गया?
ठीक है, हम जरूरत जा रहे हैं कि याद apostrophe निपटने होंगे.
तो यह है कि कुछ हद तक एक का होने जा रहा है इस कार्यक्रम में विशेष मामला.
>> अब याद कैसे एक Trie वास्तव में काम करता है.
हम शब्द का अनुक्रमण रहे हैं हम कहते हैं "बिल्लियों." फिर Trie की जड़ से,
हम बच्चे को देखने के लिए जा रहे हैं सरणी, और हम को देखने के लिए जा रहे हैं
पत्र से मेल खाती है कि सूचकांक 2 अनुक्रमित किया जाएगा कि सी. तो.
इसलिए दिया कि, कि वसीयत हमें एक नया नोड दे.
और फिर हम उस नोड से काम करेंगे.
>> इसलिए कि नोड दिया, हम एक बार फिर कर रहे हैं बच्चों सरणी को देखने जा.
और हम सूचकांक शून्य को देखने के लिए जा रहे हैं बिल्ली में एक के अनुरूप करने के लिए.
तो फिर हम उस नोड के लिए जाने के लिए जा रहे हैं, और कि नोड देखते हुए कि हम जा रहे हैं
अंत में यह देखने के लिए एक मेल खाती है टी. और उस नोड पर जाने से, करने के लिए
अंत में, हम पूरी तरह से देखा है के माध्यम से हमारे शब्द "बिल्ली." और अब bool
शब्द संकेत मिलता है कि माना जाता है इस दिए गए शब्द वास्तव में एक शब्द है.
>> तो हम क्यों कि विशेष मामला क्या ज़रूरत है?
खैर क्या शब्द की "तबाही" हमारे शब्दकोश में है, लेकिन
शब्द "बिल्ली" नहीं है?
तो और देखने के लिए देख अगर शब्द "बिल्ली" हमारे शब्दकोश में, हम कर रहे है
सफलतापूर्वक के माध्यम से देखने के लिए जा क्षेत्र नोड में सूचकांक सी ए टी.
लेकिन यह है कि केवल क्योंकि तबाही रास्ते में नोड्स बनाने के लिए हुआ
सी ए टी से, सभी तरह से करने के लिए शब्द के अंत.
तो bool शब्द यह इंगित करने के लिए प्रयोग किया जाता है इस विशेष स्थान
वास्तव में एक शब्द इंगित करता है.
>> ठीक है.
तो अब हम यह Trie है क्या पता कि की तरह लग रहा है, चलो हम देखते हैं
समारोह लोड.
इसलिए लोड एक bool वापस जाने के लिए जा रहा है चाहे हम सफलतापूर्वक या के लिए
असफल शब्दकोश भरा हुआ है.
और इस शब्दकोश होने जा रहा है हम लोड करने के लिए चाहते हैं.
>> हम ऐसा करने के लिए कर रहे हैं तो पहली बात यह खुला है पढ़ने के लिए कि शब्दकोश.
और हम यह सुनिश्चित करना है हम असफल नहीं किया.
शब्दकोश में नहीं था तो अगर सफलतापूर्वक खोला, यह वापस आ जाएगी
अशक्त, जो मामले में हम कर रहे हैं झूठी वापस जाने के लिए जा रहा है.
लेकिन यह सोचते हैं कि यह सफलतापूर्वक खोला, तो हम वास्तव में पढ़ सकते हैं
शब्दकोश के माध्यम से.
>> हम करने जा रहे हैं तो पहली बात क्या करना चाहते हैं कि हम इस किया है
वैश्विक चर जड़.
अब रूट * एक नोड होने जा रहा है.
यह हम कर रहे हैं कि हमारे Trie के ऊपर है के माध्यम से पुनरावृति होने जा रहा.
हम जा रहे हैं तो पहली बात क्या करना चाहते करने के लिए आवंटित है
हमारे रूट के लिए स्मृति.
हम calloc का उपयोग कर रहे हैं कि सूचना मूलतः एक ही है जो समारोह,
malloc समारोह के रूप में, सिवाय यह है है कि कुछ वापसी की गारंटी
पूरी तरह से बाहर चुना.
हम malloc इस्तेमाल किया तो, अगर हम करने की आवश्यकता होगी में संकेत के सभी के माध्यम से जाना हमारे
नोड, और सुनिश्चित करें कि वे सभी अशक्त हो.
तो calloc हमारे लिए ऐसा करेंगे.
>> अब सिर्फ malloc की तरह, हमें करना चाहिए आवंटन वास्तव में था कि यकीन
सफल.
इस अशक्त लौटे, तो हम बंद करने या शब्दकोश करने की जरूरत है
फ़ाइल और झूठी वापसी.
इसलिए कि आवंटन किया गया था संभालने सफल, हम * एक नोड का उपयोग करने के लिए जा रहे हैं
हमारे Trie के माध्यम से पुनरावृति करने के लिए कर्सर.
तो अपनी जड़ों को बदलने के लिए कभी नहीं जा रहा, लेकिन हम करने के लिए कर्सर का उपयोग करने के लिए जा रहे हैं
वास्तव में नोड से नोड के पास जाओ.
>> तो इस में पाश के लिए हम पढ़ रहे हैं शब्दकोश फ़ाइल के माध्यम से.
और हम fgetc प्रयोग कर रहे हैं.
Fgetc एक भी हड़पने के लिए जा रहा है फ़ाइल से चरित्र.
हम हथियाने जारी रखने के लिए जा रहे हैं संदेश तक पहुँच नहीं है, जबकि
फ़ाइल का अंत.
>> हम संभाल करने की जरूरत है दो मामले हैं.
पहला, अगर चरित्र एक नई लाइन नहीं था.
इसलिए हम यह तो, एक नई लाइन था पता हम एक नया शब्द पर स्थानांतरित करने के बारे में कह रहे हैं.
लेकिन फिर, यह एक नई लाइन नहीं था संभालने यहाँ हम यह पता लगाने के लिए चाहते हैं
सूचकांक हम में सूचकांक के लिए जा रहे हैं बच्चों सरणी में कि
हम पहले देखा.
>> तो, जैसा मैंने पहले कहा, हम करने की आवश्यकता विशेष मामला apostrophe.
हम त्रिगुट का उपयोग कर रहे हैं नोटिस यहाँ ऑपरेटर.
तो हम हैं, के रूप में इस पढ़ने के लिए जा रहे हैं हम में पढ़ा चरित्र एक था
apostrophe, तो हम स्थापित करने के लिए जा रहे हैं सूचकांक = "वर्णमाला" -1, जो होगा
सूचकांक 26 हो.
>> वरना, यह एक apostrophe नहीं था, तो वहाँ हम सूचकांक सेट करने के लिए जा रहे हैं
सी के बराबर - एक.
तो वापस पहले पी सेट से याद है, सी - एक हमें देने जा रहा है
सी. की वर्णमाला स्थिति तो अगर सी यह, पत्र एक है
हमें सूचकांक शून्य दे.
पत्र बी के लिए यह दे देंगे इतने पर हमें सूचकांक 1, और.
>> तो यह हमारे में सूचकांक देता है हम चाहते हैं कि बच्चों सरणी.
अब इस सूचकांक में फिलहाल शून्य है बच्चों, इसका मतलब है कि एक नोड
वर्तमान में मौजूद नहीं है उस रास्ते से.
इसलिए हम आवंटित की जरूरत उस पथ के लिए एक नोड.
यही कारण है कि हम यहाँ क्या करेंगे.
>> तो हम फिर calloc का उपयोग करने के लिए जा रहे हैं समारोह, हम की जरूरत नहीं है कि इतनी
सभी संकेत बाहर शून्य.
और हम फिर से जांच की जरूरत कि calloc असफल नहीं किया.
Calloc असफल हो गए हैं, तो हम की जरूरत सब कुछ खाली करने के लिए, बंद हमारे
शब्दकोश, और झूठी वापसी.
तो यह तो असफल नहीं किया यह सोचते हैं कि यह हमारे लिए एक नया बच्चा पैदा करेगा.
और फिर हम उस बच्चे के लिए जाना जाएगा.
हमारे कर्सर पुनरावृति होगी उस बच्चे को नीचे.
>> अब इस के साथ शुरू करने के लिए अशक्त नहीं था, तब कर्सर बस पुनरावृति कर सकते हैं
वास्तव में बिना उस बच्चे को नीचे कुछ भी आवंटित कर रही है.
यह हम पहली बार हुआ जहां मामला है शब्द का आवंटन "बिल्ली." और
हम आवंटित करने के लिए जाने के लिए जब इसका मतलब है कि "तबाही" हम बनाने की जरूरत नहीं है
फिर सी ए टी के लिए नोड्स.
वे पहले से ही मौजूद हैं.
>> और यह क्या है?
यह सी थी जहां हालत है सी एक नई लाइन थी जहां बैकस्लैश एन,.
यह हम सफलतापूर्वक किया है इसका मतलब एक शब्द पूरा किया.
अब क्या हम क्या करना चाहते हैं जब हम सफलतापूर्वक एक शब्द पूरा?
हम इस शब्द के क्षेत्र का उपयोग करने के लिए जा रहे हैं हमारे संरचना नोड के अंदर.
हम सच करने के लिए कि सेट करना चाहते हैं.
इसलिए कि इंगित करता है कि इस नोड एक सफल इंगित करता है
शब्द, एक वास्तविक शब्द.
>> अब सच करने के लिए कि निर्धारित किया है.
हम बात करने के लिए हमारे कर्सर रीसेट करना चाहते हैं फिर Trie की शुरुआत करने के लिए.
और अंत में, हमारे शब्दकोश वेतन वृद्धि आकार, हम एक और काम मिल गया है.
इसलिए हम चाहते हैं कि कर रखने के लिए जा रहे हैं, , चरित्र से चरित्र में पढ़
हमारे Trie में नए नोड्स के निर्माण और शब्दकोश में, जब तक प्रत्येक शब्द के लिए
हम अंत में सी तक पहुँचने! = EOF, जिसमें मामले में हम फाइल से बाहर तोड़.
>> अब दो मामलों के तहत कर रहे हैं हम EOF हिट हो सकता है.
वहाँ एक त्रुटि थी, तो सबसे पहले है फ़ाइल से पढ़ने में.
वहाँ एक त्रुटि थी तो, अगर हम ठेठ करने की ज़रूरत है.
करीब, सब कुछ उतार फ़ाइल, वापसी झूठी.
, कोई त्रुटि नहीं था मानते हुए कि अभी हम वास्तव में के अंत हिट का मतलब
फाइल है, जो मामले में, हम बंद फ़ाइल और सच वापसी के बाद से हम
सफलतापूर्वक लोड शब्दकोश हमारे Trie में.
>> तो अब चेक की जाँच करते हैं.
चेक समारोह को देखते हुए, हम देखते हैं कि चेक एक bool वापस जाने के लिए जा रहा है.
इस शब्द यह है कि अगर यह सच रिटर्न पारित किया जा रहा है हमारे Trie में है.
यह अन्यथा झूठी देता है.
तो आप कैसे निर्धारित करें कि क्या कर रहे हैं इस शब्द हमारे Trie में है?
>> हम यहाँ देखते हैं, पहले की तरह, हम पुनरावृति करने के लिए कर्सर का उपयोग करने के लिए जा रहे हैं
हमारे Trie के माध्यम से.
अब यहाँ हम पुनरावृति करने के लिए जा रहे हैं हमारे पूरे शब्द पर.
तो, हम पिछले रहे हैं शब्द पर iterating हम यह निर्धारित करने के लिए जा रहे हैं
सूचकांक बच्चों सरणी में कि शब्द ब्रैकेट मैं से मेल खाती है तो यह
बिल्कुल वैसा ही लग रहा है लोड, जहां अगर शब्द [मैं]
एक apostrophe, तो हम चाहते है सूचकांक "वर्णमाला" का उपयोग करने के लिए - 1.
हम निर्धारित उसकी वजह है कि हम स्टोर करने के लिए जा रहे हैं, जहां है
apostrophes.
>> वरना हम दो कम शब्द का प्रयोग करने जा रहे हैं ब्रैकेट मैं तो उस शब्द को याद कर सकते हैं
मनमाना पूंजीकरण है.
और इसलिए हम हम कर रहे हैं कि यह सुनिश्चित करना चाहते हैं चीजों के एक छोटे संस्करण का उपयोग कर.
और फिर उस 'एक' के लिए एक बार से घटाना हमें फिर से वर्णमाला दे
उस चरित्र की स्थिति.
इसलिए कि हमारे सूचकांक होने जा रहा है बच्चों सरणी में.
>> और अब अगर बच्चों में है कि सूचकांक सरणी रिक्त है, कि हम का मतलब
अब कोई पुनरावृति को जारी रख सकते हैं हमारे Trie नीचे.
यदि यह मामला है, इस शब्द नहीं कर सकते संभवतः हमारे Trie में हो.
अगर यह थे, उस के बाद से एक रास्ता होगा मतलब
उस शब्द के लिए नीचे.
और तुम अशक्त मुठभेड़ कभी नहीं होगा.
तो अशक्त सामना, हम वापसी झूठी.
शब्द शब्दकोश में नहीं है.
यह रिक्त नहीं थे, तो हम कर रहे हैं पुनरावृति को जारी रखने के लिए जा रहा है.
>> इसलिए हम वहाँ कर्सर बाहर जा रहे हैं उस विशेष को इंगित करने के लिए
कि सूचकांक में नोड.
हम पूरे कर रही है कि रखना पूरे शब्द, यह सोचते हैं
हम अशक्त कभी नहीं मारा.
यही कारण है कि हम के माध्यम से प्राप्त करने में सक्षम थे, इसका मतलब पूरे शब्द और लगता है
हमारी कोशिश में एक नोड.
लेकिन हम अभी तक नहीं किया हो.
>> हम सिर्फ सच वापसी नहीं करना चाहती.
हम कर्सर> शब्द वापस करना चाहते हैं.
फिर याद के बाद से, "बिल्ली" नहीं है हमारे शब्दकोश में, और "तबाही"
, तो हम सफलतापूर्वक हम मिल जाएगा के माध्यम से शब्द "बिल्ली." लेकिन कर्सर
शब्द झूठे और सच नहीं होगा.
इसलिए हम इंगित करने के लिए कर्सर शब्द लौटने चाहे इस नोड वास्तव में एक शब्द है.
और कहा कि जांच के लिए यह बात है.
>> तो चलो आकार की जाँच करते हैं.
तो आकार बहुत आसान होने जा रहा है के बाद से, भार में याद है, हम कर रहे हैं
शब्दकोश आकार incrementing हम मुठभेड़ कि प्रत्येक शब्द.
तो आकार बस जा रहा है शब्दकोश आकार वापसी.
और यह बात है.
>> तो अंत में हम उतारना है.
तो उतारना, हम प्रयोग करने जा रहे हैं एक वास्तव में सब करने के लिए पुनरावर्ती समारोह
हमारे लिए काम की.
इसलिए हमारे कार्य करने के लिए जा रहा है unloader पर कहा जा.
क्या unloader क्या करने जा रहा है?
हम चाहते हैं कि unloader जा रहा है यहाँ देख बच्चों के सभी पर अधिक पुनरावृति
इस विशेष नोड.
और बच्चे के नोड नहीं है अगर अशक्त, तो हम करने जा रहे हैं
बच्चे के नोड उतारना.
>> तो यह आप बारी बारी से उतारना है अपने बच्चों के सभी.
हमें यकीन है कि कर रहे हैं एक बार अपने बच्चों के सभी उतार दिया गया है, तो हम
खुद मुक्त है, तो कर सकते हैं खुद को उतारना.
इस बारी बारी से काम करेंगे पूरे Trie उतारना.
और फिर जो कुछ किया है एक बार, हम सिर्फ सच लौट सकते हैं.
अनलोड असफल नहीं हो सकता.
हम सिर्फ बातें मुक्त कराने रहे हैं.
तो एक बार हम मुक्त कराने के काम हो गया सब कुछ, सच वापसी.
और यह बात है.
मेरा नाम रोब है.
और इस स्पेलर था.
>> [संगीत खेल]