1
00:00:00,000 --> 00:00:11,856

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

3
00:00:13,050 --> 00:00:16,210
હું રોબ છું, અને ચાલો હેશ
આ ઉપાય શોધી.

4
00:00:16,210 --> 00:00:20,070
અહીં અમે અમલ રહ્યા છીએ
એક સામાન્ય હેશ ટેબલ.

5
00:00:20,070 --> 00:00:24,090
આપણે જોઈએ છીએ કે અમારા હેશ ના સ્ટ્રક્ટ નોડ
કોષ્ટક આ જેમ દેખાય રહ્યું છે.

6
00:00:24,090 --> 00:00:28,710
તેથી તે ચાર રચે શબ્દ હોય બનશે
કદ લંબાઈ માટે વત્તા 1 એરે.

7
00:00:28,710 --> 00:00:32,259
મહત્તમ થી 1 ભૂલી નથી
શબ્દકોશમાંનાં શબ્દ 45 છે

8
00:00:32,259 --> 00:00:35,110
અક્ષરો, અને પછી અમે જઈ રહ્યાં છો
આ માટે એક વધારાની પાત્ર જરૂર

9
00:00:35,110 --> 00:00:37,070
બેકસ્લેશ 0.

10
00:00:37,070 --> 00:00:40,870
>> અને પછી દરેક અમારી હેશ કોષ્ટક
ડોલ સંગ્રહ રહ્યું છે એક

11
00:00:40,870 --> 00:00:42,320
ગાંઠો કડી થયેલ યાદી.

12
00:00:42,320 --> 00:00:44,420
અમે અહીં ચકાસણી રેખીય કરી રહ્યા છીએ.

13
00:00:44,420 --> 00:00:48,430
અને તેથી ક્રમમાં આગામી માટે લિંક
ડોલમાં તત્વ, અમે જરૂર

14
00:00:48,430 --> 00:00:51,110
સ્ટ્રક્ટ નોડ * આગામી.

15
00:00:51,110 --> 00:00:53,090
જેથી નોડ શું લાગે છે.

16
00:00:53,090 --> 00:00:56,180
હવે, અહીં જાહેરાત છે
અમારા હેશ કોષ્ટક.

17
00:00:56,180 --> 00:01:01,910
તે 16.384 ડોલથી હોય રહ્યા છે, પરંતુ
કે જે નંબર ખરેખર તો કોઈ વાંધો નથી.

18
00:01:01,910 --> 00:01:05,450
અને છેલ્લે, અમે હોય રહ્યા છીએ આ
વૈશ્વિક ચલ hashtable_size, જે

19
00:01:05,450 --> 00:01:08,640
0 તરીકે બોલ શરૂ થઈ રહ્યું છે, અને તે છે છે
સાચવી રાખે રહ્યું કેટલા શબ્દો

20
00:01:08,640 --> 00:01:10,080
અમારા શબ્દકોશ હતા.

21
00:01:10,080 --> 00:01:10,760
અધિકાર છે.

22
00:01:10,760 --> 00:01:13,190
>> તેથી આપણે લોડ પર એક નજર કરીએ.

23
00:01:13,190 --> 00:01:16,390
જેથી લોડ નોટિસ,
તે એક bool આપે છે.

24
00:01:16,390 --> 00:01:20,530
તે સફળતાપૂર્વક તો તમે સાચું પરત
અન્યથા લોડ અને ખોટા.

25
00:01:20,530 --> 00:01:23,990
અને તે એક const ઘરનાં પરચૂરણ કામો * સ્ટાર છે
શબ્દકોશમાંનાં છે શબ્દકોશ,

26
00:01:23,990 --> 00:01:25,280
અમે ખોલવા માંગો છો.

27
00:01:25,280 --> 00:01:27,170
જેથી પ્રથમ વાત છે
અમે કરી રહ્યા છીએ.

28
00:01:27,170 --> 00:01:30,420
અમે માટે શબ્દકોશમાં fopen રહ્યા છીએ
વાંચન, અને અમે હોય રહ્યા છીએ

29
00:01:30,420 --> 00:01:34,700
તે જો એમ હોય તો સફળ છે તેની ખાતરી કરવા
તે NULL પરત, તો પછી અમે કર્યું

