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

2
00:00:02,832 --> 00:00:05,670

3
00:00:05,670 --> 00:00:08,560
>> ડો LLOYD: ઠીક છે, એટલી
દરમિયાન આ મુદ્દે,

4
00:00:08,560 --> 00:00:15,300
અમે સી ઓફ બેઝિક્સ ઘણો આવરી કર્યું
અમે ચલો, એરે વિશે ઘણું જાણો

5
00:00:15,300 --> 00:00:17,610
પોઇન્ટર, કે જે બધી સારી સામગ્રી.

6
00:00:17,610 --> 00:00:21,610
તે બધા સૉર્ટ બાંધવામાં આવે છે
માં, ફંડામેન્ટલ્સ તરીકે જોવા

7
00:00:21,610 --> 00:00:23,880
પરંતુ અમે અધિકાર છે, વધારે કરી શકો?

8
00:00:23,880 --> 00:00:27,930
અમે વસ્તુઓ ભેગા કરી શકો છો
એકસાથે રસપ્રદ રીતે.

9
00:00:27,930 --> 00:00:31,010
>> અને તેથી ચાલો શરૂ કરીએ, ચાલો કે નથી
સી અમને આપે શું નવા નવા ઉદ્યોગો માટે,

10
00:00:31,010 --> 00:00:35,270
અને આપણા પોતાના માહિતી બનાવવા માટે શરૂ
આ ઇમારત ઉપયોગ માળખાં

11
00:00:35,270 --> 00:00:40,590
સાથે મળીને બ્લોકો કંઈક કરવા
ઉપયોગી, ખરેખર મૂલ્યવાન છે.

12
00:00:40,590 --> 00:00:43,420
અમે આ કરી શકો છો એક રીત છે
સંગ્રહો વિશે વાત કરવા માટે.

13
00:00:43,420 --> 00:00:48,360
જેથી અત્યાર સુધી અમે માહિતી એક પ્રકારની પડ્યું
સંગ્રહો રજૂ કરવા માટે માળખું

14
00:00:48,360 --> 00:00:51,030
કિંમતો સમાન કિંમતો ગમે છે.

15
00:00:51,030 --> 00:00:52,350
કે જે એરે હશે.

16
00:00:52,350 --> 00:00:57,020
અમે પૂર્ણાંકો સંગ્રહ હોય છે, અથવા
તેથી અક્ષરો અને સંગ્રહ.

17
00:00:57,020 --> 00:01:00,890
>> માળખું પણ એક માહિતી પ્રકારના હોય છે
માહિતી એકત્ર કરવા માટે માળખું,

18
00:01:00,890 --> 00:01:03,220
પરંતુ તે કિંમતો એકત્ર કરવા માટે નથી.

19
00:01:03,220 --> 00:01:08,090
તે સામાન્ય રીતે અલગ ડેટા પ્રકારો સૂર
સાથે મળીને એક બોક્સની અંદર.

20
00:01:08,090 --> 00:01:10,750
પરંતુ તે પોતે નથી
સાથે મળીને સાંકળ માટે વપરાય

21
00:01:10,750 --> 00:01:16,920
અથવા એક સાથે સમાન જોડાવા
એક એરે જેવી વસ્તુઓ.

22
00:01:16,920 --> 00:01:20,960
એરે માટે મહાન છે
તત્વ ઉપર દેખાય છે, પરંતુ રિકોલ

23
00:01:20,960 --> 00:01:24,262
તે ખૂબ જ મુશ્કેલ છે કે
એક એરે માં દાખલ કરવા માટે,

24
00:01:24,262 --> 00:01:26,470
અમે દાખલ કરી રહ્યા છો જ્યાં સુધી
કે એરે ખૂબ જ અંત થાય છે.

25
00:01:26,470 --> 00:01:29,730
>> અને શ્રેષ્ઠ ઉદાહરણ હું હોય
તે માટે નિવેશ જેવું છે.

26
00:01:29,730 --> 00:01:31,650
તમે અમારા વિડિઓ યાદ તો
નિવેશ સૉર્ટ પર

27
00:01:31,650 --> 00:01:34,110
ઘણો ત્યાં હતી
ખર્ચ કર્યા સામેલ

28
00:01:34,110 --> 00:01:37,970
તત્વો પસંદ કરો, અને તેમને પાળી
કંઈક ફિટ રીતે બહાર

29
00:01:37,970 --> 00:01:41,290
તમારા એરે મધ્યમાં માં.

30
00:01:41,290 --> 00:01:44,690
એરે પણ અન્ય પીડાય
સમસ્યા છે, કે જે દૃઢતા છે.

31
00:01:44,690 --> 00:01:47,150
અમે એક એરે જાહેર કરે છે ત્યારે,
અમે તેને એક શોટ વિચાર.

32
00:01:47,150 --> 00:01:49,790
અમે હું માંગો છો, કહે છે વિચાર
આ ઘણા તત્વો છે.

33
00:01:49,790 --> 00:01:51,940
100 હોઈ શકે છે, તે કદાચ
1,000 હોઇ શકે છે, તે કદાચ

34
00:01:51,940 --> 00:01:55,930
એક્સ વપરાશકર્તા એ સંખ્યા છે કે જ્યાં X હોઈ
પ્રોમ્પ્ટ પર અથવા આદેશ પર અમને આપ્યો

35
00:01:55,930 --> 00:01:56,630
લાઇન.

36
00:01:56,630 --> 00:01:59,905
>> પરંતુ અમે ફક્ત તે એક શોટ વિચાર, અમે
હું ખરેખર, તો પછી ઓહ કહે મળી નથી

37
00:01:59,905 --> 00:02:04,360
101 જરૂરી છે, અથવા હું એક્સ વત્તા 20 જરૂર છે.

38
00:02:04,360 --> 00:02:07,910
ખૂબ અંતમાં, અમે પહેલેથી જ જાહેર કર્યું
એરે, અને અમે 101 અથવા વિચાર કરવા માંગો છો, તો X

39
00:02:07,910 --> 00:02:12,050
વત્તા 20, અમે જાહેર હોય છે
એક સંપૂર્ણપણે અલગ એરે,

40
00:02:12,050 --> 00:02:15,540
એરે તમામ તત્વો નકલ
પર, અને પછી અમે પૂરતી હોય છે.

41
00:02:15,540 --> 00:02:19,880
અને અમે ફરી ખોટું હોય તો, શું શું
અમે ખરેખર 102, અથવા એક્સ વત્તા 40 જરૂર હોય તો,

42
00:02:19,880 --> 00:02:21,970
અમે ફરી આ કરવું પડશે.

43
00:02:21,970 --> 00:02:26,250
જેથી તેઓ ખૂબ જ આગ્રહી છો
અમારી માહિતી માપ બદલવાની માટે,

44
00:02:26,250 --> 00:02:29,360
પરંતુ અમે સાથે કેટલાક ભેગા
અમે પહેલેથી જ છે કે બેઝિક્સ

45
00:02:29,360 --> 00:02:33,230
પોઇંટરો અને માળખાં વિશે શીખી,
ખાસ કરીને ગતિશીલ મેમરીનો ઉપયોગ

46
00:02:33,230 --> 00:02:36,180
malloc સાથે ફાળવણી, અમે
સાથે મળીને આ ટુકડાઓ મૂકી શકો છો

47
00:02:36,180 --> 00:02:40,960
નવી માહિતી માળખું એક બનાવવા માટે
એકલા અમે કહેવું શકે છે યાદી કડી

48
00:02:40,960 --> 00:02:45,400
કે અમને વધવા માટે પરવાનગી આપે છે અને
કિંમતો સંગ્રહ સંકોચો

49
00:02:45,400 --> 00:02:48,800
અને અમે કોઈપણ પામે જગ્યા હશે નહીં.

50
00:02:48,800 --> 00:02:53,320
>> તેથી ફરી, અમે આ વિચાર કહી,
આ વિચારને, એક કડી થયેલ યાદી.

51
00:02:53,320 --> 00:02:56,320
ખાસ કરીને, આ વિડિઓ માં અમે છો
એકલા કડી થયેલ યાદી વિશે વાત,

52
00:02:56,320 --> 00:02:59,185
અને પછી બીજા વિડિઓ અમે વાત કરીશું
વિશે સમયમાં બમણું કડી થયેલ યાદીઓ, જે

53
00:02:59,185 --> 00:03:01,560
અહીં એક થીમ પર માત્ર એક તફાવત છે.

54
00:03:01,560 --> 00:03:05,200
પરંતુ એકલા કડી થયેલ યાદી
ગાંઠો બનેલું છે,

55
00:03:05,200 --> 00:03:08,559
ગાંઠો એક અમૂર્ત term-- હોવા
તે હું ફોન કરું છું કંઇક છે

56
00:03:08,559 --> 00:03:10,350
તે એક પ્રકારની છે
માળખું, સામાન્ય રીતે, હું છું?

57
00:03:10,350 --> 00:03:16,190
માત્ર તે એક નોડ અને આ કૉલ જાઉં
નોડ બે સભ્યો, અથવા બે ક્ષેત્રો છે.

58
00:03:16,190 --> 00:03:20,300
તે સામાન્ય રીતે એક માહિતી છે
પૂર્ણાંક, એક અક્ષર ફ્લોટ,

59
00:03:20,300 --> 00:03:23,790
અથવા અમુક અન્ય માહિતી પ્રકાર હોઈ શકે છે
તમે એક પ્રકાર ડેફ સાથે વ્યાખ્યાયિત કર્યું છે.

