1
00:00:00,000 --> 00:00:02,740
[Powered by Google Translate] [Walkthrough - પ્રોબ્લેમ 5 સમૂહ]

2
00:00:02,740 --> 00:00:04,870
[Zamyla ચાન - હાર્વર્ડ યુનિવર્સિટી]

3
00:00:04,870 --> 00:00:07,190
[આ CS50 છે. - CS50.TV]

4
00:00:07,190 --> 00:00:10,400
>> અધિકાર છે. હેલો, દરેકને, અને 5 Walkthrough સ્વાગત છે.

5
00:00:10,400 --> 00:00:17,400
>> Pset5 ખોટી જોડણી છે, જેમાં અમે જોડણી-પરીક્ષક બનાવવા આવશે.

6
00:00:17,400 --> 00:00:21,030
સ્પેલ-ચેકર્સ અત્યંત મહત્વપૂર્ણ છે.

7
00:00:21,030 --> 00:00:23,390
આ ક્યારેય તમે શું થયું?

8
00:00:23,390 --> 00:00:27,170
તમે ખૂબ જ કામ કરે છે, ખૂબ સંઘર્ષ માટે એક કાગળ પર સંગ્રહ કરવો

9
00:00:27,170 --> 00:00:33,120
અને પછી હજુ પણ અંત એક ડી અથવા ડી = જેમ ખૂબ ગ્લો rade મેળવવામાં

10
00:00:33,120 --> 00:00:39,390
અને કારણ કે તમે વ્હેલ વ્યાપક શબ્દ માં liverwurst સ્પોઇલર છે બધા.

11
00:00:39,390 --> 00:00:44,710
હા, તમારા મરી proofreading આ બાબત, તે અત્યંત કમજોરી છે.

12
00:00:44,710 --> 00:00:49,140
આ એક સમસ્યા છે કે મેનલી, મેનલી વિદ્યાર્થીઓ અસર કરે છે.

13
00:00:49,140 --> 00:00:56,260
હું એક વખત મારા sith ગ્રેડ અત્યાચાર દ્વારા કહેવામાં આવ્યું કે હું એક સારા સાથી માં ક્યારેય વિચાર કરશે.

14
00:00:56,260 --> 00:01:00,250
અને તે તમામ હું ક્યારેય માગતા હતા, કે કોઇ પણ તમામ બાળક મારી ઉંમર અંતે માંગે છે,

15
00:01:00,250 --> 00:01:04,569
ફક્ત એક સારી સહ - કાર્યકર પ્રવેશ મેળવવા માટે.

16
00:01:04,569 --> 00:01:12,720
અને માત્ર કોઇ સહ - કાર્યકર નથી. નંબર મેં એક આઇવરી કાનૂની સાથી પર જાઓ માગતા હતા.

17
00:01:12,720 --> 00:01:18,360
તેથી જો હું સુધાર ન હતી, ગઇ હાર્વર્ડ જવા મારા સપના હશે,

18
00:01:18,360 --> 00:01:22,730
Jale, અથવા જેલ - તમે જાણતા જેલ માં, ન્યૂ જર્સી.

19
00:01:22,730 --> 00:01:25,170
તેથી હું મારી જાતને જોડણી-ચેકર મળ્યું.

20
00:01:25,170 --> 00:01:29,380
કે મારા એક પ્રિય બોલાતી શબ્દ કલાકારો, ટેલર માલી પાસેથી થોડી ટૂંકસાર છે.

21
00:01:29,380 --> 00:01:34,630
શું છે, તેઓ કહે છે, એક જોડણી-પરીક્ષક કર્યા મહત્વ ખૂબ જ મહત્વપૂર્ણ છે.

22
00:01:34,630 --> 00:01:39,440
>> તેથી 5 Walkthrough સ્વાગત છે, જેમાં અમે pset5 વિશે વાત કરવામાં આવશે: ખોટી જોડણી,

23
00:01:39,440 --> 00:01:44,300
જેમાં અમે અમારી પોતાની જોડણી-પરીક્ષક બનાવવા આવશે.

24
00:01:44,300 --> 00:01:50,880
આ સપ્તાહ માટે શોધો, વિતરણ કોડ માટે મહત્વપૂર્ણ બનવા માટે જોવા રહ્યું છે

25
00:01:50,880 --> 00:01:54,950
માત્ર વિવિધ કાર્યો કે જે તમારી શબ્દકોશ હોય રહ્યું છે તે સમજવા માટે.

26
00:01:54,950 --> 00:02:01,500
અમે ખરેખર ઘણી. કેચ ફાઈલો છે કે જે એકસાથે અમારા pset બનાવવા કરવામાં જઈ રહ્યાં છો.

27
00:02:01,500 --> 00:02:05,420
અને તેથી વિવિધ પાસાઓ દ્વારા શોધી, તેમ છતાં અમે ખરેખર નથી સંપાદિત કરી રહ્યા છો

28
00:02:05,420 --> 00:02:10,770
ફાઈલોની, એક speller.c, એ જાણીને તેને કેવી રીતે dictionary.c સંબંધમાં સાથે કામ કરે છે,

29
00:02:10,770 --> 00:02:14,100
જે અમે લખી હશે, માટે ખૂબ મહત્વપૂર્ણ પ્રયત્ન રહ્યું છે.

30
00:02:14,100 --> 00:02:16,970
આ pset સ્પેક પણ ઉપયોગી ઘણી માહિતી સમાવે છે

31
00:02:16,970 --> 00:02:21,360
વસ્તુઓ શરતો છે કે જે તમને ધારણ કરી શકે છે, તે જેવા નિયમો અને વસ્તુઓ,

32
00:02:21,360 --> 00:02:24,710
તેથી ટીપ્સ માટે pset સ્પેક ધ્યાનથી વાંચો ખાતરી કરો.

33
00:02:24,710 --> 00:02:29,310
અને જ્યારે કે નિયમ કંઈક ની શંકા હોય, તો પછી હંમેશા pset સ્પેક નો સંદર્ભ લો

34
00:02:29,310 --> 00:02:31,550
ચર્ચા કરો અથવા.

35
00:02:31,550 --> 00:02:34,060
આ pset માટે પોઇન્ટર પર ભારે આધાર રાખે રહ્યું છે,

36
00:02:34,060 --> 00:02:37,890
તેથી અમે ખાતરી કરવા માટે કે અમે ઉમેરીને તારાઓ વચ્ચે તફાવત સમજી બનાવવા માંગો છો

37
00:02:37,890 --> 00:02:41,680
આ નિર્દેશક નામ અને ampersands, કેવી રીતે તેને મુક્ત કરવા માટે, વગેરે સામે

38
00:02:41,680 --> 00:02:47,550
તેથી પોઇંટરો એક મુખ્ય હોવાથી આ સમસ્યા સેટ ખૂબ મદદરૂપ થઈ રહ્યું છે.

39
00:02:47,550 --> 00:02:50,460
અમે સંલગ્ન યાદીઓ એક બીટ વધુ જોવા જઈ રહ્યાં છો,

40
00:02:50,460 --> 00:02:57,790
જ્યાં અમે તત્વો હોય છે કે અમે નોડ કે જે બંને તેમજ નિર્દેશક કિંમત હોય કૉલ

41
00:02:57,790 --> 00:03:02,520
બીજા ગાંઠ છે, અને તેથી અનિવાર્યપણે જુદા જુદા તત્વો એક અન્ય બાદ જોડે છે.

42
00:03:02,520 --> 00:03:07,190
તમારા વાસ્તવિક શબ્દકોશ અમલમાં થોડા અલગ વિકલ્પો છે.

43
00:03:07,190 --> 00:03:13,150
અમે બે મુખ્ય પદ્ધતિઓ છે, કે જે હેશ કોષ્ટકો છે અને પછી પ્રયાસ કરે છે તપાસ જઈ રહ્યાં છો.

44
00:03:13,150 --> 00:03:17,660
તે બંને માં, તેમણે એક કડી થયેલ યાદી ખ્યાલ અમુક પ્રકારના સમાવેશ થાય છે

45
00:03:17,660 --> 00:03:20,790
જ્યાં તમે તત્વો એક બીજા સાથે કડી થયેલ છે.

46
00:03:20,790 --> 00:03:25,640
અને તેથી અમે જોશે કે તમે કેવી રીતે કડી થયેલ છે યાદીઓ આસપાસ કામ કરવાનો હોઇ શકે જઈ રહ્યાં છો,

47
00:03:25,640 --> 00:03:29,680
તેમને બનાવવા, કેવી રીતે દ્રષ્ટિએ નેવિગેટ કરો, ઉદાહરણ તરીકે, એક નોડ સામેલ

48
00:03:29,680 --> 00:03:32,760
અથવા મફત તેમજ ગાંઠો હોય.

49
00:03:32,760 --> 00:03:34,740
મુક્ત ગાંઠો દ્રષ્ટિએ, તે ખરેખર મહત્વનું છે

50
00:03:34,740 --> 00:03:37,700
કે જ્યારેપણ અમે malloc મેમરી, પછીથી અમે તેને મુક્ત.

51
00:03:37,700 --> 00:03:42,910
તેથી અમે ખાતરી કરો કે કોઈ નિર્દેશક unfreed જાય બનાવવા માંગો છો, કે જે આપણે કોઇ મેમરી લીક્સ નથી.

52
00:03:42,910 --> 00:03:48,330
અમે Valgrind કહેવાય સાધન છે કે જે તમારા કાર્યક્રમ ચાલે દાખલ જઈ રહ્યાં છો

53
00:03:48,330 --> 00:03:52,260
અને બધી મેમરીનો કે તમે ફાળવવામાં કે શું ચકાસે પછી મુક્ત છે.

54
00:03:52,260 --> 00:03:59,080
તમારા pset ત્યારે જ કાર્ય કરે છે તે પૂર્ણ થાય છે અને તે પૂર્ણ કાર્યક્ષમતા ધરાવે છે,

55
00:03:59,080 --> 00:04:03,990
પણ, Valgrind તમને કહે છે કે તમે કોઈપણ મેમરી લીક્સ મળ્યા નથી.

56
00:04:03,990 --> 00:04:06,690
છેલ્લે, આ pset માટે, હું ખરેખર ભાર માંગો છો -

57
00:04:06,690 --> 00:04:11,360
હું તેનો અર્થ, હંમેશની જેમ, હું નિશ્ચિતપણે તમારી સમસ્યા સમૂહો માટે પેન અને કાગળ મદદથી એક ટેકેદાર છું,

58
00:04:11,360 --> 00:04:14,840
પરંતુ આ એક છે, મને લાગે છે કે પેન અને કાગળ માટે ખાસ કરીને મહત્વનું છે રહ્યું છે

59
00:04:14,840 --> 00:04:19,000
જ્યારે તમે તીર વસ્તુઓ માટે ચિત્રકામ કરી અને સમજવા કેવી રીતે વસ્તુઓ કામ કરવા માંગો છો.

60
00:04:19,000 --> 00:04:24,440
તેથી નિશ્ચિતપણે પેન અને કાગળ વાપરવા માટે વસ્તુઓ દોરવા બહાર તે પહેલાં તમે કોડિંગ મળશે પ્રયાસ

61
00:04:24,440 --> 00:04:26,970
કારણ કે તે એક બીટ અવ્યવસ્થિત વિચાર કરી શકે છે.

62
00:04:26,970 --> 00:04:30,700
>> પ્રથમ, ચાલો સંલગ્ન યાદીઓ એક બીટ જાઓ.

63
00:04:30,700 --> 00:04:35,510
લિંક કરેલા યાદીઓ ગાંઠો, જ્યાં દરેક નોડ તેની સાથે સંકળાયેલ મૂલ્ય છે સમાવે છે,

64
00:04:35,510 --> 00:04:39,810
તેમજ તે પછી બીજા ગાંઠ પર એક નિર્દેશક.

65
00:04:39,810 --> 00:04:43,680
લિંક કરેલા યાદીઓ સાથે મહત્વની બાબતો એક દંપતી છે કે અમે યાદ કરવાની જરૂર છે

66
00:04:43,680 --> 00:04:48,810
જ્યાં અમારી પ્રથમ નોડ છે, અને પછી એક વાર અમે જાણીએ છીએ કે જ્યાં પ્રથમ નોડ છે,

67
00:04:48,810 --> 00:04:52,990
કે રીતે આપણે નોડ ઍક્સેસ કરી શકો છો કે જે પ્રથમ નોડ પોઇન્ટ

68
00:04:52,990 --> 00:04:55,850
અને પછી તે પછી એક અને તે પછી એક.

69
00:04:55,850 --> 00:05:00,340
અને પછી તમારી સાથે લિંક યાદી છેલ્લા તત્વ કે નોડ નિર્દેશક છે

70
00:05:00,340 --> 00:05:02,340
છે હંમેશા માટે નલ નિર્દેશ જઈ રહી છે.

71
00:05:02,340 --> 00:05:08,230
જ્યારે નોડ પોઇન્ટ નલ, પછી તમે જાણો છો કે તમે યાદીમાંથી ઓવરને પહોંચી ગયા છો,

72
00:05:08,230 --> 00:05:12,320
કે જે નોડ છેલ્લા એક છે, કે એ પછી કશું જ નથી.

73
00:05:12,320 --> 00:05:16,970
આ યોજનાકીય અહીં, તમે જુઓ કે તીર પોઇન્ટર છે,

74
00:05:16,970 --> 00:05:20,290
અને વાદળી વિભાગમાં જ્યાં કિંમત સંગ્રહિત છે,

75
00:05:20,290 --> 00:05:24,420
અને પછી તે નિર્દેશક સાથે લાલ બોક્સ જે નોડ નિર્દેશક છે

76
00:05:24,420 --> 00:05:27,050
તેના પછી બીજા ગાંઠ તરફ સંકેત આપતા.

77
00:05:27,050 --> 00:05:33,730
અને તમે અહીં જુઓ, જેથી ડી નોડ માટે નલ નિર્દેશ કારણ કે તે યાદી છેલ્લા તત્વ આવે છે.

78
00:05:33,730 --> 00:05:38,240
>> ચાલો અમે કેવી રીતે નોડ માટે સ્ટ્રક્ટ વ્યાખ્યાયિત કરી શકે છે જુઓ.

79
00:05:38,240 --> 00:05:40,130
અને ત્યારથી અમે ઘણા નોડો માંગો છો,

80
00:05:40,130 --> 00:05:43,180
આ એક typedef સ્ટ્રક્ટ બની રહ્યું છે

81
00:05:43,180 --> 00:05:46,870
જેમાં અમે ગાંઠો અનેક જુદા જુદા ઘટકોને હોય રહ્યા છીએ.

82
00:05:46,870 --> 00:05:50,850
અને તેથી અમે તેને નવા દશાંશ માહિતી પ્રકાર તરીકે વ્યાખ્યાયિત કરે છે.

83
00:05:50,850 --> 00:05:53,630
અહીં, અમે typedef સ્ટ્રક્ટ નોડ છે.

84
00:05:53,630 --> 00:05:56,160
આ ઉદાહરણમાં, અમે પૂર્ણાંક ગાંઠો સાથે કામ કરીએ છીએ,

85
00:05:56,160 --> 00:06:00,490
તેથી અમે પૂર્ણાંક કિંમત નામ આપવામાં આવ્યું હોય છે અને તે પછી અમે અન્ય નિર્દેશક હોય છે,

86
00:06:00,490 --> 00:06:07,390
અને આ કિસ્સામાં, તે નોડ માટે નિર્દેશક છે, તેથી અમે એક સ્ટ્રક્ટ નોડ * આગામી કહેવાય છે.

87
00:06:07,390 --> 00:06:09,520
અને પછી અમે આ સમગ્ર બાબત નોડ કૉલ કરી રહ્યાં છો.

88
00:06:09,520 --> 00:06:11,110
ખાતરી કરો કે તમે આ વાક્યરચના પાલન કરો.

89
00:06:11,110 --> 00:06:17,940
નોટિસ નોડ વાસ્તવમાં ઉપર છે અપ તરીકે તરીકે સર્પાકાર કૌંસ બરાબર નીચે સંદર્ભ છે.

90
00:06:17,940 --> 00:06:23,400
પછી ટ્રેક રાખવા માટે જ્યાં મારી પ્રથમ નોડ આ સંલગ્ન યાદીમાં છે,

91
00:06:23,400 --> 00:06:29,390
પછી હું નોડ વડા તરીકે ઓળખાય નિર્દેશક હોય છે, અને મને એક નોડ માપ માટે malloc પૂરતી જગ્યા.

92
00:06:29,390 --> 00:06:36,240
સૂચના, તેમ છતાં, વડા ખરેખર નોડ નિર્દેશક તરીકે વાસ્તવિક નોડ પોતે વિરોધ છે.

93
00:06:36,240 --> 00:06:40,130
તેથી વડા ખરેખર કોઇ કિંમત નથી,

94
00:06:40,130 --> 00:06:45,590
તે માત્ર જે મારી સાથે લિંક યાદીમાં પ્રથમ નોડ છે નિર્દેશ કરે છે.

95
00:06:55,080 --> 00:06:58,340
>> સાથે કડી યાદીઓ સારી સૂઝ મેળવવા માટે, કારણ કે તે ખૂબ જ મહત્વપૂર્ણ છે

96
00:06:58,340 --> 00:07:02,220
ખાતરી કરવા માટે કે જે તમે સાંકળ જાળવી બનાવવા ટ્રેક રાખવા માટે,

97
00:07:02,220 --> 00:07:09,990
હું તેને લાગે છે માંગતા તરીકે રેખા લોકો હાથ હોલ્ડિંગ,

98
00:07:09,990 --> 00:07:14,330
દરેક વ્યક્તિ આગામી એક સાથે હાથ જ્યાં હોલ્ડિંગ છે.

