1
00:00:00,000 --> 00:00:02,730
[Powered by Google Translate] [6 વિભાગ ઓછુ: સાધારણ]

2
00:00:02,730 --> 00:00:05,040
[Nate Hardison] [હાર્વર્ડ યુનિવર્સિટી]

3
00:00:05,040 --> 00:00:07,320
[આ CS50 છે.] [CS50.TV]

4
00:00:07,320 --> 00:00:11,840
અધિકાર છે. 6 વિભાગમાં આપનું સ્વાગત છે.

5
00:00:11,840 --> 00:00:14,690
આ અઠવાડિયે, અમે માહિતી માળખાં વિશે વાત કરી વિભાગમાં જઈ રહ્યાં છો,

6
00:00:14,690 --> 00:00:19,780
મુખ્યત્વે કારણ કે આ સપ્તાહ સમસ્યા spellr પર સેટ

7
00:00:19,780 --> 00:00:24,410
વિવિધ માહિતી બંધારણ સંશોધન સંપૂર્ણ જથ્થો કરે છે.

8
00:00:24,410 --> 00:00:26,520
ત્યાં અલગ અલગ રીતે તમે આ સમસ્યા સેટ સાથે જઈ શકે છે સમૂહ છે,

9
00:00:26,520 --> 00:00:31,570
અને વધુ માહિતી માળખાં તમારા વિશે જાણવું વધુ રસપ્રદ વસ્તુઓ તમે કરી શકો છો.

10
00:00:31,570 --> 00:00:34,990
>> તેથી આપણે શરૂ કરો. પ્રથમ અમે રન ટાઇમ સ્ટેકનું વિશે વાત જઈ રહ્યાં છો,

11
00:00:34,990 --> 00:00:37,530
સ્ટેક અને કતાર માહિતી માળખાં કે અમે વિશે વાત જઈ રહ્યાં છો.

12
00:00:37,530 --> 00:00:40,560
રન ટાઇમ સ્ટેકનું અને ક્યુને ખરેખર મદદરૂપ છે જ્યારે અમે ગ્રાફ વિશે વાત શરૂ કરવા માટે,

13
00:00:40,560 --> 00:00:44,390
જે અમે આમ અધિકાર ખૂબ હવે નથી રહ્યા છીએ.

14
00:00:44,390 --> 00:00:52,820
પરંતુ તેઓ ખરેખર એક મોટી સીએસ મૂળભૂત માહિતી બંધારણોની સમજી શકો છો.

15
00:00:52,820 --> 00:00:54,880
સમસ્યા સેટ સ્પષ્ટીકરણમાં વર્ણન,

16
00:00:54,880 --> 00:00:59,260
જો તમે તેને ખેંચી અપ સમાન તરીકે, રન ટાઇમ સ્ટેકનું વિશે વાત કરે છે

17
00:00:59,260 --> 00:01:05,239
ડાઇનિંગ ટ્રે ના ખૂંટો કે તમે ડાઇનિંગ હોલ ખાતે કાફેટેરિયા હોય

18
00:01:05,239 --> 00:01:09,680
જ્યાં જ્યારે ડાઇનિંગ સ્ટાફ આવે છે અને ડાઇનિંગ ટ્રે મૂકે બહાર પછી તેઓ તેમને સાફ કરી લો,

19
00:01:09,680 --> 00:01:12,000
તેઓ એક બીજા ઉપર ગંજી.

20
00:01:12,000 --> 00:01:15,050
અને પછી જ્યારે બાળકો માટે ખોરાક વિચાર આવે છે,

21
00:01:15,050 --> 00:01:19,490
તેઓ ટ્રેમાં ખેંચવાનો બોલ, પ્રથમ ટોચ એક, પછી તેને નીચે એક, પછી કે નીચે એક.

22
00:01:19,490 --> 00:01:25,190
તેથી, અસર માં, પ્રથમ ટ્રે કે ડાઇનિંગ સ્ટાફ નીચે મૂકવામાં છેલ્લા એક કે બોલ લેવામાં નહીં આવે છે.

23
00:01:25,190 --> 00:01:32,330
છેલ્લા એક કે ડાઇનિંગ સ્ટાફ પર મૂકી પ્રથમ એક કે બોલ રાત્રિભોજન માટે લેવામાં નહીં આવે છે.

24
00:01:32,330 --> 00:01:38,100
સમસ્યા એ સેટ સ્પેક, જે તમે જો તમે પહેલાથી જ નથી ડાઉનલોડ કરી શકો છો,

25
00:01:38,100 --> 00:01:46,730
અમે સ્ટેક માહિતી આ પ્રકારની સ્ટ્રક્ટ મદદથી stucture મોડેલીંગ વિશે વાત કરો.

26
00:01:46,730 --> 00:01:51,070
>> તેથી આપણે શું અહીં મળી છે, આ શું વ્યાખ્યાન માં રજૂ કરવામાં આવ્યો હતો સમાન છે,

27
00:01:51,070 --> 00:01:58,120
વ્યાખ્યાન સિવાય અમે ints તરીકે ઘરનાં પરચૂરણ કામો * ઓ વિરોધ સાથે આ પ્રસ્તુત કર્યું.

28
00:01:58,120 --> 00:02:06,250
આ સ્ટેક કે સ્ટોર્સ શું હોવું રહ્યું છે?

29
00:02:06,250 --> 00:02:09,009
ડેનિયલ? અમે શું આ સ્ટેક માં સંગ્રહિત થાય છે?

30
00:02:09,009 --> 00:02:15,260
[ડીએલ] સ્ટ્રીંગ્સ? >> અમે આ સ્ટેક માં શબ્દમાળાઓ સ્ટોર છે બરાબર.

31
00:02:15,260 --> 00:02:20,950
બધા તમે જરૂર ક્રમમાં સ્ટેક બનાવવા ઝાકઝમાળ છે

32
00:02:20,950 --> 00:02:23,920
ચોક્કસ ક્ષમતા, આ કિસ્સામાં જે,

33
00:02:23,920 --> 00:02:28,020
ક્ષમતા માટે તમામ કેપ્સ શકે છે કારણ કે તે સતત છે રહ્યું છે.

34
00:02:28,020 --> 00:02:36,340
અને પછી એરે માટે વધુમાં, બધા અમે ટ્રૅક કરવાની જરૂર એરે ની વર્તમાન માપ છે.

35
00:02:36,340 --> 00:02:38,980
એક અહીં નોંધ કરો કે ઠંડી પ્રકારની છે વસ્તુ

36
00:02:38,980 --> 00:02:47,060
છે કે અમે બીજી માહિતી માળખું, એરે શીર્ષ પર મુક્યા માહિતી માળખું બનાવી રહ્યાં છો.

37
00:02:47,060 --> 00:02:50,110
ત્યાં અલગ રન ટાઇમ સ્ટેકનું અમલ માર્ગો છે.

38
00:02:50,110 --> 00:02:54,250
અમે તેને તદ્દન હજી પરંતુ આસ્થાપૂર્વક તે સંલગ્ન યાદી સમસ્યાઓ કરી પછી, શું કરશે,

39
00:02:54,250 --> 00:03:00,520
તમે જોશો કે તમે કેવી રીતે સરળતાથી કડી થયેલ યાદી ટોચ પર એક તેમજ સ્ટેક અમલ કરી શકે છે.

40
00:03:00,520 --> 00:03:02,640
પરંતુ હવે માટે, અમે એરે વળગી પડશે.

41
00:03:02,640 --> 00:03:06,350
તેથી ફરી, બધા અમે જરૂર ઝાકઝમાળ છે અને અમે માત્ર એરે માપ ટ્રેક કરવાની જરૂર છે.

42
00:03:06,350 --> 00:03:09,850
[સેમ] માફ કરશો, તો તે શા માટે છે કે તમે કહ્યું હતું કે, આ સ્ટેક શબ્દમાળાઓ ટોચ પર છે?

43
00:03:09,850 --> 00:03:13,440
મને એવું લાગે છે જેમ શબ્દમાળાઓ સ્ટેક અંદર હોય છે.

44
00:03:13,440 --> 00:03:16,790
[Hardison] યાહ. અમે બનાવી રહ્યા છીએ, અમે અમારા એરે માહિતી માળખું વાત કરી રહ્યાં છે -

45
00:03:16,790 --> 00:03:22,130
કે જે મહાન પ્રશ્ન છે. તેથી પ્રશ્ન શા માટે લોકો આ ઑનલાઇન જોવાનું આવે છે,

46
00:03:22,130 --> 00:03:24,140
અમે શા માટે કહે છે કે સ્ટેક આ શબ્દમાળાઓ ટોચ પર છે,

47
00:03:24,140 --> 00:03:27,990
કારણ કે અહીં તે જેમ શબ્દમાળાઓ સ્ટેક અંદર છે લાગે છે?

48
00:03:27,990 --> 00:03:31,050
જે તદ્દન કેસ છે.

49
00:03:31,050 --> 00:03:34,660
હું ઉલ્લેખ કરવામાં આવ્યો હતો શું હતું કે અમે એક એરે માહિતી માળખું મેળવ્યા છે.

50
00:03:34,660 --> 00:03:39,290
અમે ઘરનાં પરચૂરણ કામો * ઓ ઝાકઝમાળ, શબ્દમાળાઓ આ એરે મળી છે,

51
00:03:39,290 --> 00:03:45,300
અને અમે તે માટે ઉમેરો કરવા માટે સ્ટૅક્ડ માહિતી માળખું ઊભું થવાનું છે.

52
00:03:45,300 --> 00:03:48,620
>> તેથી સ્ટેક થોડી વધારે ઝાકઝમાળ કરતાં જટિલ છે.

53
00:03:48,620 --> 00:03:51,890
અમે એક એરે ઉપયોગ સ્ટેક બનાવી શકો છો.

54
00:03:51,890 --> 00:03:55,810
તેથી કે જ્યાં અમે કહે છે કે સ્ટેક ઝાકઝમાળ ટોચ પર બનેલ છે.

55
00:03:55,810 --> 00:04:02,510
તેવી જ રીતે, હું અગાઉ જણાવ્યું હતું કે, જેમ અમે યાદીની લિંક ટોચ પર એક સ્ટેક બનાવી શકો છો.

56
00:04:02,510 --> 00:04:04,960
તેના બદલે એક એરે મદદથી અમારી તત્વો ધરાવે છે એક,

57
00:04:04,960 --> 00:04:10,070
અમે સંલગ્ન યાદી વાપરવા માટે અમારા તત્વો ધરાવે છે અને તે આસપાસ સ્ટેક બિલ્ડ કરી શકે છે.

58
00:04:10,070 --> 00:04:12,420
ચાલો ઉદાહરણો એક દંપતી દ્વારા ચાલી, અમુક કોડ અંતે looking,

59
00:04:12,420 --> 00:04:14,960
શું ખરેખર અહીં ચાલી રહ્યું છે.

60
00:04:14,960 --> 00:04:23,400
ડાબી બાજુ પર, હું નીચે ફેંકી કર્યું છે કે સ્ટેક સ્ટ્રક્ટ શું મેમરી જોવા કરશે

61
00:04:23,400 --> 00:04:28,330
જો ક્ષમતા # ચાર પ્રયત્ન વ્યાખ્યાયિત કરવામાં આવી હતી.

62
00:04:28,330 --> 00:04:33,490
અમે અમારા ચાર તત્વ ઘરનાં પરચૂરણ કામો * એરે મેળવ્યા છે.

63
00:04:33,490 --> 00:04:38,110
અમે શબ્દમાળાઓ [0] શબ્દમાળાઓ [1], શબ્દમાળાઓ [2] શબ્દમાળાઓ, [3], મળી છે

64
00:04:38,110 --> 00:04:43,800
અને પછી અમારી કદની પૂર્ણાંક માટે તે છેલ્લા જગ્યા.

65
00:04:43,800 --> 00:04:46,270
શું આ અર્થમાં છે? ઠીક છે.

66
00:04:46,270 --> 00:04:48,790
આ શું થાય છે જો હું શું જમણી બાજુ પર કરવા માટે,

67
00:04:48,790 --> 00:04:55,790
જે મારી કોડ હશે, માત્ર એક સ્ટ્રક્ટ, સ્ટેક ઓ કહેવાય સ્ટ્રક્ટ જાહેર છે.

68
00:04:55,790 --> 00:05:01,270
આ આપણે શું મળે છે. તે મેમરીમાં આ પદચિહ્ન મૂકે છે.

69
00:05:01,270 --> 00:05:05,590
પ્રથમ અહીં પ્રશ્ન એ છે કે આ સ્ટેક સ્ટ્રક્ટ સમાવિષ્ટો શું છે?

70
00:05:05,590 --> 00:05:09,250
હમણાં તેઓ કંઇ છીએ, પરંતુ તેઓ તદ્દન કશું નથી.

71
00:05:09,250 --> 00:05:13,300
તેઓ કચરો આ પ્રકારની છો. અમે કોઇ વિચાર શું તેમને છે હોય છે.

72
00:05:13,300 --> 00:05:17,000
જ્યારે અમે સ્ટેક ઓ જાહેર, અમે માત્ર કે ફેંકવાની કરી રહ્યાં છો મેમરી શીર્ષ પર નહીં.

73
00:05:17,000 --> 00:05:19,840
તે પૂર્ણાંક હું જાહેર અને પ્રારંભ નથી તે જેવા પ્રકારની છે.

74
00:05:19,840 --> 00:05:21,730
તમે જાણતા નથી કે શું ત્યાં છે. તમે વાંચી શકો છો શું ત્યાં છે,

75
00:05:21,730 --> 00:05:27,690
પરંતુ તે સુપર ન હોઈ મદદરૂપ થઈ શકે છે.

76
00:05:27,690 --> 00:05:32,680
એક વાત તમે હંમેશા કરવા યાદ કરવા માંગો છો પ્રારંભ ગમે માટે આરંભ કરવાની જરૂર છે.

77
00:05:32,680 --> 00:05:35,820
આ કિસ્સામાં, અમે કદ પ્રારંભ કરવા માટે શૂન્ય હોઈ જઈ રહ્યાં છો,

78
00:05:35,820 --> 00:05:39,960
કારણ કે બહાર ચાલુ કરવા માટે અમારા માટે ખૂબ જ મહત્વપૂર્ણ હશે.

79
00:05:39,960 --> 00:05:43,450
અમે આગળ વધીશું અને પોઇંટરો તમામ, બધા ઘરનાં પરચૂરણ કામો * ઓ પ્રારંભ કરી શકે છે,

80
00:05:43,450 --> 00:05:49,670
કેટલાક સમજી કિંમત, કદાચ નલ છે.

81
00:05:49,670 --> 00:05:58,270
પરંતુ તે તદ્દન જરૂરી છે કે અમે આ કરી નથી.

82
00:05:58,270 --> 00:06:04,200
>> હવે, રન ટાઇમ સ્ટેકનું પર બે મુખ્ય કામગીરી છે?

83
00:06:04,200 --> 00:06:07,610
કોઈની વ્યાખ્યાન યાદ તમે શું રન ટાઇમ સ્ટેકનું સાથે કરે છે? હા?

84
00:06:07,610 --> 00:06:09,700
[સ્ટેલા] પુશિંગ અને ધાણી? ચોક્કસ. >>

85
00:06:09,700 --> 00:06:13,810
દબાણ અને ધાણી રન ટાઇમ સ્ટેકનું પર બે મુખ્ય કામગીરી છે.

86
00:06:13,810 --> 00:06:17,060
અને દબાણની શું થાય છે? >> તે ટોચ પર કંઈક મૂકે

87
00:06:17,060 --> 00:06:19,300
સ્ટેક, અને પછી ધાણી તે લે નહીં.

88
00:06:19,300 --> 00:06:23,150
[Hardison] ચોક્કસ. તેથી દબાણ સ્ટેક ઉપર કંઈક રન નોંધાયો નહીં.

89
00:06:23,150 --> 00:06:27,700
તે ડાઇનિંગ એક ડાઇનિંગ ટ્રે ગણક પર નીચે મૂકી સ્ટાફ જેવું છે.

90
00:06:27,700 --> 00:06:33,630
અને ધાણી એક ડાઇનિંગ ટ્રે લઈ આવે છે સ્ટેક નહીં.

91
00:06:33,630 --> 00:06:36,460
ચાલો શું થાય ઉદાહરણો એક દંપતી લઈ જવામાં

92
00:06:36,460 --> 00:06:39,720
જ્યારે અમે સ્ટેક માં વસ્તુઓ દબાણ.

93
00:06:39,720 --> 00:06:45,110
જો, અમે અમારા સ્ટેક પર 'હેલો' શબ્દમાળા દબાણ હતા

94
00:06:45,110 --> 00:06:49,760
આ છે આપણા રેખાકૃતિ શું હવે જોવા આવશે.

95
00:06:49,760 --> 00:06:53,410
શું થાય છે?

96
00:06:53,410 --> 00:06:56,530
અમે અમારા શબ્દમાળાઓ એરે પ્રથમ તત્વ દબાણ

97
00:06:56,530 --> 00:07:01,420
અને અમે અમારી કદની ગણતરી વધારીને માટે 1 છે.

98
00:07:01,420 --> 00:07:05,340
તેથી જો આપણે બે સ્લાઇડ્સ વચ્ચે તફાવત જોવા માટે, અહીં 0 હતો, અહીં દબાણ પહેલાં છે.

99
00:07:05,340 --> 00:07:08,690
અહીં દબાણ પછી છે.

100
00:07:08,690 --> 00:07:13,460
દબાણ પહેલાં, દબાણ પછી.

101
00:07:13,460 --> 00:07:16,860
અને હવે અમે અમારા સ્ટેક એક તત્વ છે.

102
00:07:16,860 --> 00:07:20,970
તે શબ્દમાળા "હેલો" છે, અને તે છે.

103
00:07:20,970 --> 00:07:24,440
એરે માં બીજું બધું, અમારા શબ્દમાળાઓ એરે માં, હજુ પણ છે કચરો.

104
00:07:24,440 --> 00:07:27,070
અમે તેને આરંભ છે.

105
00:07:27,070 --> 00:07:29,410
હવે કહો કે અમે અમારા સ્ટેક પર અન્ય શબ્દમાળા દબાણ.

106
00:07:29,410 --> 00:07:32,210
અમે આ સમય પર "વિશ્વ" દબાણ રહ્યા છીએ.

107
00:07:32,210 --> 00:07:35,160
આમ તમે જોઈ શકે છે "વિશ્વ" અહીં "હેલો" શીર્ષ પર જાય છે,

108
00:07:35,160 --> 00:07:40,040
અને માપ ગણતરી માટે 2 વધતું જાય છે.

109
00:07:40,040 --> 00:07:44,520
હવે અમે "CS50", અને તે ટોચ પર ફરી જઈશ દબાણ કરી શકો છો.

110
00:07:44,520 --> 00:07:51,110
જો અમે પાછા જાઓ, તમે જોઈ શકો છો કે અમે કેવી રીતે સ્ટેક ટોચ પર વસ્તુઓ દબાણ કરી રહ્યાં છે.

111
00:07:51,110 --> 00:07:53,320
અને હવે અમે પૉપ મેળવો.

112
00:07:53,320 --> 00:07:58,910
જ્યારે આપણે સ્ટેક બોલ કંઈક પોપ, શું થયું?