60
00:03:23,790 --> 00:03:29,290
અને તે માટે એક નિર્દેશક છે
એક જ પ્રકારના અન્ય નોડ.

61
00:03:29,290 --> 00:03:34,710
>> તેથી અમે અંદર બે વસ્તુઓ હોય છે
આ નોડ, માહિતી અને નિર્દેશક

62
00:03:34,710 --> 00:03:36,380
અન્ય નોડ માટે.

63
00:03:36,380 --> 00:03:39,370
અને તમે વિઝ્યુઅલાઈઝ શરૂ કરો, તો
આ તમને તે વિશે વિચાર કરી શકો છો

64
00:03:39,370 --> 00:03:42,280
ગાંઠો એક સાંકળ જેમ કે
સાથે મળીને જોડાયેલ છે.

65
00:03:42,280 --> 00:03:45,070
અમે પ્રથમ નોડ છે, તે
માહિતી, અને નિર્દેશક ધરાવે

66
00:03:45,070 --> 00:03:49,110
સમાવે છે કે જે બીજા નોડ માટે
માહિતી, અને ત્રીજા નોડ માટે નિર્દેશક.

67
00:03:49,110 --> 00:03:52,940
અને તેથી તે અમે તે કૉલ શા માટે છે
યાદીની લિંક, તેઓ સાથે મળીને કડી રહ્યાં છો.

68
00:03:52,940 --> 00:03:56,070
>> આ ખાસ શું કરે છે
નોડ માળખું જેવો હવો?

69
00:03:56,070 --> 00:04:01,120
સારું, તમે પર અમારા વિડિઓ થી યાદ તો
પ્રકાર ડેફ સાથે, વૈવિધ્યપૂર્ણ પ્રકારો વ્યાખ્યાયિત

70
00:04:01,120 --> 00:04:05,400
અમે એક માળખું વ્યાખ્યાયિત કરી શકો છો અને
આ જેમ એક માળખું વ્યાખ્યાયિત લખો.

71
00:04:05,400 --> 00:04:11,240
સ્ટ્રક્ટ sllist tyepdef, અને પછી હું છું
આપખુદ અહીં શબ્દ મૂલ્યનો ઉપયોગ

72
00:04:11,240 --> 00:04:13,891
ખરેખર કોઇ માહિતી પ્રકાર સૂચવે છે.

73
00:04:13,891 --> 00:04:16,890
તમે પૂર્ણાંક અથવા ફ્લોટ પર પસાર કરી શકે છે
તમે ગમે તમે ઇચ્છો કરી શકે છે.

74
00:04:16,890 --> 00:04:19,389
તે માત્ર પ્રતિબંધિત નથી
પૂર્ણાંકો, અથવા જેમ કંઈપણ.

75
00:04:19,389 --> 00:04:22,790
તેથી કિંમત માત્ર એક મનસ્વી છે
પછી માહિતી પ્રકાર છે, અને નિર્દેશક

76
00:04:22,790 --> 00:04:26,310
એક જ પ્રકારના અન્ય નોડ માટે.

77
00:04:26,310 --> 00:04:29,690
>> હવે, થોડી કેચ છે
અહીં એક માળખું વ્યાખ્યાયિત સાથે

78
00:04:29,690 --> 00:04:33,030
જ્યારે તે સ્વ સંદર્ભ માળખું છે.

79
00:04:33,030 --> 00:04:35,340
હું હંગામી હોય છે
મારા માળખું માટે નામ.

80
00:04:35,340 --> 00:04:37,640
આ દિવસ હું ઓવરને અંતે
સ્પષ્ટ રીતે તે કૉલ કરવા માંગો છો

81
00:04:37,640 --> 00:04:43,030
sll નોડ, કે છેવટે નવું
મારા પ્રકારની વ્યાખ્યા ભાગ નામ આપો,

82
00:04:43,030 --> 00:04:47,450
પરંતુ હું sll નોડ ઉપયોગ કરી શકતા નથી
આ મધ્યમાં.

83
00:04:47,450 --> 00:04:51,430
તેનું કારણ એ છે, હું નથી
એક પ્રકાર કહેવાય sll નોડ બનાવવામાં

84
00:04:51,430 --> 00:04:55,200
હું અહીં આ અંતિમ બિંદુ હિટ સુધી.

85
00:04:55,200 --> 00:04:59,720
તે બિંદુ સુધી, હું હોય છે
બીજી રીતે આ ડેટા પ્રકાર નો સંદર્ભ લો.

86
00:04:59,720 --> 00:05:02,440
>> અને આ એક સ્વ છે
સંદર્ભ માહિતી પ્રકાર.

87
00:05:02,440 --> 00:05:06,314
તે; એ એક માહિતી પ્રકાર છે
માહિતી સમાવે છે કે જે માળખું,

88
00:05:06,314 --> 00:05:08,480
અને અન્ય એક નિર્દેશક
એક જ પ્રકારના માળખું.

89
00:05:08,480 --> 00:05:11,750
જેથી હું સંદર્ભ માટે કરવાનો પ્રયત્ન કરવાની જરૂર
આ માહિતી પ્રકારના ઓછામાં ઓછા અસ્થાયી,

90
00:05:11,750 --> 00:05:14,910
તેથી તે કામચલાઉ આપ્યા
સ્ટ્રક્ટ sllist નામ

91
00:05:14,910 --> 00:05:18,540
મને પછી હું માંગો છો કહે છે માટે પરવાનગી આપે છે
અન્ય સ્ટ્રક્ટ sllist માટે નિર્દેશક છે,

92
00:05:18,540 --> 00:05:24,690
એક સ્ટ્રક્ટ sllist સ્ટાર, અને પછી
હું વ્યાખ્યા પૂર્ણ કરી લીધી પછી,

93
00:05:24,690 --> 00:05:27,220
હવે હું આ પ્રકારના એક sll નોડ કૉલ કરી શકો છો.

94
00:05:27,220 --> 00:05:30,520
>> તમે જુઓ ત્યાં તેથી કે શા માટે
અહીં એક કામચલાઉ નામ,

95
00:05:30,520 --> 00:05:31,879
પરંતુ અહીં કાયમી નામ.

96
00:05:31,879 --> 00:05:33,920
ક્યારેક તમે જોઈ શકો
માળખું વ્યાખ્યાઓ,

97
00:05:33,920 --> 00:05:36,570
ઉદાહરણ માટે, કે નથી
સ્વ સંદર્ભ, કે

98
00:05:36,570 --> 00:05:39,390
અહીં એક specifier નામ નથી.

99
00:05:39,390 --> 00:05:43,040
તે માત્ર typedef સ્ટ્રક્ટ કહે છે
સર્પાકાર તાણવું ખોલો અને પછી તે વ્યાખ્યાયિત કરે છે.

100
00:05:43,040 --> 00:05:45,620
તમે છો તો પણ સ્ટ્રક્ટ સ્વ છે
સંદર્ભ છે, આ એક છે,

101
00:05:45,620 --> 00:05:49,010
તમે સ્પષ્ટ કરવાની જરૂર છે
કામચલાઉ પ્રકાર નામ.

102
00:05:49,010 --> 00:05:51,310
પરંતુ આખરે, હવે
અમે આ કર્યું છે,

103
00:05:51,310 --> 00:05:53,620
અમે હમણાં જ ઉલ્લેખ કરી શકે છે
આ ગાંઠો, આ એકમો,

104
00:05:53,620 --> 00:05:57,900
હેતુઓ માટે sll ગાંઠો તરીકે
આ વિડિઓ બાકીના.

105
00:05:57,900 --> 00:06:00,900
>> બધા હક છે, તેથી અમે કેવી રીતે ખબર
એક કડી થયેલ યાદી નોડ બનાવવા.

106
00:06:00,900 --> 00:06:03,240
અમે વ્યાખ્યાયિત કરવા માટે કેવી રીતે ખબર
એક કડી થયેલ યાદી નોડ.

107
00:06:03,240 --> 00:06:06,670
હવે, આપણે શરૂ કરવા માટે જઈ રહ્યાં છો, તો
માહિતી એકત્રિત કરવા માટે તેમને ઉપયોગ,

108
00:06:06,670 --> 00:06:10,360
કામગીરી એક દંપતિ છે અમે
સમજવા અને સાથે કામ કરવા માટે જરૂર છે.

109
00:06:10,360 --> 00:06:12,860
અમે બનાવવા માટે કેવી રીતે ખબર જરૂર
પાતળી હવા બહાર એક કડી થયેલ યાદી.

110
00:06:12,860 --> 00:06:14,901
કોઈ યાદી પહેલાથી જ ત્યાં છે, તો
અમે એક શરૂ કરવા માંગો છો.

111
00:06:14,901 --> 00:06:16,960
તેથી અમે કરવાનો પ્રયત્ન કરવાની જરૂર
એક કડી થયેલ યાદી બનાવવા માટે,

112
00:06:16,960 --> 00:06:19,130
અમે કદાચ શોધવા માટે જરૂર છે
લિંક યાદી મારફતે

113
00:06:19,130 --> 00:06:21,830
અમે શોધી રહ્યાં છો એક તત્વ શોધવા માટે.

114
00:06:21,830 --> 00:06:24,430
અમે સામેલ સમક્ષ રજુ કરવાનો પ્રયત્ન કરવાની જરૂર છે
યાદી માં નવી વસ્તુઓ,