30
00:01:34,700 --> 00:01:37,440
સફળતાપૂર્વક શબ્દકોશ ખોલો
અને અમે ખોટા પરત કરવાની જરૂર છે.

31
00:01:37,440 --> 00:01:41,580
>> પરંતુ તે સફળતાપૂર્વક કર્યું એમ ધારી રહ્યા છીએ
ઓપન, તો પછી અમે પણ વાંચવી પાંચ

32
00:01:41,580 --> 00:01:42,400
આપનું સ્વાગત છે.

33
00:01:42,400 --> 00:01:46,210
અમે કેટલાક શોધવા સુધી તેથી રહ્યાં રાખવા
આ બહાર ભંગ કારણ

34
00:01:46,210 --> 00:01:47,570
અમે જોશો જે લૂપ.

35
00:01:47,570 --> 00:01:51,780
તેથી રહ્યાં રાખવા, અને હવે અમે રહ્યા છીએ
એક જ નોડ malloc છે.

36
00:01:51,780 --> 00:01:56,800
અને અલબત્ત, અમે તપાસ ભૂલ જરૂર
ફરીથી mallocing સફળ થઈ ન હતી, તેથી જો

37
00:01:56,800 --> 00:02:00,660
અને અમે તે અમે કોઈ નોડ અનલોડ કરવા માંગો છો
પહેલાં malloc માટે થયું, બંધ

38
00:02:00,660 --> 00:02:02,590
શબ્દકોશ અને ખોટા આવો.

39
00:02:02,590 --> 00:02:07,440
>> પરંતુ તે અવગણીને એમ ધારી રહ્યા છીએ અમે
સફળ, તો પછી અમે fscanf ઉપયોગ કરવા માંગો છો

40
00:02:07,440 --> 00:02:12,400
એક એક શબ્દ વાંચી અમારા
અમારા નોડ શબ્દકોશ.

41
00:02:12,400 --> 00:02:17,310
જેથી એન્ટ્રી> શબ્દ યાદ ઘરનાં પરચૂરણ કામો છે
શબ્દ કદ લંબાઈ બફર વત્તા

42
00:02:17,310 --> 00:02:20,300
અમે જઈ રહ્યાં છો કે જે એક
સાઇન શબ્દ સંગ્રહ

43
00:02:20,300 --> 00:02:25,280
તેથી fscanf 1 સુધી પાછા જઈ રહ્યું છે
તે સફળતાપૂર્વક વાંચવામાં સક્ષમ હતી

44
00:02:25,280 --> 00:02:26,750
ફાઇલમાંથી શબ્દ.

45
00:02:26,750 --> 00:02:31,030
>> ભૂલ ક્યાં થાય છે અથવા અમે પહોંચી તો
આ ફાઈલના અંતે, તે નહીં કરે

46
00:02:31,030 --> 00:02:34,950
જો તેમ ન હોય તો કે જે કિસ્સામાં 1 પરત
1 પરત, અમે આખરે તોડી રહ્યા છીએ

47
00:02:34,950 --> 00:02:37,280
આ વખતે લૂપ બહાર.

48
00:02:37,280 --> 00:02:42,770
તેથી અમે જુઓ કે અમે સફળતાપૂર્વક છે એક વખત
એક શબ્દ વાંચી

49
00:02:42,770 --> 00:02:48,270
એન્ટ્રી> શબ્દ, તો પછી અમે હેશ રહ્યા છીએ
અમારા હેશ વિધેય ઉપયોગ કરીને તે શબ્દ.

50
00:02:48,270 --> 00:02:49,580
ખાતે એક નજર
હેશ વિધેય.

51
00:02:49,580 --> 00:02:52,430

52
00:02:52,430 --> 00:02:55,610
>> તેથી જો તમે ખરેખર જરૂર નથી
આ સમજવા માટે.

53
00:02:55,610 --> 00:02:59,460
અને ખરેખર, અમે ફક્ત આ ખેંચાય
ઇન્ટરનેટ પરથી કાર્ય હેશ.

54
00:02:59,460 --> 00:03:04,010
તમે ઓળખી જરૂર આ જ વસ્તુ છે
આ એક const ઘરનાં પરચૂરણ કામો * શબ્દ લે,