99
00:07:14,330 --> 00:07:18,350
તમે આ ચિત્ર જોઈ, પરંતુ મૂળભૂત રીતે તેઓ આગામી વ્યક્તિ તરફ ઇશારો કરી શકો છો

100
00:07:18,350 --> 00:07:23,760
કે તેમના સાંકળ છે.

101
00:07:23,760 --> 00:07:29,270
અને તેથી જો તમે સંલગ્ન યાદી જ્યાં આ લોકો પસાર કરવા માંગો છો -

102
00:07:29,270 --> 00:07:32,830
તે બધા લોકોને કલ્પના તેમની સાથે સંકળાયેલ કિંમતો છે

103
00:07:32,830 --> 00:07:36,590
અને પણ લીટી માં આગામી વ્યક્તિ માટે નિર્દેશ -

104
00:07:36,590 --> 00:07:40,810
જો તમે સંલગ્ન યાદી પસાર કરવા માંગો છો, ઉદાહરણ માટે, ક્યાં કિંમતો ફેરફાર કરવા માટે

105
00:07:40,810 --> 00:07:42,830
અથવા જેમ કિંમત કંઈક માટે શોધ અથવા,

106
00:07:42,830 --> 00:07:48,270
પછી તમે ચોક્કસ વ્યક્તિ માટે નિર્દેશક માંગો છો પડશે.

107
00:07:48,270 --> 00:07:52,670
તેથી અમે એ માહિતી પ્રકાર નોડ નિર્દેશક હોય રહ્યા છીએ.

108
00:07:52,670 --> 00:07:55,580
આ ઉદાહરણ તરીકે, ચાલો તે કર્સર કૉલ કરો.

109
00:07:55,580 --> 00:07:59,630
અન્ય સામાન્ય આ નામ રીતે iterator અથવા તે કંઈક હશે

110
00:07:59,630 --> 00:08:05,130
કારણ કે તે ઉપર વારો છે અને વાસ્તવમાં ખસેડવાની નોડ કે જે તેને તરફ ઇશારો કરે છે.

111
00:08:05,130 --> 00:08:14,410
આ અહીં અમારા કર્સર હશે.

112
00:08:14,410 --> 00:08:20,180
અમારા કર્સર પ્રથમ અમારી યાદીમાં પ્રથમ તત્વ માટે નિર્દેશ કરશે.

113
00:08:20,180 --> 00:08:26,910
અને તેથી અમે કરવા માંગો છો શું છે અમે મૂળભૂત કર્સર ચાલુ રાખવામાં આવે છે,

114
00:08:26,910 --> 00:08:29,130
તે બાજુ માંથી બાજુ ખસેડી.

115
00:08:29,130 --> 00:08:33,409
આ કિસ્સામાં, અમે તેને યાદીમાં આગામી તત્વ ખસેડવા માંગો છો.

116
00:08:33,409 --> 00:08:38,480
સંગ્રહ સાથે, અમે શું થશે શું છે અમે કહી અમે 1 દ્વારા ઇન્ડેક્સ વધારો કરશે.

117
00:08:38,480 --> 00:08:46,020
આ કિસ્સામાં, અમે જરૂર પડે છે ખરેખર શું શોધી છે જે વ્યક્તિ આ વર્તમાન વ્યક્તિ તરફ ઇશારો છે,

118
00:08:46,020 --> 00:08:48,930
અને તે માટે આગામી કિંમત જ હશે.

119
00:08:48,930 --> 00:08:53,230
તેથી જો કર્સર માત્ર એક નોડ નિર્દેશક હોય, તો પછી આપણે શું કરવા માંગો છો

120
00:08:53,230 --> 00:08:56,320
અમે કિંમત મેળવવા કે કર્સર પોઇન્ટ છે કરવા માંગો છો.

121
00:08:56,320 --> 00:09:01,350
અમે તે નોડ મેળવવા અને પછી, એક વખત અમે તે નોડ પર છો, શોધો જ્યાં તે પોઇન્ટ છે કરવા માંગો છો.

122
00:09:01,350 --> 00:09:05,820
માટે વાસ્તવિક નોડ કે જે કર્સર પોઇન્ટ છે વિચાર,

123
00:09:05,820 --> 00:09:13,160
સામાન્ય રીતે અમે તેને દ્વારા (* કર્સર) દર્શાવે છે.

124
00:09:13,160 --> 00:09:19,160
કે તમે વાસ્તવિક નોડ કે જે કર્સર પોઇન્ટ છે આપતા.

125
00:09:19,160 --> 00:09:21,730
અને પછી તે પછી, અમે કરવા માંગો છો શું છે અમે ઍક્સેસ કરવા માંગો છો

126
00:09:21,730 --> 00:09:25,680
ગમે કે નોડ આગામી કિંમત છે.

127
00:09:25,680 --> 00:09:32,820
આમ કરવા માટે કે, સ્ટ્રક્ટ ની અંદર કિંમતો ઍક્સેસ કરવા માટે, અમે કોઈ ઓપરેટર છે.

128
00:09:32,820 --> 00:09:39,530
તેથી પછી તે (* કર્સર) હોઇ આગામી. કરશે.

129
00:09:39,530 --> 00:09:44,840
પરંતુ આ * કર્સર આસપાસ કૌંસ કર્યા દ્રષ્ટિએ થોડી અવ્યવસ્થિત હોય છે,

130
00:09:44,840 --> 00:09:56,800
અને તેથી અમે કર્સર-> સાથે આ સમગ્ર નિવેદન બદલો.

131
00:09:56,800 --> 00:10:02,700
આ એક છે અને પછી એક કરતા વધારે સાઇન આડંબર છે, તેથી એક તીર બનાવે છે.

132
00:10:02,700 --> 00:10:05,840
કર્સર-> આગામી.

133
00:10:05,840 --> 00:10:12,390
કે ખરેખર તમે નોડ મળશે કે કર્સર નિર્દેશ કરે છે. કિંમત છે કે આગામી એક છે.

134
00:10:12,390 --> 00:10:16,790
તેથી બદલે તારો અને કોઈ રહી, તમે એક તીર સાથે બદલી રહ્યાં છો.

135
00:10:16,790 --> 00:10:24,820
ખૂબ ખાતરી કરો કે તમે આ વાક્યરચના વાપરે પ્રયાસ કરો ખૂબ કાળજી રાખો.

136
00:10:33,550 --> 00:10:37,620
>> હવે અમે અમારા કર્સર હોય, જો અમે કિંમત ઍક્સેસ કરવા માંગો છો,

137
00:10:37,620 --> 00:10:40,450
પહેલાં, અમે કર્સર-> આગામી હતી,

138
00:10:40,450 --> 00:10:46,260
પરંતુ ગાંઠ પર મૂલ્ય કે કર્સર પોઇન્ટ છે ઍક્સેસ કરવા માટે, અમે ફક્ત કહેવું

139
00:10:46,260 --> 00:10:48,070
નોડ-> મૂલ્ય.

140
00:10:48,070 --> 00:10:53,600
ત્યાંથી, તે માહિતી પ્રકારની છે ગમે અમે કિંમતો અને પ્રયત્ન ગાંઠો વ્યાખ્યાયિત કર્યું છે.

141
00:10:53,600 --> 00:10:59,620
જો તે પૂર્ણાંક નોડ છે, પછી કર્સર-> કિંમત માત્ર પૂર્ણાંક હોવો રહ્યું છે.

142
00:10:59,620 --> 00:11:04,870
તેથી અમે તે પર કામગીરી કરી શકે છે, equalities તપાસ, તે અલગ અલગ કિંમતો, વગેરે સોંપી

143
00:11:04,870 --> 00:11:11,090
પછી જેથી તમે શું કરવા માંગો છો જો તમે આગલા વ્યક્તિ તમારા કર્સરને ખસેડવા માંગો છો,

144
00:11:11,090 --> 00:11:15,270
તમે ખરેખર કર્સર કિંમત બદલો.

145
00:11:15,270 --> 00:11:19,340
ત્યારથી કર્સર નોડ નિર્દેશક છે, તો તમે વાસ્તવિક નિર્દેશક સરનામું બદલવા

146
00:11:19,340 --> 00:11:23,890
તમારા યાદીમાં આગામી નોડને સરનામા માટે.

147
00:11:23,890 --> 00:11:28,930
આ માત્ર કેટલાક કોડ જ્યાં તમે ફરી વળવું શકે છે.

148
00:11:28,930 --> 00:11:31,230
, જ્યાં હું પાસે ટિપ્પણી કંઈક

149
00:11:31,230 --> 00:11:33,850
કે જ્યાં તમે કદાચ કિંમત ઍક્સેસ જઈ રહ્યાં છો

150
00:11:33,850 --> 00:11:37,850
અથવા જે ચોક્કસ નોડ સાથે કરી કંઈક.

151
00:11:37,850 --> 00:11:43,050
તેને શરૂ કરવા માટે આ બોલ પર, હું કહે છે કે મારા કર્સર શરૂઆતમાં

152
00:11:43,050 --> 00:11:48,430
છે યાદીની લિંક પ્રથમ તત્વ માટે નિર્દેશ જઈ રહી છે.

153
00:11:48,430 --> 00:11:52,910
અને તેથી અપ આગળ, હું તે નોડ વડા તરીકે વ્યાખ્યાયિત થયેલ છે.

154
00:11:52,910 --> 00:11:57,610
>> હું પહેલા ઉલ્લેખ થયો છે, મુક્ત કરીને ખરેખર મહત્વપૂર્ણ છે.

155
00:11:57,610 --> 00:12:02,440
તમે ખાતરી કરો કે તમે યાદીમાં દરેક તત્વ મુક્ત એકવાર તમે તેની સાથે પૂર્ણ કરી લો છો બનાવવા માંગો છો.

156
00:12:02,440 --> 00:12:04,940
જ્યારે તમે તે પોઇંટરો કોઈપણ હવે સંદર્ભ જરૂર નથી,

157
00:12:04,940 --> 00:12:10,620
તમે ખાતરી કરો કે તમે તે પોઇંટરો તમામ મુક્ત બનાવવા માંગો છો.

158
00:12:10,620 --> 00:12:14,460
પરંતુ તમે ખૂબ કાળજી રાખો અહીં માંગો છો કે તમે કોઈપણ મેમરી લીક્સ ટાળવા માંગો.

159
00:12:14,460 --> 00:12:25,080
અકાળે તમે મફત એક વ્યક્તિ જો, પછી પોઇંટરો બધી છે કે જે આ નોડ પોઇન્ટ

160
00:12:25,080 --> 00:12:26,900
છે ખોવાઈ જવાનું.

161
00:12:26,900 --> 00:12:32,070
આ વ્યક્તિ ઉદાહરણ પર પાછા જવું તે થોડી વધુ ઊંચા હિસ્સો બનાવે છે,

162
00:12:32,070 --> 00:12:49,600
ચાલો આ લોકોને આ કિસ્સામાં તેઓ મોન્સ્ટર સાથે તળાવ પર હોવર છે, અપવાદરૂપે છે.

163
00:12:49,600 --> 00:12:53,200
અમે ખાતરી કરવા માટે કે જ્યારે પણ અમે મુક્ત, અમે ગુમાવી નથી બનાવવા માંગો છો

164
00:12:53,200 --> 00:12:58,920
દો અને કોઈપણ ગાંઠો પહેલા અમે ખરેખર તેમને મુક્ત કરી દીધું છે.

165
00:12:58,920 --> 00:13:05,730
હમણાં પૂરતું, જો તમે માત્ર આ વ્યક્તિ પર મુક્ત અહીં કહી હતી,

166
00:13:05,730 --> 00:13:15,350
પછી તેમણે મુક્ત થઇ જશે, પણ પછી આ ગાય્સ તમામ પછી ખોવાઇ જશે

167
00:13:15,350 --> 00:13:18,450
અને તેઓ આ બોલ પર લક્ષ્ય અને નીચે જશે.

168
00:13:18,450 --> 00:13:24,900
તેથી અમે ખાતરી કરો કે તેના બદલે, અમે બાકીના એક લિંક જાળવવા માંગો છો બનાવવા માંગો છો.

169
00:13:37,630 --> 00:13:42,480
અમારા વડા નિર્દેશક, કે જે યાદીમાં પ્રથમ તત્વ નિર્દેશ કરે છે.

170
00:13:42,480 --> 00:13:49,990
તે પ્રથમ વ્યક્તિ લાંગર્યું દોરડું જેવા પ્રકારની છે.

171
00:13:52,870 --> 00:13:57,470
તમે શું કરવા માંગો છો જ્યારે તમે મુક્ત શકે યાદી હોય છે -

172
00:13:57,470 --> 00:14:04,520
જો તમે પ્રથમ તત્વ પ્રથમ મુક્ત કરવા માંગો છો, તો પછી તમે કામચલાઉ નિર્દેશક હોઈ શકે છે

173
00:14:04,520 --> 00:14:07,370
કે પોઇન્ટ ગમે તે પ્રથમ તત્વ છે.

174
00:14:07,370 --> 00:14:11,420
જેથી તમે તમારા કામચલાઉ નિર્દેશક અહીં પોઇન્ટ ધરાવે છે.

175
00:14:11,420 --> 00:14:15,840
તે રીતે, અમે પ્રથમ નોડ એક પકડ ધરાવે છે.

176
00:14:15,840 --> 00:14:18,930
અને પછી, અમે ત્યારથી ખબર છે કે પ્રથમ નોડ માટે મુક્ત થઇ રહ્યું છે,

177
00:14:18,930 --> 00:14:24,890
પછી અમે આ દોરડું, આ એન્કર, અમારા વડા ખસેડી શકો છો,

178
00:14:24,890 --> 00:14:31,930
ખરેખર ગમે તે પ્રથમ એક પોઇન્ટ હોય છે નિર્દેશ કરે છે.

179
00:14:31,930 --> 00:14:38,760
તેથી આ વડા ખરેખર બીજી તત્વ હવે નિર્દેશ કરે છે.

180
00:14:38,760 --> 00:14:43,980
હવે અમે મુક્ત ગમે કામચલાઉ નોકર માં સંગ્રહાય છે જ મંજૂરી છે,

181
00:14:43,980 --> 00:14:53,360
અને તેથી અમે તેને અમારા યાદીમાં અન્ય ગાંઠો તમામ endangering વગર કે ભૂંસી શકાય છે.

182
00:14:54,140 --> 00:15:05,020
બીજી રીતે કે તમે આ કરી શકે હોઈ શકે છે

183
00:15:05,020 --> 00:15:08,650
દર વખતે તમે ફક્ત યાદી છેલ્લા તત્વ મુક્ત

184
00:15:08,650 --> 00:15:11,010
કારણ કે તેઓ ખાતરી આપી રહ્યાં છો કંઈપણ કરવા માટે નથી નિર્દેશ કરવામાં આવે છે.

185
00:15:11,010 --> 00:15:15,570
તેથી તમે ફક્ત આ એક છે, પછી મફત આ એક છે, પછી મફત આ એક મુક્ત કરી શકે છે.

186
00:15:15,570 --> 00:15:21,900
કે ચોક્કસપણે કામ કરે છે પરંતુ કારણ કે સંકળાયેલા યાદીઓની પ્રકૃતિ દ્વારા, થોડી ધીમી છે

187
00:15:21,900 --> 00:15:24,670
અમે ફક્ત છેલ્લા એક તરત જ ન બાંધી શકે છે.

188
00:15:24,670 --> 00:15:28,030
અમે કડી થયેલ યાદી દરેક તત્વ પસાર છે

189
00:15:28,030 --> 00:15:31,020
અને કે કેમ તેની તપાસ કે જે એક નલ પોઇન્ટ છે, દર વખતે તે ચકાસવા માટે,

190
00:15:31,020 --> 00:15:33,780
અને પછી એક વાર અમે ઓવરને પહોંચે છે, તો પછી તે મફત.

191
00:15:33,780 --> 00:15:40,270
જો તમે આ પ્રક્રિયા કરી રહ્યા હતા, તમે ખરેખર અહીં ચકાસણી આવશે,

192
00:15:40,270 --> 00:15:44,190
અહીં ચકાસીને, પછી અહીં ચકાસીને, તે મુક્ત કરીને,

193
00:15:44,190 --> 00:15:47,470
પછી પાછા જવાનું, અહીં ચકાસીને, અહીં ચકાસીને, તે મુક્ત કરીને,

194
00:15:47,470 --> 00:15:49,660
અહીં ચકાસણી, અને પછી તેને મુક્ત કરીને.

195
00:15:49,660 --> 00:15:52,880
કે થોડી વધુ સમય લે છે. યાહ.

196
00:15:52,880 --> 00:15:59,060
>> [વિદ્યાર્થી] શક્ય હોઈ કડી થયેલ યાદી છે કે જે ઓવરને માટે બહાર નીકળો નિર્દેશક સંગ્રહે બનાવવા માંગો છો?

197
00:15:59,060 --> 00:16:01,320
કે ચોક્કસપણે શક્ય છે.

198
00:16:01,320 --> 00:16:08,340
આ પ્રશ્નના પુનરાવર્તન, તે શક્ય છે યાદીની લિંક માળખું ધરાવે છે

199
00:16:08,340 --> 00:16:12,490
જેમ કે તમે એક કડી થયેલ યાદી અંતે પોઇન્ટ નિર્દેશક છે?

200
00:16:12,490 --> 00:16:18,090
હું કે શક્ય છે જેમ કે, અને છો તે દરેક સમયે તમે તમારા કડી થયેલ યાદી માં કંઈક દાખલ કરો

201
00:16:18,090 --> 00:16:21,470
તમે તે અને કે નિર્દેશક વસ્તુઓ સુધારવા પડશે.

202
00:16:21,470 --> 00:16:26,640
તમે હમણાં માટે નોડ * પૂંછડી હોય.