115
00:06:24,430 --> 00:06:25,930
અમે અમારી યાદી વધવા માટે સમર્થ હોઈ કરવા માંગો છો.

116
00:06:25,930 --> 00:06:28,638
અને એ જ રીતે, અમે સમક્ષ રજુ કરવાનો પ્રયત્ન કરવા માંગો છો
અમારા યાદી વસ્તુઓ કાઢી નાંખવા માટે,

117
00:06:28,638 --> 00:06:30,250
અમે અમારી યાદી સંકોચો સમક્ષ રજુ કરવાનો પ્રયત્ન કરવા માંગો છો.

118
00:06:30,250 --> 00:06:32,160
અને ઓવરને અંતે અમારી
કાર્યક્રમો, ખાસ કરીને

119
00:06:32,160 --> 00:06:34,550
જો અમે છો કે, યાદ તો
ગતિશીલ મેમરી ફાળવણી

120
00:06:34,550 --> 00:06:38,337
ખાસ કરીને આ યાદીઓ બનાવવા માટે,
અમે તે મેમરી બધા મુક્ત કરવા માંગો છો

121
00:06:38,337 --> 00:06:39,670
અમે તેની સાથે કામ કરી રહ્યાં છો છે.

122
00:06:39,670 --> 00:06:44,627
અને તેથી અમે એક કાઢી નાખવા માટે સક્ષમ હોવા જરૂરી છે
એક સમગ્ર કડી થયેલ યાદી તરાપ મારો નિષ્ફળ જાય છે.

123
00:06:44,627 --> 00:06:46,460
તેથી આપણે મારફતે જાઓ
આ કામગીરી કેટલાક

124
00:06:46,460 --> 00:06:51,192
અને અમે તેમને આત્મસાત્ કરી શકે છે કેવી રીતે,
ખાસ સ્યુડોકોડનો કોડ વાત.

125
00:06:51,192 --> 00:06:53,150
તેથી અમે એક બનાવવા માંગો છો
યાદી કડી થયેલ છે, જેથી કદાચ અમે

126
00:06:53,150 --> 00:06:56,480
એક કાર્ય વ્યાખ્યાયિત કરવા માંગો છો
આ પ્રોટોટાઇપ સાથે.

127
00:06:56,480 --> 00:07:01,690
sll નોડ સ્ટાર, બનાવો, અને હું પસાર છું
એક દલીલ, કેટલાક મનસ્વી માહિતી

128
00:07:01,690 --> 00:07:05,530
કેટલાક મનસ્વી માહિતી પ્રકાર, ફરી લખો.

129
00:07:05,530 --> 00:07:10,482
પરંતુ હું આ કામ કરીશું returning-- છું
એક એકલા, મને એક નિર્દેશક પાછા

130
00:07:10,482 --> 00:07:11,190
કડી થયેલ યાદી નોડ.

131
00:07:11,190 --> 00:07:14,050
ફરીથી, અમે બનાવવા માટે પ્રયાસ કરી રહ્યાં છો
પાતળી હવા બહાર એક કડી થયેલ યાદી

132
00:07:14,050 --> 00:07:17,900
તેથી હું એક નિર્દેશક જરૂર
જ્યારે હું પૂર્ણ છું કે યાદી.

133
00:07:17,900 --> 00:07:19,420
>> તેથી અહીં સામેલ પગલાંઓ શું છે?

134
00:07:19,420 --> 00:07:20,960
ઠીક છે, હું પ્રથમ વસ્તુ છું
કરવા જઇ ગતિશીલ છે

135
00:07:20,960 --> 00:07:22,550
નવી નોડ માટે જગ્યા ફાળવી.

136
00:07:22,550 --> 00:07:26,689
ફરીથી, અમે પાતળા બહાર બનાવી રહ્યા છો
હવા, તેથી અમે તે માટે malloc જગ્યા કરવાની જરૂર છે.

137
00:07:26,689 --> 00:07:28,480
અને અલબત્ત, તરત જ
અમે malloc પછી,

138
00:07:28,480 --> 00:07:31,692
અમે હંમેશા ખાતરી કરો કે તેની ખાતરી કરવા તપાસો અમારા
નિર્દેશક અમે પાછા નલ મળી ન હતી.

139
00:07:31,692 --> 00:07:33,650
અમે પ્રયાસ કારણ કે જો અને
એક નલ નિર્દેશક અદબ,

140
00:07:33,650 --> 00:07:36,190
અમે સહન કરવા જઈ રહ્યાં છો
segfault અને અમે તે કરવા નહિં માંગો.

141
00:07:36,190 --> 00:07:39,510
>> પછી અમે આ ક્ષેત્રમાં ભરો છો,
અમે કિંમત ક્ષેત્ર પ્રારંભ કરવા માંગો છો

142
00:07:39,510 --> 00:07:41,690
અને આગામી ક્ષેત્ર પ્રારંભ.

143
00:07:41,690 --> 00:07:45,450
અને પછી અમે આખરે તરીકે રહ્યો માંગો છો
અમે માંગો છો indicates-- કાર્ય પ્રોટોટાઇપ

144
00:07:45,450 --> 00:07:49,940
એક sll નોડ માટે નિર્દેશક પાછા.

145
00:07:49,940 --> 00:07:51,710
તેથી શું આ દૃષ્ટિની જેવો બનાવવા?

146
00:07:51,710 --> 00:07:55,230
વેલ, પ્રથમ અમે ગતિશીલ જઈ રહ્યાં છો
નવી sll નોડ માટે જગ્યા ફાળવી શકે છે,

147
00:07:55,230 --> 00:07:58,320
તેથી અમે તે છે malloc--
એક દ્રશ્ય રજૂઆત

148
00:07:58,320 --> 00:08:00,020
નોડ અમે હમણાં બનાવેલ છે.

149
00:08:00,020 --> 00:08:02,757
અને અમે ખાતરી કરવા માટે ચકાસણી
તે આ કિસ્સામાં નલ નથી

150
00:08:02,757 --> 00:08:04,840
ચિત્ર ન હોત
જો તે નલ હતી બતાવ્યા,

151
00:08:04,840 --> 00:08:07,298
અમે મેમરી રન આઉટ હોત
તેથી અમે ત્યાં જવા માટે સારા છો.

152
00:08:07,298 --> 00:08:10,200
તેથી હવે અમે સી પગલાં પર છો,
ગાંઠો કિંમત ક્ષેત્ર પ્રારંભ.

153
00:08:10,200 --> 00:08:12,280
વેલ, આ કાર્ય પર આધારિત
, હું અહીં ઉપયોગ કરું છું કૉલ

154
00:08:12,280 --> 00:08:16,700
હું 6 પાસ કરવા માંગો છો, જેમ કે દેખાય છે
તેથી હું કિંમત ક્ષેત્રમાં 6 પડશે.

155
00:08:16,700 --> 00:08:18,865
હવે, આગામી ક્ષેત્ર પ્રારંભ.

156
00:08:18,865 --> 00:08:21,640
ઠીક છે, શું હું ત્યાં કરવા જઇ રહ્યો છું,
કંઇ અધિકાર આગામી છે,

157
00:08:21,640 --> 00:08:23,600
આ યાદીમાં જ વસ્તુ છે.

158
00:08:23,600 --> 00:08:27,206
તેથી યાદીમાં આગામી વસ્તુ શું છે?

159
00:08:27,206 --> 00:08:29,660
>> તે અધિકાર કંઈપણ માટે નિર્દેશ ન જોઈએ.

160
00:08:29,660 --> 00:08:33,600
કંઇ તેથી શું છે, બીજું ત્યાં
અમે તે ખબર ખ્યાલ કંઇ છે

161
00:08:33,600 --> 00:08:35,638
કંઈ પોઇંટરો?

162
00:08:35,638 --> 00:08:37,929
તે કદાચ અમે માંગો છો પ્રયત્ન કરીશું
ત્યાં એક નલ નિર્દેશક મૂકી,

163
00:08:37,929 --> 00:08:40,178
અને હું નલ પ્રતિનિધિત્વ પડશે
તરીકે માત્ર એક લાલ બોક્સ નિર્દેશક

164
00:08:40,178 --> 00:08:41,559
અમે વધુ કોઇ જઇ શકો છો.

165
00:08:41,559 --> 00:08:44,430
અમે પાછળથી થોડો જોશો,
અમે આખરે સાંકળો હશે

166
00:08:44,430 --> 00:08:46,330
તીર જોડાઈ
સાથે મળીને આ ગાંઠો,

167
00:08:46,330 --> 00:08:48,480
પરંતુ તમે હિટ જ્યારે
લાલ બોક્સ કે, નલ

168
00:08:48,480 --> 00:08:51,150
અમે આગળ કોઈ જઈ શકો નહિં
કે યાદી ઓવરને છે.

169
00:08:51,150 --> 00:08:53,960
>> અને છેલ્લે, અમે માત્ર કરવા માંગો છો
આ નોડ માટે નિર્દેશક આવો.

170
00:08:53,960 --> 00:08:56,160
તેથી અમે નવા તે કહી શકશો,
અને નવા આપશે

171
00:08:56,160 --> 00:08:59,370
તેથી તે વાપરી શકાય છે
ગમે કાર્ય બનાવી છે.

172
00:08:59,370 --> 00:09:03,100
તેથી ત્યાં અમે જાઓ, અમે એક એકલા બનાવી છે
પાતળી હવા બહાર કડી થયેલ યાદી નોડ,