55
00:03:04,010 --> 00:03:08,960
તેથી તે ઇનપુટ તરીકે શબ્દમાળા લેવા અને છે
આઉટપુટ તરીકે પૂર્ણાંક સહી થયેલ નહિં પરત.

56
00:03:08,960 --> 00:03:12,360
જેથી બધા હેશ વિધેય છે, તે છે
ઇનપુટ લે છે, તો તે તમને એક આપે છે

57
00:03:12,360 --> 00:03:14,490
હેશ કોષ્ટક માં ઇન્ડેક્સ.

58
00:03:14,490 --> 00:03:18,530
અમે NUM_BUCKETS દ્વારા modding રહ્યાં છો નોંધ કરો કે
જેથી હેશ કિંમત પરત

59
00:03:18,530 --> 00:03:21,730
ખરેખર હેશ કોષ્ટક માં એક અનુક્રમણિકા છે
અને કરે છે બહાર નથી અનુક્રમણિકા

60
00:03:21,730 --> 00:03:24,320
એરે સીમાથી.

61
00:03:24,320 --> 00:03:27,855
>> તેથી હેશ વિધેય, અમે જઈ રહ્યાં છો કે જે આપેલ
એ જણાવે છે કે શબ્દ હેશ

62
00:03:27,855 --> 00:03:31,700
શબ્દકોશમાં અને પછી અમે જઈ રહ્યાં છો
કે વાપરવા માટે દાખલ કરવા માટે છે

63
00:03:31,700 --> 00:03:33,750
હેશ કોષ્ટક પ્રવેશ.

64
00:03:33,750 --> 00:03:38,830
હવે, hashtable હેશ વર્તમાન છે
કડી હેશ કોષ્ટકમાં યાદી, અને

65
00:03:38,830 --> 00:03:41,410
તે માત્ર NULL છે કે ખૂબ જ શક્ય છે.

66
00:03:41,410 --> 00:03:45,640
અમે અમારા પ્રવેશ સામેલ કરવા માંગો છો
આ યાદીની લિંક શરૂ, અને તેથી

67
00:03:45,640 --> 00:03:48,910
અમે અમારી વર્તમાન પ્રવેશ હોય રહ્યા છીએ
હાલમાં શું હેશ કોષ્ટક નિર્દેશ

68
00:03:48,910 --> 00:03:54,030
પોઇન્ટ અને પછી અમે સ્ટોર રહ્યા છીએ
હેશ પર હેશ કોષ્ટકમાં

69
00:03:54,030 --> 00:03:55,350
વર્તમાન પ્રવેશ.

70
00:03:55,350 --> 00:03:59,320
>> તેથી આ બે રેખાઓ સફળતાપૂર્વક દાખલ
પાંચ શરૂઆતમાં પ્રવેશ

71
00:03:59,320 --> 00:04:02,270
કે અનુક્રમણિકા પર કડી થયેલ યાદી
હેશ કોષ્ટકમાં.

72
00:04:02,270 --> 00:04:04,900
અમે તે પૂર્ણ કરી લીધું છે, એટલે હંમેશાં ખબર
અમે અન્ય શબ્દ મળી કે

73
00:04:04,900 --> 00:04:07,800
શબ્દકોશ અને અમે ફરી વધારો.

74
00:04:07,800 --> 00:04:13,960
તેથી અમે કરી રાખવા કે fscanf સુધી
આખરે પર બિન કંઈક 1 આપે છે

75
00:04:13,960 --> 00:04:18,560
જે બિંદુએ અમે જરૂર યાદ રાખો કે
મુક્ત પ્રવેશ, તેથી અહીં, અમે એક malloced

76
00:04:18,560 --> 00:04:21,329
પ્રવેશ અને અમે કંઇક વાંચવા માટે પ્રયાસ કર્યો હતો
શબ્દકોશમાં થી.

77
00:04:21,329 --> 00:04:24,110
અને અમે સફળતાપૂર્વક વાંચી ન હતી
શબ્દકોશમાં માંથી કંઈક જેમાં

