1
00:00:00,000 --> 00:00:12,350
>> [સંગીત વગાડવાનો]

2
00:00:12,350 --> 00:00:13,050
>> રોબ બોડેન: હાય.

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 buckets હોય બનશે.

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
તે NULL પરત જો હા, તો અમે કર્યું
સફળતાપૂર્વક શબ્દકોશ ખોલો.

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
તેથી તે ઇનપુટ તરીકે શબ્દમાળા લેવા, અને
આઉટપુટ તરીકે પૂર્ણાંક સહી થયેલ નહિં પરત.

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
તમે હોઇ શકે છે જેથી પ્રથમ વસ્તુ
આશ્ચર્ય, શા માટે ALPHABET છે

170
00:08:42,020 --> 00:08:44,660
એડ 27 તરીકે વ્યાખ્યાયિત?

171
00:08:44,660 --> 00:08:47,900
વેલ, અમને જરૂર જઈ રહ્યાં છો યાદ રાખો કે
એપોસ્ટ્રોફી સંભાળવા છે.

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

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

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
એપોસ્ટ્રોફી, તો પછી અમે સેટ રહ્યા છીએ
ઇન્ડેક્સ = "મૂળાક્ષર" -1, જે કરશે

241
00:12:35,330 --> 00:12:37,680
ઇન્ડેક્સ 26 છે.

242
00:12:37,680 --> 00:12:41,130
>> બાકી, તે એપોસ્ટ્રોફી ન હોય તો, ત્યાં
અમે ઇન્ડેક્સ સેટ રહ્યા છીએ

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

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

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
એપોસ્ટ્રોફી, તો પછી અમે માંગો છો છે
અનુક્રમણિકા "મૂળાક્ષર" વાપરવા માટે - 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
>> [સંગીત વગાડવાનો]