173
00:09:03,100 --> 00:09:05,920
અને હવે અમે સાથે કામ કરી શકે યાદી હોય છે.

174
00:09:05,920 --> 00:09:08,260
>> હવે, પહેલેથી જ અમે કહી દો
એક મોટી સાંકળ હોય છે,

175
00:09:08,260 --> 00:09:09,800
અને અમે તેને કંઈક શોધવા માંગો છો.

176
00:09:09,800 --> 00:09:12,716
અને અમે જઈ રહ્યું છે કે કાર્ય કરવા માંગો છો
સાચું કે ખોટું પાછા આધાર રાખીને

177
00:09:12,716 --> 00:09:15,840
નીચેની યાદી અસ્તિત્વમાં છે કે કેમ તે છે.

178
00:09:15,840 --> 00:09:18,160
એક કાર્ય પ્રોટોટાઇપ, અથવા
તે કાર્ય માટે ઘોષણા,

179
00:09:18,160 --> 00:09:23,320
છે આ શોધવા bool જેવો છે, અને શકે છે
પછી અમે બે દલીલો પસાર કરવા માંગો છો.

180
00:09:23,320 --> 00:09:26,996
>> પ્રથમ, એક નિર્દેશક છે
યાદીની લિંક પ્રથમ તત્વ.

181
00:09:26,996 --> 00:09:29,620
આ તમે પડશે ખરેખર કંઈક છે
હંમેશા ટ્રેક રાખવા માંગો છો,

182
00:09:29,620 --> 00:09:33,110
અને ખરેખર કંઈક હોઈ શકે છે
તમે પણ એક વૈશ્વિક ચલ મૂકો.

183
00:09:33,110 --> 00:09:35,360
તમે યાદી બનાવી જાય,
હંમેશા તમે,

184
00:09:35,360 --> 00:09:38,990
ખૂબ જ ટ્રેક રાખવા માંગો છો
યાદીમાં પ્રથમ તત્વ.

185
00:09:38,990 --> 00:09:43,690
તમે બીજા બધા ઉલ્લેખ કરી શકે છે આ રીતે
માત્ર સાંકળ દ્વારા અનુસરીને તત્વો,

186
00:09:43,690 --> 00:09:47,300
પોઇન્ટર રાખવા કર્યા વગર
દરેક એક તત્વ અકબંધ.

187
00:09:47,300 --> 00:09:50,920
તમે માત્ર પ્રથમ ટ્રેક રાખવા માટે જરૂર છે
તેઓ બધા સાથે મળીને સંકળાયેલ હોઈ શકે કરી રહ્યાં છો.

188
00:09:50,920 --> 00:09:52,460
>> અને પછી બીજા વસ્તુ
અમે ફરીથી પસાર કરી રહ્યાં છો

189
00:09:52,460 --> 00:09:54,376
આપખુદ some-- છે
ગમે ડેટા પ્રકાર અમે છો

190
00:09:54,376 --> 00:09:59,640
ત્યાં શોધી અંદર છે
આસ્થાપૂર્વક યાદીમાં ગાંઠો છે.

191
00:09:59,640 --> 00:10:00,980
તેથી પગલાંઓ શું છે?

192
00:10:00,980 --> 00:10:04,250
વેલ, અમે શું પ્રથમ વસ્તુ છે
અમે એક છેદક રેખા નિર્દેશક બનાવવા

193
00:10:04,250 --> 00:10:06,015
યાદીઓ વડા તરફ ઇશારો.

194
00:10:06,015 --> 00:10:08,890
વેલ, કે શા માટે, અમે પહેલાથી જ કરવું
યાદીઓ વડા પર એક નિર્દેશક હોય છે,

195
00:10:08,890 --> 00:10:10,974
શા માટે આપણે માત્ર આસપાસ કે એક ખસેડવા નથી?

196
00:10:10,974 --> 00:10:13,140
ઠીક છે, હું માત્ર જણાવ્યું હતું કે, જેમ
તે અમારા માટે ખરેખર મહત્વનું છે

197
00:10:13,140 --> 00:10:17,580
હંમેશા ટ્રેક રાખવા માટે
યાદીમાં ખૂબ જ પ્રથમ તત્વ.

198
00:10:17,580 --> 00:10:21,270
અને તેથી તે ખરેખર સારી છે
તે એક નકલી બનાવવા માટે,

199
00:10:21,270 --> 00:10:25,350
અને તેથી અમે ક્યારેય આસપાસ ખસેડવા માટે કે ઉપયોગ
આકસ્મિક દૂર ખસેડવા માટે, અથવા હંમેશા અમે

200
00:10:25,350 --> 00:10:30,430
છે કે અમુક બિંદુએ એક નિર્દેશક હોય
અધિકાર યાદીમાં પ્રથમ તત્વ છે.

201
00:10:30,430 --> 00:10:33,290
તેથી તે બનાવવા માટે સારી છે
અમે ખસેડવા માટે ઉપયોગ કરે છે બીજા એક.

202
00:10:33,290 --> 00:10:35,877
>> પછી અમે માત્ર કે શું તુલના
કે નોડ કિંમત ક્ષેત્ર

203
00:10:35,877 --> 00:10:38,960
તે તો અમે શોધી રહ્યાં છો, અને શું છે
નથી, અમે ફક્ત બીજા ગાંઠ પર ખસેડો.

204
00:10:38,960 --> 00:10:41,040
અને અમે તે કરવાનું ચાલુ રાખી
ઉપર, અને ઉપર, અને ઉપર,

205
00:10:41,040 --> 00:10:44,811
અમે ક્યાં શોધવા સુધી
તત્વ, અથવા આપણે હિટ

206
00:10:44,811 --> 00:10:47,310
null-- અમે ઓવરને પહોંચી ગયા છો
અને આ યાદીમાં તે નથી.

207
00:10:47,310 --> 00:10:50,540
આ આસ્થાપૂર્વક ઘંટડી જોઈએ
તમે માત્ર રેખીય શોધ,

208
00:10:50,540 --> 00:10:54,430
અમે હમણાં જ તે પ્રતિકૃતિ રહ્યાં છો
એક એકલા કડી થયેલ યાદી માળખું

209
00:10:54,430 --> 00:10:56,280
તેના બદલે તે કરવા માટે એક એરે ઉપયોગ.

210
00:10:56,280 --> 00:10:58,210
>> તેથી અહીં એક ઉદાહરણ છે
એક એકલા કડી થયેલ યાદી.

211
00:10:58,210 --> 00:11:00,043
આ એક સમાવેશ થાય છે
પાંચ ગાંઠો, અને અમે છે

212
00:11:00,043 --> 00:11:04,330
ના માથા પર એક નિર્દેશક
યાદી કહે છે, જે યાદી.

213
00:11:04,330 --> 00:11:07,385
અમે કરવા માંગો છો પ્રથમ વસ્તુ છે
ફરીથી, કે ટ્રાવર્સલને નિર્દેશક બનાવો.

214
00:11:07,385 --> 00:11:09,760
તેથી અમે હવે બે પોઇન્ટર છે
આ જ વસ્તુ છે કે બિંદુ.

215
00:11:09,760 --> 00:11:15,025
>> હવે, પણ અહીં નોટિસ હું ન હતી
Trav માટે કોઇ જગ્યા malloc છે.

216
00:11:15,025 --> 00:11:18,970
હું Trav malloc બરાબર ન કહી હતી
કંઈક કે નોડ પહેલેથી જ અસ્તિત્વમાં છે

217
00:11:18,970 --> 00:11:21,160
મેમરી કે જગ્યા પહેલેથી હાજર છે.

218
00:11:21,160 --> 00:11:24,290
તેથી હું ખરેખર કરી રહ્યો છું બધા છે
તે બીજા નિર્દેશક બનાવવા.

219
00:11:24,290 --> 00:11:28,210
હું વધારાની mallocing રહ્યો નથી
જગ્યા, માત્ર હવે બે પોઇન્ટર છે

220
00:11:28,210 --> 00:11:31,370
આ જ વાત તરફ ઇશારો.

221
00:11:31,370 --> 00:11:33,710
>> તેથી 2 હું શોધી રહ્યો છું શું છે?

222
00:11:33,710 --> 00:11:37,220
ના, ઠીક છે, તેથી તેના બદલે હું છું
આગામી એક ખસેડવા માટે જઈ રહી છે.

223
00:11:37,220 --> 00:11:41,740
જેથી મૂળભૂત હું કહે છે
Trav આગામી Trav સમકક્ષ હોય છે.

224
00:11:41,740 --> 00:11:43,630
હું કોઈ શું શોધી રહ્યો છું 3 છે.

225
00:11:43,630 --> 00:11:45,780
તેથી હું જવા માટે ચાલુ
દ્વારા આખરે ત્યાં સુધી

226
00:11:45,780 --> 00:11:48,690
હું શોધી રહ્યો છું શું છે જે 6 મેળવવા
આ વિધેય કોલ પર આધારિત માટે

227
00:11:48,690 --> 00:11:51,600
હું ટોચ પર હોય છે
ત્યાં, અને તેથી હું કરી રહ્યો છું.

228
00:11:51,600 --> 00:11:54,150
>> હવે, તત્વ હું શું છું તો
માટે જોઈ, યાદીમાં ન હોય

229
00:11:54,150 --> 00:11:55,510
તે હજુ પણ કામ રહ્યું છે?

230
00:11:55,510 --> 00:11:57,120
વેલ, આ યાદી છે કે નોટિસ
અહીં, subtly અલગ છે