113
00:07:58,910 --> 00:08:01,540
કોઈની તફાવત જુઓ છો? તે ખૂબ ગૂઢ છે.

114
00:08:01,540 --> 00:08:05,810
[વિદ્યાર્થી] આ માપ. >> અરે વાહ, આ માપ બદલાઈ.

115
00:08:05,810 --> 00:08:09,040
>> બીજું શું તમે તેને બદલવા માટે અપેક્ષિત હોત?

116
00:08:09,040 --> 00:08:14,280
[વિદ્યાર્થી] આ પણ શબ્દમાળાઓ. >> અધિકાર. ખૂબ શબ્દમાળાઓ.

117
00:08:14,280 --> 00:08:17,110
તે તારણ છે કે જ્યારે તમે તેને આ રીતે કરી રહ્યા છીએ,

118
00:08:17,110 --> 00:08:21,960
કારણ કે અમે તત્વો અમારી સ્ટેક માં નકલ કરી રહ્યા છો,

119
00:08:21,960 --> 00:08:24,670
અમે ખરેખર કશું કરવાનું નથી; આપણે માત્ર કદ ઉપયોગ કરી શકો છો

120
00:08:24,670 --> 00:08:28,630
વસ્તુઓ સંખ્યા અમારી એરે ટ્રૅક રાખવા

121
00:08:28,630 --> 00:08:33,780
જેથી જ્યારે અમે ફરી પૉપ, ફરી અમે ફક્ત 1 અમારી કદ નીચે હ્રાસ.

122
00:08:33,780 --> 00:08:39,440
ત્યાં કોઈ વાસ્તવમાં માં જાઓ અને કંઈપણ પર ફરીથી લખી જરૂર નથી.

123
00:08:39,440 --> 00:08:41,710
ફંકી પ્રકારની.

124
00:08:41,710 --> 00:08:46,520
તે તારણ છે કે અમે લાક્ષણિક રીતે માત્ર વસ્તુઓ એકલા છોડી કારણ કે તે ઓછું કામ અમારા માટે શું કરવું.

125
00:08:46,520 --> 00:08:50,060
જો અમે પાછા જવા માટે અને કાંઇક પર ફરીથી લખી નથી, તો પછી તે શા માટે કરે છે?

126
00:08:50,060 --> 00:08:54,150
તેથી જ્યારે અમે સ્ટેક બે વાર બોલ પૉપ, બધા કરે છે જે છે કદ વખત બે હ્રાસ.

127
00:08:54,150 --> 00:08:59,120
અને ફરીથી, આ માત્ર કારણ કે અમે વસ્તુઓ અમારા સ્ટેક માં નકલ કરી રહ્યા છીએ.

128
00:08:59,120 --> 00:09:01,320
હા? આગળ જાઓ.

129
00:09:01,320 --> 00:09:04,460
[વિદ્યાર્થી, દુર્બોધ] >> અને પછી શું થાય છે જ્યારે તમે કંઈક ફરીથી દબાણ?

130
00:09:04,460 --> 00:09:08,570
જ્યારે તમે કંઈક ફરીથી દબાણ, જ્યાં તે જાઓ નથી?

131
00:09:08,570 --> 00:09:12,390
તે છે, જ્યાં નથી બેસિલ જાઓ? [1] શબ્દમાળાઓ ઇનટુ >>? >> અધિકાર.

132
00:09:12,390 --> 00:09:14,530
તે [3] શબ્દમાળાઓ માં શા માટે ન જાય છે?

133
00:09:14,530 --> 00:09:19,410
[બેસિલ] કારણ કે તે ભૂલી ગયા છે કે શબ્દમાળાઓ પણ હતા [1] અને [2]

134
00:09:19,410 --> 00:09:24,040
[Hardison] ચોક્કસ. અમારા સ્ટેક છે, જરૂરીયાતમાં, "ભૂલી ગયા હતા કે" તે પર કંઈપણ કરવા માટે હોલ્ડિંગ હતી

135
00:09:24,040 --> 00:09:29,480
શબ્દમાળાઓ માં [1] અથવા શબ્દમાળાઓ [2] છે, તેથી જ્યારે અમે "woot" દબાણ

136
00:09:29,480 --> 00:09:36,670
તે ફક્ત તત્વ માં [1] શબ્દમાળાઓ ખાતે મૂકે છે.

137
00:09:36,670 --> 00:09:41,590
આ કેવી રીતે કામ કરે છે તેના પર કોઇ પ્રશ્નો ત્યાં મૂળભૂત સ્તરે છે?

138
00:09:41,590 --> 00:09:45,160
[સેમ] તેથી કોઈપણ રીતે ગતિશીલ નથી જથ્થો દ્રષ્ટિએ છે

139
00:09:45,160 --> 00:09:47,620
અથવા સ્ટેક કદની બાબતમાં?

140
00:09:47,620 --> 00:09:56,750
[Hardison] ચોક્કસ. આ છે - બિંદુ હતું કે આ એક ગતિશીલ growning સ્ટેક ન હતી.

141
00:09:56,750 --> 00:10:02,850
આ એક સ્ટેક કે, મોટા ભાગના ચાર ઘરનાં પરચૂરણ કામો * ઓ ખૂબ ચાર બાબતો છે, પકડી શકે છે.

142
00:10:02,850 --> 00:10:07,580
જો અમે પ્રયાસ અને એક પાંચમા વસ્તુ દબાણ હતા, તમે શું વિચારો છો કરીશું થાય?

143
00:10:07,580 --> 00:10:11,870
[વિદ્યાર્થીઓ, દુર્બોધ]

144
00:10:11,870 --> 00:10:14,600
[Hardison] ચોક્કસ. ત્યાં વસ્તુઓ છે કે જે બની શકે છે તેમ એક નંબર છે.

145
00:10:14,600 --> 00:10:19,330
તે કદાચ દોષ seg શકે આપણે શું હતા તેના પર આધાર રાખીને -

146
00:10:19,330 --> 00:10:22,530
ખરેખર કેવી રીતે અમે બેક અમલમાં આવી હતી.

147
00:10:22,530 --> 00:10:31,740
તે પર ફરીથી લખી શકે છે. તે બફર ઓવરફ્લો કે અમે વર્ગમાં વિશે વાત કરી શકે છે.

148
00:10:31,740 --> 00:10:35,240
શું સૌથી સ્પષ્ટ બાબત ફરીથી લખાઈ હોઈ શકે થશે

149
00:10:35,240 --> 00:10:42,370
જો અમે અમારી સ્ટેક પર વધારાની વસ્તુ દબાણ કરવાનો પ્રયત્ન કર્યો હતો?

150
00:10:42,370 --> 00:10:44,550
તેથી તમે એક બફર ઓવરફ્લો ઉલ્લેખ કર્યો છે.

151
00:10:44,550 --> 00:10:47,870
શું ચીજ છે કે ઉપર લખાયેલ કરશે અથવા stomped હોઈ શકે છે

152
00:10:47,870 --> 00:10:52,320
જો આપણે વધારાનો વસ્તુ દબાણ કરવાનો પ્રયાસ દ્વારા આકસ્મિક overflowed?

153
00:10:52,320 --> 00:10:54,730
[ડીએલ, દુર્બોધ] >> શક્ય.

154
00:10:54,730 --> 00:10:58,440
પરંતુ શરૂઆતમાં, શું થાય શકે છે? જો આપણે એક ચોથા વસ્તુ દબાણ કરવાનો પ્રયત્ન કર્યો હતો?

155
00:10:58,440 --> 00:11:06,220
આ મેમરી રેખાકૃતિ કે અમે મળી છે સાથે ઓછામાં ઓછા માપ, પર ફરીથી લખી શકે છે.

156
00:11:06,220 --> 00:11:10,880
>> સમસ્યા સેટ સ્પષ્ટીકરણમાં, કે જે અમે શું કરીએ અમલ કરી આજે જઈ રહ્યાં છો,

157
00:11:10,880 --> 00:11:16,030
અમે આમ કરવા માંગો છો શું માત્ર ખોટા પરત આવે છે.

158
00:11:16,030 --> 00:11:20,030
અમારા દબાણ પદ્ધતિ એ બુલિયન કિંમત પાછી રહ્યું છે,

159
00:11:20,030 --> 00:11:22,920
અને તે બુલિયન કિંમત સાચી હોઈ શકે જો દબાણ સફળ થશે

160
00:11:22,920 --> 00:11:29,730
અને ખોટા જો અમે વધુ કંઇ નથી કારણ કે દબાણ સ્ટેક સંપૂર્ણ છે.

161
00:11:29,730 --> 00:11:33,620
ચાલો કે કોડ થોડો દ્વારા હમણાં નીકળી જાવ.

162
00:11:33,620 --> 00:11:36,400
અહીં અમારા દબાણ કાર્ય છે.

163
00:11:36,400 --> 00:11:40,380
અમારા સ્ટેક માટે દબાણ કામ કરવા માટે શબ્દમાળા માં લેવા માટે સ્ટેક પર મૂકી રહ્યું છે.

164
00:11:40,380 --> 00:11:45,820
તે સાચું પરત ચાલી રહ્યું છે જો શબ્દમાળા સફળતાપૂર્વક દબાણ કરવામાં આવ્યું હતું

165
00:11:45,820 --> 00:11:51,820
સ્ટેક અને ખોટા અન્યથા છે.

166
00:11:51,820 --> 00:11:59,740
શું કોઈ સૂચનો સારા પ્રથમ અહીં વસ્તુ હોઈ શકે છે?

167
00:11:59,740 --> 00:12:20,630
[સેમ] જો માપ ક્ષમતા સમકક્ષ પછી ખોટા પાછા?

168
00:12:20,630 --> 00:12:23,320
[Hardison] બિન્ગો. નાઇસ જોબ.

169
00:12:23,320 --> 00:12:26,310
જો માપ ક્ષમતા છે, અમે ખોટા પાછા જઈ રહ્યાં છો.

170
00:12:26,310 --> 00:12:29,270
અમે અમારા સ્ટેક વધુ કંઇ નથી મૂકી શકો છો.

171
00:12:29,270 --> 00:12:36,900
અન્યથા, અમે સ્ટેક ટોચ પર કંઈક મૂકેલ.

172
00:12:36,900 --> 00:12:41,670
"સ્ટેક ટોચ," શરૂઆતમાં શું છે?

173
00:12:41,670 --> 00:12:43,650
[ડીએલ] કદ 0? >> 0 માપ.

174
00:12:43,650 --> 00:12:49,990
સ્ટેક પછી ત્યાં સ્ટેક એક વાત છે ઉપરની શું છે? Missy, તમે જાણો છો?

175
00:12:49,990 --> 00:12:52,720
[Missy] એક. >> કદ એક બરાબર છે. તમે કદ ઉમેરીને રાખવા માટે,

176
00:12:52,720 --> 00:13:01,690
અને દરેક વખતે જ્યારે તમે એરે માં ઇન્ડેક્સ કદ ખાતે નવું તત્વ માં આપી રહ્યા છીએ.

177
00:13:01,690 --> 00:13:05,470
અમે તેને એક લાઇનર તે પ્રકારના સાથે કરવા માટે, જો તે અર્થમાં બનાવે કરી શકો છો.

178
00:13:05,470 --> 00:13:11,910
જેથી અમે અમારા શબ્દમાળાઓ એરે મળી છે, તો અમે તેને માપ અનુક્રમણિકા પર ઍક્સેસ જઈ રહ્યાં છો,

179
00:13:11,910 --> 00:13:14,780
અને અમે હમણાં જ ત્યાં અમારા ઘરનાં પરચૂરણ કામો * સંગ્રહવા જઈ રહ્યાં છો.

180
00:13:14,780 --> 00:13:19,340
નોંધ કેવી રીતે ત્યાં કોઈ શબ્દમાળા નકલ અહીં છે રહ્યું,

181
00:13:19,340 --> 00:13:29,680
મેમરી કોઈ ગતિશીલ ફાળવણી?

182
00:13:29,680 --> 00:13:34,440
અને પછી Missy અપ લાવવામાં આપણે હવે હોય તો,

183
00:13:34,440 --> 00:13:40,570
કારણ કે અમે એરે યોગ્ય જગ્યાએ શબ્દમાળા સ્ટોર કરી,

184
00:13:40,570 --> 00:13:49,230
અને તેને જણાવ્યું હતું કે અમે એક માપ વધારો કે જેથી અમે આગામી દબાણ કરવા માટે તૈયાર છો હતો.

185
00:13:49,230 --> 00:13:53,950
તેથી અમે s.size સાથે કરી શકો છો + +.

186
00:13:53,950 --> 00:13:59,330
આ બિંદુએ, અમે અમારી એરે દબાણ કર્યું છે. છેલ્લા વસ્તુ અમે હોય તો શું છે?

187
00:13:59,330 --> 00:14:10,110
[વિદ્યાર્થી] સાચું પાછા ફરો. >> સાચું પાછા ફરો.

188
00:14:10,110 --> 00:14:14,690
તેથી તે ખૂબ સરળ છે, એક ખૂબ સરળ કોડ. ખૂબ જ નથી.

189
00:14:14,690 --> 00:14:17,070
એકવાર તમે કેવી રીતે કામ કરે છે સ્ટેક આસપાસ તમારા માથા આવરિત કરી લીધી છે,

190
00:14:17,070 --> 00:14:21,910
આ ખૂબ અમલ સરળ છે.

191
00:14:21,910 --> 00:14:26,390
>> હવે, આ આગામી ભાગ સ્ટેક શબ્દમાળા બોલ પોપિંગ છે.

192
00:14:26,390 --> 00:14:29,410
હું તમને ગાય્ઝ કેટલાક આ થોડો સમય પર કામ આપી જાઉં છું.

193
00:14:29,410 --> 00:14:34,320
તે લગભગ અનિવાર્ય આપણે શું દબાણ અહીં કર્યું છે તે રિવર્સ છે.

194
00:14:34,320 --> 00:14:38,510
હું કર્યું છે ખરેખર શું છે - oops.

195
00:14:38,510 --> 00:14:48,160
હું બુટ કર્યા છે તે અહીં ઉપર, અને સાધન એક સાધન,

196
00:14:48,160 --> 00:14:53,600
હું ખેંચાતું કરેલા સમસ્યા 5 સ્પષ્ટીકરણ સુયોજિત કરો.

197
00:14:53,600 --> 00:15:02,560
જો અમે અહીં ઝૂમ, અમે જોઈ શકે છે હું cdn.cs50.net/2012/fall/psets/pset5.pdf અંતે છું.

198
00:15:02,560 --> 00:15:08,590
શું તમે આ ગાય્સ કોડ કે અહીં સ્થિત છે, section6.zip ડાઉનલોડ?

199
00:15:08,590 --> 00:15:15,030
અધિકાર છે. જો તમે ન કર્યું હોય કે, હમણાં જ તે કરવા, ખરેખર ઝડપથી.

200
00:15:15,030 --> 00:15:22,130
હું તેને મારા ટર્મિનલ વિન્ડોમાં કરવું પડશે.

201
00:15:22,130 --> 00:15:25,090
હું ખરેખર તેને અહીં કર્યું છે. યાહ.

202
00:15:25,090 --> 00:15:34,730
હા, સેમ? >> હું તમને કદ 'ઓ s.string કૌંસ શા માટે કહ્યું નહોતું str = વિશે કોઈ પ્રશ્ન છે?

203
00:15:34,730 --> 00:15:42,910
Str શું છે? છે કે જે પહેલાં ક્યાંક વ્યાખ્યાયિત, અથવા - ઓહ, તો ઘરનાં પરચૂરણ કામો * str છે?

204
00:15:42,910 --> 00:15:47,160
[Hardison] હા, બરાબર. કે દલીલ હતી. >> ઓહ, ઠીક છે. માફ કરશો.

205
00:15:47,160 --> 00:15:49,470
[Hardison] અમે સાઇન દબાણ શબ્દમાળા સ્પષ્ટ કરી રહ્યા છીએ

206
00:15:49,470 --> 00:15:55,220
અન્ય પ્રશ્ન છે કે જે આવે છે કે અમે ખરેખર અહીં વિશે વાત ન શકે હતો

207
00:15:55,220 --> 00:15:58,810
અમે લીધો માટે મંજૂર છે કે અમે આ ઓ કહેવાય ચલ હતી

208
00:15:58,810 --> 00:16:02,710
કે અવકાશ અને અમને સુલભ હતી.

209
00:16:02,710 --> 00:16:06,960
અમે લીધો માટે મંજૂર છે કે ઓ આ સ્ટેક સ્ટ્રક્ટ હતી.

210
00:16:06,960 --> 00:16:08,930
તેથી આ દબાણ કોડ અંતે પાછા looking,

211
00:16:08,930 --> 00:16:13,450
તમે જોઈ શકો છો કે જે આપણે આ શબ્દમાળા કે માં પસાર થયો સાથે સામગ્રી કરી રહ્યા છીએ

212
00:16:13,450 --> 00:16:19,210
પરંતુ પછી અચાનક તમામ, અમે s.size ઍક્સેસ કરો છો, જેમ કે, જ્યાં s પરથી આવ્યા હતા?

213
00:16:19,210 --> 00:16:23,020
તે કોડ અમે વિભાગ પેટીમાં જોવા જઈ રહ્યાં છો ફૂટ

214
00:16:23,020 --> 00:16:27,100
અને પછી તે સામગ્રી છે કે તમે તમારી સમસ્યા માં કરી આવશે સુયોજિત કરે છે,

215
00:16:27,100 --> 00:16:32,440
અમે કર્યા અમારા સ્ટેક વૈશ્વિક ચલ સ્ટ્રક્ટ

216
00:16:32,440 --> 00:16:36,380
જેથી અમે અમારા તમામ વિવિધ કાર્યો તેને ઍક્સેસ કરી શકો છો

217
00:16:36,380 --> 00:16:40,630
તેને જાતે પસાર આસપાસ અને તે સંદર્ભ દ્વારા પસાર કર્યા વગર,

218
00:16:40,630 --> 00:16:44,870
તે સામગ્રી તમામ પ્રકારની હોય છે.

219
00:16:44,870 --> 00:16:52,280
અમે હમણાં જ થોડો છેતરપિંડી કરી રહ્યાં છે જો તમે કરશે, માટે NICER વસ્તુઓ બનાવે છે.

220
00:16:52,280 --> 00:16:57,430
અને તે કંઈક અહીં કરી રહ્યા છીએ કારણ કે તે આનંદ માટે છે તેને સરળ છે.

221
00:16:57,430 --> 00:17:02,800
ઘણી વખત, તમે લોકો આવું જોવા જો તેઓ એક મોટા માહિતી માળખું પડશે

222
00:17:02,800 --> 00:17:07,750
કે તેમના કાર્યક્રમ અંદર આવી રહી છે પર સંચાલિત.

223
00:17:07,750 --> 00:17:09,560
>> ચાલો આ ઉપકરણ પર પાછા જાઓ.

224
00:17:09,560 --> 00:17:15,240
શું બધાને સફળતાપૂર્વક section6.zip મળી શકે?

225
00:17:15,240 --> 00:17:20,440
એવરીબડી તે ઝિપસાંકળ છોડવી ઝિપસાંકળ છોડવી section6.zip મદદથી?

226
00:17:20,440 --> 00:17:27,200
જો તમે કલમ 6 ડિરેક્ટરીમાં જાઓ -