78
00:04:24,110 --> 00:04:27,440
કેસ અમે તે અમે પ્રવેશ મુક્ત કરવાની જરૂર છે
વાસ્તવમાં હેશ ટેબલ મૂકવા ક્યારેય

79
00:04:27,440 --> 00:04:29,110
અને છેલ્લે તૂટી જાય છે.

80
00:04:29,110 --> 00:04:32,750
>> અમે ભંગ એકવાર, અમે, શું કરવાની જરૂર છે
અમે કારણ કે ત્યાં ભંગ હતી

81
00:04:32,750 --> 00:04:35,840
ભૂલ ફાઈલ માંથી વાંચવા, અથવા આવી હતી
અમે પહોંચી કારણ કે અમે તોડી નહોતો

82
00:04:35,840 --> 00:04:37,120
આ ફાઈલના અંતે?

83
00:04:37,120 --> 00:04:40,150
કોઈ ભૂલ હતી, તો પછી અમે કરવા માંગો છો
લોડ ન હતી કારણ કે ખોટા પરત

84
00:04:40,150 --> 00:04:43,260
સફળ, અને આ પ્રક્રિયામાં, અમે કરવા માંગો છો
એ જણાવે છે કે તમામ શબ્દો અનલોડ

85
00:04:43,260 --> 00:04:45,670
અને સૌથી શબ્દકોશ ફાઈલ બંધ કરો.

86
00:04:45,670 --> 00:04:48,740
અમે કરી ગઈ એમ ધારી રહ્યા છીએ, તો પછી અમે માત્ર
હજુ શબ્દકોશમાં બંધ કરવાની જરૂર છે

87
00:04:48,740 --> 00:04:51,970
ફાઇલ, અને છેલ્લે, કારણ સાચું પરત
અમે સફળતાપૂર્વક લોડ કરેલા

88
00:04:51,970 --> 00:04:53,040
આપનું સ્વાગત છે.

89
00:04:53,040 --> 00:04:54,420
અને તે ભાર માટે છે.

90
00:04:54,420 --> 00:04:59,020
>> તેથી હવે એક ભરેલી હેશ કોષ્ટક આપવામાં આવે છે, ચકાસણી,
આ જેમ દેખાય રહ્યું છે.

91
00:04:59,020 --> 00:05:02,690
તેથી, તે એક bool આપે છે, તપાસ જે
સૂચવે છે કે શું રહ્યું છે

92
00:05:02,690 --> 00:05:07,530
પસાર ઈન ઘરનાં પરચૂરણ કામો * શબ્દ, કે શું
પસાર ઈન શબ્દમાળા અમારા શબ્દકોશ છે.

93
00:05:07,530 --> 00:05:10,530
તે શબ્દકોશમાં છે તેથી, તે છે
અમારા હેશ કોષ્ટકમાં, અમે આપશે

94
00:05:10,530 --> 00:05:13,380
સાચું, અને જો તેમાં તે નથી,
અમે ખોટા આપશે.

95
00:05:13,380 --> 00:05:17,770
આ પસાર ઈન શબ્દ આપેલ છે, અમે છો
શબ્દ હેશ રહ્યું.

96
00:05:17,770 --> 00:05:22,020
>> હવે, ઓળખી એક મહત્વપૂર્ણ બાબત એ છે કે
લોડ, અમે જાણતા હતા કે તે તમામ

97
00:05:22,020 --> 00:05:25,820
શબ્દો નાના અક્ષરોમાં કરવા માટે જતાં હતા,
પરંતુ અહીં, અમે જેથી ખાતરી નથી.

98
00:05:25,820 --> 00:05:29,510
અમે અમારા હેશ વિધેય પર એક નજર તો
ખરેખર અમારા હેશ વિધેય

99
00:05:29,510 --> 00:05:32,700
દરેક અક્ષર lowercasing છે
જો શબ્દના આ.

100
00:05:32,700 --> 00:05:37,580
તેથી કે શું ના કેપિટલાઈઝેશનના
શબ્દ અમારા હેશ વિધેય રહ્યું છે

101
00:05:37,580 --> 00:05:42,270
ગમે તે માટે જ અનુક્રમણિકા પરત
કેપિટલાઈઝેશન તે હશે છે