231
00:11:57,120 --> 00:11:59,410
અને આ છે કે અન્ય બાબત એ છે કે
કડી થયેલ યાદીઓ સાથે મહત્વપૂર્ણ,

232
00:11:59,410 --> 00:12:01,780
તમે સાચવવા માટે નથી
તેમને કોઇ ખાસ ક્રમમાં.

233
00:12:01,780 --> 00:12:05,390
જો તમે ઇચ્છો તો તમે કરી શકો છો પરંતુ
જો તમે પહેલાથી જ સૂચન કર્યું છે

234
00:12:05,390 --> 00:12:09,310
અમે ટ્રેક રાખવા નથી કે
અમે શું નંબર તત્વ હોય છે.

235
00:12:09,310 --> 00:12:13,150
>> અને તે એક વેપાર જેવું છે કે અમે
એરે છંદો કડી થયેલ યાદી સાથે હોય છે,

236
00:12:13,150 --> 00:12:15,300
તે અમે નથી છે
હવે રેન્ડમ ઍક્સેસ.

237
00:12:15,300 --> 00:12:18,150
અમે હમણાં જ હું માંગો છો કહી ન શકે,
આ 0th તત્વ પર જવા માટે,

238
00:12:18,150 --> 00:12:21,410
કે મારા એરે 6 ઠ્ઠી તત્વ,
જે હું ઝાકઝમાળ કરી શકો છો.

239
00:12:21,410 --> 00:12:25,080
હું જવા માંગો છો નથી કહી શકો છો
0th તત્વ, અથવા 6 ઠ્ઠી તત્વ,

240
00:12:25,080 --> 00:12:30,360
કે મારા યાદીની લિંક 25 તત્વ,
તેમની સાથે સંકળાયેલ કોઈ ઈન્ડેક્સ છે.

241
00:12:30,360 --> 00:12:33,660
અને તેથી તે ખરેખર તો કોઈ વાંધો નથી
અમે ક્રમમાં અમારી યાદી જાળવી રાખવા હોય તો.

242
00:12:33,660 --> 00:12:36,080
તમે કરવા માંગો છો, તો
ચોક્કસપણે કરી શકો છો, પરંતુ ત્યાં છે

243
00:12:36,080 --> 00:12:38,567
તેઓ જરૂર શા માટે કોઈ કારણ
કોઈપણ ક્રમમાં સચવાય.

244
00:12:38,567 --> 00:12:40,400
તેથી ફરી, ચાલો પ્રયાસ અને
આ યાદીમાં 6 શોધો.

245
00:12:40,400 --> 00:12:43,200
વેલ, અમે પર શરૂ
શરૂઆત, અમે 6 શોધી નથી

246
00:12:43,200 --> 00:12:47,690
અને પછી અમે શોધવા નથી ચાલુ
6, અમે આખરે અહીં વિચાર ત્યાં સુધી.

247
00:12:47,690 --> 00:12:52,790
નોડ તેથી હમણાં Trav પોઇન્ટ
8 સમાવતી, અને છ ત્યાં નથી.

248
00:12:52,790 --> 00:12:55,250
>> તેથી આગામી પગલું હશે
આગામી નિર્દેશક પર જવા માટે,

249
00:12:55,250 --> 00:12:57,440
તેથી Trav આગામી Trav બરાબર કહે છે.

250
00:12:57,440 --> 00:13:00,750
વેલ, Trav આગળ, દ્વારા સૂચવાયેલ
ત્યાં લાલ બોક્સ નલ છે.

251
00:13:00,750 --> 00:13:03,020
તેથી ક્યાંય છે
તેથી આ બિંદુએ જાય છે, અને

252
00:13:03,020 --> 00:13:06,120
અમે પહોંચી ગયા છો કે પૂર્ણ કરી શકો છો
યાદીની લિંક ઓવરને

253
00:13:06,120 --> 00:13:07,190
અને 6 ત્યાં નથી.

254
00:13:07,190 --> 00:13:10,980
અને તે પરત આવશે
આ કેસમાં ખોટા.

255
00:13:10,980 --> 00:13:14,540
>> ઠીક છે, અમે કેવી રીતે એક નવી દાખલ કરી શકું
કડી થયેલ યાદી માં નોડ?

256
00:13:14,540 --> 00:13:17,310
તેથી અમે બનાવવા માટે સક્ષમ કરવામાં આવી છે
ક્યાંય બહાર એક કડી થયેલ યાદી

257
00:13:17,310 --> 00:13:19,370
પરંતુ અમે કદાચ કરવા માંગો છો
એક સાંકળ બિલ્ડ કરવા અને નથી

258
00:13:19,370 --> 00:13:22,620
અલગ યાદીઓ એક ટોળું બનાવો.

259
00:13:22,620 --> 00:13:25,700
અમે એક યાદી હોય માંગો છો કે
તે ગાંઠો એક ટોળું છે

260
00:13:25,700 --> 00:13:28,040
એક નોડ સાથે યાદીઓ નથી એક ટોળું.

261
00:13:28,040 --> 00:13:31,260
તેથી અમે ફક્ત બનાવો નો ઉપયોગ ચાલુ રાખી શકતા નથી
કાર્ય આપણે હવે અગાઉ નિર્ધારિત અમે

262
00:13:31,260 --> 00:13:33,860
એક દાખલ કરવા માંગો છો
પહેલેથી જ અસ્તિત્વમાં છે કે યાદી.

263
00:13:33,860 --> 00:13:36,499
>> આ કિસ્સામાં તેથી, અમે જઈ રહ્યાં છો
બે દલીલો પસાર કરવા માટે,

264
00:13:36,499 --> 00:13:39,290
કે વડા નિર્દેશક
અમે ઍડ કરવા માંગો છો યાદી કડી થયેલ છે.

265
00:13:39,290 --> 00:13:40,910
તેથી તે છે શા માટે તે ફરીથી છે, કે
મહત્વપૂર્ણ હંમેશા અમે કે

266
00:13:40,910 --> 00:13:43,400
કારણ કે, તે ટ્રેક રાખવા
તે ખરેખર માત્ર એક જ રસ્તો અમે છે

267
00:13:43,400 --> 00:13:46,690
સમગ્ર યાદી છે નો સંદર્ભ લો છે
માત્ર પ્રથમ તત્વ માટે નિર્દેશક છે.

268
00:13:46,690 --> 00:13:49,360
તેથી અમે એક પાસ કરવા માંગો છો
કે પ્રથમ તત્વ માટે નિર્દેશક,

269
00:13:49,360 --> 00:13:52,226
અને ગમે કિંમત અમે
યાદીમાં ઉમેરવા માંગો છો.

270
00:13:52,226 --> 00:13:54,600
અને આખરે આ કાર્ય
એક નિર્દેશક પાછા જઈ રહ્યું છે

271
00:13:54,600 --> 00:13:57,980
એક કડી થયેલ યાદી નવા વડા છે.

272
00:13:57,980 --> 00:13:59,700
>> અહીં સામેલ પગલાંઓ શું છે?

273
00:13:59,700 --> 00:14:02,249
વેલ, માત્ર બનાવવા સાથે જેમ,
અમે ગતિશીલ ફાળવણી કરવાની જરૂર

274
00:14:02,249 --> 00:14:05,540
નવી નોડ માટે જગ્યા છે, અને ખાતરી કરવા તપાસો
ખાતરી કરો કે અમે મેમરી રન આઉટ નથી, ફરી,

275
00:14:05,540 --> 00:14:07,150
અમે malloc ઉપયોગ કરી રહ્યાં છો કારણ કે.

276
00:14:07,150 --> 00:14:09,080
પછી અમે રચના કરવા માંગો છો
અને નોડ દાખલ

277
00:14:09,080 --> 00:14:12,730
જેથી નંબર મૂકી, ગમે
વૅલ નોડ માં છે.

278
00:14:12,730 --> 00:14:17,310
અમે ઓછામાં નોડ સામેલ કરવા માંગો છો
આ કડી થયેલ યાદી શરૂઆત.

279
00:14:17,310 --> 00:14:19,619
>> એક કારણ છે કે હું
આ કરવા માંગો છો, અને તે

280
00:14:19,619 --> 00:14:21,910
બીજા લેતી વર્થ હોઈ શકે
અહીં વિડિઓ વિરામ,

281
00:14:21,910 --> 00:14:25,860
અને હું કરવા માંગો છો શા માટે વિશે વિચારો
એક કડી થયેલ શરૂઆત પર દાખલ

282
00:14:25,860 --> 00:14:26,589
યાદી.

283
00:14:26,589 --> 00:14:28,630
ફરીથી, હું અગાઉ ઉલ્લેખ કર્યો છે
તે ખરેખર નથી કે

284
00:14:28,630 --> 00:14:33,020
અમે કોઇ પણ જાળવી તો વાંધો
ક્રમમાં, તેથી કદાચ કે ચાવી છે.

285
00:14:33,020 --> 00:14:36,040
અને જો અમે તો શું થશે જોયું
માગે રહ્યો અથવા માત્ર એક બીજા થી

286
00:14:36,040 --> 00:14:37,360
પહેલાં જ્યારે અમે જતા હતા
શોધ મારફતે

287
00:14:37,360 --> 00:14:39,235
શું શકે જોઈ શકે
અમે પ્રયાસ કરી રહ્યા હતા, તો થાય

288
00:14:39,235 --> 00:14:41,330
આ યાદી ઓવરને અંતે દાખલ કરવા માટે.