203
00:16:26,640 --> 00:16:29,840
પરંતુ જ્યારે તમે આ સુવિધાને અમલમાં કરી રહ્યાં છો, તો તમે વેપાર ન લાગે છે,

204
00:16:29,840 --> 00:16:32,700
ગમે કેટલી વખત હું આ બોલ વારો આવશે જાઉં છું,

205
00:16:32,700 --> 00:16:36,100
કેવી રીતે મુશ્કેલ તે માટે પૂંછડી ટ્રેક તેમજ વડા રાખવા પ્રયત્ન રહ્યું છે

206
00:16:36,100 --> 00:16:38,400
તેમજ મારા iterator, અને તે જેવી વસ્તુઓ છે.

207
00:16:40,730 --> 00:16:42,480
કે કરે છે -? >> [વિદ્યાર્થી] યાહ.

208
00:16:42,480 --> 00:16:48,270
શક્ય છે, પરંતુ ડિઝાઇન નિર્ણયો દ્રષ્ટિએ, તો તમે વિકલ્પો તોલવું છે.

209
00:16:53,850 --> 00:17:01,090
>> અહીં કોડ એક હાડપિંજર કે તમે કડી થયેલ યાદી દરેક તત્વ મુક્ત કરવા માટે પરવાનગી આપે જશે.

210
00:17:01,090 --> 00:17:05,460
ફરીથી, કારણ હું સંકળાયેલી યાદી પર વારો છું, હું કર્સરને કેટલાક પ્રકારની માંગો છો જાઉં છું

211
00:17:05,460 --> 00:17:08,670
અથવા iterator.

212
00:17:08,670 --> 00:17:14,640
અમે ત્યાં સુધી કર્સર NULL છે વારો આવે છે.

213
00:17:14,640 --> 00:17:17,640
તમે ફરી વળવું જ્યારે તમારું કર્સર NULL છે નથી માંગતા

214
00:17:17,640 --> 00:17:20,579
કારણ કે તે અર્થ એ થાય કે ત્યાં યાદીમાં કંઈપણ નથી.

215
00:17:20,579 --> 00:17:25,069
તેથી તે પછી અહીં હું એક કામચલાઉ નોડ * બનાવવા

216
00:17:25,069 --> 00:17:29,610
હું શું ધ્યાનમાં છું તરફ મારું યાદી પ્રથમ છે,

217
00:17:29,610 --> 00:17:35,340
અને પછી હું મારા કર્સર 1 આગળ અને પછી મફત ગમે હું કામચલાઉ સંગ્રહ હતી ખસેડો.

218
00:17:38,460 --> 00:17:43,650
>> હવે અમે સંલગ્ન યાદીઓ માં દાખલ કરવા માટે આવે છે.

219
00:18:00,200 --> 00:18:09,660
હું મારા સંલગ્ન યાદીમાં ત્રણ ગાંઠો હોય છે, અને આપણે સરળ કેસ સાથે જાઓ

220
00:18:09,660 --> 00:18:18,970
જ્યાં અમે અમારા યાદીની લિંક ઓવરને અંતે અન્ય નોડ સામેલ કરવા માંગો છો.

221
00:18:18,970 --> 00:18:25,980
કે કરવા માટે, બધા અમે જશે અમે પસાર થશે

222
00:18:25,980 --> 00:18:32,100
શોધવા જ્યાં કડી થયેલ યાદીમાં વર્તમાન અંત છે, જેથી નોડ જે માટે નલ પોઇન્ટ છે -

223
00:18:32,100 --> 00:18:33,850
કે આ એક છે -

224
00:18:33,850 --> 00:18:37,260
અને પછી કહે, ખરેખર, આ એક એ છેલ્લા નોડ નથી રહ્યું છે;

225
00:18:37,260 --> 00:18:39,830
અમે ખરેખર બીજી એક હોય રહ્યા છીએ.

226
00:18:39,830 --> 00:18:46,260
તેથી અમે ગમે અમે દાખલ કરી રહ્યાં છે આ વર્તમાન એક બિંદુ હોય.

227
00:18:46,260 --> 00:18:50,080
તેથી હવે આ લાલ વ્યક્તિ અહીં કડી થયેલ યાદી છેલ્લા નોડ બની જાય છે.

228
00:18:50,080 --> 00:18:56,080
અને તેથી યાદીની લિંક છેલ્લા નોડને લાક્ષણિકતા તે છે કે તે નલ નિર્દેશ કરે છે.

229
00:18:56,080 --> 00:19:09,380
તેથી તો અમે કરવા પડશે આ શું લાલ વ્યક્તિ નિર્દેશક સુયોજિત કરવા માટે નલ છે. ત્યાં.

230
00:19:09,380 --> 00:19:25,370
>> પરંતુ જો આપણે બીજા અને ત્રીજા એક વચ્ચે એક નોડ દાખલ કરવા ઈચ્છતા?

231
00:19:25,370 --> 00:19:28,960
કે એક તદ્દન તરીકે સરળ કારણ કે અમે ખાતરી કરવા માંગો છો નથી

232
00:19:28,960 --> 00:19:34,290
કે અમે નથી દો અમારી સાથે લિંક યાદી કોઈપણ ગાંઠની જાઓ.

233
00:19:34,290 --> 00:19:43,450
અમે શું હશે શું ખાતરી કરો કે આપણે આપણી જાતને દરેક એક માટે ANCHOR બનાવવાનો છે.

234
00:19:43,450 --> 00:19:49,900
ઉદાહરણ માટે, આ બીજા એક કૉલ દો.

235
00:19:49,900 --> 00:19:54,390
જો તમે કહ્યું હતું કે બીજા એક હવે આ એક નવી નિર્દેશ

236
00:19:54,390 --> 00:20:02,520
અને તમે માત્ર એક નિર્દેશક ત્યાં કર્યો હતો, પછી તે આ વ્યક્તિ ગુમ થઈ પરિણમી

237
00:20:02,520 --> 00:20:07,830
કારણ કે ત્યાં તેમને કોઇ કડી નથી.

238
00:20:07,830 --> 00:20:18,970
તેના બદલે - હું આ ફરી દોરવા પડશે. મારા કલાત્મક ક્ષમતાઓ ક્ષમાપાત્ર.

239
00:20:18,970 --> 00:20:26,570
અમે જાણીએ છીએ કે અમે હમણાં જ એક નવી ન સીધી 2 લિંક કરી શકો છો.

240
00:20:26,570 --> 00:20:30,480
અમે ખાતરી કરવા માટે કે અમે છેલ્લા એક ને પકડી બનાવવા હોય છે.

241
00:20:30,480 --> 00:20:39,200
અમે કરવા માંગો છો શકે શું કામચલાઉ નિર્દેશક હોય છે

242
00:20:39,200 --> 00:20:42,650
તત્વ કે જે પર ઉમેરાયું કરી રહ્યું છે તે માટે.

243
00:20:42,650 --> 00:20:45,140
તેથી તો અમે કામચલાઉ નિર્દેશક ત્યાં હોય છે.

244
00:20:45,140 --> 00:20:50,780
, કારણ આપણે જાણીએ છીએ કે આ તૃતીય એક રહી છે ટ્રેક રાખી

245
00:20:50,780 --> 00:20:53,680
2 હવે અમારી નવી એક લિંક કરી શકો છો.

246
00:20:53,680 --> 00:20:57,490
અને જો આ નવા લાલ વ્યક્તિ માટે પ્રયત્ન 2 અને 3 માં વચ્ચે રહ્યું છે,

247
00:20:57,490 --> 00:21:05,550
પછી કે વ્યક્તિ નિર્દેશક શું કરવા માટે નિર્દેશ રહ્યું છે? >> [વિદ્યાર્થી] ટેમ્પ.

248
00:21:05,550 --> 00:21:07,490
ટેમ્પ. યાહ.

249
00:21:07,490 --> 00:21:15,430
તેથી પછી આ લાલ વ્યક્તિ પછીના મૂલ્ય temp પ્રયત્ન રહ્યું છે.

250
00:21:26,090 --> 00:21:33,010
જ્યારે તમે સંલગ્ન યાદીઓ માં દાખલ કરી રહ્યા છો, અમે જોયું છે કે અમે કરી શકે

251
00:21:33,010 --> 00:21:38,260
સરળતાથી કામચલાઉ એરે બનાવીને ઓવરને કંઈક ઉમેરવા માટે,

252
00:21:38,260 --> 00:21:42,850
અથવા જો અમે અમારા એરે મધ્યમાં માં કંઈક ઉમેરવા માગતા હતા,

253
00:21:42,850 --> 00:21:46,810
પછી તેને થોડી વધારે લઇ લો આસપાસ shuffling કરશે.

254
00:21:46,810 --> 00:21:50,240
જો તમે કરવા માંગો છો, ઉદાહરણ તરીકે, એક છટણી સંલગ્ન યાદી હોય છે,

255
00:21:50,240 --> 00:21:54,880
પછી તમે પ્રકારની હોય છે કે જે ખર્ચ અને લાભો તોલવું

256
00:21:54,880 --> 00:21:59,720
કારણ કે જો તમે છટણી એરે માંગો છો, કે જે દરેક સમય કે તમે તેને દાખલ થાય છે,

257
00:21:59,720 --> 00:22:01,630
તે થોડી વધારે સમય લાગી રહ્યું છે.

258
00:22:01,630 --> 00:22:05,500
જોકે, જો તમે પાછળથી માંગો છો, કારણ કે અમે મળશે અમે માંગો છો કરશે,

259
00:22:05,500 --> 00:22:10,280
એક કડી થયેલ યાદી મારફતે શોધ, પછી તેને સરળ હોઈ શકે જો તમને ખબર હોય કે બધું ક્રમમાં છે શકે છે.

260
00:22:10,280 --> 00:22:15,340
તેથી તમે જે ખર્ચ અને લાભો તોલવું શકો છો.

261
00:22:20,150 --> 00:22:27,740
>> બીજી યાદીની લિંક દાખલ રીત યાદી ખૂબ જ શરૂઆત દાખલ છે.

262
00:22:27,740 --> 00:22:34,700
જો અમે અમારી એન્કર અહીં દોરે - આ અમારા વડા છે -

263
00:22:34,700 --> 00:22:40,960
અને પછી આ લોકો તેને સાથે કડી થયેલ છે,

264
00:22:40,960 --> 00:22:48,460
અને પછી અમે એક નવી શરૂઆત દાખલ કરી નોડ છે,

265
00:22:48,460 --> 00:22:52,590
પછી આપણે શું કરવા માંગો છો શકે છે?

266
00:22:55,220 --> 00:23:03,580
શું માત્ર કહેતા હું વાદળી માટે લાલ લિંક કરવા માંગો છો ખોટું હશે,

267
00:23:03,580 --> 00:23:05,790
કારણ કે પ્રથમ એક છે?

268
00:23:05,790 --> 00:23:08,570
અહીં શું શું થશે?

269
00:23:08,570 --> 00:23:12,130
ત્રણ આ બધી ગુમાવી મેળવી શકે છે.

270
00:23:12,130 --> 00:23:14,140
તેથી અમે તે કરવા નહિં માંગો.

271
00:23:14,140 --> 00:23:21,430
ફરીથી, અમે શીખ્યા છે કે અમે કામચલાઉ નિર્દેશક કેટલાક પ્રકારની જરૂર પડે છે.

272
00:23:21,430 --> 00:23:34,470
માતાનો આ વ્યક્તિ માટે કામચલાઉ બિંદુ હોય પસંદ કરો દો.

273
00:23:34,470 --> 00:23:39,640
પછી અમે કામચલાઉ વાદળી એક બિંદુ હોય શકે છે

274
00:23:39,640 --> 00:23:43,240
અને પછી વાદળી માટે લાલ બિંદુ.

275
00:23:43,240 --> 00:23:47,830
આ કારણ હું લોકોને ઉપયોગ કરું છું, અહીં છે કારણ કે અમે ખરેખર જોવાનું માંગો છો

276
00:23:47,830 --> 00:23:53,180
લોકો પર હોલ્ડિંગ અને ખાતરી કરો કે અમે તેમને એક લિંક છે બનાવે છે

277
00:23:53,180 --> 00:23:57,590
પહેલાં અમે બીજા અથવા જેમ હાથ કંઈક ના જાઓ.

278
00:24:05,630 --> 00:24:10,650
>> હવે અમે સાથે લિંક યાદીઓ એક અર્થમાં છે - અમે કેવી રીતે સંકળાયેલી યાદી બનાવી શકે છે

279
00:24:10,650 --> 00:24:15,090
અને એક નોડ માટે પ્રકાર વ્યાખ્યા સમાવેશ થાય છે માટે માળખાં બનાવો

280
00:24:15,090 --> 00:24:19,060
અને પછી ખાતરી કરો કે અમે તે યાદીની લિંક વડા માટે નિર્દેશક હોય બનાવે છે -

281
00:24:19,060 --> 00:24:23,210
એકવાર અમે તે હોય છે અને અમે જાણીએ છીએ કે કેવી રીતે એરે મારફતે પસાર કરવા માટે,

282
00:24:23,210 --> 00:24:28,200
વિવિધ તત્વો ઍક્સેસ કરવા માટે, અમે જાણીએ છીએ કે કેવી રીતે દાખલ કરવા માટે અને અમે જાણીએ છીએ કે કેવી રીતે તેમને મુક્ત કરવા માટે,

283
00:24:28,200 --> 00:24:30,260
તો પછી અમે ખોટી જોડણી માં મેળવી શકો છો.

284
00:24:30,260 --> 00:24:38,150
હંમેશની જેમ, અમે પ્રશ્નો વિભાગ કે તમે સંલગ્ન યાદીઓ સાથે કરવામાં આવશે સંચાલન કરવા માટે વપરાય છે

285
00:24:38,150 --> 00:24:41,750
અને ક્યુને અને રન ટાઇમ સ્ટેકનું, જેમ કે અલગ માળખાં.

286
00:24:41,750 --> 00:24:46,000
તો પછી અમે ખોટી જોડણી માં ખસેડી શકો છો.

287
00:24:46,000 --> 00:24:55,170
>> ખોટી જોડણી વિતરણ કોડ માં મહત્વ ફાઈલોની દંપતી છે.

288
00:24:55,170 --> 00:24:58,850
પ્રથમ અમે નોંધ્યું છે કે અમે આ મેકફાઇલ Language અહીં હોય છે,

289
00:24:58,850 --> 00:25:03,040
જે અમે ખરેખર પહેલાં આવી છે.

290
00:25:03,040 --> 00:25:10,090
જો તમે pset5 ફોલ્ડર અંદર દેખાતા હતા, તમે નોટિસ છો કે તમે ક. ફાઈલ હોય છે,

291
00:25:10,090 --> 00:25:12,530
પછી તમે બે સી. ફાઈલો હોય.

292
00:25:12,530 --> 00:25:18,920
આ મેકફાઇલ Language કરે છે શું આ પહેલા, અમે માત્ર બનાવવા લખો અને પછી કાર્યક્રમ નામ

293
00:25:18,920 --> 00:25:25,550
અને પછી અમે આ દલીલો અને ફ્લેગ્સ તમામ કમ્પાઇલર માં પસાર હતો.

294
00:25:25,550 --> 00:25:30,580
આ મેકફાઇલ Language કરે છે શું અમને એક સાથે ઘણા ફાઈલો કમ્પાઈલ કરવા માટે પરવાનગી આપે છે

295
00:25:30,580 --> 00:25:34,650
અને ફ્લેગ્સ કે અમે માંગો છો પાસ.

296
00:25:34,650 --> 00:25:41,300
અહીં અમે ફક્ત જુઓ ત્યાં હેડર ફાઈલ અહીં છે.

297
00:25:41,300 --> 00:25:43,730
તો પછી અમે ખરેખર બે સ્રોત ફાઈલો હોય.

298
00:25:43,730 --> 00:25:47,520
અમે speller.c અને dictionary.c છે.

299
00:25:47,520 --> 00:25:54,560
તમે મેકફાઇલ Language સંપાદિત જો તમે ઈચ્છો છો સ્વાગત છે.

300
00:25:54,560 --> 00:26:03,310
અહીં નોટિસ જો તમે સ્વચ્છ લખો, પછી તે શું કરે છે ખરેખર કંઈપણ દૂર

301
00:26:03,310 --> 00:26:06,340
કે જે મૂળ છે.

302
00:26:06,340 --> 00:26:09,190
જો તમે સેગ્મેન્ટેશન ક્ષતિમાં મળ્યું છે, મૂળભૂત રીતે તમે કોર ડમ્પ મેળવવા.

303
00:26:09,190 --> 00:26:13,260
તેથી આ નીચ થોડું ફાઇલ તમારા કોર કહેવાય ડિરેક્ટરીમાં દેખાશે.

304
00:26:13,260 --> 00:26:16,310
તમે દૂર કરવા કે બનાવવા માટે તેને સાફ કરવા માંગો છો પડશે.

305
00:26:16,310 --> 00:26:20,940
તેને કોઈપણ exe ફાઈલો દૂર કરે છે અને ઓ ફાઈલો છે..

306
00:26:27,900 --> 00:26:30,220
>> ચાલો dictionary.h એક નજર નાખો.

307
00:26:30,220 --> 00:26:34,410
આ કહે છે કે તે એક શબ્દકોશ વિધેય જાહેર.

308
00:26:34,410 --> 00:26:39,530
અમે શબ્દકોશ કોઈપણ શબ્દ માટે મહત્તમ લંબાઈ ધરાવે છે.

309
00:26:39,530 --> 00:26:45,130
અમે કહે છે કે આ સૌથી લાંબો શક્ય શબ્દ રહ્યું છે. તે 45 લંબાઈ છે.

310
00:26:45,130 --> 00:26:48,900
તેથી અમે કોઈ પણ શબ્દો કે જે લંબાઈ કરતાં વધી નથી જઈ રહ્યાં છો.