102
00:05:42,270 --> 00:05:45,280
સંપૂર્ણપણે લોઅરકેસ માટે પરત
જો શબ્દના આ આવૃત્તિ.

103
00:05:45,280 --> 00:05:45,950
અધિકાર છે.

104
00:05:45,950 --> 00:05:47,410
>> જેથી અમારી અનુક્રમણિકા છે.

105
00:05:47,410 --> 00:05:49,790
આ શબ્દ માટે હેશ ટેબલ છે.

106
00:05:49,790 --> 00:05:52,940
હવે, લૂપ માટે આ રહ્યું છે
આ કડી થયેલ યાદી વધારે હતો,

107
00:05:52,940 --> 00:05:55,000
કે કે અનુક્રમણિકા પર હતી.

108
00:05:55,000 --> 00:05:59,630
તેથી અમે પ્રવેશ પ્રારંભ કરી રહ્યા છે નોટિસ
કે ઇન્ડેક્સમાં નિર્દેશ.

109
00:05:59,630 --> 00:06:03,480
અમે પ્રવેશ કરે છે, જ્યારે ચાલુ રહ્યા છીએ
સમાન નલ, અને યાદ રાખો કે

110
00:06:03,480 --> 00:06:08,350
અમારા સંલગ્ન યાદીમાં નિર્દેશક અપડેટ
પ્રવેશ આગામી એન્ટ્રી> સમકક્ષ હોય છે, તેથી છે

111
00:06:08,350 --> 00:06:13,840
આ માટે અમારી વર્તમાન પ્રવેશ બિંદુ
કડી થયેલ યાદીમાં આગામી વસ્તુ.

112
00:06:13,840 --> 00:06:14,400
અધિકાર છે.

113
00:06:14,400 --> 00:06:19,150
>> તેથી કડી થયેલ યાદીમાં દરેક પ્રવેશ માટે,
અમે strcasecmp ઉપયોગ જઈ રહ્યાં છો.

114
00:06:19,150 --> 00:06:23,780
તે strcmp છે, કારણ કે એક વાર ફરી, અમે
insensitively વસ્તુઓ કેસ કરવા માંગો છો.

115
00:06:23,780 --> 00:06:28,830
તેથી અમે શબ્દ સરખાવવા strcasecmp ઉપયોગ
કે આ કાર્ય માટે પસાર કરવામાં આવ્યો હતો

116
00:06:28,830 --> 00:06:31,860
શબ્દ સામે કે
આ પ્રવેશ છે.

117
00:06:31,860 --> 00:06:35,570
તે 0 આપે છે, કે જે હતી અર્થ થાય છે
અમે કરવા માંગો છો કે જે કિસ્સામાં એક મેચ,

118
00:06:35,570 --> 00:06:36,630
સાચું આવો.

119
00:06:36,630 --> 00:06:39,590
અમે સફળતાપૂર્વક મળી
અમારા હેશ કોષ્ટકમાં શબ્દ.

120
00:06:39,590 --> 00:06:43,040
>> એક મેળ ન હતી, તો પછી અમે છો
ફરીથી લૂપ જવા અને જુઓ

121
00:06:43,040 --> 00:06:43,990
આગામી પ્રવેશ.

122
00:06:43,990 --> 00:06:47,640
અને અમે જ્યારે ત્યાં રહ્યાં ચાલુ રાખીશું
આ કડી થયેલ યાદીમાં પ્રવેશો છે.

123
00:06:47,640 --> 00:06:50,160
અમે તોડી તો શું થાય
લૂપ માટે આ બહાર?

124
00:06:50,160 --> 00:06:55,110
કે અમે પ્રવેશ મળ્યાં નથી અર્થ એ થાય કે
જે કિસ્સામાં, આ શબ્દ સાથે મેળ ખાતી

125
00:06:55,110 --> 00:07:00,220
અમે દર્શાવવા માટે ખોટા પરત કે અમારા
હેશ કોષ્ટક આ શબ્દ છે ન હતી.

126
00:07:00,220 --> 00:07:01,910
અને તે ચેક માટે છે.

127
00:07:01,910 --> 00:07:02,540
અધિકાર છે.

