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 node की तरह दिखेगा.

4
00:00:07,130 --> 00:00:11,040
यहाँ, हम हमारे पास करने के लिए जा रहे हैं देखते हैं एक
Bool पद और एक संरचना नोड सितारा

5
00:00:11,040 --> 00:00:12,990
बच्चे वर्णमाला ब्रैकेट.

6
00:00:12,990 --> 00:00:18,720
तो पहली बात आप सोच हो सकती है,
क्यों वर्णमाला हैश 27 के रूप में परिभाषित किया गया है?

7
00:00:18,720 --> 00:00:22,540
ठीक है, हम जरूरत जा रहे हैं कि याद
apostrophe से निपटने, ऐसा हो

8
00:00:22,540 --> 00:00:25,610
कि एक विशेष का कुछ हद तक होने जा रहा है
इस कार्यक्रम के दौरान मामला.

9
00:00:25,610 --> 00:00:28,780
>> ठीक है, अब, याद है कि कैसे एक
Trie वास्तव में काम करता है.

10
00:00:28,780 --> 00:00:33,420
हम शब्द बिल्लियों अनुक्रमण रहे हैं हम कहते हैं,
तब हमारे Trie की जड़ से,

11
00:00:33,420 --> 00:00:36,670
हम बच्चे को देखने के लिए जा रहे हैं
सरणी, और हम को देखने के लिए जा रहे हैं

12
00:00:36,670 --> 00:00:42,250
पत्र से मेल खाती है कि सूचकांक
सी. तो यह है कि सूचकांक दो होगा.

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

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
अंत में, हम पूरी तरह से देखा है
हमारे शब्द कैट के माध्यम से, और अब 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
शब्द बिल्ली नहीं है?

24
00:01:24,120 --> 00:01:29,030
तो शब्द बिल्ली है देखने के लिए तलाश में
हमारे शब्दकोश में, हम करने जा रहे हैं

25
00:01:29,030 --> 00:01:34,880
सफलतापूर्वक सूचकांक के माध्यम से देखो
सी ए टी और एक नोड तक पहुँचने, लेकिन है कि

26
00:01:34,880 --> 00:01:39,760
तबाही के लिए हुआ ही है क्योंकि
सी ए टी से रास्ते पर नोड्स बनाने के सभी

27
00:01:39,760 --> 00:01:41,250
शब्द के अंत करने के लिए रास्ता.

28
00:01:41,250 --> 00:01:46,520
तो Bool पद संकेत मिलता है कि इस्तेमाल किया जाता है
इस विशेष स्थान वास्तव में

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
लोड समारोह में.

32
00:01:54,800 --> 00:01:58,670
इसलिए लोड एक 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
वैश्विक चर जड़.

43
00:02:26,560 --> 00:02:30,250
अब, जड़ एक नोड सितारा होने जा रहा है.

44
00:02:30,250 --> 00:02:33,830
यह हम कर रहे हैं कि हमारे Trie के ऊपर है
के माध्यम से पुनरावृति होने जा रहा.

45
00:02:33,830 --> 00:02:38,200
हम चाहते करने जा रहे हैं तो पहली बात
ऐसा हमारे रूट के लिए स्मृति आवंटित है.

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

49
00:02:47,240 --> 00:02:51,350
हम Malloc इस्तेमाल किया तो, अगर हम करने की आवश्यकता होगी
में संकेत के सभी के माध्यम से जाना हमारे

50
00:02:51,350 --> 00:02:54,220
नोड और सुनिश्चित करें कि
वे सभी अशक्त हो.

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

55
00:03:04,060 --> 00:03:06,170
फ़ाइल और झूठी वापसी.

56
00:03:06,170 --> 00:03:11,040
तो आवंटन किया गया था संभालने
सफल, हम एक नोड का उपयोग करने के लिए जा रहे हैं

57
00:03:11,040 --> 00:03:14,340
पुनरावृति करने के लिए कर्सर स्टार
हमारे Trie के माध्यम से.

58
00:03:14,340 --> 00:03:17,950
इसलिए हमारे रूट बदलने के लिए कभी नहीं जा रहा है,
लेकिन हम करने के लिए कर्सर का उपयोग करने के लिए जा रहे हैं

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
और हम fgetc पर प्रयोग कर रहे हैं.

62
00:03:26,965 --> 00:03:30,360
तो fgetc एक भी हड़पने के लिए जा रहा है
फ़ाइल से चरित्र.

63
00:03:30,360 --> 00:03:33,430
हम हथियाने जारी रखने के लिए जा रहे हैं
संदेश तक पहुँच नहीं है, जबकि

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

69
00:03:52,440 --> 00:03:53,890
हम पहले देखा.

70
00:03:53,890 --> 00:03:57,950
>> जैसा कि मैंने पहले कहा तो की तरह, हम करने की आवश्यकता
विशेष मामला apostrophe.

71
00:03:57,950 --> 00:04:01,040
हम त्रिगुट ऑपरेटर का उपयोग कर रहे हैं नोटिस
यहाँ है, तो हम पढ़ने के लिए जा रहे हैं

72
00:04:01,040 --> 00:04:05,500
यह हम में पढ़ा चरित्र था मानो
एक apostrophe, तो हम करने जा रहे हैं