227
00:17:27,200 --> 00:17:29,220
આહ, બધા એક જ સ્થળ પર -

228
00:17:29,220 --> 00:17:32,840
અને તમે શું યાદી અહીં છે, તો તમે જોશો કે તમે ત્રણ અલગ સી. ફાઈલો મેળવ્યા છે.

229
00:17:32,840 --> 00:17:38,350
તમે એક કતાર, એક sll, કે જે singly સાથે જોડાયેલી યાદી છે અને સ્ટેક મેળવ્યા છે.

230
00:17:38,350 --> 00:17:44,600
જો તમે stack.c ખોલો,

231
00:17:44,600 --> 00:17:47,330
તમે જોઈ શકો છો કે જે આપણે આ આપણા માટે વ્યાખ્યાયિત સ્ટ્રક્ટ મળી છે,

232
00:17:47,330 --> 00:17:51,330
ચોક્કસ સ્ટ્રક્ટ કે અમે ફક્ત સ્લાઇડ્સ માં વિશે વાત કરી.

233
00:17:51,330 --> 00:17:56,340
અમે સ્ટેક માટે અમારા વૈશ્વિક ચલ મળ્યો છે,

234
00:17:56,340 --> 00:18:00,110
અમે અમારા દબાણ કાર્ય મળી છે,

235
00:18:00,110 --> 00:18:04,230
અને પછી અમે અમારી પોપ કાર્ય મેળવ્યા છે.

236
00:18:04,230 --> 00:18:08,320
હું કોડ મૂકવા માટે પાછા દબાણ અપ સ્લાઇડ પર અહીં પડશે,

237
00:18:08,320 --> 00:18:10,660
પરંતુ હું તમને ગાય્ઝ કરવું કરવા માંગો છો શું તમારી ક્ષમતા શ્રેષ્ઠ છે,

238
00:18:10,660 --> 00:18:13,790
જાઓ અને પોપ કાર્ય અમલ.

239
00:18:13,790 --> 00:18:18,480
એકવાર તમે તેને અમલમાં છે, તો તમે સ્ટેક બનાવવા સાથે આ કમ્પાઇલ કરી શકો છો,

240
00:18:18,480 --> 00:18:22,540
અને પછી ફલસ્વરૂપ સ્ટેક એક્ઝેક્યુટેબલ ચલાવવા માટે,

241
00:18:22,540 --> 00:18:28,390
અને એ કે આ ટેસ્ટ કોડ તમામ નીચે અહીં કે મુખ્ય માં છે ચાલશે.

242
00:18:28,390 --> 00:18:31,060
અને મુખ્ય વાસ્તવમાં દબાણ અને પોપ કોલ કરવા કાળજી લે છે

243
00:18:31,060 --> 00:18:33,220
અને ખાતરી કરો કે બધું બધા અધિકાર જાય બનાવે છે.

244
00:18:33,220 --> 00:18:36,820
તે સ્ટેક કદ અહીં પ્રારંભ

245
00:18:36,820 --> 00:18:39,780
તેથી તમે તે પ્રારંભ ચિંતા નથી.

246
00:18:39,780 --> 00:18:42,310
તમે ધારણ કરી શકે છે કે તે યોગ્ય રીતે આરંભ છે

247
00:18:42,310 --> 00:18:48,000
સમય કે તમે તેને પોપ કામગીરીમાં ઍક્સેસ દ્વારા.

248
00:18:48,000 --> 00:18:53,530
એ નથી કે સૂઝ છે?

249
00:18:53,530 --> 00:19:00,100
અહીં અમે જાઓ. ત્યાં દબાણ કોડ છે.

250
00:19:00,100 --> 00:19:13,210
હું તમને 5 ગાય્સ અથવા 10 મિનિટો આપી શકશો.

251
00:19:13,210 --> 00:19:15,690
અને જો તમે વચગાળાનું કોઈપણ પ્રશ્નો હોય, તો તમે જ્યારે કોડિંગ કરી રહ્યાં છો,

252
00:19:15,690 --> 00:19:17,710
પૂછશો બહાર અવાજે કરો.

253
00:19:17,710 --> 00:19:23,080
તેથી જો તમે ચોંટતા બિંદુ મેળવવા માટે, ફક્ત પૂછો.

254
00:19:23,080 --> 00:19:26,030
મને જણાવો, તો બીજા બધાને ખબર.

255
00:19:26,030 --> 00:19:28,160
તમારા પાડોશી સાથે પણ કામ કરે છે.

256
00:19:28,160 --> 00:19:30,360
[ડીએલ] અમે ફક્ત પોપ કરી રહ્યાં છો હમણાં અમલમાં? >> જસ્ટ પોપ.

257
00:19:30,360 --> 00:19:34,200
જોકે તમે દબાણની અમલીકરણ નકલ જો તમે ઇચ્છો કરી શકો છો

258
00:19:34,200 --> 00:19:37,780
કે જેથી પરીક્ષણ કામ કરશે.

259
00:19:37,780 --> 00:19:41,940
કારણ કે તે મુશ્કેલ માં મેળવવામાં વસ્તુઓ પરીક્ષણ -

260
00:19:41,940 --> 00:19:49,030
અથવા, તે મુશ્કેલ ધાણી વસ્તુઓ પરીક્ષણ એક સ્ટેક જો ત્યાં સ્ટેક પણ સાથે શરૂ નથી.

261
00:19:49,030 --> 00:19:55,250
>> પરત આવવી જોઈએ પોપ શું છે? સ્ટેક ટોચ માંથી તત્વ.

262
00:19:55,250 --> 00:20:01,260
તે સ્ટેક ટોચની તત્વ બોલ વિચાર તેવું માનવામાં આવે છે

263
00:20:01,260 --> 00:20:05,780
અને પછી સ્ટેક કદ હ્રાસ,

264
00:20:05,780 --> 00:20:07,810
અને હવે તમે ટોચ પર તત્વ ગુમાવ્યું છે.

265
00:20:07,810 --> 00:20:11,420
અને પછી તમે ટોચ પર તત્વ આવો.

266
00:20:11,420 --> 00:20:20,080
[વિદ્યાર્થી, દુર્બોધ]

267
00:20:20,080 --> 00:20:28,810
[Hardison] તેથી શું થાય છે જો તમે કે શું કરું? [વિદ્યાર્થી, દુર્બોધ]

268
00:20:28,810 --> 00:20:34,000
શું અંત થાય છે અપ રહ્યું છે તો તમે ક્યાં તો ઍક્સેસ કરો છો

269
00:20:34,000 --> 00:20:37,350
એક તત્વ છે કે જે હજુ સુધી કરવામાં આવી નથી આરંભ છે, જેથી તમારા ગણતરી

270
00:20:37,350 --> 00:20:39,990
જ્યાં છેલ્લા તત્વ છે બંધ છે.

271
00:20:39,990 --> 00:20:46,260
અહીં, જો તમે નોટિસ, પુશ માં, અમે s.size તત્વ અંતે શબ્દમાળાઓ ઍક્સેસ કરો છો

272
00:20:46,260 --> 00:20:48,560
કારણ કે તે એક નવા ઇન્ડેક્સ છે.

273
00:20:48,560 --> 00:20:51,460
તે સ્ટેક નવી ટોચ છે.

274
00:20:51,460 --> 00:21:01,100
પોપ, જ્યારે s.size આગામી જગ્યા હોવી રહ્યું છે,

275
00:21:01,100 --> 00:21:05,210
આ જગ્યા છે કે જે તમારા સ્ટેક તમામ તત્વો ટોચ પર છે.

276
00:21:05,210 --> 00:21:10,050
તેથી તત્વ ટોચ સૌથી s.size અંતે નથી,

277
00:21:10,050 --> 00:21:14,930
પરંતુ, તેને નીચે છે.

278
00:21:14,930 --> 00:21:19,640
>> અન્ય કરવા તમે જ્યારે વસ્તુ - પોપ માં,

279
00:21:19,640 --> 00:21:22,030
તો કદ હ્રાસ નથી.

280
00:21:22,030 --> 00:21:28,750
જો તમે અમારી થોડી રેખાકૃતિ પાછા અહીં યાદ રાખો કે,

281
00:21:28,750 --> 00:21:30,980
ખરેખર, આ જ વસ્તુ છે કે અમે થઇ રહ્યું હતો જ્યારે અમે પોપ કહેવાય

282
00:21:30,980 --> 00:21:36,150
હતું કે આ કદ પ્રથમ માટે 2 ગઇ, પછી 1 થી.

283
00:21:36,150 --> 00:21:42,620
પછી જ્યારે અમે પર નવી તત્વ દબાણ, તેના પર યોગ્ય સ્થળે જતા રહેશે.

284
00:21:42,620 --> 00:21:49,610
[બેસિલ] જો s.size 2 છે, પછી તે 2 તત્વ ન જઈ શકે છે,

285
00:21:49,610 --> 00:21:54,400
અને પછી તમે તે તત્વ પૉપ બોલ માંગો છો છો?

286
00:21:54,400 --> 00:21:59,510
તેથી જો આપણે ગયા - >> તેથી આપણે આ અંતે ફરીથી જુઓ.

287
00:21:59,510 --> 00:22:07,730
જો આ બિંદુ પર અમારી સ્ટેક છે

288
00:22:07,730 --> 00:22:12,130
અને અમે પોપ કહી,

289
00:22:12,130 --> 00:22:16,150
જેમાં ઇન્ડેક્સ તત્વ ટોચ સૌથી છે?

290
00:22:16,150 --> 00:22:19,300
[બેસિલ] 2 મુ છે, પરંતુ તેને 3 પૉપ બનશે. >> અધિકાર.

291
00:22:19,300 --> 00:22:24,220
જેથી જ્યાં અમારી કદ 3 છે, પરંતુ અમે 2 અનુક્રમણિકા ખાતે તત્વ પૉપ કરવા માંગો છો.

292
00:22:24,220 --> 00:22:29,900
તે એક છે કે જે તમે સંગ્રહ શૂન્ય-ઈન્ડેક્સીંગ સાથે હોય છે જે બંધ લાક્ષણિક પ્રકારની છે.

293
00:22:29,900 --> 00:22:36,430
તેથી તમે તૃતીય તત્વ પૉપ કરવા માંગો છો, પરંતુ ત્રીજા તત્વ 3 અનુક્રમણિકા પર નથી.

294
00:22:36,430 --> 00:22:39,430
અને કારણ અમે તે બાદ 1 કરવું જ્યારે અમે દબાણ કરી રહ્યાં ન હોય

295
00:22:39,430 --> 00:22:44,120
છે હમણાં કારણ કે, તમે નોંધ્યું છે કે જે તત્વ ટોચ સૌથી,

296
00:22:44,120 --> 00:22:47,600
, જો અમે આ સમયે સ્ટેક પર કંઈક બીજું દબાણ હતા

297
00:22:47,600 --> 00:22:50,360
અમે તેને 3 અનુક્રમણિકા પર દબાણ કરવા માંગો છો કરશે.

298
00:22:50,360 --> 00:23:03,550
અને તે માત્ર જેથી બને છે કે કદ અને સૂચકાંકોમાં અપ લાઇન જ્યારે તમે દબાણ કરી રહ્યાં છે.

299
00:23:03,550 --> 00:23:06,960
>> કોણ કામ સ્ટેક અમલીકરણ મળ્યું છે?

300
00:23:06,960 --> 00:23:09,690
તમે એક કામ એક સ્ટેક મેળવ્યા છે. શું તમને પૉપ હજુ સુધી કામ છે?

301
00:23:09,690 --> 00:23:11,890
[ડીએલ] હા. મને એવું લાગે છે.

302
00:23:11,890 --> 00:23:14,610
>> કાર્યક્રમ ચાલી રહ્યો છે અને seg faulting નથી, તેને છાપી છે?

303
00:23:14,610 --> 00:23:17,520
એ નથી કે તે આઉટ "સફળતા" છાપો જ્યારે તમે તેને ચલાવવા માટે?

304
00:23:17,520 --> 00:23:22,630
યાહ. થપ્પી કરવા માટે, તેને ચલાવવા માટે, જો તે "સફળતા" છાપે છે અને નથી ઝડપથી જાઓ નથી,

305
00:23:22,630 --> 00:23:26,000
પછી બધા સારી છે.

306
00:23:26,000 --> 00:23:34,070
અધિકાર છે. ચાલો આ ઉપકરણ પર ખરેખર ઝડપથી જાઓ,

307
00:23:34,070 --> 00:23:46,100
અને અમે આ દ્વારા લઈ જશું.

308
00:23:46,100 --> 00:23:51,110
જો આપણે શું થઈ રહ્યું છે તે પોપ સાથે અહીં જોવા,

309
00:23:51,110 --> 00:23:55,220
ડેનિયલ, શું પ્રથમ વસ્તુ કે જે તમે કર્યું હતું?

310
00:23:55,220 --> 00:23:58,850
[ડીએલ] જો s.size 0 કરતા વધારે છે.

311
00:23:58,850 --> 00:24:03,120
[Hardison] ઠીક. અને શા માટે છે કે જે તમને કરી?

312
00:24:03,120 --> 00:24:05,610
[ડીએલ] કરવા માટે ખાતરી કરો કે ત્યાં સ્ટેક અંદર કંઈક હતું બનાવે છે.

313
00:24:05,610 --> 00:24:10,950
[Hardison] અધિકાર. તમે ખાતરી કરો કે s.size 0 કરતાં મોટો છે ચકાસવા માંગો છો;

314
00:24:10,950 --> 00:24:13,280
અન્યથા, તમે શું કરવા છે કરવા માંગો છો?

315
00:24:13,280 --> 00:24:16,630
[ડીએલ] રીટર્ન નલ? >> રીટર્ન નલ, બરાબર.

316
00:24:16,630 --> 00:24:20,740
તેથી જો s.size 0 કરતા વધારે છે. પછી શું આપણે જોઈ રહ્યા છે છો?

317
00:24:20,740 --> 00:24:25,890
અમે તો શું સ્ટેક ખાલી નથી તો શું?

318
00:24:25,890 --> 00:24:31,210
[સ્ટેલા] તમે માપ હ્રાસ? >> તમે કદ હ્રાસ, ઠીક છે.

319
00:24:31,210 --> 00:24:34,440
તેથી તમે કેવી રીતે છે કે શું હતી? >> S.size -.

320
00:24:34,440 --> 00:24:37,030
[Hardison] ગ્રેટ. અને પછી તમે શું કરો છો?

321
00:24:37,030 --> 00:24:44,140
[સ્ટેલા] અને પછી હું વળતર s.string કહ્યું [s.size].

322
00:24:44,140 --> 00:24:48,560
[Hardison] ગ્રેટ.

323
00:24:48,560 --> 00:24:51,940
અન્યથા તમે નલ આવો. હા, સેમ?

324
00:24:51,940 --> 00:24:55,510
[સેમ] તે શા માટે જરૂર નથી s.size પ્રયત્ન 1 + નથી?

325
00:24:55,510 --> 00:24:58,430
[Hardison] 1 પ્લસ? >> યાહ. >> તે મળ્યું.

326
00:24:58,430 --> 00:25:00,980
[સેમ] મેં વિચાર્યું કારણ કે તમે 1 આઉટ કરી રહ્યાં છે,

327
00:25:00,980 --> 00:25:04,290
પછી તમે નથી એ છે કે જે તેઓ માટે પૂછવામાં પાછો જઈ રહ્યાં છો.

328
00:25:04,290 --> 00:25:09,400
[Hardison] અને આ હતી માત્ર અમે શું વિશે 0 સૂચકાંકોના આ સમગ્ર મુદ્દો સાથે વાત કરવામાં આવી હતી.

329
00:25:09,400 --> 00:25:11,380
તેથી જો આપણે અહીં પર પાછા ઝૂમ.

330
00:25:11,380 --> 00:25:15,650
જો અમે આ વ્યક્તિ પર અહીં જુઓ, તમે જોઈ શકો છો કે જ્યારે અમે પૉપ,

331
00:25:15,650 --> 00:25:19,340
અમે 2 અનુક્રમણિકા ખાતે તત્વ ધાણી કરી રહ્યાં છો.

332
00:25:19,340 --> 00:25:25,200
>> જેથી અમે અમારા કદ પ્રથમ ઘટાડો, પછી અમારી કદની અમારા અનુક્રમણિકા મેળ ખાય છે.

333
00:25:25,200 --> 00:25:39,650
જો અમે કદ પ્રથમ નથી હ્રાસ નથી, તો પછી અમે કદ -1 અને પછી હ્રાસ કરો.

334
00:25:39,650 --> 00:25:45,270
સરસ. બધા સારા?

335
00:25:45,270 --> 00:25:47,530
આ કોઈપણ પ્રશ્ન છે?

336
00:25:47,530 --> 00:25:54,050
ત્યાં અલગ અલગ રીતે એક નંબર માટે પણ આ લખી છે.

337
00:25:54,050 --> 00:26:03,290
હકીકતમાં, અમે કંઈક પણ કરી શકો છો - અમે એક લાઇનર કરી શકો છો.

338
00:26:03,290 --> 00:26:05,770
અમે વળતર એક લીટી કરી શકો છો.

339
00:26:05,770 --> 00:26:12,980
તેથી અમે ખરેખર પહેલાં આપણે જે દ્વારા પરત હ્રાસ કરી શકો છો.

340
00:26:12,980 --> 00:26:18,320
આ s.size પહેલાં - જેથી મૂકવા.

341
00:26:18,320 --> 00:26:22,060
જે લાઇન ખરેખર ગાઢ બનાવે છે.

342
00:26:22,060 --> 00:26:30,940
જ્યાં વચ્ચે તફાવત - ઓ કદ અને. S.size -

343
00:26:30,940 --> 00:26:40,130
છે કે આ પોસ્ટફિક્સ - તેઓ તેને પોસ્ટફિક્સ કૉલ કારણ કે - આવે પછી s.size -

344
00:26:40,130 --> 00:26:47,430
અર્થ એ થાય કે s.size ઇન્ડેક્સ શોધવા હેતુ માટે મૂલ્યાંકન કરવામાં આવે છે

345
00:26:47,430 --> 00:26:50,410
કારણ કે તે હાલમાં જ્યારે આ રેખા ચલાવવામાં આવે છે,

346
00:26:50,410 --> 00:26:54,290
અને પછી આ - થાય છે પછી રેખા ચલાવવામાં નહીં.

347
00:26:54,290 --> 00:27:00,340
પછી અનુક્રમણિકા s.size ખાતે તત્વ ઍક્સેસ છે.

348
00:27:00,340 --> 00:27:07,260
અને કે અમે શું કરવા માંગો છો, નથી કારણ કે અમે હ્રાસ પ્રથમ થાય માંગો છો.

349
00:27:07,260 --> 00:27:10,990
Othewise, અમે એરે ઍક્સેસ કરી રહ્યા છીએ, અસરકારક રીતે, બહાર સીમાથી.

350
00:27:10,990 --> 00:27:16,850
અમે એક કે અમે ખરેખર ઍક્સેસ કરવા માંગતા હો ઉપર તત્વ ઍક્સેસ કરી રહ્યા છીએ.

351
00:27:16,850 --> 00:27:23,840
અરે વાહ, સેમ? >> તે ઝડપથી કે ઓછા RAM નો ઉપયોગ કરવા માટે એક રેખા અથવા ન કરો છે?