311
00:26:48,900 --> 00:26:50,980
અહીં અમે ફક્ત કાર્ય પ્રોટોટાઇપ છે.

312
00:26:50,980 --> 00:26:55,290
અમે વાસ્તવિક અમલ નથી કારણ કે અમે શું આ pset માટે કરી આવશે નહિં.

313
00:26:55,290 --> 00:26:59,940
પરંતુ આ શું કરે છે છે કારણ કે અમે મોટી ફાઈલો સાથે વ્યવહાર કરી રહ્યા છો અહીં

314
00:26:59,940 --> 00:27:06,650
અને મોટા પાયા પર વિધેય, તે ઉપયોગી છે એક ક. ફાઈલ છે

315
00:27:06,650 --> 00:27:11,290
જેથી કોઈએ વાંચન અથવા મદદથી તમારો કોડ સમજી શકે શું થઈ રહ્યું છે.

316
00:27:11,290 --> 00:27:17,910
અને કદાચ તેઓ અમલ કરવા માંગો છો કરવાનો પ્રયત્ન કરે છે જો તમે હેશ કોષ્ટકો અથવા ઊલટું હતી.

317
00:27:17,910 --> 00:27:21,850
પછી તેઓ મારા લોડ કાર્ય કહેવું હો,

318
00:27:21,850 --> 00:27:26,950
વાસ્તવિક અમલીકરણ અલગ અલગ થઈ રહ્યું છે, પરંતુ આ પ્રોટોટાઇપ ફેરફાર કરશે નહીં.

319
00:27:26,950 --> 00:27:33,280
અહીં અમે તપાસ કરેલ છે, જે સાચા આપે છે જો આપેલ શબ્દ કોશ છે.

320
00:27:33,280 --> 00:27:39,800
તો પછી અમે ભાર છે, કે જે મૂળભૂત રીતે શબ્દકોશ ફાઈલ લે છે

321
00:27:39,800 --> 00:27:44,360
અને પછી તેને અમુક માહિતી માળખામાં લાવે છે.

322
00:27:44,360 --> 00:27:47,500
અમે કદ ધરાવે છે, જે જ્યારે કહેવાય છે, તમારા શબ્દકોશ માપ આપે છે,

323
00:27:47,500 --> 00:27:50,310
કેટલા શબ્દો છે તે સંગ્રહાયેલ છે,

324
00:27:50,310 --> 00:27:54,390
અને પછી અનલોડ છે, કે જે બધી મેમરીનો મુક્ત કરે છે કે જે તમે લેવામાં હોઈ શકે છે

325
00:27:54,390 --> 00:27:57,900
જ્યારે તમારી શબ્દકોશ બનાવે છે.

326
00:28:01,070 --> 00:28:03,590
>> ચાલો dictionary.c પર એક નજર.

327
00:28:03,590 --> 00:28:10,490
અમે જુઓ કે તે ખૂબ જ dictionary.h માટે સમાન તેને હવે ફક્ત તેને આ TODOs તમામ છે, અપવાદરૂપે જુએ છે.

328
00:28:10,490 --> 00:28:16,980
અને જેથી તમારી નોકરી છે. આખરે, તમે બહાર ભરવા પડશે આ કોડ તમામ speller.c.

329
00:28:16,980 --> 00:28:21,540
Dictionary.c, જ્યારે ચલાવો ત્યારે ખરેખર કશું નથી રહ્યું છે,

330
00:28:21,540 --> 00:28:29,590
તેથી અમે speller.c તરફ જોવાનું મંત્ર-પરીક્ષક ના વાસ્તવિક અમલ જુઓ.

331
00:28:29,590 --> 00:28:32,060
છતાં પણ તમે આ કોડ કોઇ સંપાદન કરી શકાતું નથી જઈ રહ્યાં છો,

332
00:28:32,060 --> 00:28:38,050
તે મહત્વપૂર્ણ છે, વાંચવા, સમજવા જ્યારે લોડ કહેવાય છે, જ્યારે હું ચેક ફોન કરું છું,

333
00:28:38,050 --> 00:28:42,350
માત્ર સમજવા માટે તે મેપ આઉટ, જુઓ કેવી રીતે કાર્ય કરે છે.

334
00:28:42,350 --> 00:28:49,860
અમે જુઓ કે તે યોગ્ય વપરાશ માટે ચકાસણી છે.

335
00:28:49,860 --> 00:28:55,200
આવશ્યકપણે, જ્યારે કોઈ સ્પેલર ચાલે છે, આ સૂચવે છે કે તે વૈકલ્પિક છે

336
00:28:55,200 --> 00:29:00,950
માટે તેમને શબ્દકોશ ફાઈલ પાસ કરવા માટે કારણ કે ત્યાં એક મૂળભૂત શબ્દકોશ ફાઈલ જ હશે.

337
00:29:00,950 --> 00:29:05,410
અને પછી તેઓ લખાણમાં પસાર કરવા માટે પ્રયત્ન જોડણી-ચકાસાયેલ હોય છે.

338
00:29:05,410 --> 00:29:11,410
સમય સાથે rusage સોદા કારણ કે આ pset એક ભાગ છે જેને આપણે સાથે પછીથી વ્યવહાર પડશે

339
00:29:11,410 --> 00:29:14,790
નથી માત્ર કામગીરી જોડણી-પરીક્ષક કામ મળતું

340
00:29:14,790 --> 00:29:17,190
પરંતુ ખરેખર તે ઝડપી થઈ રહ્યો.

341
00:29:17,190 --> 00:29:22,040
અને તેથી તે પછી કે જ્યાં rusage સાઇન આવી રહ્યું છે

342
00:29:22,040 --> 00:29:28,740
અહીં, અમે અમારા એક dictionary.c ફાઈલો માટે પ્રથમ કોલ જુઓ, કે જે ભાર છે.

343
00:29:28,740 --> 00:29:34,720
સફળતા પર ખરું છે, નિષ્ફળતા પર ખોટા - ભાર સાચું કે ખોટું આપે છે.

344
00:29:34,720 --> 00:29:41,400
તેથી જો શબ્દકોશ યોગ્ય રીતે લોડ થયેલ નહિં હોય, તો પછી speller.c 1 પાછા આવો અને બહાર નીકળવા આવશે.

345
00:29:41,400 --> 00:29:47,920
પરંતુ જો તે લોડ યોગ્ય રીતે કરે છે, પછી તે ચાલુ રાખવા માટે ચાલી રહ્યું છે.

346
00:29:47,920 --> 00:29:50,740
અમે ચાલુ રાખવા માટે, અને અમે અમુક ફાઈલ I / O અહીં જુઓ,

347
00:29:50,740 --> 00:29:56,210
જ્યાં તે લખાણ ફાઈલ ખોલવા સાથે વ્યવહાર કરવામાં બનશે.

348
00:29:56,210 --> 00:30:04,640
અહીં, આ કરે છે શું છે ટેક્સ્ટની દરેક એક શબ્દ જોડણી-ચકાસે છે.

349
00:30:04,640 --> 00:30:09,270
તેથી speller.c શું અહીં કરી છે ઉપર વારો છે લખાણ ફાઈલ શબ્દોના દરેક

350
00:30:09,270 --> 00:30:12,790
અને પછી તેમને શબ્દકોશ ચકાસણી.

351
00:30:24,680 --> 00:30:32,350
અહીં, અમે ખોટીજોડણીવાળું કે જો ચેક સાચી નથી અથવા આપે જોશો બુલિયન છે.

352
00:30:32,350 --> 00:30:37,110
જો શબ્દ કોશ માં ખરેખર હોય, તો પછી ચેક સાચું આપશે.

353
00:30:37,110 --> 00:30:39,760
તેનો અર્થ એ છે કે જે શબ્દ નથી ખોટીજોડણીવાળું છે.

354
00:30:39,760 --> 00:30:45,330
તેથી ખોટીજોડણીવાળું ખોટા હોય છે, અને થશે કે કેમ અમે બેંગ ત્યાં હોય છે, જે સૂચન.

355
00:30:45,330 --> 00:30:56,320
અમે જઈને પર રાખવા, અને પછી તેને કેટલા શબ્દો ખોટીજોડણીવાળું પર નજર રાખે છે

356
00:30:56,320 --> 00:30:58,910
ત્યાં ફાઈલ છે.

357
00:30:58,910 --> 00:31:03,870
તેના પર ચાલુ રહે છે અને ફાઈલ બંધ કરે છે.

358
00:31:03,870 --> 00:31:09,250
પછી અહીં, તે અહેવાલ કેટલી ખોટીજોડણીવાળું શબ્દો તમે હતું.

359
00:31:09,250 --> 00:31:12,680
તે ગણતરી કેટલો સમય તે શબ્દકોશ લોડ લીધો,

360
00:31:12,680 --> 00:31:15,080
કેટલો સમય તે તેની તપાસ કરી લીધો,

361
00:31:15,080 --> 00:31:18,510
ખૂબ સમય તે કદ ગણતરી લીધો કેવી રીતે,

362
00:31:18,510 --> 00:31:21,260
, જેમાં અમે જઈશ, ખૂબ નાના હોવા જોઈએ,

363
00:31:21,260 --> 00:31:25,390
અને પછી કેટલો સમય તે શબ્દકોશ અનલોડ લીધો હતો.

364
00:31:25,390 --> 00:31:27,700
અહીં અપ ઉપર અમે અહીં અનલોડ કોલ જુઓ.

365
00:31:27,700 --> 00:31:52,690
જો અમે કદ માટે અહીં તપાસો,

366
00:31:52,690 --> 00:31:59,050
તો પછી અમે જુઓ કે અહીં માપ કોલ જ્યાં તે શબ્દકોશ માપ નક્કી કરે છે.

367
00:32:05,730 --> 00:32:07,100
ઓસમ.

368
00:32:07,100 --> 00:32:10,920
>> આ pset માટે અમારા કાર્ય પર ભાર છે, કે જે શબ્દકોશ લોડ અમલમાં છે

369
00:32:10,920 --> 00:32:15,480
માહિતી બંધારણ - બેમાંથી જે તમે પસંદ કરો છો, તો તે હેશ ટેબલ હોઈ શકે છે અથવા એક પ્રયાસ -

370
00:32:15,480 --> 00:32:18,810
શબ્દકોષમાં ફાઇલ માંથી શબ્દો સાથે.

371
00:32:18,810 --> 00:32:25,290
પછી તમે માપ છે, કે જે શબ્દકોશ શબ્દો સંખ્યા પરત કરશે.

372
00:32:25,290 --> 00:32:29,860
અને જો તમે એક સ્માર્ટ રીતે લોડ અમલમાં મૂકવા માટે, તે પછી કદ ખૂબ જ સરળ છે.

373
00:32:29,860 --> 00:32:33,860
પછી તમે તપાસ કરેલ છે, કે જે જો આપેલ શબ્દ કોશ છે તપાસ કરશે.

374
00:32:33,860 --> 00:32:38,690
તેથી speller.c શબ્દમાળા પસાર થાય છે, અને પછી તમે કે જેઓ શબ્દમાળા તપાસો

375
00:32:38,690 --> 00:32:41,610
તમારું શબ્દકોશ અંદર સમાયેલ છે.

376
00:32:41,610 --> 00:32:46,750
નોંધ કરો કે અમે સામાન્ય રીતે ધોરણ શબ્દકોશો હોય છે,

377
00:32:46,750 --> 00:32:53,020
પરંતુ આ pset માં, મૂળભૂત રીતે કોઈ પણ શબ્દકોશ કોઈપણ ભાષામાં પસાર થયો.

378
00:32:53,020 --> 00:32:57,040
તેથી અમે માત્ર કે આ શબ્દ અંદર નથી ધારણ કરી શકે છે.

379
00:32:57,040 --> 00:33:03,090
આ શબ્દ FOOBAR ચોક્કસ શબ્દકોશ નિર્ધારિત કરી શકે છે કે અમે સાઇન પસાર

380
00:33:03,090 --> 00:33:07,920
અને પછી અમે અનલોડ કરેલ છે, કે જે મેમરી ના શબ્દકોશ મુક્ત કરે છે.

381
00:33:07,920 --> 00:33:11,930
>> પ્રથમ, હું ઉપર હેશ ટેબલ પદ્ધતિ જવા માગો છો

382
00:33:11,930 --> 00:33:14,630
અમે કેવી રીતે તે ચાર બધા વિધેયોને અમલ થઇ શકે તે વિશે,

383
00:33:14,630 --> 00:33:18,650
અને પછી હું પર જાઓ પદ્ધતિ પ્રયત્ન કરે છે, અમે કેવી રીતે કરશો તે ચાર કાર્યો અમલમાં મૂકવા માટે,

384
00:33:18,650 --> 00:33:22,720
અને અમુક સામાન્ય ટીપ્સ વિશે ઓવરને અંતે ચર્ચા જ્યારે તમે pset કરી રહ્યા છીએ

385
00:33:22,720 --> 00:33:27,870
અને પણ તમે કેવી રીતે ઉપયોગ કરવા માટે સક્ષમ હોઇ શકે છે માટે મેમરી લીક્સ માટે તપાસો Valgrind.

386
00:33:27,870 --> 00:33:30,550
>> ચાલો હેશ ટેબલ પદ્ધતિ માં મેળવો.

387
00:33:30,550 --> 00:33:35,910
એક હેશ ટેબલ buckets યાદી સમાવે છે.

388
00:33:35,910 --> 00:33:43,010
દરેક કિંમત, દરેક શબ્દ માટે એક આ buckets ઓફ જાય રહ્યું છે.

389
00:33:43,010 --> 00:33:53,200
એક હેશ ટેબલ આદર્શ સમાનરૂપે આ કિંમતો તમામ વહેંચણી કે તમે પસાર કરી રહ્યાં છે

390
00:33:53,200 --> 00:33:57,160
અને પછી તેમને જેમ કે ડોલમાં રચે દરેક બાલદી

391
00:33:57,160 --> 00:34:02,000
તેને એક કિંમતો સમાન નંબર વિશે છે.

392
00:34:02,000 --> 00:34:09,630
હેશ કોષ્ટક માટે આ માળખું, અમે કડી થયેલ યાદીઓ ઝાકઝમાળ છે.

393
00:34:09,630 --> 00:34:17,900
અમે શું છે જ્યારે અમે કિંમત પાસ, અમે તપાસ જ્યાં કિંમત સંબંધ જોઈએ,

394
00:34:17,900 --> 00:34:23,840
બાલદી જે તે અનુલક્ષે છે, અને પછી તે લિંક્ડ કે બકેટ સાથે સંકળાયેલ યાદી માં મૂકો.

395
00:34:23,840 --> 00:34:28,199
અહીં, હું શું છે હેશ વિધેય છે.

396
00:34:28,199 --> 00:34:31,320
તે પૂર્ણાંક હેશ ટેબલ છે.

397
00:34:31,320 --> 00:34:38,540
જેથી પ્રથમ બકેટ માટે, 10 નીચે કોઇપણ પૂર્ણાંકો પ્રથમ ડોલ માં જાઓ.

398
00:34:38,540 --> 00:34:42,190
10 ઉપર કોઈપણ પૂર્ણાંકો પરંતુ નીચે બીજા માં 20 હોવ,

399
00:34:42,190 --> 00:34:44,179
અને પછી એમ જ છે અને તેથી આગળ.

400
00:34:44,179 --> 00:34:52,370
મારા માટે, દરેક ડોલ આ નંબરો પ્રતિનિધિત્વ કરે છે.

401
00:34:52,370 --> 00:34:59,850
જોકે કહેવું, હું 50, ઉદાહરણ તરીકે પસાર હતા.

402
00:34:59,850 --> 00:35:07,490
એવું દેખાય છે જો તરીકે પ્રથમ ત્રણ દસ નંબરો વિસ્તાર ધરાવે છે.

403
00:35:07,490 --> 00:35:12,570
પરંતુ હું મારા હેશ ટેબલ પૂર્ણાંકો કોઇ પણ પ્રકારની માં લેવા માટે પરવાનગી આપવા માંગો છો,

404
00:35:12,570 --> 00:35:19,860
જેથી તે પછી હું બહાર છેલ્લા ડોલ માં 30 ઉપર બધી સંખ્યાઓ ફિલ્ટર હશે.

405
00:35:19,860 --> 00:35:26,660
અને તેથી પછી તે અસંતુલિત હેશ કોષ્ટક એક પ્રકારનું પરિણમી.

406
00:35:31,330 --> 00:35:35,640
પુનરુક્તિ કરવી કરવા માટે, હેશ ટેબલ માત્ર buckets ઝાકઝમાળ છે

407
00:35:35,640 --> 00:35:38,590
દરેક બકેટ સંકળાયેલી યાદી છે કે જ્યાં.

408
00:35:38,590 --> 00:35:43,730
અને તેથી જ્યાં દરેક કિંમત જાય તે નક્કી કરવા માટે, બાલદી કે જે તેને જાય,

409
00:35:43,730 --> 00:35:46,260
તમે કરવા માંગો છો શું હેશ વિધેય કહેવાય છે જઈ રહ્યાં છો

410
00:35:46,260 --> 00:35:55,010
કે જે કિંમત લે છે અને પછી કહે છે કે આ કિંમત ચોક્કસ બકેટ અનુલક્ષે છે.

411
00:35:55,010 --> 00:36:00,970
તેથી આ ઉદાહરણમાં ઉપર, મારા હેશ વિધેય દરેક કિંમત લીધો હતો.

412
00:36:00,970 --> 00:36:03,020
તે ચકાસાયેલ છે કે શું તેને 10 કરતાં ઓછી હતી.

413
00:36:03,020 --> 00:36:05,360
જો તે હતી, તેને પ્રથમ બાલદી મૂકવામાં આવશે.