128
00:07:02,540 --> 00:07:04,790
>> તેથી આપણે માપ પર એક નજર કરીએ.

129
00:07:04,790 --> 00:07:09,280
હવે, કદ ખૂબ સરળ હોઈ ચાલે છે
કારણ કે દરેક શબ્દ માટે, ભાર યાદ

130
00:07:09,280 --> 00:07:12,880
આપણે વૈશ્વિક વધે મળી
ચલ hashtable_size.

131
00:07:12,880 --> 00:07:15,830
તેથી માપ કાર્ય માત્ર છે
કે વૈશ્વિક પરત ચાલી

132
00:07:15,830 --> 00:07:18,150
ચલ, અને તે છે.

133
00:07:18,150 --> 00:07:22,300
>> હવે છેલ્લે, અમે અનલોડ જરૂર
શબ્દકોશ બધું થાય છે એક વાર.

134
00:07:22,300 --> 00:07:25,340
તેથી અમે કેવી રીતે કે શું થઈ રહ્યું છે?

135
00:07:25,340 --> 00:07:30,440
અહીં, અમે બધા પર રહ્યાં રહ્યાં છો
અમારા હેશ ટેબલ buckets.

136
00:07:30,440 --> 00:07:33,240
તેથી NUM_BUCKETS ડોલથી છે.

137
00:07:33,240 --> 00:07:37,490
અને અમારા હેશ દરેક કડી થયેલ યાદી માટે
ટેબલ, અમે પર લૂપ રહ્યા છીએ

138
00:07:37,490 --> 00:07:41,070
આ યાદીની લિંક સમગ્ર
દરેક તત્વ મુક્ત કરીને.

139
00:07:41,070 --> 00:07:46,070
હવે, આપણે સાવચેત રહેવાની જરૂર છે, તેથી અહીં અમે
કે કામચલાઉ ચલ છે

140
00:07:46,070 --> 00:07:49,740
આગામી માટે નિર્દેશક સ્ટોર
આ કડી થયેલ યાદીમાં તત્વ.

141
00:07:49,740 --> 00:07:52,140
અને પછી અમે મુક્ત રહ્યા છીએ
વર્તમાન ઘટક.

142
00:07:52,140 --> 00:07:55,990
>> અમે આપણે થી આ કરવા માટે ખાતરી કરો કરવાની જરૂર છે
માત્ર વર્તમાન તત્વ મુક્ત કરી શકો છો

143
00:07:55,990 --> 00:07:59,260
અને પછી આગામી નિર્દેશક ઍક્સેસ કરવાનો પ્રયાસ
કારણ કે એક વખત અમે તેને મુક્ત

144
00:07:59,260 --> 00:08:00,870
મેમરી અમાન્ય બની જાય છે.

145
00:08:00,870 --> 00:08:04,990
તેથી અમે માટે નિર્દેશક આસપાસ રાખવા જરૂર
આગામી તત્વ, તો પછી અમે મુક્ત કરી શકો છો આ

146
00:08:04,990 --> 00:08:08,360
વર્તમાન તત્વ, અને પછી અમે અપડેટ કરી શકો છો
માટે નિર્દેશ અમારી વર્તમાન તત્વ

147
00:08:08,360 --> 00:08:09,590
આગામી તત્વ.

148
00:08:09,590 --> 00:08:12,770
>> અમે તત્વો લૂપ છે પડશે જ્યારે
આ કડી થયેલ યાદી છે.

149
00:08:12,770 --> 00:08:16,450
અમે તમામ કડી થયેલ યાદી છે કે કરીશ
હેશ ટેબલ, અને અમે પૂર્ણ કરી એક વાર

150
00:08:16,450 --> 00:08:20,180
કે સાથે, અમે સંપૂર્ણપણે લોડ કર્યું
હેશ ટેબલ, અને અમે પૂર્ણ કરી લીધું.

151
00:08:20,180 --> 00:08:24,050
તેથી તે અનલોડ માટે ક્યારેય અશક્ય છે
ખોટા પાછા, અને અમે પૂર્ણ કરી લીધું છે, અમે

152
00:08:24,050 --> 00:08:25,320
માત્ર સાચું આવો.

153
00:08:25,320 --> 00:08:27,563