352
00:27:23,840 --> 00:27:29,620
[Hardison] પ્રામાણિકપણે, તે ખરેખર આધાર રાખે છે.

353
00:27:29,620 --> 00:27:34,220
[સામ, દુર્બોધ] >> અરે વાહ, તે આધાર રાખે છે. તમે કમ્પાઇલર યુક્તિઓ કરી શકો છો

354
00:27:34,220 --> 00:27:41,580
આ કમ્પાઈલર વિચાર કે ઓળખે છે, સામાન્ય રીતે, હું કલ્પના.

355
00:27:41,580 --> 00:27:44,840
>> તેથી અમે આ કમ્પાઈલર ઓપ્ટિમાઇઝેશન સામગ્રી વિશે થોડો ઉલ્લેખ કર્યો કર્યો છે

356
00:27:44,840 --> 00:27:47,400
કે તમે કમ્પાઇલ માં કરી શકો છો,

357
00:27:47,400 --> 00:27:50,580
અને તે વસ્તુ પ્રકાર છે કે જે કમ્પાઇલર બહાર આકૃતિ કરવાનો પ્રયત્ન શકે છે,

358
00:27:50,580 --> 00:27:54,710
ઓહ, જેમ કે હેય, કદાચ હું એક ક્રિયા આ તમામ કરી શકો છો,

359
00:27:54,710 --> 00:27:59,420
તરીકે RAM થી કદ ચલ લોડ વિરોધ કરે છે,

360
00:27:59,420 --> 00:28:03,770
તે decrementing, તે પાછા સ્ટોર બહાર, અને તે પછી તેને ફરીથી પાછા લોડ

361
00:28:03,770 --> 00:28:08,000
આ ક્રિયા બાકીના પ્રક્રિયા કરે છે.

362
00:28:08,000 --> 00:28:10,710
પરંતુ સામાન્ય રીતે, ના, આ વસ્તુ ની સૉર્ટ નથી

363
00:28:10,710 --> 00:28:20,770
કે તમારા કાર્યક્રમ નોંધપાત્ર રીતે ઝડપી કરી રહ્યા છે.

364
00:28:20,770 --> 00:28:26,000
રન ટાઇમ સ્ટેકનું પર કોઈ વધુ પ્રશ્ન છે?

365
00:28:26,000 --> 00:28:31,360
>> તેથી દબાણ અને ધાણી. જો તમે ગાય્સ માટે બહાર હેકર આવૃત્તિ પ્રયાસ કરવા માંગો છો,

366
00:28:31,360 --> 00:28:33,660
અમે હેકર આવૃત્તિ માં કર્યું છે ખરેખર શું ગઇ છે

367
00:28:33,660 --> 00:28:37,670
કરી અને આ સ્ટેક ગતિશીલ વિકસે છે.

368
00:28:37,670 --> 00:28:43,190
પડકાર ત્યાં મુખ્યત્વે અપ દબાણ કાર્ય અહીં છે,

369
00:28:43,190 --> 00:28:48,820
બહાર આકૃતિ કેવી રીતે બનાવવા માટે કે જે એરે વધવા

370
00:28:48,820 --> 00:28:52,450
કારણ કે તમે સ્ટેક પર વધુ અને વધુ તત્વો દબાણ રાખે છે.

371
00:28:52,450 --> 00:28:56,000
તે વાસ્તવમાં ખૂબ વધારાના કોડ નથી.

372
00:28:56,000 --> 00:29:00,080
તમે ત્યાં malloc માટે કોલ્સ યોગ્ય રીતે વિચાર યાદ છે - માત્ર એક કોલ

373
00:29:00,080 --> 00:29:03,310
અને પછી બહાર આકૃતિ જ્યારે તમે realloc કહી રહ્યા છીએ.

374
00:29:03,310 --> 00:29:06,090
કે જે મજા પડકાર છે જો તમે રસ છો.

375
00:29:06,090 --> 00:29:11,550
>> પરંતુ તેટલા સમય માટે, ચાલો પર ખસેડવા માટે, અને ચાલો ક્યુને વિશે વાત કરો.

376
00:29:11,550 --> 00:29:15,680
દ્વારા અહીં સ્ક્રોલ.

377
00:29:15,680 --> 00:29:19,340
આ કતાર સ્ટેક એક બંધ બહેન છે.

378
00:29:19,340 --> 00:29:25,380
તેથી સ્ટેક માં વસ્તુઓ છે કે જે છેલ્લા મૂકવામાં આવ્યા હતા

379
00:29:25,380 --> 00:29:28,810
પ્રથમ પછી પાછી મેળવી શકાય તેવી વસ્તુઓ હતા.

380
00:29:28,810 --> 00:29:33,600
અમે આ છેલ્લા છે, પ્રથમ, અથવા LIFO, ઓર્ડર મળ્યો છે.

381
00:29:33,600 --> 00:29:38,390
જ્યારે કતાર, તમે જ્યારે તમે લીટી માં સ્થાયી કરી રહ્યાં આશા હો તરીકે,

382
00:29:38,390 --> 00:29:41,980
પ્રથમ વાક્ય માં વિચાર વ્યક્તિ, પ્રથમ કતાર માં વિચાર વસ્તુ,

383
00:29:41,980 --> 00:29:47,630
પ્રથમ વસ્તુ કે કતાર માંથી મેળવાયેલ નહીં હોય.

384
00:29:47,630 --> 00:29:51,490
ક્યુને પણ ઘણીવાર ઉપયોગ થાય છે જ્યારે અમે ગ્રાફ સાથે કામ કરીએ છીએ,

385
00:29:51,490 --> 00:29:55,560
જેમ અમે વિશે સંક્ષિપ્તમાં રન ટાઇમ સ્ટેકનું સાથે વાત કરી

386
00:29:55,560 --> 00:30:00,260
અને ક્યુને પણ અન્ય વસ્તુઓ સમૂહ માટે સરળ હોય છે.

387
00:30:00,260 --> 00:30:06,180
એક વસ્તુ છે કે જે ઘણી વાર આવે જાળવવા પ્રયાસ કરી રહી છે, ઉદાહરણ તરીકે,

388
00:30:06,180 --> 00:30:12,310
તત્વોના છટણી યાદી.

389
00:30:12,310 --> 00:30:17,650
અને તમે એક એરે સાથે કરી શકો છો. તમે એક એરે એક વસ્તુઓ છટણી યાદી જાળવી શકે છે,

390
00:30:17,650 --> 00:30:20,650
પરંતુ જ્યાં કપટી નહીં કે પછી તમે હંમેશા શોધવા હોય

391
00:30:20,650 --> 00:30:26,160
યોગ્ય આગામી વસ્તુ સામેલ સ્થળ.

392
00:30:26,160 --> 00:30:28,250
તેથી જો તમે 10 દ્વારા નંબરો ઝાકઝમાળ, 1 છે,

393
00:30:28,250 --> 00:30:31,630
અને પછી તમે 100 મારફતે તમામ 1 નંબરો કે વિસ્તૃત કરવા માંગતા હો,

394
00:30:31,630 --> 00:30:33,670
અને તમે રેન્ડમ ક્રમમાં આ નંબરો મળી રહ્યાં છે અને બધું રાખવા પ્રયાસ કરી

395
00:30:33,670 --> 00:30:40,650
છટણી તરીકે તમે મારફતે જાઓ, તમે અંત માટે સ્થળાંતર ઘણો કરી છે.

396
00:30:40,650 --> 00:30:43,910
ક્યુને અને પાયાની માહિતી માળખાં ચોક્કસ પ્રકારના ચોક્કસ પ્રકારના સાથે,

397
00:30:43,910 --> 00:30:46,670
તમે ખરેખર તે એકદમ સરળ રાખી શકો છો.

398
00:30:46,670 --> 00:30:50,640
તમે કંઈક ઉમેરો અને પછી સમગ્ર બાબત દરેક સમય સમયે નથી.

399
00:30:50,640 --> 00:30:56,770
કે તમે આસપાસ આંતરિક ઘટકો સ્થળાંતર ઘણો કરી નથી.

400
00:30:56,770 --> 00:31:02,990
જ્યારે અમે કતાર જોવા, તમે તે જોવા માટે - પણ કલમ કોડ માં queue.c માં -

401
00:31:02,990 --> 00:31:10,950
આ સ્ટ્રક્ટ કે અમે તમને આપી છે ખરેખર સ્ટ્રક્ટ કે અમે તમને એક સ્ટેક માટે આપ્યા સમાન છે.

402
00:31:10,950 --> 00:31:13,770
>> ત્યાં એક આ અપવાદ છે કે, અને એક અપવાદ

403
00:31:13,770 --> 00:31:21,700
છે કે અમે આ વધારાના વડા તરીકે ઓળખાય પૂર્ણાંક હોય છે,

404
00:31:21,700 --> 00:31:28,120
અને અહીં વડા કતાર વડા માટે રાખવામાં આવેલ છે,

405
00:31:28,120 --> 00:31:32,160
અથવા કતાર માં પ્રથમ તત્વ.

406
00:31:32,160 --> 00:31:37,470
સ્ટેક સાથે, અમે તત્વ ટ્રેક રાખો કે અમે પુનઃપ્રાપ્ત હતા સમર્થ હતા,

407
00:31:37,470 --> 00:31:40,800
અથવા સ્ટેક ટોચ, માત્ર કદ વાપરી રહ્યા હોય,

408
00:31:40,800 --> 00:31:44,220
એક કતાર સાથે, જ્યારે અમે વિરુદ્ધ અંત સાથે કામ આવી રહી છે.

409
00:31:44,220 --> 00:31:49,000
અમે ઓવરને અંતે પર વસ્તુઓ કાર્યનીતિ માટે પ્રયાસ કરી રહ્યા છો, પરંતુ તે પછી આગળના માંથી વસ્તુઓ આવો.

410
00:31:49,000 --> 00:31:54,640
તેથી અસરકારક રીતે, માથા સાથે, અમે કતાર શરૂઆત ઇન્ડેક્સ હોય છે,

411
00:31:54,640 --> 00:31:58,920
અને માપ અમને કતાર અંતે ઇન્ડેક્સ આપે છે

412
00:31:58,920 --> 00:32:03,730
તેથી અમે પ્રમુખ વસ્તુઓ મેળવવા અને પૂંછડી પર વસ્તુઓ ઉમેરી શકો છો.

413
00:32:03,730 --> 00:32:06,890
સ્ટેક સાથે, જ્યારે અમે માત્ર ક્યારેય સ્ટેક ટોચ સાથે વ્યવહાર હતા.

414
00:32:06,890 --> 00:32:08,900
આપણે ક્યારેય સ્ટેક નીચે ઍક્સેસ કરો.

415
00:32:08,900 --> 00:32:12,220
અમે ફક્ત ટોચ પર વસ્તુઓ ઉમેરવામાં અને વસ્તુઓ ટોચની ઉપડ્યો

416
00:32:12,220 --> 00:32:17,470
જેથી અમે અમારા સ્ટ્રક્ટ અંદર કે જે વધારાના ક્ષેત્ર જરૂર ન હતી.

417
00:32:17,470 --> 00:32:20,590
એ નથી કે સામાન્ય અર્થમાં છે?

418
00:32:20,590 --> 00:32:27,670
અધિકાર છે. હા, શાર્લોટ? [ચાર્લોટ, દુર્બોધ]

419
00:32:27,670 --> 00:32:32,660
[Hardison] તે એક મહાન પ્રશ્ન છે, અને તે એક કે વ્યાખ્યાન માં આવ્યા હતા.

420
00:32:32,660 --> 00:32:36,290
કદાચ થોડા ઉદાહરણો મારફતે વૉકિંગ સમજાવે છે કે શા માટે કરશે

421
00:32:36,290 --> 00:32:41,400
અમે શબ્દમાળાઓ કતાર વડા તરીકે [0] વાપરવા માંગો નહિં.

422
00:32:41,400 --> 00:32:46,770
>> તેથી કલ્પના કે અમે અમારા કતાર છે, તો અમે તેને કતાર કહી રહ્યા છીએ.

423
00:32:46,770 --> 00:32:49,210
શરૂઆતમાં, જ્યારે અમે ફક્ત instantiated કરી લીધી છે,

424
00:32:49,210 --> 00:32:53,330
જ્યારે અમે માત્ર તે જાહેર કર્યું નથી, આપણે કંઈ પણ ન આરંભ છે.

425
00:32:53,330 --> 00:32:56,790
તે બધા કચરો છે. તેથી અલબત્ત અમે ખાતરી કરવા માટે કે અમે પ્રારંભ કરવા માંગો છો

426
00:32:56,790 --> 00:33:00,950
બંને કદ અને માથા ક્ષેત્રો 0, વાજબી કંઈક છે.

427
00:33:00,950 --> 00:33:05,770
અમે પણ આગળ જાઓ અને શકે અમારી કતાર માં તત્વો null.

428
00:33:05,770 --> 00:33:09,930
અને આ રેખાકૃતિ ફિટ બનાવે નોટિસ કે, હવે અમારી કતાર માત્ર ત્રણ ઘટકો પકડી શકે છે;

429
00:33:09,930 --> 00:33:13,150
જ્યારે અમારા સ્ટેક ચાર પકડી શકે છે, અમારા કતાર માત્ર ત્રણ સમાવી શકે છે.

430
00:33:13,150 --> 00:33:18,680
અને તે ફક્ત માટે રેખાકૃતિ યોગ્ય બનાવે છે.

431
00:33:18,680 --> 00:33:26,150
પ્રથમ વસ્તુ છે જે અહીં થાય છે આપણે શબ્દમાળા એન્ક્યૂ "હાય".

432
00:33:26,150 --> 00:33:30,380
અને જેમ અમે સ્ટેક કર્યું, ઘણું જ અલગ અહીં કશું,

433
00:33:30,380 --> 00:33:39,230
અમે શબ્દમાળાઓ પર [0] અને 1 કરીને અમારી કદ વધારો પર શબ્દમાળા ફેંકો.

434
00:33:39,230 --> 00:33:42,720
અમે એન્ક્યૂ "બાય", તેના પર મૂકવા નહીં.

435
00:33:42,720 --> 00:33:45,870
તેથી આ સૌથી ભાગ માટે એક સ્ટેક જેવો દેખાય છે.

436
00:33:45,870 --> 00:33:53,230
અમે બોલ અહીં શરૂ, નવી તત્વ, નવી તત્વ, કદ ઉપર જઈને રાખે છે.

437
00:33:53,230 --> 00:33:56,330
શું આ બિંદુએ થાય છે જ્યારે અમે કંઈક dequeue કરવા માંગો છો?

438
00:33:56,330 --> 00:34:01,280
જ્યારે અમે dequeue માંગો છો, કે જે તત્વ કે અમે dequeue કરવા માંગો છો?

439
00:34:01,280 --> 00:34:04,110
[બેસિલ] સ્ટ્રીંગ્સ [0]. ઝીરો. >> બરાબર અધિકાર બેસિલ.

440
00:34:04,110 --> 00:34:10,960
અમે પ્રથમ શબ્દમાળા, આ એક, "હાય" છૂટકારો મેળવવા માંગો છો.

441
00:34:10,960 --> 00:34:13,170
તેથી અન્ય વસ્તુ કે જે બદલાયેલ શું હતું?

442
00:34:13,170 --> 00:34:17,010
નોંધ જ્યારે અમે સ્ટેક બંધ કંઈક પોપ, અમે ફક્ત બદલાયેલ માપ,

443
00:34:17,010 --> 00:34:22,080
પરંતુ અહીં, અમે વસ્તુઓ ફેરફાર એક દંપતી મેળવ્યા છે.

444
00:34:22,080 --> 00:34:27,440
માત્ર માપ બદલો, પરંતુ વડા ફેરફારો કરે છે.

445
00:34:27,440 --> 00:34:31,020
આ પાછાં ચાર્લોટ અગાઉ બિંદુ પર જઈને છે:

446
00:34:31,020 --> 00:34:38,699
અમે આ વડા શા માટે નથી તેમજ છે?

447
00:34:38,699 --> 00:34:42,110
એ નથી કે તે અર્થમાં હવે બનાવવા માટે, શાર્લોટ? ઓફ >> કાઇન્ડ.

448
00:34:42,110 --> 00:34:47,500
[Hardison] ના પ્રકાર? તેથી શું થયું જ્યારે અમે dequeued?

449
00:34:47,500 --> 00:34:54,340
માથા શું નહોતી કે હવે રસપ્રદ છે?

450
00:34:54,340 --> 00:34:56,449
[ચાર્લોટ] ઓહ કારણ કે, તેને બદલી - ઠીક છે. હું જુઓ.

451
00:34:56,449 --> 00:35:02,090
કારણ કે માથા - જ્યાં વડા સ્થાન દ્રષ્ટિએ ફેરફારો પોઇન્ટ છે.

452
00:35:02,090 --> 00:35:07,200
તે લાંબા સમય સુધી હંમેશા શૂન્ય ઇન્ડેક્સ એક છે. >> યાહ બરાબર.

453
00:35:07,200 --> 00:35:17,660
થયું શું હતું જો ઊંચા તત્વ dequeueing

454
00:35:17,660 --> 00:35:20,590
હતી કર્યું અને અમે આ વડા ક્ષેત્ર ન હતી

455
00:35:20,590 --> 00:35:26,880
કારણ કે અમે હંમેશા 0 અનુક્રમણિકા અમારા કતાર માથામાંથી આવતા હતા આ શબ્દમાળાને કૉલ,

456
00:35:26,880 --> 00:35:30,170
પછી અમે કતાર બાકીના પાળી નીચે હોય તો.

457
00:35:30,170 --> 00:35:36,010
અમે માંથી "બાય" શબ્દમાળાઓ થી [1] શબ્દમાળાઓ [0] માટે પાળી હોય તો.

458
00:35:36,010 --> 00:35:38,760
અને શબ્દમાળાઓ [2] ડાઉન માટે શબ્દમાળાઓ. [1]

459
00:35:38,760 --> 00:35:43,050
અને અમે તત્વો સમગ્ર યાદી માટે આવું હોય હો,

460
00:35:43,050 --> 00:35:45,110
તત્વોના સમગ્ર એરે.

461
00:35:45,110 --> 00:35:50,490
અને જ્યારે અમે ઝાકઝમાળ સાથે આ કરી રહ્યા છીએ, કે ખરેખર ખર્ચાળ નોંધાયો નહીં.

462
00:35:50,490 --> 00:35:53,340
તેથી અહીં તે મોટા સોદો નથી. અમે અમારા એરે ત્રણ ઘટકો છે.

463
00:35:53,340 --> 00:35:57,230
પરંતુ જો આપણે એક હજાર તત્વોના કતાર અથવા મિલિયન તત્વો હતા,

464
00:35:57,230 --> 00:36:00,060
અને પછી અચાનક તમામ, અમે dequeue સમૂહ કમાવવાનું શરૂ લુપ માં બધા કહે છે,

465
00:36:00,060 --> 00:36:03,930
વસ્તુઓ ખરેખર ધીમી તરીકે તે બધું સ્થળાંતરિત નીચે સતત રહ્યા છે.

466
00:36:03,930 --> 00:36:07,320
તમે જાણો છો, 1 દ્વારા પાળી, 1 દ્વારા 1 પાળી દ્વારા પાળી, 1 દ્વારા પાળી.