414
00:36:05,360 --> 00:36:08,910
તે ચકાસે છે કે શું તે 20 કરતા પણ ઓછી છે, તે બીજી માં મૂકે સાચું જો,

415
00:36:08,910 --> 00:36:12,880
તપાસમાં જો તે 30 કરતાં ઓછી, અને પછી છે તે તૃતીય ડોલ માં મૂકે છે,

416
00:36:12,880 --> 00:36:16,990
અને પછી બધું માત્ર ચોથા બાલદી પર પડે છે.

417
00:36:16,990 --> 00:36:20,110
તેથી જ્યારે પણ તમે એક મૂલ્ય છે, તમારા હેશ વિધેય

418
00:36:20,110 --> 00:36:25,420
યોગ્ય ડોલ માં તે કિંમત મૂકશે.

419
00:36:25,420 --> 00:36:32,430
હેશ વિધેય મૂળભૂત જાણવા કેટલા buckets તમારી પાસે જરૂર છે.

420
00:36:32,430 --> 00:36:37,960
તમારા હેશ ટેબલ કદ, buckets તમારી પાસે સંખ્યા,

421
00:36:37,960 --> 00:36:41,190
કે જે નિશ્ચિત નંબર છે કે જે તમારા પર છે, માટે તમારે એ નક્કી કરવા માટે જ હશે,

422
00:36:41,190 --> 00:36:43,590
પરંતુ તે માટે ચોક્કસ નંબર જ હશે.

423
00:36:43,590 --> 00:36:51,840
તમારા હેશ વિધેય કે જેથી તે નક્કી કરવા માટે પર આધાર આવશે બકેટ જે દરેક કી જાય

424
00:36:51,840 --> 00:36:54,450
જેમ કે તે સમાનરૂપે વિતરિત છે.

425
00:36:56,150 --> 00:37:03,820
કડી થયેલ યાદીઓ અમારી અમલીકરણ, હવે હેશ કોષ્ટક દરેક નોડ માટે સમાન

426
00:37:03,820 --> 00:37:07,000
છે ખરેખર એક પ્રકાર ઘરનાં પરચૂરણ કામો હોય જવાનું.

427
00:37:07,000 --> 00:37:14,340
તેથી અમે ઘરનાં પરચૂરણ કામો શબ્દ કહેવાય એરે અને પછી બીજા ગાંઠ બીજા નિર્દેશક હોય છે,

428
00:37:14,340 --> 00:37:19,010
અર્થમાં બનાવે છે કારણ કે તે એક કડી થયેલ યાદી જ હશે જે.

429
00:37:19,010 --> 00:37:24,350
યાદ રાખો જ્યારે અમે યાદીઓ કડી થયેલ હતી, હું એક નોડ વડા કહેવાય * બનાવવામાં

430
00:37:24,350 --> 00:37:31,060
કે કડી થયેલ યાદીમાં પ્રથમ નોડ માટે પોઇન્ટ આવ્યો હતો.

431
00:37:31,060 --> 00:37:34,020
પરંતુ અમારા હેશ કોષ્ટક માટે, કારણ કે અમે બહુવિધ કડી થયેલ યાદીઓ હોય છે,

432
00:37:34,020 --> 00:37:37,520
આપણે ઇચ્છીએ શું છે અમે અમારા હેશ કોષ્ટક, જેમ માંગો છો "શું બકેટ છે?"

433
00:37:37,520 --> 00:37:43,340
એક ડોલ માત્ર નોડ પોઇંટરો યાદી છે,

434
00:37:43,340 --> 00:37:50,620
અને તેથી ડોલમાં દરેક તત્વ ખરેખર તેના અનુરૂપ કડી થયેલ યાદી તરફ ઇશારો કરે છે.

435
00:37:56,180 --> 00:38:01,520
આ યોજનાકીય પર પાછા જાઓ, તમે જુઓ કે પોતાને buckets આ તીર છે,

436
00:38:01,520 --> 00:38:06,980
ગાંઠો નથી વાસ્તવિક.

437
00:38:11,680 --> 00:38:16,420
એક જટિલ કાર્ય જરૂરી મિલકત છે કે તેઓ નિર્ધારિત છો.

438
00:38:16,420 --> 00:38:19,440
કે કે જ્યારેપણ હેશ તમે 2 નંબર, એનો અર્થ એ થાય

439
00:38:19,440 --> 00:38:22,270
તે હંમેશા એક જ બકેટ પરત કરીશું.

440
00:38:22,270 --> 00:38:26,440
દરેક એક કિંમત છે કે જે હેશ વિધેય જાય, જો વારંવાર,

441
00:38:26,440 --> 00:38:29,690
એ જ અનુક્રમણિકા વિચાર ધરાવે છે.

442
00:38:29,690 --> 00:38:34,210
તેથી તમારા હેશ વિધેય એરે ની અનુક્રમણિકા આપે છે

443
00:38:34,210 --> 00:38:38,530
જ્યાં તે કિંમત અનુસરે છે.

444
00:38:38,530 --> 00:38:41,790
હું પહેલા ઉલ્લેખ થયો છે, buckets સંખ્યા સુધારેલ છે,

445
00:38:41,790 --> 00:38:49,630
અને તેથી તમારા ઇન્ડેક્સ છે કે જે તમને પાછા buckets સંખ્યા કરતા ઓછી હોવી ધરાવે છે

446
00:38:49,630 --> 00:38:52,680
પરંતુ 0 કરતાં મોટો.

447
00:38:52,680 --> 00:39:00,780
કારણ શા માટે આપણે માત્ર એક જ કડી થયેલ યાદી ને બદલે હેશ કાર્યો કરતા હોય છે

448
00:39:00,780 --> 00:39:09,290
અથવા એક વ્યૂહરચના છે કે અમે ચોક્કસ વિભાગમાં કૂદી કરવાનો સૌથી સરળતાથી પ્રયત્ન કરવા માંગો છો

449
00:39:09,290 --> 00:39:11,720
જો અમે કિંમત લાક્ષણિકતા ખબર -

450
00:39:11,720 --> 00:39:14,760
તેના બદલે સમગ્ર સમગ્ર શબ્દકોશ મારફતે શોધવા કર્યા છે,

451
00:39:14,760 --> 00:39:18,320
તે એક ચોક્કસ વિભાગમાં કૂદી કરવાનો છે.

452
00:39:19,880 --> 00:39:24,440
તમારા હેશ વિધેય એકાઉન્ટમાં કે આદર્શ રીતે લેવી જોઇએ,

453
00:39:24,440 --> 00:39:28,980
દરેક બકેટ આશરે કીઓ એક જ નંબર છે.

454
00:39:28,980 --> 00:39:35,040
કારણ કે હેશ કોષ્ટક સાથે લિંક યાદીઓ શ્રેણી છે,

455
00:39:35,040 --> 00:39:38,480
પછી કડી થયેલ પોતાને યાદીઓ એક કરતાં વધુ નોડ હોય જતાં હોય છે.

456
00:39:38,480 --> 00:39:43,210
પહેલાંના ઉદાહરણમાં, બે અલગ અલગ નંબરો, તેમ છતાં તેઓ ન હતા,

457
00:39:43,210 --> 00:39:46,950
જ્યારે hashed, એ જ અનુક્રમણિકા પરત ફરશે.

458
00:39:46,950 --> 00:39:53,620
તેથી જ્યારે તમે શબ્દો સાથે વ્યવહાર કરવામાં આવે છે, એક શબ્દ જ્યારે hashed

459
00:39:53,620 --> 00:39:57,450
અન્ય શબ્દ જેવા જ હેશ કિંમત હશે.

460
00:39:57,450 --> 00:40:04,140
કે અમે શું ટક્કર કૉલ, જ્યારે અમે નોડ કે જે, જ્યારે hashed હોય છે,

461
00:40:04,140 --> 00:40:09,610
કે બાલદી પર કડી થયેલ યાદી ખાલી નથી.

462
00:40:09,610 --> 00:40:14,180
આ ટેકનિક કે અમે ત્યાં કૉલ રેખીય છે પ્રોબીંગ,

463
00:40:14,180 --> 00:40:22,550
તમે જ્યાં યાદીની લિંક જાય અને પછી શોધી કે જ્યાં તમે કે નોડ સામેલ કરવા માંગો છો

464
00:40:22,550 --> 00:40:25,520
કારણ કે તમે એક ટક્કર છે.

465
00:40:25,520 --> 00:40:28,070
તમે જોઈ શકો છો કે ત્યાં વેપાર બોલ અહીં, શકે અધિકાર?

466
00:40:28,070 --> 00:40:33,760
જો તમે ખૂબ નાની હેશ ટેબલ, buckets એક અત્યંત નાના નંબર છે,

467
00:40:33,760 --> 00:40:36,380
તો પછી તમારે અથડામણમાં ઘણો હોય રહ્યા છીએ.

468
00:40:36,380 --> 00:40:40,460
પરંતુ પછી જો તમે એક ખૂબ મોટા હેશ કોષ્ટક બનાવવા માટે,

469
00:40:40,460 --> 00:40:44,110
તમે કદાચ અકસ્માતથી ઘટાડવા જઈ રહ્યાં છો,

470
00:40:44,110 --> 00:40:47,170
પરંતુ તે ખૂબ મોટી માહિતી માળખું જ હશે.

471
00:40:47,170 --> 00:40:49,310
ત્યાં સાથે વેપાર ન જ હશે.

472
00:40:49,310 --> 00:40:51,310
તેથી જ્યારે તમે તમારા pset કરી રહ્યા છીએ, માટે આસપાસ રમી પ્રયાસ

473
00:40:51,310 --> 00:40:54,210
કદાચ નાના હેશ ટેબલ બનાવે વચ્ચે

474
00:40:54,210 --> 00:41:02,100
પરંતુ તે પછી એ જાણીને કે તે થોડોક લાંબો સમય લાગી જુદા જુદા તત્વો પસાર થઈ રહ્યું છે તે

475
00:41:02,100 --> 00:41:04,270
તે સંલગ્ન યાદીઓની.

476
00:41:04,270 --> 00:41:09,500
>> લોડ શું કરવા જઇ છે શબ્દકોશમાં શબ્દ દરેક ઉપર ફરી વળવું.

477
00:41:09,500 --> 00:41:13,180
તે શબ્દકોશ ફાઈલ માટે પોઇન્ટર પસાર કરે છે.

478
00:41:13,180 --> 00:41:18,050
તેથી તમારે ફાઈલની લાભ લેવા I / O વિધેયો કે જે તમે pset4 માં mastered જઈ રહ્યાં છો

479
00:41:18,050 --> 00:41:23,010
અને ઉપર શબ્દકોશ દરેક શબ્દ ફરી વળવું.

480
00:41:23,010 --> 00:41:26,620
તમે શબ્દકોશમાં દરેક શબ્દ માટે એક નવી નોડ બનવા માગો છો,

481
00:41:26,620 --> 00:41:32,730
અને તમે તમારા શબ્દકોશ માહિતી માળખાની અંદર તે ગાંઠો દરેક એક મૂકી રહ્યા છીએ.

482
00:41:32,730 --> 00:41:36,560
જ્યારે પણ તમે એક નવો શબ્દ મેળવવા માટે, તમે જાણો છો કે તે સ્થળ બની રહ્યું છે.

483
00:41:36,560 --> 00:41:46,590
તેથી તમે straightaway જાઓ અને malloc કરી શકો છો દરેક નવો શબ્દ કે તમારી પાસે એક નોડ નિર્દેશક.

484
00:41:46,590 --> 00:41:52,610
અહીં હું મારા નોડ નિર્દેશક new_node કૉલ છું અને હું શું mallocing છું? નોડ માપ.

485
00:41:52,610 --> 00:41:59,190
પછી ફાઈલ ના વાસ્તવિક શબ્દમાળા વાંચવા માટે છે, કારણ કે શબ્દકોશ ખરેખર સંગ્રહાયેલ છે

486
00:41:59,190 --> 00:42:03,340
એક શબ્દ અને તે પછી એક નવી લીટી, અમે શું લાભ ના લઇ શકો છો દ્વારા

487
00:42:03,340 --> 00:42:06,520
કાર્ય fscanf છે,

488
00:42:06,520 --> 00:42:10,280
ફાઇલ શબ્દકોશ ફાઈલ જેમાં એ છે કે આપણે પસાર કરી રહ્યાં છો,

489
00:42:10,280 --> 00:42:18,900
તેથી તે શબ્દમાળા માટે ફાઈલ સ્કેન કરે છે અને છેલ્લા દલીલ માં શબ્દમાળા કે મૂકે છે.

490
00:42:18,900 --> 00:42:26,890
જો તમે વ્યાખ્યાન એક, જ્યારે અમે ઉપર ગયા પાછા યાદ

491
00:42:26,890 --> 00:42:29,320
અને આ પ્રકારના સ્તરો પાછા peeled આ CS50 પુસ્તકાલય પર,

492
00:42:29,320 --> 00:42:33,430
અમે fscanf એક અમલીકરણ ત્યાં થયો હતો.

493
00:42:33,430 --> 00:42:37,700
માટે fscanf પાછળ જવા માટે, અમે ફાઈલ કે અમે માંથી વાંચવા રહ્યાં છો છે,

494
00:42:37,700 --> 00:42:42,570
અમે તે ફાઈલમાં શબ્દમાળા માટે શોધી રહ્યા છો, અને પછી અમે તેને માં મૂકીને કરી રહ્યાં છો

495
00:42:42,570 --> 00:42:48,340
અહીં હું new_node-> શબ્દ છે કારણ કે new_node નોડ નિર્દેશક છે,

496
00:42:48,340 --> 00:42:50,380
વાસ્તવિક નથી નોડ એક.

497
00:42:50,380 --> 00:42:57,100
તેથી પછી હું new_node કહી રહ્યો છું, હું નોડ પર જાઓ કે તે પોઇન્ટ છે કરવા માંગો છો

498
00:42:57,100 --> 00:43:01,190
અને પછી શબ્દ કે કિંમત સોંપી.

499
00:43:01,190 --> 00:43:08,540
અમે પછી તે શબ્દ ભરે છે અને તેને હેશ કોષ્ટક દાખલ કરવા માંગો છો.

500
00:43:08,540 --> 00:43:13,750
સમજો કે અમે નોડ નિર્દેશક new_node બનાવવામાં

501
00:43:13,750 --> 00:43:18,230
કારણ કે અમે ખબર પડી કે નોડને સરનામા શું છે કરવા માંગો છો જઈ રહ્યાં છો

502
00:43:18,230 --> 00:43:23,940
જ્યારે અમે તેને કારણે પોતે ગાંઠો ની સ્ટ્રક્ટ છે, માળખું માં સામેલ

503
00:43:23,940 --> 00:43:26,380
એ છે કે તેઓ એક નવી નોડ માટે નિર્દેશક હોય છે.

504
00:43:26,380 --> 00:43:30,820
પછી કે જેથી માટે નિર્દેશ જઈને નોડને સરનામા શું છે?

505
00:43:30,820 --> 00:43:34,550
સરનામા કે new_node પ્રયત્ન રહ્યું છે.

506
00:43:34,550 --> 00:43:42,140
એ નથી કે અર્થમાં બનાવવા માટે, અમે એક નોડ * new_node તરીકે નોડ વિરોધ શા માટે કરી રહ્યા છીએ?

507
00:43:43,700 --> 00:43:45,700
ઠીક છે.

508
00:43:45,700 --> 00:43:52,840
અમે એક શબ્દ છે. કિંમત છે કે જે new_node-> શબ્દ છે.

509
00:43:52,840 --> 00:43:55,970
કે શબ્દકોશ પરથી શબ્દ કે અમે ઇનપુટ કરવા માંગો છો સમાવે છે.

510
00:43:55,970 --> 00:44:00,210
તેથી અમે કરવા માંગો છો શું છે અમે તે શબ્દમાળા પર અમારા હેશ વિધેય કૉલ કરવા માંગો છો

511
00:44:00,210 --> 00:44:03,780
કારણ કે અમારી હેશ વિધેય શબ્દમાળા લે અને પછી અમને પૂર્ણાંક આપે,

512
00:44:03,780 --> 00:44:12,090
જ્યાં કે પૂર્ણાંક ઇન્ડેક્સ જ્યાં કે અનુક્રમણિકા પર hashtable કે બકેટ પ્રતિનિધિત્વ કરે છે.

513
00:44:12,090 --> 00:44:18,260
અમે તે ઇન્ડેક્સ લેવા માંગો છો અને પછી હેશ ટેબલ કે ઇન્ડેક્સ પર જાઓ

514
00:44:18,260 --> 00:44:26,960
અને પછી તે યાદીની લિંક વાપરવા માટે new_node ખાતે નોડ દાખલ કરો.

515
00:44:26,960 --> 00:44:31,950
યાદ રાખો કે જો કે તમે તમારા નોડ દાખલ નિર્ણય

516
00:44:31,950 --> 00:44:34,370
શું તે મધ્યમાં છે જો તમે તેને સૉર્ટ કરવા માંગો છો

517
00:44:34,370 --> 00:44:39,650
અથવા શરૂઆતમાં અથવા ઓવરને અંતે, માત્ર ખાતરી કરો કે તમારા છેલ્લા નોડ હંમેશા નલ નિર્દેશ કરો

518
00:44:39,650 --> 00:44:46,730
કે માત્ર એ જ રીતે જે રીતે આપણે જાણીએ છીએ કે જ્યાં અમારી યાદીની લિંક ના છેલ્લા તત્વ છે એટલા માટે છે કે.

519
00:44:50,790 --> 00:44:59,710
>> જો માપ પૂર્ણાંક છે કે જે શબ્દકોશ શબ્દો સંખ્યા પ્રતિનિધિત્વ કરે છે,