289
00:14:41,330 --> 00:14:44,750
અમે નથી, કારણ કે
આ યાદી ઓવરને પોઇન્ટર.

290
00:14:44,750 --> 00:14:47,490
>> તેથી કારણ હું માંગો છો કે
શરૂઆતમાં દાખલ કરવા માટે,

291
00:14:47,490 --> 00:14:49,380
હું તરત જ તે કરી શકો છો, કારણ કે છે.

292
00:14:49,380 --> 00:14:52,730
હું શરૂઆતમાં એક નિર્દેશક હોય છે, અને
અમે એક બીજા એક દ્રશ્ય માં આ જોશો.

293
00:14:52,730 --> 00:14:55,605
પરંતુ હું ઓવરને અંતે દાખલ કરવા માંગો છો, તો
હું શરૂઆતમાં શરૂ હોય છે

294
00:14:55,605 --> 00:14:58,760
આ બધી રીતે પસાર
અંત, અને પછી તે પર ખીલી.

295
00:14:58,760 --> 00:15:01,420
જેથી તેનો અર્થ એ થાય
આ યાદી ઓવરને અંતે દાખલ

296
00:15:01,420 --> 00:15:04,140
n ના ઓ બનશે
કામગીરી, પાછા જવાનું

297
00:15:04,140 --> 00:15:06,720
અમારી ચર્ચા
ગણતરીની જટિલતા.

298
00:15:06,720 --> 00:15:10,140
તે n કામગીરી, જ્યાં એક ઓ બની છો
આ યાદી મોટી છે, અને મોટા થઈ જાય છે, કારણ કે

299
00:15:10,140 --> 00:15:13,310
અને મોટી છે, તે વધુ બની શકશો અને
કંઈક કાર્યનીતિ માટે વધુ મુશ્કેલ

300
00:15:13,310 --> 00:15:14,661
ઓવરને અંતે છે.

301
00:15:14,661 --> 00:15:17,410
પરંતુ તે હંમેશા માટે ખરેખર સરળ છે
શરૂઆતમાં પર કંઈક ખીલી,

302
00:15:17,410 --> 00:15:19,060
તમે શરૂઆતમાં હંમેશા છો.

303
00:15:19,060 --> 00:15:21,620
>> અને અમે ફરી આ દ્રશ્ય જોવા મળશે.

304
00:15:21,620 --> 00:15:24,100
અને પછી અમે એક વાર, પૂર્ણ કરી લો
અમે નવા નોડ દાખલ કર્યો છે,

305
00:15:24,100 --> 00:15:26,880
અમે અમારા નિર્દેશક પરત કરવા માંગો છો
એક કડી થયેલ યાદી નવા વડા છે, કે જે

306
00:15:26,880 --> 00:15:29,213
અમે અંતે દાખલ કરી રહ્યા છો, કારણ કે
શરૂઆત ખરેખર હશે

307
00:15:29,213 --> 00:15:31,060
અમે હમણાં જ બનાવેલ નોડ માટે નિર્દેશક.

308
00:15:31,060 --> 00:15:33,280
, આ આત્મસાત્ કરીએ
કારણ કે હું તે મદદ મળશે છે.

309
00:15:33,280 --> 00:15:36,661
>> તેથી અહીં અમારા યાદી છે, તે સમાવે છે
ચાર તત્વો, નોડ, 15 સમાવતી

310
00:15:36,661 --> 00:15:38,410
જે નોડ માટે નિર્દેશ
9 સમાવતી જે

311
00:15:38,410 --> 00:15:41,370
13 સમાવતી નોડ માટે નિર્દેશ,
જે સમાવતી નોડ માટે નિર્દેશ

312
00:15:41,370 --> 00:15:44,840
નલ ધરાવે છે, જે 10,
તેની આગામી નિર્દેશક તરીકે નિર્દેશક

313
00:15:44,840 --> 00:15:47,010
કે જેથી યાદી ઓવરને છે.

314
00:15:47,010 --> 00:15:50,200
તેથી અમે એક દાખલ કરવા માંગો છો
કિંમત 12 નવા નોડ

315
00:15:50,200 --> 00:15:52,720
આ શરૂઆતમાં
યાદી, અમે શું કરવું?

316
00:15:52,720 --> 00:15:58,770
વેલ, પ્રથમ અમે માટે જગ્યા malloc
નોડ, અને પછી અમે ત્યાં 12 મૂકો.

317
00:15:58,770 --> 00:16:02,211
>> તેથી હવે અમે પહોંચી ગયા છો એક
નિર્ણય બિંદુ, અધિકાર?

318
00:16:02,211 --> 00:16:03,960
અમે એક દંપતિ છે
પોઇન્ટર છે કે અમે કરી શકે છે

319
00:16:03,960 --> 00:16:06,770
અમે પ્રથમ એક કે જે ખસેડવા જોઇએ, ખસેડવા?

320
00:16:06,770 --> 00:16:09,250
અમે 12 બિંદુ બનાવવા જોઈએ
આ યાદી નવા વડા

321
00:16:09,250 --> 00:16:13,020
અથવા મને માફ, અમે 12 કરવી જોઈએ
યાદીમાં જૂના વડા નિર્દેશિત કરવા માટે?

322
00:16:13,020 --> 00:16:15,319
અથવા આપણે કહેવું જોઈએ કે
યાદી હવે 12 શરૂ થાય છે.

323
00:16:15,319 --> 00:16:17,110
ભેદ છે
ત્યાં છે, અને અમે જોવા મળશે

324
00:16:17,110 --> 00:16:19,870
સાથે બંને એક બીજા શું થાય છે.

325
00:16:19,870 --> 00:16:23,350
>> પરંતુ આ એક તરફ દોરી જાય છે
સાઇડબાર માટે મહાન વિષય,

326
00:16:23,350 --> 00:16:26,280
જે કે એક છે
કડી થયેલ યાદીઓ સાથે trickiest વસ્તુઓ

327
00:16:26,280 --> 00:16:30,980
પોઇંટરો વ્યવસ્થા છે
યોગ્ય ક્રમમાં.

328
00:16:30,980 --> 00:16:34,520
તમે ઓર્ડર બહાર વસ્તુઓ ખસેડવા તો,
જો તમે આકસ્મિક અંત કરી શકે છે

329
00:16:34,520 --> 00:16:36,050
આ યાદી બાકીના orphaning.

330
00:16:36,050 --> 00:16:37,300
અને અહીં એક ઉદાહરણ છે.

331
00:16:37,300 --> 00:16:40,540
તેથી આ વિચાર સાથે જવા દો of--
ઠીક છે, આપણે 12 બનાવી છે.

332
00:16:40,540 --> 00:16:43,180
અમે 12 હોઈ ચાલે છે ખબર
યાદીમાં નવા વડા,

333
00:16:43,180 --> 00:16:47,660
અને તેથી શા માટે આપણે માત્ર ખસેડવા નથી
આ યાદી નિર્દેશક ત્યાં નિર્દેશ કરે છે.

334
00:16:47,660 --> 00:16:49,070
>> ઠીક છે, તેથી તે સારી છે.

335
00:16:49,070 --> 00:16:51,560
તેથી હવે જ્યાં 12 આગામી બિંદુ કરે છે?

336
00:16:51,560 --> 00:16:54,580
હું દૃષ્ટિની અમે જોઈ શકો છો, તેનો અર્થ એ
તે 15 માટે નિર્દેશ કરશે કે,

337
00:16:54,580 --> 00:16:57,250
મનુષ્યો, કે અમને ખરેખર સ્પષ્ટ છે.

338
00:16:57,250 --> 00:17:00,300
કેવી રીતે કમ્પ્યૂટર ખબર નથી?

339
00:17:00,300 --> 00:17:02,720
અમે કંઈ નથી
હવે 15 પોઇન્ટ, અધિકાર?

340
00:17:02,720 --> 00:17:05,869
>> અમે 15 નો સંદર્ભ લો કોઇ ક્ષમતા ગુમાવી છે.

341
00:17:05,869 --> 00:17:11,460
અમે નવી તીર આગામી સમકક્ષ કહી શકો છો
કંઈક ત્યાં કશું જ નથી.

342
00:17:11,460 --> 00:17:13,510
હકીકતમાં, અમે અનાથ કર્યું
આ યાદી બાકીના

343
00:17:13,510 --> 00:17:16,465
આમ કરવાથી, અમે કર્યું
આકસ્મિક સાંકળ તૂટી.

344
00:17:16,465 --> 00:17:18,089
અને અમે ચોક્કસપણે તે કરવા માંગો છો નથી.

345
00:17:18,089 --> 00:17:20,000
>> તેથી આપણે પાછા જાઓ અને આ ફરીથી પ્રયાસ કરો.

346
00:17:20,000 --> 00:17:24,060
કદાચ યોગ્ય વસ્તુ કરવા માટે
12 આગામી નિર્દેશક સુયોજિત કરવા માટે છે

347
00:17:24,060 --> 00:17:28,290
પ્રથમ યાદીમાં જૂના વડા માટે,
પછી અમે યાદી પર ખસેડી શકો છો.

348
00:17:28,290 --> 00:17:30,420
અને હકીકતમાં, કે છે
યોગ્ય ક્રમમાં અમે તે

349
00:17:30,420 --> 00:17:32,836
અમે હોય ત્યારે અનુસરવાની જરૂર
એકલા કડી થયેલ યાદી સાથે કામ કરે છે.