467
00:36:07,320 --> 00:36:13,650
તેના બદલે આપણે આ વડા ઉપયોગ, અમે તેને "નિર્દેશક" કૉલ ભલે તે ખરેખર એક નિર્દેશક નથી

468
00:36:13,650 --> 00:36:16,430
કડક અર્થમાં; તે નિર્દેશક પ્રકાર નથી.

469
00:36:16,430 --> 00:36:19,410
તે પૂર્ણાંક * અથવા ઘરનાં પરચૂરણ કામો * અથવા કે કંઈપણ નથી.

470
00:36:19,410 --> 00:36:28,930
પરંતુ તે પોઇન્ટ અથવા અમારી કતાર વડા સૂચવે છે. યાહ?

471
00:36:28,930 --> 00:36:38,800
>> [વિદ્યાર્થી] dequeue માત્ર બોલ પૉપ ગમે તે વડા છે કેવી રીતે ખબર નથી?

472
00:36:38,800 --> 00:36:43,620
[Hardison] dequeue કેવી રીતે ખબર નથી કે કેવી રીતે આ બોલ પર પોપ ગમે તે વડા અંતે છે? >> અધિકાર, હા.

473
00:36:43,620 --> 00:36:49,050
>> તેને જોઈ છે શું છે માત્ર માથા ક્ષેત્ર ગમે સુયોજિત થયેલ છે.

474
00:36:49,050 --> 00:36:52,710
તેથી આ પ્રથમ કિસ્સામાં જો, અમે અહીં જુઓ,

475
00:36:52,710 --> 00:36:55,690
અમારા વડા 0, અનુક્રમણિકા 0 છે. >> અધિકાર.

476
00:36:55,690 --> 00:37:00,500
[Hardison] તેથી તે માત્ર ઠીક, પણ 0 અનુક્રમણિકા ખાતે તત્વ, શબ્દમાળા "હાય" કહે છે,

477
00:37:00,500 --> 00:37:03,050
અમારા કતાર વડા ખાતે તત્વ છે.

478
00:37:03,050 --> 00:37:05,570
તેથી અમે તે વ્યક્તિ dequeue રહ્યા છીએ.

479
00:37:05,570 --> 00:37:09,800
અને તે તત્વ કે કૉલર પરત ફર્યા નહીં હશે.

480
00:37:09,800 --> 00:37:14,540
હા, સાદ? >> તેથી વડા મારાથી સુયોજિત કરે છે - જ્યાં તમે તેને ઇન્ડેક્સ જઈ રહ્યાં છો?

481
00:37:14,540 --> 00:37:17,750
કે તે શરૂઆતમાં છે? >> યાહ. ઠીક છે. >>

482
00:37:17,750 --> 00:37:22,900
[Hardison] તે અમારી એરે માટે નવી જ શરૂઆત બની છે.

483
00:37:22,900 --> 00:37:28,930
તેથી જ્યારે તમે કંઈક dequeue, બધા તમારે હોય છે અનુક્રમણિકા q.head ખાતે તત્વ ઍક્સેસ કરવા માટે,

484
00:37:28,930 --> 00:37:32,240
અને તે તત્વ કે જે તમે કરવા માંગો છો dequeue હશે.

485
00:37:32,240 --> 00:37:34,930
તમે પણ કદ હ્રાસ છે.

486
00:37:34,930 --> 00:37:39,430
અમે થોડી જુઓ જ્યાં વસ્તુઓ થોડો આ સાથે કાવતરાબાજ મળશે.

487
00:37:39,430 --> 00:37:46,520
અમે dequeue, અને હવે, જો આપણે ફરી એન્ક્યૂ,

488
00:37:46,520 --> 00:37:51,300
જ્યાં અમે એન્ક્યૂ છે?

489
00:37:51,300 --> 00:37:55,000
આગામી તત્વ અમારા કતાર જ્યાં જાઓ નથી?

490
00:37:55,000 --> 00:37:57,980
કહો અમે શબ્દમાળા "સીએસ" એન્ક્યૂ કરવા માંગો છો.

491
00:37:57,980 --> 00:38:02,240
અનુક્રમણિકા જેમાં તે જશે? [વિદ્યાર્થીઓ] સ્ટ્રીંગ્સ. [2] બે. >>

492
00:38:02,240 --> 00:38:04,980
શા માટે 2 અને ન 0?

493
00:38:04,980 --> 00:38:13,570
[બેસિલ] કારણ કે હવે વડા 1 છે, જેથી કે યાદી શરૂઆત જેવું છે?

494
00:38:13,570 --> 00:38:21,220
[Hardison] અધિકાર. અને શું યાદી ઓવરને સૂચવે છે?

495
00:38:21,220 --> 00:38:23,290
માટે અમે શું અમારી કતાર ઓવરને દર્શાવવા ઉપયોગ કરી રહ્યા હતા?

496
00:38:23,290 --> 00:38:25,970
વડા અમારા કતાર વડા, અમારા કતાર શરૂઆત છે.

497
00:38:25,970 --> 00:38:29,530
અમારા કતાર ઓવરને શું છે? કદ [વિદ્યાર્થીઓ]. >> કદ, બરાબર.

498
00:38:29,530 --> 00:38:36,360
તેથી અમારા નવા તત્વો કદ પર જાઓ, અને તત્વો કે અમે લઇ બોલ વડા અંતે બોલ આવે છે.

499
00:38:36,360 --> 00:38:45,390
જ્યારે આપણે આગામી તત્વ એન્ક્યૂ, અમે તેને કદ પર આપી રહ્યા છીએ.

500
00:38:45,390 --> 00:38:48,530
તમે તે પહેલાં [વિદ્યાર્થી] મૂકી છે કે જોકે, કદ 1 હતી, અધિકાર?

501
00:38:48,530 --> 00:38:55,690
[Hardison] અધિકાર. તેથી ન તદ્દન માપ છે. કદ +, પરંતુ ને +1 + + વડા.

502
00:38:55,690 --> 00:38:59,990
કારણ કે અમે વડા જથ્થો દ્વારા બધું જ બદલ્યા.

503
00:38:59,990 --> 00:39:14,270
તેથી અહીં, હવે અમે કદ 1 નું એક કતાર કે 1 ઇન્ડેક્સ શરૂ થાય મેળવ્યા છે.

504
00:39:14,270 --> 00:39:20,730
પૂંછડી 2 અનુક્રમણિકા છે. હા?

505
00:39:20,730 --> 00:39:25,780
>> [વિદ્યાર્થી] શું થાય છે જ્યારે તમે dequeue શબ્દમાળાઓ [0], અને મેમરી માં 'શબ્દમાળાઓ સ્લોટ્સ

506
00:39:25,780 --> 00:39:29,420
માત્ર ખાલી રહે, મૂળભૂત રીતે, અથવા માત્ર ભૂલી?

507
00:39:29,420 --> 00:39:34,700
[Hardison] યાહ. આ અર્થમાં, અમે ફક્ત તેને ભૂલી રહ્યા છીએ.

508
00:39:34,700 --> 00:39:42,640
જો અમે તેમને નકલ માટે સ્ટોર કરવામાં આવી હતી -

509
00:39:42,640 --> 00:39:46,310
અનેક માહિતી માળખાં ઘણીવાર તત્વો પોતાના નકલો સ્ટોર કરશે

510
00:39:46,310 --> 00:39:51,760
જેથી આ માહિતી માળખું વ્યવસ્થા વ્યક્તિ માટે ચિંતા નથી

511
00:39:51,760 --> 00:39:53,650
જ્યાં તે તમામ પોઇંટરો કરવાના છો તે વિશે.

512
00:39:53,650 --> 00:39:56,000
આ માહિતી માળખું બધું પર ધરાવે છે, બધી નકલો પર ધરાવે છે,

513
00:39:56,000 --> 00:39:59,580
ખાતરી કરવા માટે કે બધું યોગ્ય ચાલુ રહે બનાવે છે.

514
00:39:59,580 --> 00:40:03,140
જોકે, આ કિસ્સામાં, આ માહિતી બંધારણોની જ સરળતા માટે,

515
00:40:03,140 --> 00:40:05,580
છે બનાવે કંઇ નથી નકલો કે અમે તેમને સ્ટોર કરી રહ્યાં છે.

516
00:40:05,580 --> 00:40:08,630
[વિદ્યાર્થી] તેથી આ એક સતત એરે છે -? હા. >>

517
00:40:08,630 --> 00:40:14,350
જો અમે વ્યાખ્યા શું આ માળખું હતું પર એક નજર, તે છે.

518
00:40:14,350 --> 00:40:19,110
તે માત્ર એક માનક એરે છે કે તમે જોઇ છે,

519
00:40:19,110 --> 00:40:24,280
ઘરનાં પરચૂરણ કામો * ઓ પણ દર્શાવે છે.

520
00:40:24,280 --> 00:40:26,340
કે કરે છે -? >> અરે વાહ, હું હમણાં જ આશ્ચર્ય પામી હતી

521
00:40:26,340 --> 00:40:29,130
જો તમે છેવટે મેમરી રન આઉટ પડશે, અમુક ચોક્કસ હદ સુધી,

522
00:40:29,130 --> 00:40:32,330
જો તમે તમારા એરે આ તમામ ખાલી સ્થળો છે?

523
00:40:32,330 --> 00:40:36,390
[Hardison] અરે વાહ, કે સારી બિંદુ છે.

524
00:40:36,390 --> 00:40:41,530
>> જો આપણે શું થયું છે અંતે હવે આ બિંદુએ, જુઓ

525
00:40:41,530 --> 00:40:46,350
અમે અમારા કતાર ભરી દીધા પછી, તે જેવી દેખાય છે.

526
00:40:46,350 --> 00:40:50,390
પરંતુ અમે ખરેખર ન અમારા કતાર ભરેલી છે

527
00:40:50,390 --> 00:40:57,710
કારણ કે અમે એક કતાર કે 2 માપ છે ધરાવે છે, પરંતુ તેને 1 ઇન્ડેક્સ શરૂ થાય છે,

528
00:40:57,710 --> 00:41:02,160
કારણ કે તે છે જ્યાં અમારી વડા નિર્દેશક છે.

529
00:41:02,160 --> 00:41:08,400
જેમ તમે કહેતા હતા કે, શબ્દમાળાઓ પર તત્વ [0] 0 અનુક્રમણિકા પર, ખરેખર ત્યાં નથી.

530
00:41:08,400 --> 00:41:10,450
તે અમારી કતાર માં હવે નથી.

531
00:41:10,450 --> 00:41:16,460
અમે હમણાં જ જાય છે અને તેને ફરીથી લખી ત્યારે અમે તેને dequeued નથી સંતાપ ન હતી.

532
00:41:16,460 --> 00:41:18,700
તેથી ભલે લાગે છે કે અમે મેમરી રન કર્યા છે, અમે ખરેખર નથી.

533
00:41:18,700 --> 00:41:23,270
હાજર છે કે જેઓ ઉપલબ્ધ છે માટે અમને વાપરવા માટે.

534
00:41:23,270 --> 00:41:29,310
યોગ્ય વર્તન, જો અમે પ્રયાસ અને પ્રથમ dequeue કંઈક હતા

535
00:41:29,310 --> 00:41:34,420
"બાય" માંગો કે, બાય પૉપ બોલ કરશે.

536
00:41:34,420 --> 00:41:38,460
હવે અમારા કતાર 2 ઇન્ડેક્સ શરૂ થાય છે અને 1 માપ છે.

537
00:41:38,460 --> 00:41:42,240
અને હવે જો આપણે પ્રયત્ન કરો અને કંઈક એન્ક્યૂ ફરીથી, 50 કહેવું,

538
00:41:42,240 --> 00:41:47,880
50 આ સ્થળ માં 0 અનુક્રમણિકા પર જવા જોઈએ

539
00:41:47,880 --> 00:41:51,270
કારણ કે તે હજુ આપણા માટે ઉપલબ્ધ છે. હા, સાદ?

540
00:41:51,270 --> 00:41:53,630
[સાદ] કે જે આપોઆપ થાય છે?

541
00:41:53,630 --> 00:41:56,150
[Hardison] તે તદ્દન આપોઆપ બનશે નહિં. તમે ગણિત કરો

542
00:41:56,150 --> 00:42:00,380
બનાવવા માટે કામ કરે છે, પરંતુ આવશ્યક અમે કર્યું છે શું છે અમે માત્ર આસપાસ આવરિત કર્યું છે.

543
00:42:00,380 --> 00:42:04,070
[સાદ] અને તે ઠીક જો આ તે મધ્યમાં એક કાણું છે?

544
00:42:04,070 --> 00:42:08,720
[Hardison] એવું છે જો અમે કરી શકો છો ગણિત બહાર યોગ્ય રીતે કામ કરે છે.

545
00:42:08,720 --> 00:42:15,470
>> અને તે તારણ છે કે જે વાસ્તવમાં છે કે જે મોડ ઓપરેટર સાથે શું હાર્ડ નથી.

546
00:42:15,470 --> 00:42:20,040
તેથી જેમ અમે સીઝર અને ક્રિપ્ટો સામગ્રી સાથે હતી,

547
00:42:20,040 --> 00:42:25,190
મોડ મદદથી, અમે વસ્તુઓ ફરતે વીંટળાય મેળવવા અને જઈને રાખી શકો છો

548
00:42:25,190 --> 00:42:28,090
આસપાસ અને આસપાસ અને આસપાસ સાથે અમારી કતાર,

549
00:42:28,090 --> 00:42:32,180
કે વડા નિર્દેશક આસપાસ ખસેડવા રાખી હતી.

550
00:42:32,180 --> 00:42:38,840
તે માપ નોટિસ હંમેશા સંખ્યાબંધ તત્વો છે તે ખરેખર બાબતમાં એ કતાર અંદર.

551
00:42:38,840 --> 00:42:43,110
અને તે માત્ર માથા કે નિર્દેશક દ્વારા સાયકલની રાખે છે.

552
00:42:43,110 --> 00:42:49,660
જો આપણે શું અહીં થયું જોવા, જો આપણે શરૂઆત પર પાછા જાઓ,

553
00:42:49,660 --> 00:42:55,020
અને તમે માત્ર જોઈ શું માથા પર થાય છે

554
00:42:55,020 --> 00:42:58,240
જ્યારે અમે કંઈક એન્ક્યૂ, કંઇ વડા થયું.

555
00:42:58,240 --> 00:43:00,970
જ્યારે આપણે કંઈક બીજું enqueued, કંઇ વડા થયું.

556
00:43:00,970 --> 00:43:04,130
જલદી અમે કંઈક dequeued, માથા એક દ્વારા વધતું જાય છે.

557
00:43:04,130 --> 00:43:06,600
અમે કંઈક enqueued, કંઇ માથા પર થાય છે.

558
00:43:06,600 --> 00:43:11,060
જ્યારે આપણે કંઈક dequeue, અચાનક તમામ વડા વધે નહીં.

559
00:43:11,060 --> 00:43:14,660
જ્યારે આપણે કંઈક એન્ક્યૂ, કંઇ માથા પર થાય છે.

560
00:43:14,660 --> 00:43:20,240
>> શું આ બિંદુએ થાય જો આપણે કંઈક ફરીથી dequeue હતા છો?

561
00:43:20,240 --> 00:43:23,240
કોઈપણ વિચારો? શું માથા પર શું થશે?

562
00:43:23,240 --> 00:43:27,190
શું માથા પર શું કરીશું

563
00:43:27,190 --> 00:43:32,990
જો અમે કંઈક બીજું dequeue હતા?

564
00:43:32,990 --> 00:43:35,400
વડા હમણાં 2 અનુક્રમણિકા છે,

565
00:43:35,400 --> 00:43:38,920
જેનો અર્થ છે કે કતાર વડા શબ્દમાળાઓ [2] છે.

566
00:43:38,920 --> 00:43:44,280
[વિદ્યાર્થી] કયા 0 આપે છે? >> તે 0 થી પરત કરીશું. તે પાછા ફરતે વીંટળાય છે, બરાબર કરીશું.

567
00:43:44,280 --> 00:43:48,440
અત્યાર સુધીમાં, દર વખતે આપણે dequeue કહેવાય છે, અમે માથા પર થઈ એક ઉમેરીને,

568
00:43:48,440 --> 00:43:50,960
માથા પર એક ઉમેરવા માટે, માથા પર એક ઉમેરવા માટે, માથા પર એક ઉમેરો.

569
00:43:50,960 --> 00:43:58,400
જલદી કે વડા નિર્દેશક અમારા એરે છેલ્લા ઇન્ડેક્સ નહીં,

570
00:43:58,400 --> 00:44:05,650
પછી અમે તેને લપેટી પાછા શરૂઆતમાં આસપાસ હોય, તો 0 થી પાછા જાઓ.

571
00:44:05,650 --> 00:44:09,900
[ચાર્લોટ] શું સ્ટેક માં કતાર ક્ષમતા નક્કી કરે છે?

572
00:44:09,900 --> 00:44:13,120
[Hardison] આ કિસ્સામાં, અમે માત્ર એક # વ્યાખ્યાયિત કર્યું છે સતત ઉપયોગ કરીને કરવામાં આવ્યો છે. ઠીક છે. >>

573
00:44:13,120 --> 00:44:19,590
[Hardison] વાસ્તવિક. કેચ ફાઈલ, તમે અને ખાતર તે થોડો સાથે જઈ શકે છે

574
00:44:19,590 --> 00:44:21,710
અને તે મોટી અથવા થોડી તમે ઇચ્છતા હો તે કરો.

575
00:44:21,710 --> 00:44:25,310
[ચાર્લોટ] તેથી જ્યારે તમે તેને કતાર બનાવી રહ્યા છો, તમે કેવી રીતે બનાવવા તે કોમ્પ્યુટર ખબર

576
00:44:25,310 --> 00:44:29,120
મોટું તમે કેવી રીતે સ્ટેક પ્રયત્ન કરવા માંગો છો?

577
00:44:29,120 --> 00:44:31,700
[Hardison] તે એક મહાન પ્રશ્ન છે.

578
00:44:31,700 --> 00:44:34,800
ત્યાં ઘણી રીતે દંપતી છે. એક માત્ર તેને વ્યાખ્યાયિત અપ ફ્રન્ટ છે

579
00:44:34,800 --> 00:44:42,050
અને આ કહેવા માટે એક કતાર કે 4 તત્વો અથવા 50 તત્વો અથવા 10,000 છે પ્રયત્ન રહ્યું છે.

580
00:44:42,050 --> 00:44:45,430
અન્ય માર્ગ આમ હેકર આવૃત્તિ લોકો શું કરી છે

581
00:44:45,430 --> 00:44:52,310
અને તમારી કતાર ગતિશીલ વધવા વધુ વસ્તુઓ સાઇન ઉમેરવામાં કરો વિધેયો બનાવવા

582
00:44:52,310 --> 00:44:54,740
>> [ચાર્લોટ] તેથી પ્રથમ વિકલ્પ સાથે જાઓ, વાક્યરચના શું તમે વાપરો નહિં

583
00:44:54,740 --> 00:44:57,830
કાર્યક્રમને કહેવું એ કતાર માપ શું છે?

584
00:44:57,830 --> 00:45:04,780
[Hardison] આહ. તેથી આપણે આ નીકળી જાય છે.