520
00:44:59,710 --> 00:45:03,060
પછી એક આ કરવા માટે માર્ગ જ્યારે માપ કહેવાય છે કે

521
00:45:03,060 --> 00:45:05,840
અમે અમારા હેશ કોષ્ટક દરેક તત્વ મારફતે જાઓ

522
00:45:05,840 --> 00:45:09,410
અને પછી હેશ કોષ્ટકમાં દરેક કડી થયેલ યાદી મારફતે ફરી વળવું

523
00:45:09,410 --> 00:45:13,770
અને પછી તે લંબાઈ ગણતરી 1 કરીને અમારી કાઉન્ટર 1 વધી જાય છે.

524
00:45:13,770 --> 00:45:16,580
પરંતુ દર વખતે તે માપ કહેવાય છે, કે જે લાંબા સમય લાગી રહ્યું છે

525
00:45:16,580 --> 00:45:22,120
કારણ કે અમે linearly પ્રયત્ન દરેક એક કડી થયેલ યાદી ચકાસણી રહ્યા છીએ.

526
00:45:22,120 --> 00:45:30,530
તેના બદલે, તે ખૂબ સરળ હશે જો તમે ટ્રેક રાખવા કેટલા શબ્દો સાઇન પસાર થાય છે

527
00:45:30,530 --> 00:45:36,330
તેથી જો તમે તમારું લોડ કાર્ય અંદર એક કાઉન્ટર સમાવેશ થાય છે

528
00:45:36,330 --> 00:45:42,430
કે જરૂરી સુધારાઓ, પછી કાઉન્ટર, જો તમે તેને વૈશ્વિક ચલ સુયોજિત,

529
00:45:42,430 --> 00:45:44,930
કદ દ્વારા ઍક્સેસ કરી કરવાનો પ્રયત્ન કરશે.

530
00:45:44,930 --> 00:45:51,450
તેથી કદ શું ખાલી કરી શકે એક વાક્ય છે, ફક્ત કાઉન્ટર કિંમત પાછી,

531
00:45:51,450 --> 00:45:55,500
શબ્દકોષમાં માપ છે, કે જે તમે પહેલાથી જ ભાર સાથે કર્યો છે.

532
00:45:55,500 --> 00:46:05,190
કે હું શું જ્યારે હું જણાવ્યું હતું કે અર્થ થાય છે જો તમે મદદરૂપ રીતે લોડ અમલમાં મૂકવા માટે,

533
00:46:05,190 --> 00:46:08,540
પછી માપ ખૂબ જ સરળ છે રહ્યું છે.

534
00:46:08,540 --> 00:46:11,350
>> તેથી હવે અમે તપાસ મેળવો.

535
00:46:11,350 --> 00:46:15,960
હવે અમે શબ્દો સાથે ઇનપુટ ટેક્સ્ટ ફાઇલ માંથી વ્યવહાર કરી રહ્યાં છો,

536
00:46:15,960 --> 00:46:19,910
અને તેથી અમે તે ઇનપુટ શબ્દો છે કે શું બધા ચકાસણી કરી રહ્યા છીએ

537
00:46:19,910 --> 00:46:22,520
શબ્દકોશમાં નથી અથવા ખરેખર છે.

538
00:46:22,520 --> 00:46:26,520
ભાંખોડિયાંભર થઈને જેમ, અમે કેસ સંવેદનશૂન્યતાની માટે પરવાનગી આપવા માંગો છો.

539
00:46:26,520 --> 00:46:32,110
તમે ખાતરી કરો કે બધા જ શબ્દો માં પસાર બનાવવા માંગો છો, તેમ છતાં તેઓ મિશ્ર કેસ કરશો,

540
00:46:32,110 --> 00:46:37,840
જ્યારે શબ્દમાળા સરખાવો સાથે કહે છે, સમાન છે.

541
00:46:37,840 --> 00:46:42,450
શબ્દકોષમાં લખાણ ફાઇલોમાં શબ્દો ખરેખર તમામ લોઅરકેસ છે.

542
00:46:42,450 --> 00:46:49,280
અન્ય બાબત એ છે કે તમે ધારણ કરી શકે છે કે જે દરેક શબ્દ છે, દરેક શબ્દમાળા પસાર કર્યો હતો,

543
00:46:49,280 --> 00:46:53,200
છે ક્યાં મૂળાક્ષર અથવા apostrophes સમાવે હશે.

544
00:46:53,200 --> 00:46:58,010
Apostrophes અમારા શબ્દકોશ માન્ય શબ્દો હશે આવે છે.

545
00:46:58,010 --> 00:47:06,470
તેથી જો તમે એપોસ્ટ્રોફી S સાથે એક શબ્દ છે, કે જે તમારી શબ્દકોશ ખરેખર કાયદેસરની શબ્દ છે

546
00:47:06,470 --> 00:47:11,650
કે જે એક તમારી હેશ કોષ્ટકમાં ગાંઠો જ હશે.

547
00:47:13,470 --> 00:47:18,350
જો શબ્દ અસ્તિત્વમાં ચલાવે તપાસો, પછી તે અમારી હેશ કોષ્ટક હોવું મળ્યું છે.

548
00:47:18,350 --> 00:47:22,210
જો શબ્દ કોશ હોય, તો પછી શબ્દકોશમાં બધા જ શબ્દો હેશ કોષ્ટક હોય છે,

549
00:47:22,210 --> 00:47:26,560
તેથી આપણે હેશ કોષ્ટક આ શબ્દ માટે જુઓ.

550
00:47:26,560 --> 00:47:29,250
અમે જાણીએ છીએ કે અમે અમારા હેશ વિધેય અમલમાં

551
00:47:29,250 --> 00:47:38,420
જેમ કે દરેક અનન્ય શબ્દ હંમેશા સમાન મૂલ્ય માટે hashed છે,

552
00:47:38,420 --> 00:47:43,340
પછી આપણે જાણીએ છીએ કે તેના બદલે અમારી સંપૂર્ણ સમગ્ર હેશ ટેબલ દ્વારા શોધખોળ છે,

553
00:47:43,340 --> 00:47:48,310
અમે ખરેખર સંલગ્ન યાદી છે કે જે આ શબ્દ સંબંધ કરીશું શોધી શકો છો.

554
00:47:48,310 --> 00:47:51,850
જો તે શબ્દકોશ હતા, પછી તે ડોલમાં હશે.

555
00:47:51,850 --> 00:47:57,140
, અમે શું કરી, જો શબ્દ અમારા પસાર શબ્દમાળાને નામ છે

556
00:47:57,140 --> 00:48:01,560
અમે ફક્ત હેશ કરી શકો છો કે જે સંકળાયેલા યાદી અંતે શબ્દ દેખાવ

557
00:48:01,560 --> 00:48:06,410
hashtable કિંમત ([શબ્દ) હેશ] છે.

558
00:48:06,410 --> 00:48:12,410
ત્યાંથી, અમે શું કરી શકો છો છે અમે ગાંઠો એક નાની ઉપગણ આ શબ્દ શોધવા માટે હોય છે,

559
00:48:12,410 --> 00:48:16,770
અને તેથી અમે સંલગ્ન યાદી પસાર, તો walkthrough પહેલાં એક ઉદાહરણ મદદથી કરી શકો છો,

560
00:48:16,770 --> 00:48:24,110
અને પછી કૉલ શબ્દમાળા શબ્દ પર સરખાવવા ત્યાં કર્સર તરફ ઇશારો છે,

561
00:48:24,110 --> 00:48:28,430
કે શબ્દ, જુઓ અને શું તે તુલના.

562
00:48:30,280 --> 00:48:35,110
આધાર રાખીને કે જે રીતે તમે તમારી હેશ વિધેય ગોઠવવા પર,

563
00:48:35,110 --> 00:48:39,260
જો તે છટણી છે, તો તમે ખોટા થોડી અગાઉ પરત કરવાનો પ્રયત્ન કરી શકે છે,

564
00:48:39,260 --> 00:48:43,440
પરંતુ જો તે ક્રમમાંગોઠવાયેલનથી છે, તો પછી તમે તમારી સાથે લિંક યાદી મારફતે સરકાઉ ચાલુ રાખવા માંગો છો

565
00:48:43,440 --> 00:48:46,480
જ્યાં સુધી તમે યાદીમાંથી ના છેલ્લા તત્વ શોધો.

566
00:48:46,480 --> 00:48:53,320
અને જો તમે હજુ પણ આ સમય તમે સંકળાયેલા યાદી ઓવરને પહોંચી ગયા છો દ્વારા શબ્દ મળ્યા નથી,

567
00:48:53,320 --> 00:48:56,890
, કે જે અર્થ એ છે કે તમારા શબ્દ શબ્દકોશ અસ્તિત્વમાં નથી

568
00:48:56,890 --> 00:48:59,410
અને જેથી શબ્દ અમાન્ય છે,

569
00:48:59,410 --> 00:49:02,730
અને ચેક ખોટા પરત કરીશું.

570
00:49:02,730 --> 00:49:09,530
>> હવે અમે અનલોડ આવે છે, જ્યાં અમે ગાંઠો કે અમે malloc'd છે બધા મુક્ત કરવા માંગો છો,

571
00:49:09,530 --> 00:49:14,050
જેથી મફત અમારા હેશ કોષ્ટક અંદર ગાંઠો હોય.

572
00:49:14,050 --> 00:49:20,270
અમે માટે આ બોલ પર કડી થયેલ યાદીઓ અને તેમાં ગાંઠોની તમામ મફત તમામ ભારપૂર્વક કહેવું માંગો છો જઈ રહ્યાં છો.

573
00:49:20,270 --> 00:49:29,350
જો તમે walkthrough ઉપર જોવા ઉદાહરણ જ્યાં અમે સંકળાયેલી યાદી મુક્ત

574
00:49:29,350 --> 00:49:35,140
પછી તમે હેશ કોષ્ટક દરેક તત્વ કે પ્રક્રિયા પુનરાવર્તન કરવા માંગો છો પડશે.

575
00:49:35,140 --> 00:49:37,780
અને હું આ બોલ walkthrough ના અંત તરફ જવા પડશે,

576
00:49:37,780 --> 00:49:46,600
પરંતુ Valgrind એ સાધન છે કે જ્યાં તમે જો તમે યોગ્ય રીતે મુક્ત છે જોઈ શકે છે છે

577
00:49:46,600 --> 00:49:53,600
દરેક નોડ કે જે તમે malloc'd અથવા કર્યા છે જે કંઈપણ છે કે તમે malloc'd કર્યા છે, અન્ય કોઈ પણ નિર્દેશક.

578
00:49:55,140 --> 00:50:00,530
જેથી હેશ કોષ્ટકો છે, જ્યાં અમે buckets એક મર્યાદિત સંખ્યામાં છે

579
00:50:00,530 --> 00:50:09,220
અને હેશ વિધેય કે જે કિંમત લેવા અને પછી તે ચોક્કસ બકેટ તે કિંમત સોંપી.

580
00:50:09,220 --> 00:50:13,340
>> હવે અમે પ્રયત્નોમાં માટે આવે છે.

581
00:50:13,340 --> 00:50:18,750
આ જેવા દેખાવ પ્રકારની કરવાનો પ્રયત્ન કરે છે, અને હું પણ એક ઉદાહરણ દોરવા પડશે.

582
00:50:18,750 --> 00:50:25,630
મૂળભૂત રીતે, તમે સંભવિત અક્ષરો સંપૂર્ણ એરે હોય છે,

583
00:50:25,630 --> 00:50:29,210
અને પછી તમે એક શબ્દ જ્યારે પણ બાંધવા કરી રહ્યાં છો,

584
00:50:29,210 --> 00:50:36,490
કે પત્ર શક્યતાઓ વ્યાપક શ્રેણી માટે એક શબ્દકોશ માટે લિંક કરી શકાય છે.

585
00:50:36,490 --> 00:50:40,840
કેટલાક શબ્દો C સાથે શરૂ પરંતુ પછી એક સાથે ચાલુ રાખવા માટે,

586
00:50:40,840 --> 00:50:42,960
પરંતુ અન્ય ઓ સાથે, ઉદાહરણ તરીકે ચાલુ રાખો.

587
00:50:42,960 --> 00:50:51,090
એક trie તે શબ્દોની શક્ય મિશ્રણોનો તમામ દ્રશ્યાત્મક એક માર્ગ છે.

588
00:50:51,090 --> 00:50:59,070
એક trie પત્રો કે શબ્દો સમાવેશ મોટે ટ્રૅક રાખવા રહ્યું છે,

589
00:50:59,070 --> 00:51:08,280
બંધ ડાળીઓ જ્યારે જરૂરી હોય ત્યારે, જ્યારે એક પત્ર અક્ષરોના બહુવિધ દ્વારા અનુસરવામાં કરી શકાય છે,

590
00:51:08,280 --> 00:51:16,630
અને ઓવરને અંતે દરેક તબક્કે સૂચવે છે કે શું શબ્દ માન્ય નથી અથવા

591
00:51:16,630 --> 00:51:30,120
કારણ કે જો તમે આ શબ્દ MAT શબ્દરચના કરી રહ્યાં છો, MA મને લાગતું નથી માન્ય શબ્દ છે, પરંતુ MAT છે.

592
00:51:30,120 --> 00:51:37,820
અને તેથી તમારા trie, તે સૂચવે છે કે MAT પછી કે જે વાસ્તવમાં એક માન્ય શબ્દ છે.

593
00:51:41,790 --> 00:51:48,590
અમારા trie દરેક નોડ ખરેખર નોડ પોઇંટરો ઝાકઝમાળ સમાવી રહ્યું છે,

594
00:51:48,590 --> 00:51:52,970
અને અમે હોય છે, ખાસ કરીને, 27 તે નોડ પોઇંટરો ઓફ જઈ રહ્યાં છો,

595
00:51:52,970 --> 00:52:00,550
એક મૂળાક્ષર દરેક અક્ષર તેમજ એપોસ્ટ્રોફી પાત્ર છે.

596
00:52:00,550 --> 00:52:10,450
કે એરે દરેક તત્વ પોતે અન્ય નોડ માટે નિર્દેશ રહ્યું છે.

597
00:52:10,450 --> 00:52:14,020
તેથી જો કે નોડ NULL છે, જો તે પછી કશું જ નથી,

598
00:52:14,020 --> 00:52:20,550
પછી આપણે જાણીએ છીએ કે એ શબ્દ ક્રમ આગળ કોઈ અક્ષરો છે.

599
00:52:20,550 --> 00:52:26,950
પરંતુ જો તે નોડ NULL નથી, તેનો અર્થ એ કે કે એ પત્ર ક્રમ વધુ અક્ષરો છે.

600
00:52:26,950 --> 00:52:32,160
અને પછી વળી, દરેક નોડ સૂચવે છે કે શું તે શબ્દ નથી અથવા ના છેલ્લા અક્ષર છે.

601
00:52:38,110 --> 00:52:43,170
>> ચાલો એક trie ઉદાહરણ જાય.

602
00:52:50,500 --> 00:52:58,340
પ્રથમ હું આ એરે માં 27 ગાંઠો માટે જગ્યા હોય છે.

603
00:52:58,340 --> 00:53:03,200
જો હું શબ્દ પટ્ટીમાં હોય -

604
00:53:13,310 --> 00:53:15,370
જો હું શબ્દ બાર હોય છે અને હું તે સામેલ કરવા માંગો છો,

605
00:53:15,370 --> 00:53:22,700
પ્રથમ અક્ષર બી છે, તેથી જો મારા trie ખાલી હોય છે,

606
00:53:22,700 --> 00:53:29,910
બી મૂળાક્ષરમાંથી બીજા અક્ષર છે, તેથી હું આ ઇન્ડેક્સ પર અહીં મૂકો પસંદ કરો જાઉં છું.

607
00:53:29,910 --> 00:53:33,450
હું બી અહીં જાઉં છું.

608
00:53:33,450 --> 00:53:42,400
બી નોડ કે જે બધા શક્ય અક્ષરો અન્ય એરે નિર્દેશ પ્રયત્ન રહ્યું છે

609
00:53:42,400 --> 00:53:45,870
કે પત્ર બી પછી અનુસરી શકે છે

610
00:53:45,870 --> 00:53:57,610
આ કિસ્સામાં, હું શબ્દ બાર સાથે વ્યવહાર છું, તેથી અહીં જશે.

611
00:54:02,000 --> 00:54:08,990
એ પછી, હું અક્ષર આર, જેથી પછી તેની પોતાની મિશ્રણ માટે હવે પોઇન્ટ હોય છે,

612
00:54:08,990 --> 00:54:15,120
અને પછી આર અહીં રહેશે.

613
00:54:15,120 --> 00:54:22,470
બાર સંપૂર્ણ શબ્દ છે, તેથી તે પછી હું અન્ય નોડ માટે આર બિંદુ હોય જાઉં છું

614
00:54:22,470 --> 00:54:33,990
કહે છે કે જે શબ્દ માન્ય છે.

615
00:54:36,010 --> 00:54:40,970
નોડ કે જે પણ ગાંઠો ઝાકઝમાળ હોય રહ્યું છે,

616
00:54:40,970 --> 00:54:45,260
પરંતુ તે NULL હોઈ શકે છે.

617
00:54:45,260 --> 00:54:49,080
પરંતુ મૂળભૂત રીતે, તે જેમ ચાલુ રાખી શકો છો.

618
00:54:49,080 --> 00:54:54,250
કે થોડી વધુ સ્પષ્ટ બને છે જ્યારે આપણે વિવિધ ઉદાહરણ માટે જશે,

619
00:54:54,250 --> 00:54:56,780
જેથી માત્ર મારી સાથે ત્યાં ઉઠાવે.

620
00:54:56,780 --> 00:55:02,050
હવે અમે અમારા શબ્દકોશ ની અંદર બાર હોય છે.