350
00:17:32,836 --> 00:17:36,460
અમે હંમેશા કનેક્ટ કરવા માંગો છો
યાદી માં નવી તત્વ,

351
00:17:36,460 --> 00:17:41,010
અમે તે પ્રકારના લેવા પહેલાં
બદલવા મહત્વપૂર્ણ પગલું

352
00:17:41,010 --> 00:17:43,360
જ્યાં કડી થયેલ યાદી વડા છે.

353
00:17:43,360 --> 00:17:46,740
ફરીથી, જેમ કે મૂળભૂત વાત છે,
અમે તેને ટ્રેક ગુમાવી કરવા માંગો છો નથી.

354
00:17:46,740 --> 00:17:49,310
>> તેથી અમે તે ખાતરી કરવા માંગો છો
બધું મળીને સંકળાયેલ હોઈ શકે છે

355
00:17:49,310 --> 00:17:52,040
અમે કે નિર્દેશક ખસેડવા તે પહેલાં.

356
00:17:52,040 --> 00:17:55,300
અને તેથી આ યોગ્ય ક્રમમાં હશે,
જે યાદી 12 જોડાવા માટે છે,

357
00:17:55,300 --> 00:17:57,630
પછી યાદી 12 શરૂ થાય છે કે જે કહે છે.

358
00:17:57,630 --> 00:18:00,860
અમે યાદી 12 પર શરૂ થાય છે જણાવ્યું હતું કે અને
પછી, આ યાદીમાં 12 કનેક્ટ કરવાનો પ્રયાસ કર્યો

359
00:18:00,860 --> 00:18:02,193
અમે પહેલાથી જ શું થાય છે જોઇ છે.

360
00:18:02,193 --> 00:18:04,920
અમે ભૂલથી યાદી ગુમાવી બેસે છે.

361
00:18:04,920 --> 00:18:06,740
>> ઠીક છે, તેથી વધુ એક વસ્તુ વિશે વાત કરવા માટે.

362
00:18:06,740 --> 00:18:09,750
અમે શું છુટકારો મેળવવા માંગો છો, તો
સમગ્ર સમયે યાદી કડી?

363
00:18:09,750 --> 00:18:11,750
ફરીથી, અમે mallocing કરી રહ્યાં છો
આ બધા જગ્યા, અને તેથી અમે

364
00:18:11,750 --> 00:18:13,351
અમે પૂર્ણ કરી લીધું ત્યારે તેને મુક્ત કરવાની જરૂર છે.

365
00:18:13,351 --> 00:18:15,350
તેથી હવે અમે કાઢી નાખવા માંગો છો
સમગ્ર કડી થયેલ યાદી.

366
00:18:15,350 --> 00:18:16,850
વેલ, અમે શું કરવા માંગો છો?

367
00:18:16,850 --> 00:18:20,460
>> અમે નલ નિર્દેશક પહોંચી ગયા છો, તો અમે
નહિંતર, માત્ર કાઢી, બંધ કરવા માંગો છો

368
00:18:20,460 --> 00:18:23,420
પછી યાદી બાકીના અને મને મુક્ત.

369
00:18:23,420 --> 00:18:28,890
આ યાદી બાકીના કાઢી નાખો,
અને પછી વર્તમાન નોડ મુક્ત.

370
00:18:28,890 --> 00:18:32,850
જેમ કે સાઉન્ડ શું કરે છે,
શું ટેકનિક અમે વાત કરી છે

371
00:18:32,850 --> 00:18:35,440
વિશે અગાઉ જેમ કે સાઉન્ડ કરે છે?

372
00:18:35,440 --> 00:18:39,560
પછી, બીજા બધાને કાઢી નાખો
પાછા આવો અને મને કાઢી.

373
00:18:39,560 --> 00:18:42,380
>> કે પુનરાવર્તનના છે, અમે કરેલા
થોડી નાની સમસ્યા,

374
00:18:42,380 --> 00:18:46,910
અમે બધાને કાઢી કહી રહ્યાં છે
બીજું, પછી તમે મને કાઢી શકો છો.

375
00:18:46,910 --> 00:18:50,940
અને વધુ રોડ નીચે, કે નોડ
બીજા બધાને કાઢી, કહે છે કરશે.

376
00:18:50,940 --> 00:18:53,940
પરંતુ છેવટે અમે મળશે
આ યાદી નલ જ્યાં બિંદુ,

377
00:18:53,940 --> 00:18:55,310
અને તે અમારા આધાર કેસ છે.

378
00:18:55,310 --> 00:18:57,010
>> તેથી આપણે આ પર એક નજર કરીએ,
અને આ કામ કરી શકે છે કેવી રીતે.

379
00:18:57,010 --> 00:18:59,759
તેથી અહીં અમારા યાદી છે, તે જ છે
, અમે ફક્ત વિશે વાત કરવામાં આવી હતી યાદી

380
00:18:59,759 --> 00:19:00,980
અને પગલાંઓ છે.

381
00:19:00,980 --> 00:19:04,200
લખાણ ઘણો, અહીં છે, પરંતુ
આસ્થાપૂર્વક દ્રશ્ય માટે મદદ કરશે.

382
00:19:04,200 --> 00:19:08,557
>> તેથી અમે અહી અને હું પણ ખેંચાય
અમારા સ્ટેક ફ્રેમ ઉદાહરણ ઉપર

383
00:19:08,557 --> 00:19:10,890
કોલ રન ટાઇમ સ્ટેકનું પર અમારા વિડિઓ પ્રતિ,
અને આસ્થાપૂર્વક આ તમામ

384
00:19:10,890 --> 00:19:13,260
સાથે મળીને શું થઈ રહ્યું છે તમને બતાવશે.

385
00:19:13,260 --> 00:19:14,510
તેથી અહીં અમારા સ્યુડોકોડનો કોડ છે.

386
00:19:14,510 --> 00:19:17,830
અમે નલ સુધી પહોંચવા તો
નિર્દેશક, અન્યથા બંધ

387
00:19:17,830 --> 00:19:21,320
આ યાદી બાકીના કાઢી શકો છો,
પછી વર્તમાન નોડ મુક્ત.

388
00:19:21,320 --> 00:19:25,700
તેથી હમણાં, યાદી
અમે છો કે નિર્દેશક

389
00:19:25,700 --> 00:19:28,410
પસાર 12 પોઇન્ટ નાશ.

390
00:19:28,410 --> 00:19:33,340
12 નલ નિર્દેશક નથી, તેથી અમે છો
આ યાદી બાકીના કાઢી નાખવા જઈ રહી છે.

391
00:19:33,340 --> 00:19:35,450
>> શું કાઢવા છે
અમને બાકીના સામેલ?

392
00:19:35,450 --> 00:19:37,950
વેલ, તે બનાવવા થાય છે
કહીને, નાશ કરવા માટે કૉલ

393
00:19:37,950 --> 00:19:42,060
15 કે શરૂઆત છે
અમે નાશ કરવા માંગો છો યાદીમાં બાકીના.

394
00:19:42,060 --> 00:19:47,480
અને તેથી કોલ નાશ
12 હોલ્ડ પર પ્રકારની છે.

395
00:19:47,480 --> 00:19:52,690
તે માટે રાહ જોઈ, ત્યાં સ્થિર છે
તેના કામ સમાપ્ત કરવા માટે, 15 નાશ કરવા માટે કૉલ કરો.

396
00:19:52,690 --> 00:19:56,280
>> વેલ, 15 નલ નિર્દેશક નથી, અને
તેથી તે કહી રહ્યું છે, બધા અધિકાર,

397
00:19:56,280 --> 00:19:58,450
વેલ, આ યાદી બાકીના કાઢી.

398
00:19:58,450 --> 00:20:00,760
આ યાદી બાકીના શરૂ થાય છે
9, અને તેથી અમે ફક્ત પડશે

399
00:20:00,760 --> 00:20:04,514
તમે બધા કાઢી ત્યાં સુધી રાહ જુઓ કે
સામગ્રી, પછી પાછા આવો અને મને કાઢી.

400
00:20:04,514 --> 00:20:06,680
વેલ 9 વેલ, કહી રહ્યું છે,
હું એક નલ નિર્દેશક નથી

401
00:20:06,680 --> 00:20:09,020
તેથી અહીં બાકીના યાદી કાઢી.

402
00:20:09,020 --> 00:20:11,805
અને તેથી પ્રયાસ અને 13 નાશ.

403
00:20:11,805 --> 00:20:15,550
13, હું નલ નિર્દેશક નથી, કહે છે
એક જ વસ્તુ છે, તે નર હરણ પસાર કરે છે.

404
00:20:15,550 --> 00:20:17,930
10, 10 નલ નિર્દેશક નથી
એક નલ નિર્દેશક છે,

405
00:20:17,930 --> 00:20:20,200
પરંતુ 10 પોતે એક છે
નલ હમણાં નિર્દેશક,

406
00:20:20,200 --> 00:20:22,470
અને તેથી તે ખૂબ હરણ પસાર કરે છે.

407
00:20:22,470 --> 00:20:25,560
>> અને હવે, ત્યાં તે પોઇન્ટ યાદી
ખરેખર some-- નિર્દેશ કરશે

408
00:20:25,560 --> 00:20:28,710
હું છબી વધુ જગ્યા હોય તો,
તે કેટલાક રેન્ડમ જગ્યા માટે નિર્દેશ કરશે