585
00:45:04,780 --> 00:45:12,650
હું અહીં stack.c હજુ પણ છું, જેથી હું માત્ર ઉપર અહીં સ્ક્રોલ જાઉં છું.

586
00:45:12,650 --> 00:45:17,920
તમે આ જમણે જુઓ અહીં કરી શકો છો? આ છે # 10 ક્ષમતા વ્યાખ્યાયિત કરે છે.

587
00:45:17,920 --> 00:45:24,600
અને આ લગભગ ચોક્કસ જ વાક્યરચના કે અમે કતાર માટે હોય છે.

588
00:45:24,600 --> 00:45:28,390
કતાર સિવાય, અમે અહીં જે વધારાના સ્ટ્રક્ટ ક્ષેત્ર મેળવ્યા છે.

589
00:45:28,390 --> 00:45:32,760
[ચાર્લોટ] ઓહ, મેં વિચાર્યું ક્ષમતા શબ્દમાળા માટે ક્ષમતા હતો.

590
00:45:32,760 --> 00:45:36,770
[Hardison] આહ. >> તે તે શબ્દ મહત્તમ લંબાઈ છે. >> તે મળ્યું.

591
00:45:36,770 --> 00:45:41,180
યાહ. અહીં ક્ષમતા - કે જે એક મહાન બિંદુ છે.

592
00:45:41,180 --> 00:45:44,000
અને આ એવું કંઈક છે જે કપટી છે છે

593
00:45:44,000 --> 00:45:49,480
કારણ કે અમે અહીં જાહેર કર્યું છે શું કામની પાળી * ઓ ઝાકઝમાળ છે.

594
00:45:49,480 --> 00:45:52,770
પોઇન્ટર પણ દર્શાવે છે.

595
00:45:52,770 --> 00:45:56,690
આ અક્ષરો એક વ્યૂહરચના છે.

596
00:45:56,690 --> 00:46:01,690
આ સંભવિત છે કે તમે શું જ્યારે તમે ફાઇલ માટે તમે તમારા બફરો જાહેર જોઇ છે I / O,

597
00:46:01,690 --> 00:46:06,840
જ્યારે તમે શબ્દમાળાઓ થઈ જાતે બનાવી સ્ટેક પર.

598
00:46:06,840 --> 00:46:09,090
જો કે, અમે અહીં મળી છે શું કામની પાળી * ઓ ઝાકઝમાળ છે.

599
00:46:09,090 --> 00:46:13,400
તેથી તે પોઇંટરો ઝાકઝમાળ છે.

600
00:46:13,400 --> 00:46:18,350
ખરેખર, જો અમે પાછા ઝૂમ આઉટ અને અમે જોવા શું થઈ રહ્યું છે તે અહીં

601
00:46:18,350 --> 00:46:23,140
પ્રસ્તુતિ, તમે કે વાસ્તવિક તત્વો, અક્ષર માહિતી જુઓ

602
00:46:23,140 --> 00:46:26,180
એરે પોતાની અંદર સંગ્રહિત નથી.

603
00:46:26,180 --> 00:46:42,690
છે અમારા એરે અંદર અહીં સંગ્રહિત શું અક્ષર માહિતી માટે પોઇન્ટર છે.

604
00:46:42,690 --> 00:46:52,560
ઠીક છે. તેથી અમે જોઇ છે કેવી રીતે કતાર માપ ફક્ત સ્ટેક સાથે ગમે છે,

605
00:46:52,560 --> 00:46:58,670
કદ હંમેશા સંખ્યાબંધ તત્વો હાલમાં આદર કતારમાં છે.

606
00:46:58,670 --> 00:47:02,720
2 enqueues કર્યા પછી, કદ 2 છે.

607
00:47:02,720 --> 00:47:07,110
એક dequeue કર્યા પછી માપ હવે 1 હોય છે.

608
00:47:07,110 --> 00:47:09,330
અન્ય એન્ક્યૂ કર્યા પછી કદ બેકઅપ માટે 2 છે.

609
00:47:09,330 --> 00:47:12,340
જેથી કદ ચોક્કસપણે કતાર માં સંખ્યાબંધ તત્વો આદર,

610
00:47:12,340 --> 00:47:15,580
અને પછી વડા માત્ર સાયકલ રાખે છે.

611
00:47:15,580 --> 00:47:20,210
તે 0-1-2, 0-1-2 0-1-2, ના જાય છે.

612
00:47:20,210 --> 00:47:25,620
અને દર વખતે અમે dequeue કૉલ, માથા નિર્દેશક આગામી ઇન્ડેક્સ વધે નહીં.

613
00:47:25,620 --> 00:47:29,930
અને જો માથા વિશે છે ઉપર જાય છે, તેની આસપાસ 0 પાછા આંટીઓ.

614
00:47:29,930 --> 00:47:34,870
જેથી સાથે, અમે dequeue કાર્ય લખી શકો છો.

615
00:47:34,870 --> 00:47:40,200
અને અમે એન્ક્યૂ કાર્ય છોડી માટે તમે ગાય્સ બદલે અમલીકરણ કરવા જઈ રહ્યાં છો.

616
00:47:40,200 --> 00:47:45,880
>> , જ્યારે અમે અમારા કતાર એક તત્વ બહાર dequeue

617
00:47:45,880 --> 00:47:55,490
શું પ્રથમ વસ્તુ કે ડીએલ હતી જ્યારે અમે રન ટાઇમ સ્ટેકનું માટે પોપ કાર્ય લખવાનું શરૂ કર્યું હતું?

618
00:47:55,490 --> 00:48:00,490
મને કોઈકને જે હજુ સુધી નથી બોલાય છે સાંભળવા.

619
00:48:00,490 --> 00:48:06,710
ચાલો જોવા માટે, સાદ, તમે યાદ નથી ડીએલ શું પ્રથમ વસ્તુ જ્યારે તેમણે પોપ લખ્યું હતી?

620
00:48:06,710 --> 00:48:08,860
[સાદ] ત્યાં, તે હતી - >> તેઓ કંઈક માટે પરીક્ષણ કર્યું છે.

621
00:48:08,860 --> 00:48:12,140
[સાદ] જો માપ 0 કરતા વધારે છે. ચોક્કસ. >>

622
00:48:12,140 --> 00:48:14,390
અને માટે તે પરીક્ષણ શું હતું?

623
00:48:14,390 --> 00:48:19,090
[સાદ] તે જોવા માટે જો ત્યાં એરે અંદર કશું છે પરીક્ષણ કરવામાં આવ્યું હતું.

624
00:48:19,090 --> 00:48:23,210
[Hardison] યાહ. બરાબર. તેથી તમે સ્ટેક બહાર કંઈપણ પૉપ જો તે ખાલી શકે છે.

625
00:48:23,210 --> 00:48:26,510
તેવી જ રીતે, તમે કંઈપણ એક કતાર નથી dequeue જો તે ખાલી શકે છે.

626
00:48:26,510 --> 00:48:30,420
પ્રથમ વસ્તુ અમે અમારા dequeue કાર્ય અહીં શું કરવું જોઈએ શું છે, તમે શું વિચારો છો?

627
00:48:30,420 --> 00:48:33,860
[સાદ] જો માપ 0 કરતાં મોટો છે? >> યાહ.

628
00:48:33,860 --> 00:48:37,710
આ કિસ્સામાં, હું ખરેખર માત્ર કર્યું છે તે જોવા માટે તેની 0 છે પરીક્ષણ કર્યું છે.

629
00:48:37,710 --> 00:48:42,240
જો તે 0 છે, અમે નલ પાછા આવી શકો છો.

630
00:48:42,240 --> 00:48:45,280
પરંતુ ચોક્કસ જ તર્ક.

631
00:48:45,280 --> 00:48:49,110
દો અને આ સાથે ચાલુ રાખો.

632
00:48:49,110 --> 00:48:54,600
જો માપ 0 નથી, જ્યાં તત્વ કે અમે dequeue કરવા માંગો છો?

633
00:48:54,600 --> 00:48:58,550
[સાદ] માથા પર? ચોક્કસ. >>

634
00:48:58,550 --> 00:49:01,720
અમે હમણાં જ અમારી કતાર કરી પ્રથમ તત્વ ખેંચવાનો

635
00:49:01,720 --> 00:49:07,040
માથા પર તત્વ ઍક્સેસ દ્વારા.

636
00:49:07,040 --> 00:49:14,630
ઉન્મત્ત કંઈ નથી.

637
00:49:14,630 --> 00:49:19,620
તે પછી, અમે શું કરીશું? શું થાય છે?

638
00:49:19,620 --> 00:49:23,740
અન્ય વસ્તુ કે અમે dequeue માં વિશે વાત કરી શું હતો?

639
00:49:23,740 --> 00:49:28,130
બે વસ્તુઓ માટે થાય છે, કારણ કે અમારા કતાર બદલાઈ ગયેલ છે.

640
00:49:28,130 --> 00:49:35,640
[ડીએલ] માપ ઘટાડો. >> અમે કદ ઘટાડવા અને માથા વધારો છે? બરાબર.

641
00:49:35,640 --> 00:49:40,600
તે માથામાં વધારો, અમે માત્ર અકારણ વડા નથી વધારો કરી શકે છે, યાદ કરે છે.

642
00:49:40,600 --> 00:49:45,080
માત્ર અમે કરી શકતા નથી queue.head કરવું + +.

643
00:49:45,080 --> 00:49:51,630
અમે પણ ક્ષમતા દ્વારા આ મોડ સમાવેશ થાય છે.

644
00:49:51,630 --> 00:49:54,740
અને શા માટે અમે ક્ષમતા દ્વારા mod નથી, સ્ટેલા?

645
00:49:54,740 --> 00:49:58,680
[સ્ટેલા] કારણ કે તે માટે ફરતે વીંટળાય છે. ચોક્કસ. >>

646
00:49:58,680 --> 00:50:04,750
અમે ક્ષમતા દ્વારા મોડ કારણ કે તે 0 થી આસપાસ પાછળ લપેટી છે.

647
00:50:04,750 --> 00:50:07,400
તેથી હવે, આ બિંદુએ, અમે શું કરી શકો છો ડીએલ શું કહ્યું હતું.

648
00:50:07,400 --> 00:50:12,700
અમે કદ હ્રાસ કરી શકો છો.

649
00:50:12,700 --> 00:50:29,170
અને પછી અમે માત્ર તત્વ કે કતાર ટોચ પર હતી પાછા આવી શકો છો.

650
00:50:29,170 --> 00:50:34,000
તે પ્રકારની વાંકું વળી ગયેલું લાગે પ્રથમ છે. તમે એક પ્રશ્ન હોય શકે છે. માફ કરશો?

651
00:50:34,000 --> 00:50:37,260
>> [સેમ] એ કતાર ટોચ પર પ્રથમ શા માટે છે? જ્યાં જાઓ કે નથી?

652
00:50:37,260 --> 00:50:42,480
[Hardison] તે નીચે ના ચોથા લીટી આવે છે.

653
00:50:42,480 --> 00:50:46,060
પછી અમે ખાતરી કરો કે અમારા કતાર ખાલી નથી ચકાસો,

654
00:50:46,060 --> 00:50:54,100
અમે ઘરનાં પરચૂરણ કામો * પ્રથમ ખેંચવાનો, અમે તત્વ કે વડા અનુક્રમણિકા પર બેસીને છે ખેંચવાનો

655
00:50:54,100 --> 00:50:58,680
અમારા ઍરેની, અમારા શબ્દમાળાઓ એરે >>, અને પ્રથમ તે કોલ ઓફ?

656
00:50:58,680 --> 00:51:04,500
[Hardison] અને અમે તેને પ્રથમ ફોન કરો. યાહ.

657
00:51:04,500 --> 00:51:09,850
હમણાં પર અનુસરણ કરવા માટે શા માટે તમે વિચારો છો અમે તે કરવા હતો?

658
00:51:09,850 --> 00:51:18,270
[સેમ] દરેક પ્રથમ માત્ર q.strings પરત છે [q.head] >> યાહ.

659
00:51:18,270 --> 00:51:23,830
>> કારણે અમે મોડ કાર્ય સાથે q.head આ બદલાતી કરી રહ્યા છીએ,

660
00:51:23,830 --> 00:51:27,810
અને ત્યાં કોઈ વળતર રેખા અંદર પણ આવું રીત છે.

661
00:51:27,810 --> 00:51:31,640
[Hardison] ચોક્કસ. તમે હાજર છો. સામ તદ્દન પર સ્પોટ છે.

662
00:51:31,640 --> 00:51:36,800
કારણ કે અમે અમારી કતાર માં પ્રથમ તત્વ ખેંચવાનો અને તે ચલ માં સ્ટોર હતો

663
00:51:36,800 --> 00:51:43,030
કારણ એ છે કે આ વાક્ય જ્યાં અમે ફક્ત q.head હતી,

664
00:51:43,030 --> 00:51:47,030
ત્યાં ત્યાં માં મોડ ઓપરેટર કંઈક કે અમે શું કરી શકો છો નથી

665
00:51:47,030 --> 00:51:51,230
એક લીટી માં - અને તે વિના છે માથા પર અસર કરશે.

666
00:51:51,230 --> 00:51:54,480
તેથી અમે ખરેખર બહાર પ્રથમ તત્વ ખેંચવાનો હોય, તો પછી વડા સંતુલિત,

667
00:51:54,480 --> 00:52:00,430
માપ વ્યવસ્થિત અને પછી તત્વ કે અમે બહાર ખેંચી આવો.

668
00:52:00,430 --> 00:52:02,680
અને આ એવું કંઈક છે કે અમે આવો જોશો સાથે પછીથી

669
00:52:02,680 --> 00:52:04,920
કડી થયેલ યાદી છે, કારણ કે અમે તેમની સાથે આસપાસ ભજવે છે.

670
00:52:04,920 --> 00:52:08,410
ઘણી વખત જ્યારે તમે ખાલી અથવા રહ્યાં છો કડી થયેલ યાદીઓ નિકાલ

671
00:52:08,410 --> 00:52:13,500
તમે આગલા તત્વ, એક કડી થયેલ યાદી આગળના નિર્દેશક યાદ કરવાની જરૂર છે

672
00:52:13,500 --> 00:52:16,330
વર્તમાન એક નિકાલ પહેલાં.

673
00:52:16,330 --> 00:52:23,580
કારણ કે અન્યથા તમે દૂર શું યાદીમાં બાકી છે તે માહિતી ફેંકો.

674
00:52:23,580 --> 00:52:34,160
હવે, જો તમે તમારા ઉપકરણ પર જાઓ, તમે આ queue.c-x ખોલવા બહાર.

675
00:52:34,160 --> 00:52:39,390
તેથી જો હું queue.c ખોલવા માટે, અહીં મને ઝૂમ દો,

676
00:52:39,390 --> 00:52:44,970
તમે જોશો કે તમે ફાઈલ સમાન દેખાવ ધરાવે છે.

677
00:52:44,970 --> 00:52:49,200
સમાન દેખાવ આપણે શું stack.c સાથે અગાઉ ફાઇલ.

678
00:52:49,200 --> 00:52:54,690
અમે હમણાં જ વ્યાખ્યાયિત તરીકે અમે સ્લાઇડ્સ પર જોયું કતાર માટે અમારા સ્ટ્રક્ટ મેળવ્યા છે.

679
00:52:54,690 --> 00:52:59,870
>> અમે અમારા એન્ક્યૂ કાર્ય કરે છે, જે તમારા માટે શું કરવું છે.

680
00:52:59,870 --> 00:53:04,340
અને અમે dequeue કાર્ય અહીં છે.

681
00:53:04,340 --> 00:53:06,870
ફાઈલમાં dequeue કાર્ય સ્વીકારેલનથી છે,

682
00:53:06,870 --> 00:53:13,230
પરંતુ મેં પાછા મૂકવા અપ કરશો તો પાવરપોઈન્ટ પર કે જેથી તમે તેને ટાઇપ, જો તમે ઇચ્છો કરી શકો છો.

683
00:53:13,230 --> 00:53:16,690
જેથી આગામી 5 જેથી અથવા મિનિટ માટે, તમે ગાય્સ એન્ક્યૂ પર કામ

684
00:53:16,690 --> 00:53:22,570
જે લગભગ માત્ર dequeue ની વિરુદ્ધ છે.

685
00:53:22,570 --> 00:53:29,560
તમે વડા સંતુલિત જ્યારે તમે enqueueing કરી રહ્યાં નથી, પરંતુ તમે શું સંતુલિત છે?

686
00:53:29,560 --> 00:53:38,920
માપ. તેથી જ્યારે તમે એન્ક્યૂ, માથા પ્રવર્તતી રહે છે, માપ બદલાયેલ નહીં.

687
00:53:38,920 --> 00:53:46,920
પરંતુ તે થોડો સમય લાગી નથી - તમે તે મોડ સાથે આસપાસ રમી પડશે

688
00:53:46,920 --> 00:53:57,560
બહાર બરાબર આકૃતિ ઇન્ડેક્સ શું નવું તત્વ અંતે શામેલ હોવી જોઈએ.

689
00:53:57,560 --> 00:54:03,080
તેથી હું તમને ગાય્ઝ થોડો આપીશું, સ્લાઇડ પર પાછા ઉપર dequeue મૂકી,

690
00:54:03,080 --> 00:54:05,200
અને જેમ તમે ગાય્સ પ્રશ્નો હોય, તેમને પોકાર બહાર કે જેથી અમે કરી શકો છો

691
00:54:05,200 --> 00:54:09,220
એક જૂથ તરીકે તેમને વિશે તમામ ચર્ચા.

692
00:54:09,220 --> 00:54:13,960
પણ, કદ તમે don't સાથે - જ્યારે તમે માપ વ્યવસ્થિત, તો તમે હંમેશા માત્ર કરી શકો છો -

693
00:54:13,960 --> 00:54:18,720
તો તમારે માપ ક્યારેય mod છે? [ડીએલ] નં >> તમે કદ mod નથી, અધિકાર.

694
00:54:18,720 --> 00:54:24,260
કારણ કે કદ હંમેશા, જો you're કરશે - ધારી રહ્યા છીએ કે તમે વસ્તુઓ કરી રહ્યાં યોગ્ય વ્યવસ્થા કરવા માટે,

695
00:54:24,260 --> 00:54:30,840
કદ હંમેશા 0 અને 3 ની વચ્ચે રહેશે.

696
00:54:30,840 --> 00:54:38,680
તમે mod જ્યારે તમે એન્ક્યૂ કરી રહ્યા છીએ જ્યાં છે?

697
00:54:38,680 --> 00:54:41,060
માથા માટે માત્ર [વિદ્યાર્થી]. માથા માટે માત્ર >> બરાબર.

698
00:54:41,060 --> 00:54:44,620
અને તમે એન્ક્યૂ બધી અંતે mod શા માટે છે?

699
00:54:44,620 --> 00:54:48,830
એક પરિસ્થિતિ છે કે જેમાં તમે નકામી હોય છે હો ક્યારે છે?

700
00:54:48,830 --> 00:54:53,630
[વિદ્યાર્થી] જો તમે જગ્યાઓ પર સામગ્રી છે, 1 જગ્યાઓ અને 2 ગમે છે,

701
00:54:53,630 --> 00:54:55,950
અને પછી તમે 0 અંતે કંઈક ઉમેરવા જરૂર છે.