73
00:04:05,500 --> 00:04:11,740
वर्णमाला शून्य के बराबर सूचकांक सेट
1, जो सूचकांक 26 हो जाएगा.

74
00:04:11,740 --> 00:04:15,190
वरना, यह एक apostrophe नहीं था,
तो हम सूचकांक सेट करने के लिए जा रहे हैं

75
00:04:15,190 --> 00:04:17,820
सी शून्य से एक के बराबर.

76
00:04:17,820 --> 00:04:23,090
तो वापस पिछले पी सेट से याद है,
सी शून्य से एक हमें देने जा रहा है

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
पत्र बी के लिए यह देना होगा
इतने पर हमें सूचकांक 1, और.

80
00:04:32,180 --> 00:04:37,070
>> तो यह हमारे में सूचकांक देता है
हम चाहते हैं कि बच्चे सरणी.

81
00:04:37,070 --> 00:04:42,540
अब, इस सूचकांक में फिलहाल शून्य है
बच्चे सरणी, इसका मतलब है कि

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
संकेत के सभी बाहर शून्य, और करने के लिए हम,
फिर, कि 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
शब्दकोश, और झूठी वापसी.

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

93
00:05:19,030 --> 00:05:23,390
अब, इस के साथ शुरू करने के लिए अशक्त नहीं था,
तब कर्सर बस पुनरावृति कर सकते हैं

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

98
00:05:35,720 --> 00:05:37,620
वे पहले से ही मौजूद हैं.

99
00:05:37,620 --> 00:05:40,140
>> ठीक है, तो यह और क्या है?

100
00:05:40,140 --> 00:05:44,600
यह सी थी जहां हालत है
सी एक नई लाइन थी जहां बैकस्लैश एन,.

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 node के अंदर.

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
फाइल से बाहर.

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
फाइल है, जो मामले में, हम बंद
फ़ाइल और सच वापसी के बाद से हम

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
चेक समारोह को देखते हुए, हम देखते हैं
जाँच करें कि एक bool वापस जाने के लिए जा रहा है.

122
00:06:58,780 --> 00:07:03,740
इस शब्द यह है कि अगर यह सच रिटर्न
पारित किया जा रहा है हमारे 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
हम यहाँ देखते हैं, पहले की तरह,
हम पुनरावृति करने के लिए कर्सर का उपयोग करने के लिए जा रहे हैं

126
00:07:14,270 --> 00:07:16,010
हमारे Trie के माध्यम से.

127
00:07:16,010 --> 00:07:20,650
अब, यहाँ, हम पुनरावृति करने के लिए जा रहे हैं
हमारे पूरे शब्द पर.

128
00:07:20,650 --> 00:07:24,680
इसलिए हम कर रहे हैं शब्द पर iterating
पारित कर दिया, हम यह निर्धारित करने के लिए जा रहे हैं

129
00:07:24,680 --> 00:07:29,280
सूचकांक बच्चे सरणी में कि
शब्द ब्रैकेट मैं से मेल खाती है.

130
00:07:29,280 --> 00:07:34,150
तो यह बिल्कुल वैसा ही लग रहा है
लोड, जहां शब्द ब्रैकेट मैं एक है अगर

131
00:07:34,150 --> 00:07:38,110
apostrophe, तो हम सूचकांक का उपयोग करना चाहते हैं
1 शून्य से वर्णमाला हम निर्धारित क्योंकि

132
00:07:38,110 --> 00:07:41,160
हम कहाँ जा रहे हैं कि है
apostrophes स्टोर करने के लिए.

133
00:07:41,160 --> 00:07:44,440
>> वरना हम tolower उपयोग करने के लिए जा रहे हैं
शब्द ब्रैकेट मैं.

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

140
00:08:06,480 --> 00:08:09,050
अब कोई पुनरावृति को जारी रख सकते हैं
हमारे 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
अशक्त मुठभेड़ कभी नहीं.

144
00:08:19,350 --> 00:08:21,910
तो अशक्त सामना, हम वापसी झूठी.

145
00:08:21,910 --> 00:08:23,810
शब्द शब्दकोश में नहीं है.

146
00:08:23,810 --> 00:08:28,200
यह रिक्त नहीं थे, तो हम करने जा रहे हैं
पुनरावृति को जारी रखते हैं, तो हम जा रहे हैं

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
, हम अशक्त कभी नहीं मारा मान लिया जाये कि साधन
हम पूरे के माध्यम से प्राप्त करने में सक्षम थे

150
00:08:40,630 --> 00:08:44,840
दुनिया और हमारे Trie में एक नोड लगता है,
लेकिन हम अभी तक नहीं किया हो.

151
00:08:44,840 --> 00:08:46,350
हम सिर्फ सच वापसी नहीं करना चाहती.

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
इतना आकार बहुत आसान होने जा रहा है
के बाद से, लोड में याद है, हम कर रहे हैं

159
00:09:11,410 --> 00:09:15,480
शब्दकोश आकार incrementing
हम मुठभेड़ कि प्रत्येक शब्द.

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

166
00:09:40,640 --> 00:09:45,810
इस विशेष नोड, और अगर बच्चा
नोड रिक्त नहीं है, तो हम करने जा रहे हैं

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
किया, हम सिर्फ सच लौट सकते हैं.

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
मेरा नाम रोब है, और इस
[सुनाई] था.

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