409
00:20:28,710 --> 00:20:29,960
અમે તે શું છે ખબર નથી.

410
00:20:29,960 --> 00:20:34,680
તે છતાં નલ નિર્દેશક છે, યાદી
શાબ્દિક હવે તે નલ કિંમતો છે સુયોજિત થયેલ છે.

411
00:20:34,680 --> 00:20:36,820
તે અધિકાર કે લાલ બોક્સ અંદર પોઇન્ટ છે.

412
00:20:36,820 --> 00:20:39,960
અમે, તેથી નલ નિર્દેશક પહોંચી
અમે બંધ કરી શકો છો, અને અમે પૂર્ણ કરી રહ્યાં છો.

413
00:20:39,960 --> 00:20:46,230
>> અને જેથી જાંબલી ફ્રેમ પર now-- છે
સક્રિય ફ્રેમ કે stack-- ટોચ

414
00:20:46,230 --> 00:20:47,017
પરંતુ તે થાય છે.

415
00:20:47,017 --> 00:20:48,600
અમે એક નલ નિર્દેશક પહોંચી ગયા છો, તો અટકાવો.

416
00:20:48,600 --> 00:20:51,290
અમે કાંઇ નથી અમે
એક નલ નિર્દેશક મુક્ત કરી શકો છો,

417
00:20:51,290 --> 00:20:55,070
અમે કોઈ malloc ન હતી
જગ્યા, અને તેથી અમે પૂર્ણ કરી રહ્યાં છો.

418
00:20:55,070 --> 00:20:57,590
તે કાર્ય ફ્રેમ તેથી
નાશ છે, અને અમે છે

419
00:20:57,590 --> 00:21:00,930
અમે બાકી છે resume-- અમે બનાવ્યો
આગામી સૌથી વધુ એક સાથે બંધ જે

420
00:21:00,930 --> 00:21:02,807
અહીં આ ઘેરો વાદળી ફ્રેમ હોય છે.

421
00:21:02,807 --> 00:21:04,390
તેથી અમે અમે બોલ છોડી જ્યાં અધિકાર બનાવ્યો.

422
00:21:04,390 --> 00:21:06,598
અમે બાકીના કાઢી
યાદી પહેલેથી, તેથી હવે અમે છો

423
00:21:06,598 --> 00:21:08,000
વર્તમાન ગાંઠો મુક્ત બનશે.

424
00:21:08,000 --> 00:21:12,920
તેથી હવે અમે હવે આ નોડ મુક્ત શકો છો, અને
અમે કાર્ય અંત સુધી પહોંચી ગયા છો.

425
00:21:12,920 --> 00:21:16,810
અને તેથી તે કાર્ય ફ્રેમ, નાશ પામે છે
અને અમે પ્રકાશ વાદળી એક બનાવ્યો.

426
00:21:16,810 --> 00:21:20,650
>> તેથી તે મને પહેલેથી જ done-- કર્યું says--
આ યાદીમાં બાકીના કાઢી નાંખવા જેથી

427
00:21:20,650 --> 00:21:23,140
વર્તમાન નોડ મુક્ત.

428
00:21:23,140 --> 00:21:26,520
અને હવે યલો ફ્રેમ છે
પાછા સ્ટેક ટોચ પર.

429
00:21:26,520 --> 00:21:29,655
તમે જુઓ અને તેથી, અમે હવે છો
જમણેથી યાદી નાશ બાકી છે.

430
00:21:29,655 --> 00:21:33,710

431
00:21:33,710 --> 00:21:37,280
>> શું છે, જોકે, થયું હશે
અમે વસ્તુઓ ખોટી રીતે કર્યું હતું તો શું?

432
00:21:37,280 --> 00:21:39,410
જસ્ટ અમે પ્રયત્ન કર્યો ત્યારે જેવી
એક તત્વ ઉમેરો.

433
00:21:39,410 --> 00:21:41,909
અમે તો સાંકળ, મિશ્રિત થયેલા હોય તો
અમે પોઇંટરો કનેક્ટ ન હતી

434
00:21:41,909 --> 00:21:44,690
યોગ્ય ક્રમમાં, અમે તો
માત્ર પ્રથમ તત્વ મુક્ત,

435
00:21:44,690 --> 00:21:47,420
અમે હમણાં જ મુક્ત તો
યાદીમાં વડા હવે અમે

436
00:21:47,420 --> 00:21:49,642
નો સંદર્ભ લો કરવા માટે કોઈ રીત હોય છે
આ યાદી બાકીના.

437
00:21:49,642 --> 00:21:51,350
અને તેથી અમે હશે
અનાથ બધું

438
00:21:51,350 --> 00:21:53,880
અમે શું હતા
મેમરી છિદ્ર કહેવાય છે.

439
00:21:53,880 --> 00:21:56,800
તમે અમારા વિડિઓ થી યાદ તો
ગતિશીલ મેમરી ફાળવણી પર

440
00:21:56,800 --> 00:21:58,650
તે ખૂબ જ સારી બાબત નથી.

441
00:21:58,650 --> 00:22:00,810
>> તેથી હું ત્યાં જણાવ્યું હતું કે,
અનેક કામગીરી છે

442
00:22:00,810 --> 00:22:04,010
અમે કામ કરવા માટે વાપરવા માટે જરૂર છે કે જે
સાથે અસરકારક રીતે યાદી કડી થયેલ છે.

443
00:22:04,010 --> 00:22:08,430
અને તમે, હું એક અવગણવામાં સૂચન કર્યું છે
એક કડી થયેલ એક એક તત્વ કાઢી નાંખવા

444
00:22:08,430 --> 00:22:09,064
યાદી.

445
00:22:09,064 --> 00:22:10,980
હું તે કર્યું કારણ
તે ખરેખર પ્રકારની છે છે

446
00:22:10,980 --> 00:22:14,360
કાઢી કેવી રીતે વિશે વિચારો મુશ્કેલ
એક એકલા એક એક તત્વ

447
00:22:14,360 --> 00:22:15,600
કડી થયેલ યાદી.

448
00:22:15,600 --> 00:22:19,950
અમે ઉપર છોડી દો સમક્ષ રજુ કરવાનો પ્રયત્ન કરવાની જરૂર છે
આ યાદીમાં કંઈક કે જે

449
00:22:19,950 --> 00:22:22,975
અમે એક બિંદુ અમે વિચાર અર્થ એ થાય
આ નોડ કાઢી નાખવા માંગો છો

450
00:22:22,975 --> 00:22:25,350
પરંતુ ક્રમમાં અમે તેને જેથી બનાવવા માટે
કોઇ માહિતી ગુમાવી નથી,

451
00:22:25,350 --> 00:22:30,530
અમે આ જોડાણ કરવાની જરૂર
અહીં પર નોડ.

452
00:22:30,530 --> 00:22:33,390
>> તેથી હું કદાચ કે ખોટું કર્યું
એક દ્રશ્ય દ્રષ્ટિકોણથી.

453
00:22:33,390 --> 00:22:36,830
તેથી અમે શરૂઆતમાં રહ્યાં છો અમારા
યાદી, અમે મારફતે પ્રક્રિયા કરી રહ્યાં છો

454
00:22:36,830 --> 00:22:40,510
અમે આ નોડ કાઢી નાખવા માંગો છો.

455
00:22:40,510 --> 00:22:43,440
, અમે ફક્ત તેને કાઢી તો
અમે સાંકળ તૂટી છે.

456
00:22:43,440 --> 00:22:45,950
અહીં આ નોડ
બાકીનું બધું સંદર્ભ લે છે,

457
00:22:45,950 --> 00:22:48,260
તે અહીં બહાર પર સાંકળ છે.

458
00:22:48,260 --> 00:22:51,190
>> તેથી અમે ખરેખર શું કરવાની જરૂર છે
અમે આ બિંદુ મેળવવા પછી,

459
00:22:51,190 --> 00:22:56,670
અમે એક પાછા પગલું કરવાની જરૂર છે, અને
આ નોડ માટે આ નોડ પર જોડાવા માટે,

460
00:22:56,670 --> 00:22:58,590
તેથી અમે તે પછી કાઢી શકો છો
મધ્યમાં એક છે.

461
00:22:58,590 --> 00:23:02,120
પરંતુ એકલા કડી થયેલ યાદીઓ નથી
અમને પાછળની જવા માટે માર્ગ પૂરો પાડે છે.

462
00:23:02,120 --> 00:23:05,160
તેથી અમે ક્યાં રાખવા જરૂર
બે પોઇન્ટર, અને તેમને ખસેડવા

463
00:23:05,160 --> 00:23:09,527
બંધ પગલું જેવું, આ પાછળ એક
અન્ય અમે જાઓ, અથવા એક બિંદુ વિચાર

464
00:23:09,527 --> 00:23:11,110
અને પછી મારફતે અન્ય નિર્દેશક મોકલો.

465
00:23:11,110 --> 00:23:13,150
અને તમે તે જોઈ શકો છો
થોડી અવ્યવસ્થિત વિચાર કરી શકો છો.

466
00:23:13,150 --> 00:23:15,360
સદનસીબે, અમે છે
બીજી રીતે કે ઉકેલવા માટે,

467
00:23:15,360 --> 00:23:17,810
ત્યારે અમે સમયમાં બમણું કડી થયેલ યાદીઓ વિશે વાત કરો.

468
00:23:17,810 --> 00:23:20,720
>> હું ડો લોયડ છું, આ CS50 છે.

469
00:23:20,720 --> 00:23:22,298