702
00:54:55,950 --> 00:55:02,570
[Hardison] અરે વાહ, બરાબર. તેથી જો તમારા માથા નિર્દેશક ખૂબ ઓવરને અંતે છે,

703
00:55:02,570 --> 00:55:14,210
અથવા જો તમારા વત્તા તમારા માથા મોટી છે અથવા તેને બદલે, એ કતાર ફરતે વીંટળાય રહ્યું છે.

704
00:55:14,210 --> 00:55:17,830
>> તેથી આ પરિસ્થિતિ કે અમે મળી છે અહીં સ્લાઇડ પર અધિકાર હવે,

705
00:55:17,830 --> 00:55:24,370
જો હું કંઈક હમણાં એન્ક્યૂ માંગો છો,

706
00:55:24,370 --> 00:55:31,110
અમે 0 અનુક્રમણિકા પર કંઈક એન્ક્યૂ કરવા માંગો છો.

707
00:55:31,110 --> 00:55:35,450
તેથી જો તમે જ્યાં 50 એ જાય જોવા, અને હું 50 એન્ક્યૂ કહી,

708
00:55:35,450 --> 00:55:40,840
તે ત્યાં જાય તળિયે. તે ઇન્ડેક્સ 0 માં જાય છે.

709
00:55:40,840 --> 00:55:44,160
તે 'હાય' કે જે પહેલેથી dequeued હતી બદલે છે.

710
00:55:44,160 --> 00:55:46,210
[ડીએલ] નહિં કે કાળજી ન લો તમે dequeue પહેલેથી જ?

711
00:55:46,210 --> 00:55:50,550
તે એન્ક્યૂ માં વડા સાથે શા માટે નથી કંઇ?

712
00:55:50,550 --> 00:55:55,770
[Hardison] ઓહ, જેથી તમે વડા નથી ફેરફાર કરી રહ્યાં છો, માફ.

713
00:55:55,770 --> 00:56:02,310
પરંતુ તમે મોડ ઓપરેટર વાપરો જ્યારે તમે ઍક્સેસ કરો છો છે

714
00:56:02,310 --> 00:56:04,250
તત્વ કે જે તમે એન્ક્યૂ જ્યારે તમે ઍક્સેસ કરો છો માંગો છો

715
00:56:04,250 --> 00:56:06,960
તમારી કતારમાં આગામી તત્વ.

716
00:56:06,960 --> 00:56:10,960
[બેસિલ] હું કે નથી નહોતી, અને હું ત્યાં પર "સફળતા" મળી.

717
00:56:10,960 --> 00:56:13,370
[ડીએલ] ઓહ, હું સમજું છું કે તમે શું કહી રહ્યાં છે.

718
00:56:13,370 --> 00:56:16,240
[Hardison] તેથી તમે didn't - તમે હમણાં q.size અંતે હતી?

719
00:56:16,240 --> 00:56:20,670
[બેસિલ] યાહ. મેં હમણાં જ પક્ષ બદલ્યો, હું કાંઇ માથા સાથે કંઈ કર્યું નથી.

720
00:56:20,670 --> 00:56:24,300
[Hardison] તમે ખરેખર વડા ફરીથી સેટ કરવા કંઈપણ નથી,

721
00:56:24,300 --> 00:56:31,650
પરંતુ શબ્દમાળાઓ એરે માં તમે જ્યારે અનુક્રમણિકા,

722
00:56:31,650 --> 00:56:39,500
તમે ખરેખર આગળ વધો અને ગણતરી જ્યાં આગામી તત્વ છે,

723
00:56:39,500 --> 00:56:44,230
કારણ કે સ્ટેક વિલોની મજબૂત લવચીક ડાળ, તમારા સ્ટેક આગામી તત્વ હંમેશા

724
00:56:44,230 --> 00:56:48,740
આ કદ ને અનુરૂપ અનુક્રમણિકા છે.

725
00:56:48,740 --> 00:56:55,850
જો અમે અમારી સ્ટેક દબાણ કાર્ય પર બેકઅપ જુઓ,

726
00:56:55,850 --> 00:57:03,100
આપણે હંમેશા અનુક્રમણિકા કદ પર અધિકાર અમારી નવી તત્વ માં plunk શકે છે.

727
00:57:03,100 --> 00:57:06,710
આ કતાર સાથે, જ્યારે અમે તે ન કરી શકો

728
00:57:06,710 --> 00:57:10,340
જો આપણે આ પરિસ્થિતિ પર છો, કારણ કે,

729
00:57:10,340 --> 00:57:18,130
જો આપણે enqueued 50 અમારા નવા શબ્દમાળા અધિકાર [1] શબ્દમાળાઓ પર જશે

730
00:57:18,130 --> 00:57:20,540
જે અમે કરવા નહિં માંગો.

731
00:57:20,540 --> 00:57:41,200
અમે હોય નવું શબ્દમાળા 0 અનુક્રમણિકા પર જાઓ કરવા માંગો છો.

732
00:57:41,200 --> 00:57:44,320
>> શું કોઈની - હા? [વિદ્યાર્થી] હું એક પ્રશ્ન છે, પરંતુ તે ખરેખર સંબંધિત નથી.

733
00:57:44,320 --> 00:57:48,160
તે ત્યારે શું કોઈને માત્ર pred નિર્દેશક કંઈક કહે છે તેનો અર્થ એવો નથી?

734
00:57:48,160 --> 00:57:51,260
કે નામ શું છે ટૂંકા? મને ખબર છે કે તે માત્ર એક નામ છે.

735
00:57:51,260 --> 00:57:59,110
[Hardison] Pred નિર્દેશક? ચાલો જુઓ. કયા સંદર્ભમાં?

736
00:57:59,110 --> 00:58:01,790
[વિદ્યાર્થી] તે insert હતો. હું તમને પછીથી પૂછો જો તમે શકો છો

737
00:58:01,790 --> 00:58:03,920
કારણ કે તે ખરેખર સંબંધિત નથી પરંતુ હું માત્ર -

738
00:58:03,920 --> 00:58:07,300
[Hardison] માતાનો ડેવિડ વ્યાખ્યાન insert કોડ પ્રતિ?

739
00:58:07,300 --> 00:58:10,860
અમે તે ખેંચવાનો અપ કરી શકો છો અને તે અંગે વાત કરો.

740
00:58:10,860 --> 00:58:15,550
અમે કે આગામી, એક વખત અમે સંલગ્ન યાદીઓ મેળવવા વિશે વાત કરીશું.

741
00:58:15,550 --> 00:58:21,440
>> તેથી ખરેખર ઝડપથી ચાલો એન્ક્યૂ કાર્ય શું લાગે છે જુઓ.

742
00:58:21,440 --> 00:58:26,530
પ્રથમ વસ્તુ છે કે જે લોકો તમારી એન્ક્યૂ લીટી માં આપતા શું હતો? આ કતાર માં?

743
00:58:26,530 --> 00:58:29,960
તમે શું દબાણ સ્ટેક માટે કર્યું કરવા જેવી હતી.

744
00:58:29,960 --> 00:58:32,080
તમે શું, કરી સ્ટેલા?

745
00:58:32,080 --> 00:58:35,050
[સ્ટેલા, દુર્બોધ]

746
00:58:35,050 --> 00:58:45,700
[Hardison] ચોક્કસ. જો (== ક્ષમતા q.size) -

747
00:58:45,700 --> 00:58:54,720
હું યોગ્ય સ્થાન મારા કૌંસ મુકવાની જરૂર છે - ખોટા આવો.

748
00:58:54,720 --> 00:59:01,370
થોડો ઝૂમ વધારો. ઠીક છે.

749
00:59:01,370 --> 00:59:03,800
હવે આગામી વસ્તુ કે અમે શું હતું શું?

750
00:59:03,800 --> 00:59:11,370
જસ્ટ સ્ટેક સાથે ગમે, અને યોગ્ય સ્થળે શામેલ કરી.

751
00:59:11,370 --> 00:59:16,010
અને તેથી જમણી કે દાખલ સ્થળ શું હતું?

752
00:59:16,010 --> 00:59:23,170
સ્ટેક સાથે ઇન્ડેક્સ કદ હતું, આ સાથે તે નથી કે તે તદ્દન છે.

753
00:59:23,170 --> 00:59:30,210
[ડીએલ] હું q.head અથવા-હોય - >> q.strings? >> હા.

754
00:59:30,210 --> 00:59:40,470
q.strings [q.head q.size + + મોડ ક્ષમતા]

755
00:59:40,470 --> 00:59:42,740
[Hardison] અમે કદાચ આ આસપાસ કૌંસ મૂકેલ

756
00:59:42,740 --> 00:59:48,830
જેથી અમે યોગ્ય અગ્રતા કરી રહ્યાં છે અને જેથી દરેકને માટે cleart છે.

757
00:59:48,830 --> 00:59:55,800
સેટ અને તે સમાન? Str કરવા >>? Str કરવા માટે. >> સરસ.

758
00:59:55,800 --> 01:00:00,160
અને હવે છેલ્લા વસ્તુ કે અમે હોય તો શું?

759
01:00:00,160 --> 01:00:06,780
જેમ અમે સ્ટેક કર્યું હતું. >> માપ ઈજાફો? >> કદ વધારો.

760
01:00:06,780 --> 01:00:13,830
બુમ. અને પછી સ્ટાર્ટર કોડ ત્યારથી માત્ર મૂળભૂત દ્વારા ખોટા પાછો ફર્યો,

761
01:00:13,830 --> 01:00:27,460
અમે સાચા આ ફેરફાર જો તમામ જાય છે અને બધા સારી રીતે જાય કરવા માંગો છો.

762
01:00:27,460 --> 01:00:33,050
અધિકાર છે. કે વિભાગ માટે ઘણી માહિતી છે.

763
01:00:33,050 --> 01:00:39,480
અમે તદ્દન પર નથી. અમે singly સાથે જોડાયેલી યાદીઓ વિશે ખરેખર ઝડપથી વાત કરવા માંગો છો.

764
01:00:39,480 --> 01:00:44,010
હું આ મૂકી જેથી પડશે અમે પાછા તે પછી જઇ શકો છો.

765
01:00:44,010 --> 01:00:50,850
દો પરંતુ અમારી રજૂઆત પાછા ફક્ત થોડાંક વધુ સ્લાઇડ્સ માટે જાઓ.

766
01:00:50,850 --> 01:00:53,790
તેથી એન્ક્યૂ TODO છે, હવે અમે તે કર્યું છે.

767
01:00:53,790 --> 01:00:57,430
>> હવે આપણે singly સાથે જોડાયેલી યાદીઓ પર એક નજર.

768
01:00:57,430 --> 01:01:00,040
અમે વ્યાખ્યાન આ થોડો વધુ વિશે વાત કરી.

769
01:01:00,040 --> 01:01:02,540
તમે ગાય્સ ઘણા કેવી રીતે ડેમો જોવા મળી હતી જ્યાં અમે લોકો

770
01:01:02,540 --> 01:01:08,220
awkwardly દરેક અન્ય અને હોલ્ડિંગ નંબર પોઇન્ટ? >> હું કે હતી.

771
01:01:08,220 --> 01:01:16,620
>> તમે ગાય્સ શું વિચાર્યુ? કે હતી, આસ્થાપૂર્વક આ થોડો demystify?

772
01:01:16,620 --> 01:01:25,990
યાદી સાથે, તે તારણ છે કે અમે આ પ્રકારની સાથે વ્યવહાર કે અમે નોડ કહી રહ્યા છીએ.

773
01:01:25,990 --> 01:01:32,520
આ કતાર અને સ્ટેક સાથે જ્યારે અમે સ્ટ્ર્ક્ટ્સ કે અમે સ્ટેક માં કતાર કૉલ હો હતી,

774
01:01:32,520 --> 01:01:34,860
અમે સ્ટેક પ્રકારની આ નવા કતાર હતી,

775
01:01:34,860 --> 01:01:39,240
અંહિ યાદી ખરેખર માત્ર છે ગાંઠો સમૂહ બનેલી છે.

776
01:01:39,240 --> 01:01:45,920
એ જ રીતે જે શબ્દમાળાઓ માત્ર અક્ષરો સમૂહ છે બધા એકબીજા સાથે આગામી જતી.

777
01:01:45,920 --> 01:01:50,650
એક કડી થયેલ યાદી માત્ર એક નોડ અને અન્ય નોડ અને અન્ય નોડ અને અન્ય નોડ છે.

778
01:01:50,650 --> 01:01:55,080
અને તેના બદલે આ તમામ ગાંઠો મળીને સ્મેશિંગ અને તેમને નજીકના સ્ટોર કરતાં

779
01:01:55,080 --> 01:01:58,090
અધિકાર બધી મેમરીનો માં આગામી એકબીજા,

780
01:01:58,090 --> 01:02:04,470
આ આગામી નિર્દેશક કર્યા અમને ત્યાં ગાંઠો સંગ્રહવા માટે રેન્ડમ ખાતે પરવાનગી આપે છે.

781
01:02:04,470 --> 01:02:10,500
અને પછી વાયર પ્રકારની તેમને બધા એકસાથે એક બીજામાં નિર્દેશ છે.

782
01:02:10,500 --> 01:02:15,850
>> અને શું મોટો લાભ એ હતો કે આ એક એરે પર હતી?

783
01:02:15,850 --> 01:02:21,680
સંગ્રહવા બધું બોલ નજીકના માત્ર દરેક અન્ય આગળ અટકી?

784
01:02:21,680 --> 01:02:24,190
તમને યાદ? યાહ? >> ગતિશીલ મેમરી ફાળવણી?

785
01:02:24,190 --> 01:02:27,220
>> અર્થમાં શું માં ડાયનામિક મેમરી ફાળવણી?

786
01:02:27,220 --> 01:02:31,780
[વિદ્યાર્થી] કે તમે તેને મોટા અને તમે તમારા સમગ્ર એરે ખસેડવા ન હોય બનાવવા રાખી શકો છો?

787
01:02:31,780 --> 01:02:40,940
[Hardison] ચોક્કસ. તેથી ઝાકઝમાળ છે, જ્યારે તમે તેને મધ્યમાં એક નવી તત્વ મૂકેલ

788
01:02:40,940 --> 01:02:45,320
તમે બધું પાળી માટે જગ્યા કરવા છે.

789
01:02:45,320 --> 01:02:47,880
અને જેમ અમે કતાર સાથે વિશે વાત કરી,

790
01:02:47,880 --> 01:02:50,080
કે શા માટે અમે તે વડા નિર્દેશક રાખવા માટે,

791
01:02:50,080 --> 01:02:52,050
તેથી અમે સતત કામ નહીં સ્થળાંતર કરી રહ્યા છો.

792
01:02:52,050 --> 01:02:54,520
કારણ કે તે ખર્ચાળ નોંધાયો જો તમે એક મોટી એરે મળી છે

793
01:02:54,520 --> 01:02:57,130
અને તમે સતત આ રેન્ડમ દાખલ કરી રહ્યા છીએ.

794
01:02:57,130 --> 01:03:00,820
યાદી સાથે, જ્યારે તમારે હોય છે તે નવા નોડ પર ફેંકવું,

795
01:03:00,820 --> 01:03:06,330
આ પોઇંટરો સંતુલિત, અને તમે પૂર્ણ કરી રહ્યાં છો.

796
01:03:06,330 --> 01:03:10,940
શું આ અંગે sucks?

797
01:03:10,940 --> 01:03:16,830
ઉપરાંત એ હકીકત છે કે તે સરળ કરવા માટે એરે તરીકે સાથે કામ નથી માંથી? યાહ?

798
01:03:16,830 --> 01:03:22,980
[ડીએલ] વેલ, હું માનું તે ખૂબ કઠણ છે માટે યાદીની લિંક ચોક્કસ તત્વ ઍક્સેસ?

799
01:03:22,980 --> 01:03:30,470
[Hardison] તમે ફક્ત તમારા યાદીની લિંક મધ્યમાં એક મનસ્વી તત્વ ન બાંધી શકે છે.

800
01:03:30,470 --> 01:03:33,800
તમે તેને બદલે શું કેવી રીતે છે? >> તમે સમગ્ર વસ્તુ મારફતે પગલું છે.

801
01:03:33,800 --> 01:03:35,660
[Hardison] યાહ. તમે એક સમયે, એક એક સમયે પસાર થવું પડે છે.

802
01:03:35,660 --> 01:03:38,480
આ એક વિશાળ - તે એક પીડા છે.

803
01:03:38,480 --> 01:03:41,550
અન્ય શું છે - ત્યાં આ બીજી પતન છે.

804
01:03:41,550 --> 01:03:45,340
[બેસિલ] તમે આગળ અને પાછળની ન જઇ શકે? તમે એક દિશામાં જવું છે?

805
01:03:45,340 --> 01:03:48,570
[Hardison] યાહ. તેથી અમે કેવી રીતે કે નથી ક્યારેક ઉકેલ?

806
01:03:48,570 --> 01:03:53,370
[બેસિલ] યાદીઓ સમયમાં બમણું-કડી થયેલ છે? ચોક્કસ. >> ત્યાં સમયમાં બમણું-રંગસૂત્ર સાથે સંકળાયેલો યાદી છે.

807
01:03:53,370 --> 01:03:55,540
ત્યાં પણ છે - માફ કરશો?

808
01:03:55,540 --> 01:03:57,620
>> [સેમ] કે છે કે pred વસ્તુ કે મદદથી જ -

809
01:03:57,620 --> 01:04:01,090
મેં હમણાં જ યાદ નથી, કે pred વસ્તુ શું છે?

810
01:04:01,090 --> 01:04:05,850
છે સમયમાં બમણું અને singly વચ્ચે કે નહીં?

811
01:04:05,850 --> 01:04:10,020
બરાબર શું તેઓ કરી હતી [Hardison] લેટ્સ જુઓ.

812
01:04:10,020 --> 01:04:15,760
અહીં અમે જાઓ. અહીં યાદી કોડ છે.

813
01:04:15,760 --> 01:04:25,620
અહીં અમે predptr અહીં હોય છે. આ તમે શું વિશે વાત કરવામાં આવી હતી?

814
01:04:25,620 --> 01:04:30,750
તેથી આ હતો - તેમની યાદી ખાલી છે અને તે માટે તેને એક નિર્દેશક સ્ટોર કરવાનો પ્રયાસ છે.

815
01:04:30,750 --> 01:04:35,000
આ સમયમાં બમણું singly, કડી થયેલ-યાદીઓ નથી.

816
01:04:35,000 --> 01:04:40,090
અમે આ વિશે વધુ પાછળથી યાદી ખાલી વિશે શકે છે વાત થી આ વાત છે

817
01:04:40,090 --> 01:04:42,900
અને હું કેટલાક અન્ય સામગ્રી પ્રથમ બતાવવા માંગો છો.

818
01:04:42,900 --> 01:04:51,480
પરંતુ તે માત્ર - તે ptr મૂલ્ય યાદ છે

819
01:04:51,480 --> 01:04:54,170
[વિદ્યાર્થી] ઓહ, તે preceeding નિર્દેશક છે? >> યાહ.

820
01:04:54,170 --> 01:05:04,070
તેથી અમે તે પછી અમે તે પછી મફત predptr શું છે તે પહેલાં પોતે ptr વધારો કરી શકે છે.

821
01:05:04,070 --> 01:05:09,130
કારણ કે અમે મુક્ત ptr અને પછી ptr = ptr આગામી, અધિકાર? ન કહી શકો છો