621
00:55:02,050 --> 00:55:05,980
હવે કહે છે કે અમે શબ્દ BAZ છે.

622
00:55:05,980 --> 00:55:12,630
અમે બી સાથે શરૂ કરવા માટે, અને અમે પહેલાથી જ એક અક્ષરો જે આપણી શબ્દકોશ છે એક તરીકે બી હોય છે.

623
00:55:12,630 --> 00:55:15,170
કે એ પાલન છે અમે એ પહેલાથી જ હોય ​​છે.

624
00:55:15,170 --> 00:55:19,250
પરંતુ તે પછી તેના બદલે, અમે Z નીચેના હોય છે.

625
00:55:19,250 --> 00:55:25,490
તેથી તે પછી અમારા એરે એક તત્વ માટે Z પ્રયત્ન રહ્યું છે,

626
00:55:25,490 --> 00:55:30,810
અને તેથી તે પછી એક છે કે જે શબ્દ અન્ય માન્ય અંત નિર્દેશ રહ્યું છે.

627
00:55:30,810 --> 00:55:36,930
તેથી અમે જુઓ કે એ જ્યારે અમે બી મારફતે ચાલુ રાખો અને પછી,

628
00:55:36,930 --> 00:55:43,480
ત્યાં બે શબ્દો માટે અમારા શબ્દકોશ હાલમાં વિવિધ વિકલ્પો બી અને એ સાથે શરૂ થાય છે

629
00:55:49,650 --> 00:55:57,460
કહો અમે શબ્દ FOOBAR દાખલ કરવા ઈચ્છતા.

630
00:55:57,460 --> 00:56:05,620
તો પછી અમે એફ એક પ્રવેશ કરશે

631
00:56:05,620 --> 00:56:11,320
એફ નોડ કે જે સમગ્ર એરે નિર્દેશ છે.

632
00:56:11,320 --> 00:56:22,790
અમે ઓ શોધવા, ઓ જશે, ઓ પછી સંપૂર્ણ યાદી માટે કડી થાય છે.

633
00:56:22,790 --> 00:56:35,340
અમે બી હોય છે અને પછી ચાલુ રાખવા માંગો છો, તો અમે છો એ પછી અને આર

634
00:56:35,340 --> 00:56:43,570
તેથી પછી FOOBAR છેડા સુધી FOOBAR સુધી નીચે બધી રીતે સાચો શબ્દ છે.

635
00:56:43,570 --> 00:56:52,590
અને તેથી તે પછી આ માન્ય શબ્દ હશે.

636
00:56:52,590 --> 00:57:00,170
હવે કહે છે અમારી શબ્દકોશ આગામી શબ્દ ખરેખર શબ્દ foo.

637
00:57:00,170 --> 00:57:03,530
અમે કહ્યું એફ શું એફ નીચે?

638
00:57:03,530 --> 00:57:06,190
હું ખરેખર પહેલેથી ઓ માટે એક જગ્યા હોય છે, તેથી હું ચાલુ રાખવા માટે જાઉં છું.

639
00:57:06,190 --> 00:57:09,150
હું એક નવું બનાવવા જરૂર નથી. ચાલુ રાખો.

640
00:57:09,150 --> 00:57:15,500
Foo આ શબ્દકોશમાં માન્ય શબ્દ છે, તેથી તે પછી હું સૂચવવા માટે જાઉં છું

641
00:57:15,500 --> 00:57:21,660
કે જે માન્ય છે.

642
00:57:21,660 --> 00:57:28,370
જો હું મારો ક્રમ ત્યાં અટકાવો, તે યોગ્ય રહેશે.

643
00:57:28,370 --> 00:57:33,050
પરંતુ જો આપણે foo અમારા ક્રમ ચાલુ રહ્યો બી નીચે

644
00:57:33,050 --> 00:57:39,750
અને માત્ર FOOB હતી, FOOB શબ્દ, નથી અને તે માન્ય નથી સૂચવ્યું છે.

645
00:57:47,370 --> 00:57:57,600
એક trie, તમે દરેક નોડ સૂચવે છે કે શું તે માન્ય શબ્દ અથવા નથી,

646
00:57:57,600 --> 00:58:05,840
અને પછી દરેક નોડ પણ 27 નોડ પોઇંટરો ઝાકઝમાળ છે

647
00:58:05,840 --> 00:58:09,520
પછી પોતાને ગાંઠો બિંદુ કે.

648
00:58:09,520 --> 00:58:12,940
>> અહીં તમે કેવી રીતે આ વ્યાખ્યાયિત શકો છો એક માર્ગ છે.

649
00:58:12,940 --> 00:58:17,260
જોકે, માત્ર હેશ ટેબલ ઉદાહરણમાં ગમે, જ્યાં અમે નોડ * વડા હતા

650
00:58:17,260 --> 00:58:21,320
અમારી સાથે લિંક યાદી શરૂઆત સૂચવે છે, અમે પણ કરવા માંગો છો જઈ રહ્યાં છો

651
00:58:21,320 --> 00:58:29,150
જાણીને જ્યાં અમારી trie શરૂઆત છે કેટલાક માર્ગ.

652
00:58:29,150 --> 00:58:34,110
કેટલાક લોકો કૉલ વૃક્ષો કરવાનો પ્રયત્ન કરે છે, અને તે છે જ્યાં રુટ આવે છે.

653
00:58:34,110 --> 00:58:36,910
જેથી અમે અમારા વૃક્ષની રુટ ખાતરી કરો કે અમે લેવાયો રહેવા બનાવવા માટે કરવા માંગો છો

654
00:58:36,910 --> 00:58:39,570
ત્યાં અમારા trie છે.

655
00:58:42,910 --> 00:58:46,300
અમે પહેલાથી જ પ્રકારની પર ગયા

656
00:58:46,300 --> 00:58:50,240
જે રીતે તમે શબ્દકોશ માં દરેક શબ્દ લોડ વિશે વિચારો શકે છે.

657
00:58:50,240 --> 00:58:54,540
આવશ્યકપણે, દરેક શબ્દ માટે તમે તમારા trie દ્વારા ફરી વળવું માંગો છો જઈ રહ્યાં છો

658
00:58:54,540 --> 00:58:59,590
જાણીને અને આ બાળકો દરેક તત્વ - અમે તેને આ કિસ્સામાં બાળકો કહેવાય -

659
00:58:59,590 --> 00:59:04,290
અલગ પત્ર અનુલક્ષે માટે, તમારે તે કિંમતો તપાસ કરવા માંગો છો જઈ રહ્યાં છો

660
00:59:04,290 --> 00:59:08,320
ચોક્કસ ઇન્ડેક્સ કે પત્ર અનુલક્ષે છે.

661
00:59:08,320 --> 00:59:11,260
બધી રીતે વિચારી સીઝર અને Vigenere પાછા તેથી,

662
00:59:11,260 --> 00:59:16,070
ખબર છે કે, દરેક અક્ષર તમે નકશો પ્રકારની એક મૂળાક્ષર અનુક્રમણિકા પર પાછા કરી શકો છો,

663
00:59:16,070 --> 00:59:20,690
Z મારફતે નિશ્ચિતપણે ખૂબ એક મૂળાક્ષર અક્ષર માટે મેપ સરળ હોઈ રહ્યું છે,

664
00:59:20,690 --> 00:59:25,200
પરંતુ દુર્ભાગ્યે, apostrophes પણ શબ્દો માં સ્વીકૃત પાત્ર છે.

665
00:59:25,200 --> 00:59:31,650
હું પણ ખાતરી કરો કે તે ASCII કિંમત શું છે નથી,

666
00:59:31,650 --> 00:59:39,250
જેથી માટે જો તમે નક્કી કરો કે શું તમે તેને ક્યાં તો પ્રથમ એક પ્રયત્ન કરવા માંગો છો અનુક્રમણિકા શોધવા માંગો છો

667
00:59:39,250 --> 00:59:44,550
અથવા છેલ્લા એક, તમે તે માટે હાર્ડ કોડેડ ચેક કરો પડશે

668
00:59:44,550 --> 00:59:48,930
અને પછી તે પુટ 26, હમણાં પૂરતું ઇન્ડેક્સ.

669
00:59:48,930 --> 00:59:55,300
તેથી પછી તમે બાળકોને મૂલ્ય ચકાસણી કરવામાં આવે છે [i]

670
00:59:55,300 --> 00:59:58,400
જ્યાં [i] અનુલક્ષે પત્ર ગમે તમે છો.

671
00:59:58,400 --> 01:00:04,110
જો કે NULL છે, કે જે અર્થ એ છે કે ત્યાં હાલમાં કોઈ શક્ય અક્ષરો નથી

672
01:00:04,110 --> 01:00:08,150
કે જે પહેલાનાં ક્રમ ઉત્પન્ન થાય છે, જેથી તમે malloc કરવા માંગો છો જઈ રહ્યાં છો

673
01:00:08,150 --> 01:00:13,150
અને એક નવી નોડ બનાવવા અને હોય કે જે બાળકો [i] તે બિંદુ

674
01:00:13,150 --> 01:00:17,890
જેથી તમે બનાવો - જ્યારે અમે લંબચોરસ એક પત્ર શામેલ -

675
01:00:17,890 --> 01:00:23,680
બાળકો કે નવા ગાંઠમાં બિન NULL અને બિંદુ બનાવે છે.

676
01:00:23,680 --> 01:00:28,340
પરંતુ જો તે NULL નથી, foo અમારી ઉદાહરણ છો

677
01:00:28,340 --> 01:00:34,570
જ્યારે અમે પહેલાથી જ FOOBAR હતી, અમે ચાલુ રાખવા માટે,

678
01:00:34,570 --> 01:00:44,010
અને અમે સતત નવા નોડ નથી કરતા હોય છે પરંતુ તેના બદલે માત્ર સત્ય માટે is_word સુયોજિત

679
01:00:44,010 --> 01:00:47,790
કે શબ્દ ઓવરને અંતે.

680
01:00:50,060 --> 01:00:55,340
>> તેથી પછી તરીકે પહેલાં, અહીં તમે દરેક અક્ષર સાથે એક સમયે કામ કરીએ છીએ, કારણ કે,

681
01:00:55,340 --> 01:01:01,470
તે માટે તમે સરળ હોઈ કદ માટે ચાલી રહ્યું છે, તેના બદલે ગણતરી માણવાનું

682
01:01:01,470 --> 01:01:06,910
અને સમગ્ર વૃક્ષ મારફતે જાઓ અને ગણતરી કેટલા બાળકો હું હોય

683
01:01:06,910 --> 01:01:10,850
અને પછી બંધ શાખા, યાદ કેટલા ડાબી બાજુ અને જમણી બાજુ પર હોય છે

684
01:01:10,850 --> 01:01:12,850
અને તે જેવી વસ્તુઓ, તે માટે તમે ખૂબ સરળ હશે

685
01:01:12,850 --> 01:01:16,220
જો તમે હમણાં કેટલા શબ્દો તમે ઉમેરી રહ્યાં છીએ, ટ્રૅક રાખવા

686
01:01:16,220 --> 01:01:18,080
જ્યારે તમે ભાર સાથે કામ કરીએ છીએ.

687
01:01:18,080 --> 01:01:22,630
અને તેથી પછી તે રીતે માપ just કદ એક વૈશ્વિક ચલ પાછા આવી શકો છો.

688
01:01:25,320 --> 01:01:28,530
>> હવે અમે તપાસ આવે છે.

689
01:01:28,530 --> 01:01:33,920
પહેલાં જ ધોરણો, જ્યાં અમે કેસની બિનસંવેદનશીલતાની માટે પરવાનગી આપવા માટે કરવા માંગો છો.

690
01:01:33,920 --> 01:01:40,400
આ ઉપરાંત, અમે ધારે છે કે શબ્દમાળાઓ માત્ર મૂળાક્ષર અક્ષર અથવા apostrophes છે

691
01:01:40,400 --> 01:01:44,000
કારણ કે બાળકો 27 લાંબા એક વ્યૂહરચના છે,

692
01:01:44,000 --> 01:01:48,480
જેથી મૂળાક્ષર ઉપરાંત એપોસ્ટ્રોફી અક્ષરોને હોય.

693
01:01:48,480 --> 01:01:53,800
ચકાસવા માટે તમે શું કરવા માંગો છો પડશે તો રુટ શરૂ કરવા માંગો છો પડશે

694
01:01:53,800 --> 01:01:58,440
કારણ કે જે રુટ ઝાકઝમાળ કે સમાવે નિર્દેશ

695
01:01:58,440 --> 01:02:01,630
એક શબ્દના શક્ય શરૂ અક્ષરોના છે.

696
01:02:01,630 --> 01:02:03,680
તમે ત્યાં શરૂ કરવાનો છું કરી રહ્યાં છો,

697
01:02:03,680 --> 01:02:11,590
અને પછી તમે ચકાસવા જઈ રહ્યાં છો આ કિંમત NULL નથી અથવા,

698
01:02:11,590 --> 01:02:16,490
કારણ કે જો કિંમત NULL છે, કે જે અર્થ એ થાય કે શબ્દકોશ કોઈ મૂલ્ય નથી

699
01:02:16,490 --> 01:02:21,480
ચોક્કસ ક્રમમાં છે કે જે અક્ષર હોય છે.

700
01:02:21,480 --> 01:02:24,970
તે માતાનો NULL જો, તો પછી તે અર્થ એ થાય કે શબ્દ સીધા ખોટીજોડણીવાળું છે.

701
01:02:24,970 --> 01:02:27,110
પરંતુ જો તે NULL નથી, તો પછી તમે ચાલુ રાખી શકો છો,

702
01:02:27,110 --> 01:02:34,090
કહે છે કે પ્રથમ અક્ષર એક શબ્દ એક શક્ય પ્રથમ અક્ષર છે,

703
01:02:34,090 --> 01:02:40,630
તેથી હવે હું ચકાસો જો બીજા પત્રમાં, કે ક્રમ, મારા શબ્દકોશ અંદર છે કરવા માંગો છો.

704
01:02:40,630 --> 01:02:46,540
તેથી તમારે પ્રથમ નોડને બાળકો ઇન્ડેક્સ પર જાઓ જઈ રહ્યાં છો

705
01:02:46,540 --> 01:02:50,720
તપાસો અને પછી તે બીજા પત્રમાં અસ્તિત્વમાં છે.

706
01:02:50,720 --> 01:02:57,440
પછી તમે તે પ્રક્રિયા પુનરાવર્તન માટે તપાસો કે શું ક્રમ valid નથી અથવા

707
01:02:57,440 --> 01:02:59,060
તમારા trie અંદર.

708
01:02:59,060 --> 01:03:06,430
જ્યારે પણ છે કે ઇન્ડેક્સ પોઇન્ટ્સ પર નોડ બાળકો નલ માટે,

709
01:03:06,430 --> 01:03:10,710
તમે જાણો છો કે જે શ્રેણીમાં અસ્તિત્વમાં નથી,

710
01:03:10,710 --> 01:03:16,230
પરંતુ પછી જો તમે શબ્દ કે તમે ઇનપુટ કર્યું છે ઓવરને પહોંચે છે,

711
01:03:16,230 --> 01:03:20,070
પછી તમે હવે તપાસો કે હું આ ક્રમ પૂર્ણ કરી લીધી છે કરવા માંગો છો

712
01:03:20,070 --> 01:03:27,610
અને તેને મારા trie અંદર મળી છે, કે જે માન્ય નથી અથવા શબ્દ છે?

713
01:03:27,610 --> 01:03:32,480
અને તેથી તે પછી તમે તે તપાસ કરવા માંગો છો, અને તે જ્યારે જો તમે કે ક્રમ મળ્યાં છે,

714
01:03:32,480 --> 01:03:35,120
તો પછી તમારે તપાસો કે શું શબ્દ માન્ય નથી અથવા માંગો છો

715
01:03:35,120 --> 01:03:40,290
કારણ કે અગાઉના કિસ્સામાં પાછા યાદ રાખો કે હું દોર્યું જ્યાં અમે FOOB હતી,

716
01:03:40,290 --> 01:03:48,410
કે જે માન્ય ક્રમ કે અમે મળી પરંતુ એક વાસ્તવિક માન્ય શબ્દ ન હતો.

717
01:03:50,570 --> 01:03:59,000
>> એ જ રીતે, પ્રયત્નોમાં તમે તમારા trie માં ગાંઠો તમામ અનલોડ કરવા માંગો છો અનલોડ છે.

718
01:03:59,000 --> 01:04:04,790
માફ કરશો. હેશ કોષ્ટકો જ્યાં અનલોડ માં આપણે દરેક ગાંઠો મુક્ત જેમ,

719
01:04:04,790 --> 01:04:09,740
આ પ્રયત્નોમાં અમે પણ ગાંઠો તમામ મુક્ત કરવા માંગો છો.

720
01:04:09,740 --> 01:04:15,000
અનલોડ ખરેખર નીચેથી સૌથી સરળ ટોચ પર કામ કરશે

721
01:04:15,000 --> 01:04:19,290
કારણ કે આ અનિવાર્યપણે કડી થયેલ યાદી છે.

722
01:04:19,290 --> 01:04:22,540
તેથી અમે કિંમતો બધા પર ખાતરી કરો કે અમે પકડી બનાવવા માંગો છો

723
01:04:22,540 --> 01:04:25,700
અને મફત તેમને સ્પષ્ટપણે છે.

724
01:04:25,700 --> 01:04:28,840
તમે શું કરવા માંગો છો જઈને હોવ તો તમે એક સાથે કામ કરી રહ્યા છો trie

725
01:04:28,840 --> 01:04:35,640
માટે નીચે અને મફત સૌથી નીચો શક્ય નોડ પ્રથમ પ્રવાસ છે

