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
તેથી આપણે શું અમારા પર એક નજર
સ્ટ્રક્ટ નોડ આના જેવો દેખાશે.

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
વેલ, અમને જરૂર જઈ રહ્યાં છો યાદ રાખો કે
એપોસ્ટ્રોફી સંભાળવા, જેથી કરી

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
સંપૂર્ણપણે બહાર zeroed.

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
>> હું પહેલાં જણાવ્યું હતું કે, તેથી જેમ આપણે જરૂર
ખાસ કિસ્સામાં એપોસ્ટ્રોફી.

71
00:03:57,950 --> 00:04:01,040
અમે ત્રણ ભાગનું બનેલું ઓપરેટર ઉપયોગ કરી રહ્યાં છો નોંધ કરો
અહીં, તેથી અમે વાંચી રહ્યા છીએ

72
00:04:01,040 --> 00:04:05,500
આપણે વાંચી પાત્ર હતી જો
એપોસ્ટ્રોફી, તો પછી અમે રહ્યા છીએ

73
00:04:05,500 --> 00:04:11,740
મૂળાક્ષર બાદ સમાન ઇન્ડેક્સ સેટ
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
તેથી અગાઉના પી સેટ યાદ,
સી ઓછા એક ચાલો આપી રહ્યું છે

77
00:04:23,090 --> 00:04:27,470
મૂળાક્ષર સી સ્થિતિ, જો આમ હોય
સી પત્ર એક આ ઇચ્છા છે

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
આ કેચ હતી, જ્યાં સ્થિતિ છે
C નવી લાઇન હતી, જ્યાં બેકસ્લેશ n એ,.

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
અમે આ શબ્દ ક્ષેત્ર ઉપયોગ જઈ રહ્યાં છો
અમારા સ્ટ્રક્ટ નોડ ની અંદર.

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
તે તો ખોટો આપે છે.

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
તેથી અમે શબ્દ પર વારો
પસાર, અમે નક્કી જઈ રહ્યાં છો

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
એપોસ્ટ્રોફી, તો પછી અમે ઇન્ડેક્સ વાપરવા માંગતા હોવ
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
જાતને મુક્ત છે, તેથી ખુદ અનલોડ કરી શકો છો.

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