822
01:05:09,130 --> 01:05:11,260
કે ખરાબ હશે.

823
01:05:11,260 --> 01:05:20,940
તેથી આપણે જોઈ, આ વ્યક્તિ માટે નહીં.

824
01:05:20,940 --> 01:05:23,900
>> યાદીઓ વિશે અન્ય ખરાબ બાબત એ છે કે એક એરે સાથે જ્યારે

825
01:05:23,900 --> 01:05:26,520
અમે ફક્ત બધા તત્વો પોતાને એકબીજા આગામી સ્ટૅક્ડ હોય છે,

826
01:05:26,520 --> 01:05:29,050
અહીં આપણે પણ આ નિર્દેશક રજૂઆત કરી છે.

827
01:05:29,050 --> 01:05:34,060
તેથી ત્યાં મેમરી વધારાનો ભાગ કે અમે ઉપયોગ રહી છે

828
01:05:34,060 --> 01:05:37,910
દરેક તત્વ છે કે અમે અમારી યાદીમાં સ્ટોર કરી રહ્યાં છે.

829
01:05:37,910 --> 01:05:40,030
અમે સુગમતા વિચાર છે, પરંતુ તે ખર્ચે આવે છે.

830
01:05:40,030 --> 01:05:42,230
આ સમય કિંમત સાથે આવે છે,

831
01:05:42,230 --> 01:05:45,270
અને તે આ મેમરી કિંમત સાથે પણ આવે છે.

832
01:05:45,270 --> 01:05:47,800
અર્થમાં સમય કે અમે હવે એરે દરેક તત્વ કરવી

833
01:05:47,800 --> 01:05:58,670
થી 10 અનુક્રમણિકા ખાતે એક, અથવા 10 અનુક્રમણિકા ઝાકઝમાળ કરવામાં આવશે છે કે તે શોધો.

834
01:05:58,670 --> 01:06:01,230
>> જસ્ટ ખરેખર ઝડપથી, જ્યારે અમે આ યાદીઓ ડાયાગ્રામ,

835
01:06:01,230 --> 01:06:05,980
ખાસ કરીને અમે યાદી વડા અથવા યાદી પ્રથમ નિર્દેશક ને પકડી

836
01:06:05,980 --> 01:06:08,010
નોંધ કરો કે આ સાચી અને નિર્દેશક છે.

837
01:06:08,010 --> 01:06:11,100
તે ફક્ત 4 બાઇટ્સ છે. તે વાસ્તવિક નોડ પોતે નથી.

838
01:06:11,100 --> 01:06:17,120
તેથી તમે જુઓ કે તે કોઇ પૂર્ણાંક કિંમત છે, તે કોઈ આગામી નિર્દેશક ધરાવે છે.

839
01:06:17,120 --> 01:06:20,790
તે શાબ્દિક માત્ર એક નિર્દેશક છે.

840
01:06:20,790 --> 01:06:23,550
તે કંઈક કે જે વાસ્તવિક નોડ સ્ટ્રક્ટ છે નિર્દેશ બનશે.

841
01:06:23,550 --> 01:06:28,480
[સેમ] એક નોડ કહેવાય નિર્દેશક? >> આ છે - નં. આ પ્રકારની ગાંઠની કંઈક કરવા માટે એક નિર્દેશક છે.

842
01:06:28,480 --> 01:06:32,540
તે નોડ સ્ટ્રક્ટ માટે નિર્દેશક છે. >> ઓહ, ઠીક છે.

843
01:06:32,540 --> 01:06:36,870
જમણી બાજુ પર ડાબી કોડ છે, પર રેખાકૃતિ.

844
01:06:36,870 --> 01:06:42,190
અમે તેને નલ છે, કે જે સારા શરૂ કરવા માર્ગ છે સુયોજિત કરી શકો છો.

845
01:06:42,190 --> 01:06:49,850
જ્યારે તમે તે ડાયાગ્રામ, તમે ક્યાં તો તેને નલ તરીકે લખી અથવા તમે તેને મારફતે વાક્ય મૂકવામાં જ ગમે છે.

846
01:06:49,850 --> 01:06:53,910
>> એક સૌથી સરળ યાદીઓ સાથે કામ રીતે,

847
01:06:53,910 --> 01:06:57,430
અને અમે તમે બંને અંત થાય પૂછો અને તે બંને વચ્ચે તફાવતો જોવા ઉમેરી,

848
01:06:57,430 --> 01:07:01,320
પરંતુ prepending ચોક્કસપણે સરળ છે.

849
01:07:01,320 --> 01:07:05,790
જ્યારે તમે ઉમેરવું, આ તમે જ્યાં છે - જ્યારે તમે અંત (7),

850
01:07:05,790 --> 01:07:10,050
તમે જાઓ અને નોડ સ્ટ્રક્ટ બનાવો

851
01:07:10,050 --> 01:07:13,870
અને તમે પ્રથમ સેટ કરવા માટે તે નિર્દેશ, હવે કારણ કે, કારણ કે અમે તેને prepended,

852
01:07:13,870 --> 01:07:17,240
તે યાદી શરૂઆતમાં જ હશે.

853
01:07:17,240 --> 01:07:22,540
જો (3) અંત થાય છે, કે જે અન્ય નોડ બનાવે અમે, પરંતુ હવે 3 7 પહેલા આવે છે.

854
01:07:22,540 --> 01:07:31,130
જેથી અમે અમારા અનિવાર્યપણે યાદી પર કરી રહ્યાં છો વસ્તુઓ દબાણ.

855
01:07:31,130 --> 01:07:34,720
હવે, તમે જોઈ શકો છો કે અંત થાય છે, કેટલીકવાર લોકો કહી તે દબાણ,

856
01:07:34,720 --> 01:07:39,600
કારણ કે તમે તમારા યાદી પર એક નવી તત્વ દબાણ કરી રહ્યાં છે.

857
01:07:39,600 --> 01:07:43,270
તે પણ સરળ યાદી આ બોલ પર કાઢી નાંખો.

858
01:07:43,270 --> 01:07:45,650
તેથી લોકો ઘણીવાર તે પોપ કૉલ કરશે.

859
01:07:45,650 --> 01:07:52,200
અને તે રીતે, તમે એક કડી થયેલ યાદી વાપરવા સ્ટેક અનુકરણ કરી શકો છો.

860
01:07:52,200 --> 01:07:57,880
દેખીતી ભૂલ માટે માફી (માગવી તે). માફ કરશો, હવે અમે ઉમેરો માં રહ્યાં છો. અહીં અમે (7) prepended, હવે અમે અંત (3).

861
01:07:57,880 --> 01:08:02,600
જો આપણે આ યાદીમાં પર કંઈક બીજું prepended, જો આપણે prepended (4),

862
01:08:02,600 --> 01:08:06,540
તો પછી અમે 4 હોય છે અને 3 પછી અને પછી 7 છો.

863
01:08:06,540 --> 01:08:14,220
તેથી તો અમે પૉપ અને 4 દૂર કરવા માટે, 3 દૂર કરી શકે છે, 7 દૂર કરો.

864
01:08:14,220 --> 01:08:16,500
ઘણી વખત વધુ આ વિશે વિચારો રસ્તો ઉમેરો સાથે છે.

865
01:08:16,500 --> 01:08:20,310
તેથી હું diagrammed કર્યું છે કે તે શું અહીં ઉમેરો જેવો દેખાશે.

866
01:08:20,310 --> 01:08:23,380
અહીં, ઉમેરાયું (7) કોઈપણ અલગ લાગતી નથી

867
01:08:23,380 --> 01:08:25,160
કારણ કે ત્યાં માત્ર યાદીમાં એક તત્વ છે.

868
01:08:25,160 --> 01:08:28,620
અને ઉમેરવાની (3) તે ઓવરને અંતે મૂકે છે.

869
01:08:28,620 --> 01:08:31,020
કદાચ તમે હમણાં ઉમેરો સાથે યુક્તિ જોઈ શકો છો

870
01:08:31,020 --> 01:08:36,600
કે છે કારણ કે અમે માત્ર ખબર જ્યાં યાદી શરૂઆત છે,

871
01:08:36,600 --> 01:08:39,450
એક યાદી તમે યાદી મારફતે તમામ રીતે ચાલવા હોય ઉમેરો

872
01:08:39,450 --> 01:08:46,500
માટે ઓવરને મેળવવા, બંધ કરવા, પછી તમારી નોડ અને plunk નીચે બધું બિલ્ડ.

873
01:08:46,500 --> 01:08:50,590
બધી સામગ્રી WIRE છે.

874
01:08:50,590 --> 01:08:55,170
તેથી અંત સાથે, કારણ કે અમે ફક્ત આ મારફતે ખરેખર ઝડપથી ripped,

875
01:08:55,170 --> 01:08:58,170
જ્યારે તમે યાદીમાં જોડો, તે એકદમ સરળ છે.

876
01:08:58,170 --> 01:09:02,960
>> તમે તમારા નવા નોડ બનાવવા માટે, કેટલાક ગતિશીલ મેમરી ફાળવણી સમાવેશ થાય છે.

877
01:09:02,960 --> 01:09:09,830
અહીં અમે નોડ malloc મદદથી સ્ટ્રક્ટ બનાવી રહ્યા છો.

878
01:09:09,830 --> 01:09:14,710
Malloc જેથી અમે કારણ કે કોરે પછીના માટે અમારા માટે મેમરી સેટ કરશો ઉપયોગ કરી રહ્યાં છો

879
01:09:14,710 --> 01:09:20,350
કારણ કે અમે આ નથી માંગતા - અમે આ મેમરી લાંબા સમય સુધી ટકી શકયું કરવા માંગો છો.

880
01:09:20,350 --> 01:09:25,350
અને અમે મેમરીમાં જગ્યા છે કે અમે માત્ર ફાળવવામાં માટે નિર્દેશક મેળવો.

881
01:09:25,350 --> 01:09:29,260
અમે નોડ કદ વાપરવા માટે, અમે ક્ષેત્રો ન સરવાળો નથી.

882
01:09:29,260 --> 01:09:31,899
અમે જાતે બાઇટ્સ સંખ્યા પેદા નથી,

883
01:09:31,899 --> 01:09:39,750
તેના બદલે આપણે sizeof કે જેથી અમે જાણીએ છીએ કે અમે બાઇટ્સ યોગ્ય નંબર મળી રહ્યાં વાપરો.

884
01:09:39,750 --> 01:09:43,660
અમે ચકાસણી માટે કે જે અમારા malloc કોલ સફળ ખાતરી કરો.

885
01:09:43,660 --> 01:09:47,939
આ એવું કંઈક તમે સામાન્ય રીતે કરવા માંગો છો છે.

886
01:09:47,939 --> 01:09:52,590
આધુનિક મશીનો પર, મેમરી બહાર ચાલી કંઈક છે જે સરળ નથી

887
01:09:52,590 --> 01:09:56,610
જ્યાં સુધી તમે સામગ્રી એક ટન allocating કરી રહ્યાં છે અને એક વિશાળ યાદી બનાવે છે,

888
01:09:56,610 --> 01:10:02,220
પરંતુ જો તમે એક આઇફોન અથવા Android જેમ કહે છે, માટે સામગ્રી નિર્માણ કરી રહ્યાં છો,

889
01:10:02,220 --> 01:10:05,230
તમે મર્યાદિત મેમરી સ્રોતો હોય છે, ખાસ કરીને જો તમે તીવ્ર કંઈક કરી રહ્યા છીએ.

890
01:10:05,230 --> 01:10:08,300
તેથી તે સારું છે વ્યવહારમાં વિચાર.

891
01:10:08,300 --> 01:10:10,510
>> નોંધ કરો કે હું એક દંપતી અલગ કાર્યો ઉપયોગ કર્યો છે અહીં

892
01:10:10,510 --> 01:10:12,880
કે જે તમે જોઇ છે કે જે નવા પ્રકારની હોય છે.

893
01:10:12,880 --> 01:10:15,870
તેથી fprintf માત્ર printf ગમે છે

894
01:10:15,870 --> 01:10:21,320
તેના પ્રથમ દલીલ સિવાય સ્ટ્રીમ પર જે તમે છાપવાનો માંગો છો.

895
01:10:21,320 --> 01:10:23,900
આ કિસ્સામાં, અમે પ્રમાણભૂત ભૂલ શબ્દમાળા છાપવાનો માંગો છો

896
01:10:23,900 --> 01:10:29,410
જે પ્રમાણભૂત outstream અલગ છે.

897
01:10:29,410 --> 01:10:31,620
મૂળભૂત રીતે તે જ સ્થાને બતાવે છે.

898
01:10:31,620 --> 01:10:34,600
તે પણ ટર્મિનલ પર બહાર છાપે છે, પરંતુ તમે કરી શકો છો -

899
01:10:34,600 --> 01:10:38,790
તે આદેશોની મદદથી તમારા વિશે, તો પુનર્નિર્દેશન ટેકનિક શીખી

900
01:10:38,790 --> 01:10:42,290
તમે ટોમી વિડિઓમાં વિશે સમસ્યા 4 સેટ માટે શીખ્યા, તો તમે તેને દિશામાન કરી શકો છો

901
01:10:42,290 --> 01:10:47,900
વિવિધ વિસ્તારોની; પછી બહાર નીકળો, અહીં, બહાર નીકળે છે તમારા કાર્યક્રમ.

902
01:10:47,900 --> 01:10:50,440
તે મુખ્ય ફર્યા જેમ અનિવાર્યપણે છે,

903
01:10:50,440 --> 01:10:53,600
સિવાય અમે બહાર નીકળો ઉપયોગ કારણ કે અહીં વળતર કંઈપણ કરશે.

904
01:10:53,600 --> 01:10:57,140
અમે મુખ્ય નથી છો, જેથી પરત કાર્યક્રમ જેવા અમે માંગતા નથી બહાર નીકળી નથી.

905
01:10:57,140 --> 01:11:03,020
તેથી અમે બહાર કાર્ય વાપરો અને તેને ભૂલ કોડ આપે છે.

906
01:11:03,020 --> 01:11:11,890
પછી અહીં અમે નવા નોડ કિંમત ક્ષેત્ર, તેના હું ક્ષેત્ર સુયોજિત કરવા માટે હું સમાન હોય છે, અને તે પછી અમે તેને WIRE છે.

907
01:11:11,890 --> 01:11:15,530
અમે નવા નોડ આગામી નિર્દેશક સુયોજિત કરવા માટે પ્રથમ નિર્દેશ,

908
01:11:15,530 --> 01:11:20,460
અને પછી પ્રથમ હવે નવા નોડ માટે નિર્દેશ કરશે.

909
01:11:20,460 --> 01:11:25,120
કોડ આ પ્રથમ રેખાઓ, અમે ખરેખર નવી નોડ મકાન રહ્યા છો.

910
01:11:25,120 --> 01:11:27,280
આ કાર્ય છેલ્લા બે લીટીઓ પરંતુ પ્રથમ મુદ્દાઓ પર પણ.

911
01:11:27,280 --> 01:11:30,290
વાસ્તવમાં તમે એક કાર્ય માં બહાર ખેંચી શકે છે મદદગાર કાર્ય માં.

912
01:11:30,290 --> 01:11:32,560
જે ઘણીવાર મારે શું કરવું છે તે જ, હું તે કાર્ય માં બહાર ખેંચી,

913
01:11:32,560 --> 01:11:36,040
હું તેને બિલ્ડ નોડ કંઈક કહી,

914
01:11:36,040 --> 01:11:40,410
અને તે અંત થાય કાર્ય ખૂબ નાના રાખે છે, તો તે માત્ર 3 રેખાઓ પછી છે.

915
01:11:40,410 --> 01:11:48,710
હું મારા બિલ્ડ નોડ કાર્ય કૉલ કરવા માટે, અને પછી હું વાયર અપ બધું.

916
01:11:48,710 --> 01:11:51,970
>> અંતિમ વસ્તુ હું તમને બતાવવા માંગો છો,

917
01:11:51,970 --> 01:11:54,030
અને હું તમને તમારા પોતાના પર ઉમેરો અને તે તમામ કરવા માટે,

918
01:11:54,030 --> 01:11:57,500
કેવી રીતે પર યાદી પર ફરી વળવું છે.

919
01:11:57,500 --> 01:12:00,780
ત્યાં અલગ ઉપર યાદી પર ફરી વળવું રીતે સમૂહ છે.

920
01:12:00,780 --> 01:12:03,140
આ કિસ્સામાં, અમે એક યાદી લંબાઈ શોધી રહ્યા છીએ.

921
01:12:03,140 --> 01:12:06,570
તેથી અમે = 0 લંબાઈ સાથે શરૂ કરો.

922
01:12:06,570 --> 01:12:11,580
આ ખૂબ જ શબ્દમાળા માટે strlen લખવા સમાન છે.

923
01:12:11,580 --> 01:12:17,780
આ હું શું તમે દર્શાવે છે, આ લૂપ માટે અહીં માંગો છો.

924
01:12:17,780 --> 01:12:23,530
તે kinda ફંકી લાગે છે; તે સામાન્ય નથી પૂર્ણાંક હું = 0, હું ગમે <, હું + +.

925
01:12:23,530 --> 01:12:34,920
તેના બદલે તે અમારી ચલ n પ્રારંભ છે યાદીમાં શરૂઆત છે.

926
01:12:34,920 --> 01:12:40,620
અને પછી જ્યારે અમારા iterator ચલ નલ નથી, અમે જઈને રાખો.

927
01:12:40,620 --> 01:12:46,340
આ કારણ છે કે, પરંપરા દ્વારા, અમારા યાદી ઓવરને નલ હશે.

928
01:12:46,340 --> 01:12:48,770
અને પછી + + કરી બદલે વધારો કરવા માટે,

929
01:12:48,770 --> 01:12:57,010
લિંક કરેલા + + યાદી સમકક્ષ + + = n-n> આગામી છે.

930
01:12:57,010 --> 01:13:00,410
>> હું તમને અહીં અવકાશ ભરવા દો કારણ કે અમે સમય નથી પડશે.

931
01:13:00,410 --> 01:13:09,300
પરંતુ ધ્યાનમાં રાખવું આ તરીકે તમે તમારા spellr psets પર કામ કરે છે.

932
01:13:09,300 --> 01:13:11,650
લિંક કરેલા યાદીઓ, જો તમે હેશ ટેબલ અમલ કરી રહ્યાં છો,

933
01:13:11,650 --> 01:13:14,010
ચોક્કસપણે ખૂબ જ હાથમાં આવશે.

934
01:13:14,010 --> 01:13:21,780
અને વસ્તુઓ પર રહ્યાં માટે આ રૂઢિપ્રયોગ કર્યા જીવન ખૂબ સરળ બનાવવા માટે, લઇશ.

935
01:13:21,780 --> 01:13:25,910
કોઈપણ પ્રશ્નો, ઝડપથી?

936
01:13:25,910 --> 01:13:28,920
[સેમ] તમે પૂર્ણ sll અને એસસી મોકલી કરશે?

937
01:13:28,920 --> 01:13:38,360
[Hardison] યાહ. હું પૂર્ણ સ્લાઇડ્સ અને પૂર્ણ sll સ્ટેક અને queue.cs મોકલીશું.

938
01:13:38,360 --> 01:13:41,360
[CS50.TV]