726
01:04:35,640 --> 01:04:39,190
અને પછી તે બાળકો માટે તમામ ઉપર જાઓ અને મફત તે તમામ, તો પછી

727
01:04:39,190 --> 01:04:43,050
અપ જાઓ અને પછી મફત વગેરે,

728
01:04:43,050 --> 01:04:48,790
આ trie પ્રથમ નીચે સ્તર સાથે વ્યવહાર જેવા પ્રકારની

729
01:04:48,790 --> 01:04:51,940
અને પછી જઈને ટોચ એકવાર તમે બધું મુક્ત કર્યા છે.

730
01:04:51,940 --> 01:04:56,720
આ જ્યાં યાદ આવવું કાર્ય હાથમાં શકે છે એક સારું ઉદાહરણ છે.

731
01:04:56,720 --> 01:05:03,830
એકવાર તમે તમારી trie નીચે સ્તર મુક્ત કર્યા છે,

732
01:05:03,830 --> 01:05:08,000
પછી તમે તેને બાકીના પર અનલોડ કહી,

733
01:05:08,000 --> 01:05:13,620
ખાતરી કરો કે તમે દરેક મિની મુક્ત બનાવવા -

734
01:05:13,620 --> 01:05:16,410
તમે પ્રકારની તેને મીની પ્રયત્નોમાં તરીકે આત્મસાત્ કરી શકો છો.

735
01:05:23,300 --> 01:05:28,990
જેથી તમે તમારો રુટ અહીં છે.

736
01:05:30,840 --> 01:05:35,230
હું હમણાં જ તે સરળ છું તેથી હું 26 તેમાંથી દોરવા નથી.

737
01:05:37,250 --> 01:05:43,770
તેથી તમે આ છે, અને પછી આ શબ્દ ક્રમ પ્રતિનિધિત્વ

738
01:05:43,770 --> 01:05:54,620
આ થોડો બધા વર્તુળોમાંથી અક્ષરો જે letters વૈધ સિક્વન્સ છે જ્યાં છે.

739
01:06:03,040 --> 01:06:07,160
ચાલો માત્ર એક બીટ વધુ ચાલુ રાખો.

740
01:06:15,110 --> 01:06:25,750
તમે કરવા માંગો છો જઈ રહ્યાં છો શું મફત અહીં અને પછી મફત આ તળિયે છે

741
01:06:25,750 --> 01:06:31,640
અને પછી તળિયે મફત આ એક પહેલાં તમે ઉપરની એક અહીં મુક્ત

742
01:06:31,640 --> 01:06:38,180
કારણ કે તમે જો બીજા અહીં સ્તર મફત કંઈક,

743
01:06:38,180 --> 01:06:47,230
પછી તમે ખરેખર આ કિંમત અહીં ગુમાવશે.

744
01:06:47,230 --> 01:06:54,780
કે શા માટે તે માટે ખાતરી કરો કે તમે નીચે સૌપ્રથમ મફત make trie માટે અનલોડ મહત્વપૂર્ણ છે.

745
01:06:54,780 --> 01:06:59,480
તમે શું દરેક નોડ માટે છે કહેવું કરવા માંગો છો શકે છે

746
01:06:59,480 --> 01:07:06,430
હું બાળકો બધા અનલોડ કરવા માંગો છો.

747
01:07:16,060 --> 01:07:22,140
>> હવે અમે હેશ ટેબલ તેમજ trie પદ્ધતિ પદ્ધતિ માટે unload પર ચાલ્યા કરી લીધી છે,

748
01:07:22,140 --> 01:07:27,020
અમે માટે Valgrind જોવા માંગો છો રહ્યા છીએ.

749
01:07:27,020 --> 01:07:29,640
Valgrind તમે નીચેના આદેશો સાથે ચાલે છે.

750
01:07:29,640 --> 01:07:32,700
તમે valgrind-વિરુદ્ધ છે.

751
01:07:32,700 --> 01:07:40,960
તમે બધા લીક્સ માટે ચકાસણી કરી રહ્યા છીએ જ્યારે તમે આ ચોક્કસ લખાણ આપવામાં સ્પેલર સ્કોર

752
01:07:40,960 --> 01:07:46,980
કારણ કે speller પર એક ટેક્સ્ટ ફાઈલ લઇ needs.

753
01:07:46,980 --> 01:07:52,330
તેથી Valgrind તમારા કાર્યક્રમ ચલાવવા માટે, તમને કહી many કેવી રીતે બાઇટ્સ તમે ફાળવવામાં આવશે,

754
01:07:52,330 --> 01:07:57,150
કેટલા બાઇટ્સ તમે મુક્ત, અને તે તમને કહેશે કે શું તમે હમણાં જ પૂરતી મુક્ત કરશે

755
01:07:57,150 --> 01:07:58,930
અથવા શું તમે મફત પર્યાપ્ત નથી,

756
01:07:58,930 --> 01:08:02,850
અથવા તમને ક્યારેક પર મુક્ત પણ, મફત નોડ જેમ કે જેઓ પહેલાથી જ છે કરી શકો છો મુક્ત કરવામાં

757
01:08:02,850 --> 01:08:05,140
અને તેથી તે તમે ભૂલો આપશે.

758
01:08:05,140 --> 01:08:11,600
જો તમે Valgrind વાપરો, તો તે તમને કેટલાક સંદેશાઓ આપવા પડશે

759
01:08:11,600 --> 01:08:15,970
સૂચવે છે કે શું તમે ક્યાં તો મુક્ત કર્યા છે કરતાં પર્યાપ્ત ઓછા, just પર્યાપ્ત,

760
01:08:15,970 --> 01:08:19,609
અથવા પર્યાપ્ત સમય કરતાં વધુ.

761
01:08:24,370 --> 01:08:30,410
>> આ pset એક ભાગ છે, તે વૈકલ્પિક છે માટે મોટા બોર્ડ પડકાર હતો.

762
01:08:30,410 --> 01:08:35,790
પરંતુ જ્યારે અમે આ માહિતી બંધારણોની સાથે કામ કરીએ છીએ

763
01:08:35,790 --> 01:08:40,689
તે મજા પ્રકારની જોવા માટે ઝડપથી કેવી રીતે અને અસરકારક કેવી રીતે તમારી માહિતી બંધારણો હોઈ શકે છે.

764
01:08:40,689 --> 01:08:44,490
તમારા અથડામણમાં ઘણો માં હેશ વિધેય પરિણામે કરે છે?

765
01:08:44,490 --> 01:08:46,300
અથવા તમારા દશાંશ માહિતી માપ છે ખરેખર મોટી?

766
01:08:46,300 --> 01:08:49,420
એ નથી કે તે સમય ઘણો સમય લાગી પસાર?

767
01:08:49,420 --> 01:08:54,800
Speller ઓફ લોગ, તે આઉટપુટ આપે છે કેટલી વાર તમે લોડ વાપરવા માટે,

768
01:08:54,800 --> 01:08:57,700
તેની તપાસ માટે માપ લેવા માટે, અને unload,

769
01:08:57,700 --> 01:09:00,720
અને તેથી તે આ મોટા બોર્ડ મૂકવામાં આવે છે,

770
01:09:00,720 --> 01:09:03,600
જ્યાં તમે તમારા સહપાઠીઓને સામે સ્પર્ધા કરી શકે છે

771
01:09:03,600 --> 01:09:11,350
અને કેટલાક સ્ટાફ સભ્યો જોવા માટે જે સૌથી ઝડપી spell-ચેકર છે.

772
01:09:11,350 --> 01:09:14,760
એક વસ્તુ છે કે હું હેશ કોષ્ટકો વિશે નોંધ કરવા માંગો છો

773
01:09:14,760 --> 01:09:20,470
એ છે કે કેટલાક ખૂબ સરળ હેશ વિધેયોની કે અમે વિચારી શકે છે.

774
01:09:20,470 --> 01:09:27,240
હમણાં પૂરતું, તમે 26 buckets હોય છે, અને તેથી દરેક બાલદી

775
01:09:27,240 --> 01:09:30,200
એક શબ્દમાં પ્રથમ અક્ષર અનુલક્ષે,

776
01:09:30,200 --> 01:09:35,229
પરંતુ તે માટે એક સુંદર અસંતુલિત હેશ કોષ્ટકમાં પરિણામ રહ્યું છે

777
01:09:35,229 --> 01:09:40,979
કારણ કે ત્યાં ખૂબ ઓછા શબ્દો M સાથે પ્રારંભ કરતાં એક્સ સાથે, હમણાં પૂરતું શરૂ થાય છે.

778
01:09:40,979 --> 01:09:47,890
એક સ્પેલર જઈ રીતે જો તમે અન્ય બધા વિધેયો નીચે વિચાર કરવા માંગો છો,

779
01:09:47,890 --> 01:09:53,240
પછી માત્ર એક સરળ હેશ વિધેય વાપરવા માટે તમારી કોડ ચલાવી રહેલ વિચાર કરવાનો પ્રયત્ન

780
01:09:53,240 --> 01:09:58,650
અને પછી પાછા જાઓ અને તમારી હેશ કોષ્ટક અને વ્યાખ્યા માપ બદલે છે.

781
01:09:58,650 --> 01:10:03,430
ત્યાં ઇન્ટરનેટ પર સ્રોતો એક જટિલ કાર્ય માટે ઘણું છે,

782
01:10:03,430 --> 01:10:08,250
અને તેથી આ pset માટે તમે ઇન્ટરનેટ પર હેશ વિધેયોની સંશોધન માન્ય છે

783
01:10:08,250 --> 01:10:15,560
કેટલાક સંકેતો અને લાંબા તરીકે પ્રેરણા તરીકે તમે દૃષ્ટાંત જ્યાં તમે તે મળ્યું માંથી ખાતરી છે.

784
01:10:15,560 --> 01:10:22,060
તમે નજર અને કેટલાક હેશ વિધેય કે તમે ઇન્ટરનેટ પર શોધી અર્થઘટન સ્વાગત છો.

785
01:10:22,060 --> 01:10:27,460
કે પાછા, તો તમે તે જોવા માટે જો કોઈને trie ઉપયોગ કરવાનો પ્રયત્ન કરી શકે છે

786
01:10:27,460 --> 01:10:31,700
કે શું તેમના અમલીકરણ તમારા હેશ કોષ્ટક નથી અથવા કરતા ઝડપી છે.

787
01:10:31,700 --> 01:10:35,290
તમે આ મોટા બોર્ડ અને ઘણી વખત સબમિટ કરી શકો છો.

788
01:10:35,290 --> 01:10:37,660
તે તમારા એકદમ છેલ્લા પ્રવેશ રેકોર્ડ કરીશું.

789
01:10:37,660 --> 01:10:44,300
તેથી કદાચ તમે તમારા હેશ વિધેય બદલવા અને પછી ખ્યાલ છે કે તે ખરેખર ખૂબ વધુ ઝડપી છે

790
01:10:44,300 --> 01:10:46,780
અથવા તે પહેલાં કરતાં ધીમી ઘણું.

791
01:10:46,780 --> 01:10:50,960
કે જે મજા રીતે એક બીટ છે.

792
01:10:50,960 --> 01:10:57,190
ત્યાં 1 હંમેશાં અથવા 2 સ્ટાફ સભ્યો માટે સૌથી ધીમી શક્ય શબ્દકોશ બનાવવા પ્રયાસ છે,

793
01:10:57,190 --> 01:11:00,210
જેથી હંમેશા આનંદ માટે જુઓ.

794
01:11:00,210 --> 01:11:07,630
>> આ pset માટે ઉપયોગ છે તમે વૈકલ્પિક શબ્દકોશ સાથે સ્પેલર સ્કોર

795
01:11:07,630 --> 01:11:12,840
અને પછી ફરજિયાત લખાણ ફાઈલ.

796
01:11:12,840 --> 01:11:18,380
મૂળભૂત રીતે જ્યારે તમે માત્ર લખાણ ફાઈલ સાથે સ્પેલર ચલાવો અને પાસે શબ્દકોશ સ્પષ્ટ નથી,

797
01:11:18,380 --> 01:11:24,410
તે શબ્દકોશ લખાણ ફાઈલ છે, મોટા નો ઉપયોગ રહ્યું છે

798
01:11:24,410 --> 01:11:27,920
આ cs50/pset5/dictionaries ફોલ્ડર છે.

799
01:11:27,920 --> 01:11:32,760
કે એક 100,000 કરતા શબ્દો છે.

800
01:11:32,760 --> 01:11:37,950
તેઓ પણ એક નાની શબ્દકોશ કે જે નોંધપાત્ર રીતે ઓછા શબ્દો છે પાસે

801
01:11:37,950 --> 01:11:40,730
CS50 કે જે તમે માટે બનાવવામાં આવી છે.

802
01:11:40,730 --> 01:11:44,050
જો કે, તમે ખૂબ સરળતાથી ફક્ત તમારી પોતાની શબ્દકોશ કરી શકો છો

803
01:11:44,050 --> 01:11:47,150
જો તમે માત્ર નાના ઉદાહરણો માં કામ કરવા માંગો છો -

804
01:11:47,150 --> 01:11:51,140
દાખલા તરીકે, જો તમે gdb ઉપયોગ કરવા માંગો છો અને તમને ચોક્કસ કિંમતો ખબર

805
01:11:51,140 --> 01:11:53,560
કે જે તમે તમારા હેશ કોષ્ટક બહાર જ મેપ કરવા માટે કરવા માંગો છો.

806
01:11:53,560 --> 01:12:00,430
તેથી તમે બાર, BAZ, foo, અને FOOBAR સાથે જ તમારા પોતાના લખાણ ફાઈલ માત્ર બનાવવા કરી શકો છો,

807
01:12:00,430 --> 01:12:04,860
લખાણ ફાઈલ છે કે બનાવવા માટે, રેખા 1 સાથે તે દરેક અલગ,

808
01:12:04,860 --> 01:12:12,670
અને પછી તમારા પોતાના લખાણ ફાઈલ છે, જે શબ્દશઃ માત્ર 1 કદાચ અથવા 2 શબ્દો છે કરો

809
01:12:12,670 --> 01:12:15,950
જેથી તમે ચોકકસ શું આઉટપુટ પ્રયત્ન કરીશું.

810
01:12:15,950 --> 01:12:21,870
નમૂના લખાણ કેટલીક ફાઇલો કે મોટા બોર્ડ જ્યારે તમે પડકાર સ્કોર તપાસ કરશે

811
01:12:21,870 --> 01:12:25,580
યુદ્ધ અને શાંતિ અને જેન ઑસ્ટિન નવલકથા અથવા તે કંઈક છે.

812
01:12:25,580 --> 01:12:30,450
તેથી જ્યારે તમે બહાર શરૂ કરી રહ્યાં છો, તો તે ખૂબ સરળ છે તમારા પોતાના લખાણ ફાઈલો બનાવવા

813
01:12:30,450 --> 01:12:34,160
કે માત્ર શબ્દો થોડા અથવા કદાચ 10 સમાવે છે

814
01:12:34,160 --> 01:12:38,280
જેથી તમે આગાહી કરી શકે પરિણામ શું હોવું જોઈએ

815
01:12:38,280 --> 01:12:42,880
અને પછી તે સામે તપાસ, તેથી નિયંત્રિત ઉદાહરણ છે.

816
01:12:42,880 --> 01:12:45,820
અને તેથી અમે અનુમાન અને ચિત્રકામ આસપાસ વસ્તુઓ સાથે કામ કરીએ છીએ,

817
01:12:45,820 --> 01:12:48,690
ફરીથી હું તમારી પેન અને કાગળ ઉપયોગ કરવા માટે પ્રોત્સાહિત કરવા માંગો છો

818
01:12:48,690 --> 01:12:50,700
કારણ કે તે ખરેખર તમે આ મદદ ચાલી રહ્યું છે -

819
01:12:50,700 --> 01:12:55,620
આ તીર ચિત્રકામ, હેશ કોષ્ટક કેવી રીતે કેવી રીતે તમારા trie લાગે છે,

820
01:12:55,620 --> 01:12:57,980
જ્યારે તમે કંઈક જ્યાં તીરો જવું છે ખાલી કરી રહ્યાં છો,

821
01:12:57,980 --> 01:13:01,730
છે તમારી પાસે પૂરતી પર હોલ્ડિંગ, તમે કોઈપણ લિંક્સ અદ્રશ્ય થઈ જુઓ

822
01:13:01,730 --> 01:13:05,750
અને લીક મેમરી સકીંગ ઘટી રહ્યો છે.

823
01:13:05,750 --> 01:13:11,070
તેથી, કૃપા કરીને વસ્તુઓ દોરવા બહાર પણ તે પહેલાં તમે કોડ લખી નીચે મેળવવા પ્રયાસ કરો.

824
01:13:11,070 --> 01:13:14,520
વસ્તુઓ દોરો બહાર કે જેથી તમે કેવી રીતે વસ્તુઓ માટે કામ જવું છે

825
01:13:14,520 --> 01:13:22,750
કારણ કે પછી હું ગેરંટી તમે ઓછી નિર્દેશક muddles માં ત્યાં સ્કોર પડશે.

826
01:13:24,270 --> 01:13:25,910
>> અધિકાર છે.

827
01:13:25,910 --> 01:13:28,780
હું તમને બહુ આ pset સાથે શુભેચ્છા માંગો છો માંગો છો.

828
01:13:28,780 --> 01:13:31,980
તે કદાચ અત્યંત એક છે.

829
01:13:31,980 --> 01:13:40,360
તેથી વહેલી શરૂ કરવાનો પ્રયાસ કરો, વસ્તુઓ દોરવા આઉટ વસ્તુઓ દોરવા આઉટ અને સારા નસીબ.

830
01:13:40,360 --> 01:13:42,980
આ 5 Walkthrough હતી.

831
01:13:45,160 --> 01:13:47,000
>> [CS50.TV]