1
00:00:07,260 --> 00:00:10,050
[Powered by Google Translate] ప్రోగ్రామింగ్, మనం, విలువల యొక్క జాబితాలలో ప్రాతినిధ్యం అవసరం

2
00:00:10,050 --> 00:00:12,840
ఒక విభాగంలో విద్యార్ధులు పేర్లు

3
00:00:12,840 --> 00:00:15,100
తాజా క్విజ్ లేదా వారి స్కోర్లు.

4
00:00:15,100 --> 00:00:17,430
>> సి భాషలో, శ్రేణుల ఉపయోగించవచ్చు డిక్లేర్డ్

5
00:00:17,430 --> 00:00:19,160
జాబితాలు నిల్వ.

6
00:00:19,160 --> 00:00:21,200
ఇది ఒక జాబితా అంశాలు మార్చడానికి సులభం

7
00:00:21,200 --> 00:00:23,390
వ్యూహం నిల్వ మరియు మీరు ఆక్సెస్ అవసరం ఉంటే

8
00:00:23,390 --> 00:00:25,050
లేదా ith జాబితా మూలకం సవరించండి

9
00:00:25,050 --> 00:00:27,570
స్వేచ్ఛా ఇండెక్స్ కోసం నేను,

10
00:00:27,570 --> 00:00:29,910
ఆ, స్థిరమైన సమయంలో చేయవచ్చు

11
00:00:29,910 --> 00:00:31,660
కానీ శ్రేణుల కూడా లోపాలు ఉన్నాయి.

12
00:00:31,660 --> 00:00:33,850
>> మేము వాటిని డిక్లేర్ చేసినప్పుడు, మేము చెప్పడం అవసరం చేస్తున్నారు

13
00:00:33,850 --> 00:00:35,900
వారు ఎంత పెద్ద ముందు అప్,

14
00:00:35,900 --> 00:00:38,160
వారు నిల్వ ఎలా అనేక అంశాలను ఉంది

15
00:00:38,160 --> 00:00:40,780
మరియు ఎంత పెద్ద ఈ అంశాలు వారి రకం ద్వారా నిర్ణయించబడుతుంది.

16
00:00:40,780 --> 00:00:45,450
ఉదాహరణకు, Int చేరే సమయం (10)

17
00:00:45,450 --> 00:00:48,220
10 అంశాలను నిల్వ చేయవచ్చు

18
00:00:48,220 --> 00:00:50,200
ఒక Int యొక్క పరిమాణం ఉంటాయి.

19
00:00:50,200 --> 00:00:52,590
>> మేము ప్రకటన తర్వాత వ్యూహం యొక్క పరిమాణం మార్చలేరు.

20
00:00:52,590 --> 00:00:55,290
మేము మరిన్ని అంశములు నిల్వ అనుకుంటే మేము ఒక కొత్త శ్రేణి చేసుకోవాలి.

21
00:00:55,290 --> 00:00:57,410
ఈ పరిమితి ఉంది కారణం మా

22
00:00:57,410 --> 00:00:59,040
కార్యక్రమం మొత్తం యెరే నిల్వ

23
00:00:59,040 --> 00:01:02,310
మెమరీ అవిచ్ఛిన్నంగా భాగం వంటి.

24
00:01:02,310 --> 00:01:04,500
ఈ మేము మా పరిధిలో నిల్వ పేరు బఫర్ సే.

25
00:01:04,500 --> 00:01:06,910
ఇతర అంశాలపై కావచ్చు

26
00:01:06,910 --> 00:01:08,310
శ్రేణి కుడి పక్కన ఉన్న

27
00:01:08,310 --> 00:01:10,060
మెమరీ, కాబట్టి మేము కాదు

28
00:01:10,060 --> 00:01:12,060
కేవలం శ్రేణి పెద్ద చేస్తాయి.

29
00:01:12,060 --> 00:01:15,700
>> కొన్నిసార్లు మేము శ్రేణి యొక్క ఫాస్ట్ డేటా వినియోగ వేగం వ్యాపారం చేయాలనుకుంటున్న

30
00:01:15,700 --> 00:01:17,650
ఒక చిన్న మరింత మృదుత్వాన్ని.

31
00:01:17,650 --> 00:01:20,380
లింక్ జాబితా, మరొక ప్రాథమిక డేటా నిర్మాణం ఎంటర్

32
00:01:20,380 --> 00:01:22,360
మీరు వంటి తెలిసిన కాదు.

33
00:01:22,360 --> 00:01:24,200
అధిక స్థాయిలో,

34
00:01:24,200 --> 00:01:26,840
ఒక లింక్ జాబితా నోడ్స్ యొక్క క్రమంలో డేటా నిల్వ

35
00:01:26,840 --> 00:01:29,280
ఆ, లింకులు ప్రతి ఇతర కనెక్ట్

36
00:01:29,280 --> 00:01:31,760
అందుకే పేరు 'లింక్ జాబితా.'

37
00:01:31,760 --> 00:01:33,840
డిజైన్ లో మేము చూస్తారు, ఈ వ్యత్యాసం

38
00:01:33,840 --> 00:01:35,500
వివిధ ప్రయోజనాలు మరియు అప్రయోజనాలు దారితీస్తుంది

39
00:01:35,500 --> 00:01:37,000
వ్యూహం కంటే.

40
00:01:37,000 --> 00:01:39,840
>> ఇక్కడ పూర్ణాంకాల యొక్క అతి సాధారణ లింక్ జాబితా కోసం కొన్ని సి కోడ్ ఉంది.

41
00:01:39,840 --> 00:01:42,190
మీరు మేము ప్రతి నోడ్ ప్రాతినిధ్యం చేసిన చూడగలరు

42
00:01:42,190 --> 00:01:45,520
2 విషయాలు కలిగి ఉన్న ఒక struct వంటి జాబితాలో,

43
00:01:45,520 --> 00:01:47,280
'వాల్' అని నిల్వ పూర్ణాంకం

44
00:01:47,280 --> 00:01:50,460
జాబితా తదుపరి నోడ్ మరియు లింక్

45
00:01:50,460 --> 00:01:52,990
మేము అనే పాయింటర్ వంటి ఇది 'తర్వాత.'

46
00:01:54,120 --> 00:01:56,780
ఈ విధంగా, మేము మొత్తం జాబితా ట్రాక్ చెయ్యవచ్చు

47
00:01:56,780 --> 00:01:58,790
1st నోడ్ కేవలం ఒకే పాయింటర్ తో,

48
00:01:58,790 --> 00:02:01,270
తరువాత రాబోయే గమనికలు అనుసరించండి

49
00:02:01,270 --> 00:02:03,130
2 వ నోడ్కు,

50
00:02:03,130 --> 00:02:05,280
3 వ నోడ్కు,

51
00:02:05,280 --> 00:02:07,000
4 వ నోడ్కు,

52
00:02:07,000 --> 00:02:09,889
అందువలన, మేము జాబితా చివర వచ్చేవరకు.

53
00:02:10,520 --> 00:02:12,210
>> మీరు ఈ ఉంది 1 లాభం లేదు చేయగలరు

54
00:02:12,210 --> 00:02:14,490
స్టాటిక్ అర్రే నిర్మాణాన్ని పైగా - ఒక లింక్ జాబితాను,

55
00:02:14,490 --> 00:02:16,450
మేము పూర్తిగా మెమరీ పెద్ద భాగం లేదు.

56
00:02:17,400 --> 00:02:20,530
జాబితా యొక్క 1 వ నోడ్, మెమరీ లో ఈ ప్రదేశంలో చేరుకోలేకపోయారు

57
00:02:20,530 --> 00:02:23,160
మరియు 2 వ నోడ్ ఇక్కడ అన్ని మార్గం ఉంటుంది.

58
00:02:23,160 --> 00:02:25,780
మెమరీలో వారు ఎక్కడ మేము నోడ్స్ సంబంధం లేదు పొందవచ్చు

59
00:02:25,780 --> 00:02:28,890
ఎందుకంటే ప్రతి నోడ్ యొక్క తదుపరి పాయింటర్, 1st నోడ్ వద్ద మొదలు

60
00:02:28,890 --> 00:02:31,700
ఖచ్చితంగా తదుపరి వెళ్ళడానికి మాకు చెబుతుంది.

61
00:02:31,700 --> 00:02:33,670
>> అదనంగా, మేము ముందు అప్ చెప్పడానికి లేదు

62
00:02:33,670 --> 00:02:36,740
ఎంత పెద్ద అనుబంధ జాబితా, మేము స్టాటిక్ శ్రేణితో చేయండి మార్గం

63
00:02:36,740 --> 00:02:39,060
మేము ఒక జాబితాకు నోడ్స్ జోడించవచ్చు నుండి

64
00:02:39,060 --> 00:02:42,600
కాలం స్పేస్ కొత్త నోడ్స్ కోసం మెమరీ ఎక్కడో అక్కడ వంటి.

65
00:02:42,600 --> 00:02:45,370
అందువలన, అనుసంధాన జాబితాలు డైనమిక్ పరిమాణాన్ని సులభం.

66
00:02:45,370 --> 00:02:47,950
తరువాత కార్యక్రమంలో మేము మరింత నోడ్స్ జోడించడానికి, సే

67
00:02:47,950 --> 00:02:49,350
మా జాబితాలో.

68
00:02:49,350 --> 00:02:51,480
ఎగిరి మా జాబితా ఒక కొత్త నోడ్ ప్రవేశపెట్టుటకు,

69
00:02:51,480 --> 00:02:53,740
మేము అన్ని, ఆ నోడ్సుకోసం మెమరీని కేటాయించాల్సిన ఉంది

70
00:02:53,740 --> 00:02:55,630
డేటా విలువ plop,

71
00:02:55,630 --> 00:02:59,070
మేము తగిన గమనికలు సర్దుబాటు ద్వారా ఎక్కడ మరియు అప్పుడు అది ఉంచండి.

72
00:02:59,070 --> 00:03:02,310
>> ఉదాహరణకు, మధ్య లో ఒక నోడ్ ఉంచండి కోరుకుంటే

73
00:03:02,310 --> 00:03:04,020
జాబితా యొక్క 2 మరియు 3 నోడ్స్,

74
00:03:04,020 --> 00:03:06,800
 మేము అన్ని వద్ద 2 వ లేదా 3 వ నోడ్స్ తరలించడానికి కాదు.

75
00:03:06,800 --> 00:03:09,190
మేము ఈ Red నోడ్ ఇన్సర్ట్ చేస్తున్నారు అనుకోండి.

76
00:03:09,190 --> 00:03:12,890
మేము లేదు కావలసిన అన్ని కొత్త నోడ్ యొక్క తదుపరి పాయింటర్ సెట్

77
00:03:12,890 --> 00:03:14,870
3 వ నోడ్ సూచించడానికి

78
00:03:14,870 --> 00:03:18,580
తర్వాత 2 వ నోడ్ యొక్క తదుపరి పాయింటర్ rewire

79
00:03:18,580 --> 00:03:20,980
మా కొత్త నోడ్ మార్చాలి.

80
00:03:22,340 --> 00:03:24,370
కాబట్టి, మేము ఎగిరి మా జాబితాలు పరిమాణాన్ని మార్చవచ్చు

81
00:03:24,370 --> 00:03:26,090
మా కంప్యూటర్ ఇండెక్సింగ్ ఆధారపడతారు కాబట్టి,

82
00:03:26,090 --> 00:03:28,990
కానీ వాటిని నిల్వ గమనికలు ఉపయోగించి లింక్ మీద.

83
00:03:29,120 --> 00:03:31,600
>> అయితే, ఒక ప్రతికూలత లింక్ జాబితాలు

84
00:03:31,600 --> 00:03:33,370
అని, ఒక స్థిర శ్రేణి కాకుండా,

85
00:03:33,370 --> 00:03:36,690
కంప్యూటర్ కేవలం జాబితా మధ్య జంప్ కాదు.

86
00:03:38,040 --> 00:03:40,780
కంప్యూటర్ లింక్ జాబితాలో ప్రతి నోడ్ సందర్శించడానికి కలిగి ఉన్నందుకు

87
00:03:40,780 --> 00:03:42,330
తదుపరి చెయ్యడానికి,

88
00:03:42,330 --> 00:03:44,770
ఒక నిర్దిష్ట నోడ్ కనుగొనేందుకు సమయం పడుతుంది వెళుతున్న

89
00:03:44,770 --> 00:03:46,400
ఇది వ్యూహంలో దానికన్నా.

90
00:03:46,400 --> 00:03:48,660
మొత్తం జాబితా అనుపాత సమయం పడుతుంది ప్రయాణించేందుకు

91
00:03:48,660 --> 00:03:50,580
జాబితా యొక్క పొడవు,

92
00:03:50,580 --> 00:03:54,630
లేదా O (n) asymptotic విధానంలో.

93
00:03:54,630 --> 00:03:56,510
సగటున, ఏ నోడ్ చేరుకుంది

94
00:03:56,510 --> 00:03:58,800
కూడా సమయం n నిష్పత్తిలో పడుతుంది.

95
00:03:58,800 --> 00:04:00,700
>> ఇప్పుడు, యొక్క నిజానికి కొన్ని కోడ్ వ్రాయుటకు అనుమతి

96
00:04:00,700 --> 00:04:02,000
ఆ లింక్ జాబితాలు పనిచేస్తుంది.

97
00:04:02,000 --> 00:04:04,220
లెట్ యొక్క మేము పూర్ణాంకాల యొక్క లింక్ జాబితా అనుకుందాం.

98
00:04:04,220 --> 00:04:06,140
మేము మళ్ళీ మా జాబితాలో ఒక నోడ్ సూచిస్తుంది

99
00:04:06,140 --> 00:04:08,340
2 ఖాళీలను ఒక struct వంటి,

100
00:04:08,340 --> 00:04:10,750
'వాల్' అని ఒక పూర్ణ సంఖ్య విలువ

101
00:04:10,750 --> 00:04:13,490
మరియు జాబితా యొక్క తదుపరి నోడ్ ఒక తదుపరి పాయింటర్.

102
00:04:13,490 --> 00:04:15,660
Well, తగినంత సాధారణ తెలుస్తోంది.

103
00:04:15,660 --> 00:04:17,220
>> లెట్ యొక్క మేము ఒక ఫంక్షన్ రాయడానికి అనుకుందాం

104
00:04:17,220 --> 00:04:19,329
ఇది ప్రవహిస్తుంది అవుట్ జాబితా మరియు ప్రింట్లు

105
00:04:19,329 --> 00:04:22,150
విలువ జాబితా యొక్క చివరి నోడ్ నిల్వ.

106
00:04:22,150 --> 00:04:24,850
అయితే, అది మేము జాబితాలో నోడ్లు దాటటానికి అవసరం అర్థం

107
00:04:24,850 --> 00:04:27,310
చివరి కనుగొనేందుకు, కాని మేము జోడించడం లేదు నుండి

108
00:04:27,310 --> 00:04:29,250
లేదా ఏదైనా తొలగించడం, మనము అనుకుంటున్న

109
00:04:29,250 --> 00:04:32,210
జాబితా తదుపరి గమనికలు యొక్క అంతర్గత నిర్మాణం.

110
00:04:32,210 --> 00:04:34,790
>> కాబట్టి, మేము ట్రావెర్సల్ కోసం ప్రత్యేకంగా ఒక పాయింటర్ చేయాలి

111
00:04:34,790 --> 00:04:36,940
ఇది మేము 'క్రాలర్.' పిలుస్తాను

112
00:04:36,940 --> 00:04:38,870
ఇది జాబితా యొక్క అన్ని మూలకాలను ద్వారా క్రాల్ చేస్తుంది

113
00:04:38,870 --> 00:04:41,190
తదుపరి గమనికలు యొక్క గొలుసు అనుసరించడం ద్వారా.

114
00:04:41,190 --> 00:04:43,750
మేము నిల్వ అన్ని, 1st నోడ్ ఒక పాయింటర్ గా

115
00:04:43,750 --> 00:04:45,730
జాబితా లేదా 'తల'.

116
00:04:45,730 --> 00:04:47,370
1st నోడ్ వెళ్ళండి పాయింట్లు.

117
00:04:47,370 --> 00:04:49,120
టైపు పాయింటర్ నుండి నోడ్ యొక్క ఉంటుంది.

118
00:04:49,120 --> 00:04:51,280
>> జాబితాలో నిజమైన 1 నోడ్ పొందడానికి,

119
00:04:51,280 --> 00:04:53,250
మేము, dereference ఈ పాయింటర్ కలిగి

120
00:04:53,250 --> 00:04:55,100
మేము అది dereference ముందు కానీ, మేము తనిఖీ చేయాలి

121
00:04:55,100 --> 00:04:57,180
పాయింటర్ మొదటి శూన్య ఉంటే.

122
00:04:57,180 --> 00:04:59,190
అది శూన్య అయితే, జాబితా, ఖాళీగా ఉంది

123
00:04:59,190 --> 00:05:01,320
మరియు మేము, జాబితా ఖాళీగా ఉంది ఎందుకంటే ఆ, ఒక సందేశాన్ని ముద్రించండి ఉండాలి

124
00:05:01,320 --> 00:05:03,250
గత నోడ్ ఉండదు.

125
00:05:03,250 --> 00:05:05,190
కానీ, లెట్స్ జాబితా ఖాళీగా కాదు సే.

126
00:05:05,190 --> 00:05:08,340
అలా కాకపోతే, అప్పుడు మేము మొత్తం జాబితా ద్వారా క్రాల్ చెయ్యాలో

127
00:05:08,340 --> 00:05:10,440
మేము జాబితాలో చివరి నోడ్ ను వరకు,

128
00:05:10,440 --> 00:05:13,030
మరియు మేము జాబితాలో చివరి నోడ్ వద్ద చూస్తున్న ఎలా మేము చెబుతారా?

129
00:05:13,670 --> 00:05:16,660
>> Well, ఒక కణుపు యొక్క తదుపరి పాయింటర్ శూన్య ఉంటే,

130
00:05:16,660 --> 00:05:18,320
మేము చివరికి మాకు తెలుసు

131
00:05:18,320 --> 00:05:22,390
గత తదుపరి పాయింటర్ సూచించడానికి జాబితాలో తదుపరి నోడ్ కలిగి కనుక.

132
00:05:22,390 --> 00:05:26,590
ఇది ఎల్లప్పుడూ శూన్యం కు initialized గత నోడ్ యొక్క తదుపరి పాయింటర్ ఉంచడానికి మంచి పద్ధతి యొక్క

133
00:05:26,590 --> 00:05:30,800
మేము జాబితా ముగింపు చేరుకున్నారు ఉన్నప్పుడు మాకు హెచ్చరిస్తుంది ఇది ఒక ప్రామాణిక ఆస్తి కలిగి.

134
00:05:30,800 --> 00:05:33,510
>> కాబట్టి, క్రాలర్ → తరువాతి శూన్య ఉంటే,

135
00:05:34,120 --> 00:05:38,270
బాణం సింటాక్స్ dereferencing ఒక షార్ట్కట్ అని గుర్తుంచుకోండి

136
00:05:38,270 --> 00:05:40,010
ఒక struct ఒక పాయింటర్, అప్పుడు యాక్సెస్

137
00:05:40,010 --> 00:05:42,510
ఇబ్బందికరమైన సమానం తన తరువాత ఫీల్డ్:

138
00:05:42,510 --> 00:05:48,750
(* క్రాలర్). తదుపరి.

139
00:05:49,820 --> 00:05:51,260
ఒకసారి మేము గత నోడ్ అనిపిస్తే

140
00:05:51,260 --> 00:05:53,830
మేము, క్రాలర్ → Val ప్రింట్ మీరు

141
00:05:53,830 --> 00:05:55,000
ప్రస్తుత నోడ్ విలువ

142
00:05:55,000 --> 00:05:57,130
ఇది మనము గత ఒకటి.

143
00:05:57,130 --> 00:05:59,740
లేకపోతే, మేము జాబితాలో చివరి నోడ్ వద్ద ఇంకా తెలియకపోతే,

144
00:05:59,740 --> 00:06:02,340
మేము జాబితాలో తదుపరి నోడ్ వెళ్ళటానికి కలిగి

145
00:06:02,340 --> 00:06:04,750
ఆ చివరి అయితే మరియు తనిఖీ.

146
00:06:04,750 --> 00:06:07,010
ఇది చేయుటకు, మేము మా క్రాలర్ పాయింటర్ సెట్

147
00:06:07,010 --> 00:06:09,840
ప్రస్తుత నోడ్ యొక్క తదుపరి విలువ సూచించడానికి,

148
00:06:09,840 --> 00:06:11,680
ఆ, జాబితా తదుపరి నోడ్ ఉంది.

149
00:06:11,680 --> 00:06:13,030
ఈ సెట్టింగ్ చేస్తారు

150
00:06:13,030 --> 00:06:15,280
క్రాలర్ = క్రాలర్ → తరువాతి.

151
00:06:16,050 --> 00:06:18,960
అప్పుడు మేము, ఉదాహరణకు ఒక లూప్ ఈ విధానాన్ని పునరుక్తి

152
00:06:18,960 --> 00:06:20,960
మేము గత నోడ్ క్లిక్ చెయ్యండి.

153
00:06:20,960 --> 00:06:23,150
కావున, ఉదాహరణకు, క్రాలర్ తల సూచించే ఒకవేళ,

154
00:06:24,050 --> 00:06:27,710
మేము, క్రాలర్ → తరువాతి సూచించడానికి క్రాలర్ సెట్

155
00:06:27,710 --> 00:06:30,960
ఇది 1 వ నోడ్ యొక్క తదుపరి రంగంలో కూడా లేదు.

156
00:06:30,960 --> 00:06:33,620
కాబట్టి, ఇప్పుడు మా క్రాలర్, 2 వ నోడ్ కు సూచిస్తుంది

157
00:06:33,620 --> 00:06:35,480
మరియు, మళ్ళీ, మేము, ఒక లూప్ ఈ పునరావృతం

158
00:06:37,220 --> 00:06:40,610
మేము గత నోడ్ అనిపిస్తే వరకు, అనగా,

159
00:06:40,610 --> 00:06:43,640
పేరు నోడ్ యొక్క తదుపరి పాయింటర్ శూన్యం కు సూచిస్తుంది.

160
00:06:43,640 --> 00:06:45,070
మరియు అక్కడ మేము, అది కలిగి

161
00:06:45,070 --> 00:06:47,620
మేము జాబితాలో చివరి నోడ్ అనిపిస్తే, మరియు దాని విలువ ముద్రించడానికి,

162
00:06:47,620 --> 00:06:50,800
మేము కేవలం క్రాలర్ → Val ఉపయోగించండి.

163
00:06:50,800 --> 00:06:53,130
>> నదీ ప్రవాహానికి అడ్డంగా ప్రయాణం అంత చెడ్డ కాదు, కానీ ఇన్సర్ట్ గురించి?

164
00:06:53,130 --> 00:06:56,290
అనుమతిస్తుంది మేము 4 వ స్థానం లో పూర్ణాంకం ఇన్సర్ట్ అనుకుందాం

165
00:06:56,290 --> 00:06:58,040
పూర్ణాంకం జాబితాలో.

166
00:06:58,040 --> 00:07:01,280
ప్రస్తుతం 3 వ మరియు 4 వ నోడ్సుమధ్య ఉంది.

167
00:07:01,280 --> 00:07:03,760
మళ్లీ, మేము జస్ట్ జాబితా ప్రయాణించేందుకు కలిగి

168
00:07:03,760 --> 00:07:06,520
3 వ మూలకం, మేము తర్వాత ఇన్సర్ట్ చేసిన ఒక పొందండి.

169
00:07:06,520 --> 00:07:09,300
అందుకే, ఈ, జాబితా నుండి అడ్డంగా మళ్ళీ క్రాలర్ పాయింటర్ సృష్టించడానికి

170
00:07:09,300 --> 00:07:11,400
మా తల పాయింటర్ శూన్య ఉంటే, తనిఖీ

171
00:07:11,400 --> 00:07:14,810
అలా కాకపోతే మరియు, తల నోడ్ వద్ద మా క్రాలర్ పాయింటర్ అభిప్రాయపడుతున్నారు.

172
00:07:16,880 --> 00:07:18,060
కాబట్టి, మేము 1st మూలకం వద్ద ఉన్నారు.

173
00:07:18,060 --> 00:07:21,020
మేము, మేము ఇన్సర్ట్ ముందు 2 మరిన్ని అంశములు ముందుకు వెళ్ళాలి

174
00:07:21,020 --> 00:07:23,390
కాబట్టి మేము లూప్ ఒక ఉపయోగించవచ్చు

175
00:07:23,390 --> 00:07:26,430
Int i = 1; i <3; i + +

176
00:07:26,430 --> 00:07:28,590
మరియు లూప్ యొక్క ప్రతి పునరావృతం లో,

177
00:07:28,590 --> 00:07:31,540
1 నోడ్ ముందుకు మా క్రాలర్ పాయింటర్ ముందుకు

178
00:07:31,540 --> 00:07:34,570
ప్రస్తుత నోడ్ యొక్క తదుపరి రంగంలో శూన్య ఉంటే తనిఖీ చెయ్యడం ద్వారా,

179
00:07:34,570 --> 00:07:37,550
అలా కాకపోతే మరియు, తరువాత నోడ్ మా క్రాలర్ పాయింటర్ తరలించు

180
00:07:37,550 --> 00:07:41,810
ప్రస్తుత నోడ్ యొక్క తదుపరి పాయింటర్ దానిని సమానంగా చేయడం ద్వారా.

181
00:07:41,810 --> 00:07:45,210
కాబట్టి, మా కోసం లూప్ అలా ఇలా చెబుతాడు నుండి

182
00:07:45,210 --> 00:07:47,550
రెండుసార్లు,

183
00:07:49,610 --> 00:07:51,190
మేము, 3 వ నోడ్ చేరుకున్నారు

184
00:07:51,190 --> 00:07:53,110
మరియు ఒకసారి మా క్రాలర్ పాయింటర్ తర్వాత నోడ్ చేరుకుంది

185
00:07:53,110 --> 00:07:55,270
ఇది మేము, మా కొత్త పూర్ణాంక ఇన్సర్ట్ చెయ్యడానికి మీరు

186
00:07:55,270 --> 00:07:57,050
ఎలా మేము నిజంగా ఇన్సర్ట్ చేయాలి?

187
00:07:57,050 --> 00:07:59,440
>> Well, మా కొత్త పూర్ణాంక జాబితాలో చేర్చబడ్డ ఉంటుంది

188
00:07:59,440 --> 00:08:01,250
తన సొంత నోడ్ struct భాగంగా,

189
00:08:01,250 --> 00:08:03,140
ఇది నిజంగా నోడ్స్ యొక్క వరుస క్రమం నుండి.

190
00:08:03,140 --> 00:08:05,690
కాబట్టి, నోడ్ ఒక కొత్త పాయింటర్ తయారు చేద్దాము

191
00:08:05,690 --> 00:08:08,910
'new_node,' అని

192
00:08:08,910 --> 00:08:11,800
మరియు ఇది సెట్ మేము ఇప్పుడు కేటాయించాలని ఆ స్మృతి సూచించడానికి

193
00:08:11,800 --> 00:08:14,270
నోడ్ మాత్రమే కుప్ప న,

194
00:08:14,270 --> 00:08:16,000
మరియు మేము కేటాయించే ఎంత మెమరీ చేయాలి?

195
00:08:16,000 --> 00:08:18,250
Well, ఒక కణుపు యొక్క పరిమాణం,

196
00:08:20,450 --> 00:08:23,410
మరియు మేము ఇన్సర్ట్ చెయ్యడానికి కావలసిన పూర్ణాంక తన Val రంగంలో సెట్ చేయాలనుకుంటున్నారా.

197
00:08:23,410 --> 00:08:25,590
లెట్ యొక్క 6 చెబుతారు.

198
00:08:25,590 --> 00:08:27,710
ఇప్పుడు, నోడ్ మా పూర్ణాంక విలువ కలిగి ఉంది.

199
00:08:27,710 --> 00:08:30,650
ఇది కొత్త నోడ్ యొక్క తదుపరి రంగంలో ప్రారంభించడం కూడా మంచి పద్ధతి యొక్క

200
00:08:30,650 --> 00:08:33,690
శూన్యం సూచించడానికి,

201
00:08:33,690 --> 00:08:35,080
కానీ ఇప్పుడు ఏంటి?

202
00:08:35,080 --> 00:08:37,179
>> మేము జాబితాలో అంతర్గత నిర్మాణం మార్చవలసి

203
00:08:37,179 --> 00:08:40,409
మరియు తర్వాత గమనికలు జాబితా యొక్క ప్రస్తుత ఉన్న

204
00:08:40,409 --> 00:08:42,950
3 వ మరియు 4 వ నోడ్స్.

205
00:08:42,950 --> 00:08:46,560
తదుపరి గమనికలు జాబితా క్రమాన్ని గుర్తించేందుకు, నుండి

206
00:08:46,560 --> 00:08:48,650
మరియు మేము మా కొత్త నోడ్ ఇన్సర్ట్ ఉన్నందున

207
00:08:48,650 --> 00:08:50,510
కుడివైపు జాబితా యొక్క మధ్యలో,

208
00:08:50,510 --> 00:08:52,010
అది ఒక బిట్ గమ్మత్తైన ఉంటుంది.

209
00:08:52,010 --> 00:08:54,250
గుర్తు, ఎందుకంటే ఇది మా కంప్యూటర్ ఉంది

210
00:08:54,250 --> 00:08:56,250
మాత్రమే జాబితాలో ల నగర తెలుసు

211
00:08:56,250 --> 00:09:00,400
మునుపటి నోడ్స్ నిల్వ తదుపరి గమనికలు కారణంగా.

212
00:09:00,400 --> 00:09:03,940
కాబట్టి, మనం, ఈ ప్రాంతాల్లో ఏ ట్రాక్ కోల్పోతే

213
00:09:03,940 --> 00:09:06,860
మా జాబితా తదుపరి గమనికలు ఒకటి మార్చడం ద్వారా చెప్పడానికి,

214
00:09:06,860 --> 00:09:09,880
ఉదాహరణకు, మేము మార్చబడింది సే

215
00:09:09,880 --> 00:09:12,920
3 వ నోడ్ యొక్క తదుపరి రంగంలో

216
00:09:12,920 --> 00:09:15,610
ఇక్కడ కొంత నోడ్ మార్చాలి.

217
00:09:15,610 --> 00:09:17,920
మేము ఎందుకంటే మేము, అవ్ట్ అదృష్టం అంటాను

218
00:09:17,920 --> 00:09:20,940
, పేరు జాబితా మిగిలిన కనుగొనేందుకు ఏ ఆలోచన ఉంది

219
00:09:20,940 --> 00:09:23,070
మరియు స్పష్టమైన నిజంగా దురదృష్టకరం.

220
00:09:23,070 --> 00:09:25,080
అందుకే, ఈ క్రమంలో గురించి నిజంగా జాగ్రత్తగా ఉండాలి

221
00:09:25,080 --> 00:09:28,360
మేము చొప్పించడం సమయంలో మా తదుపరి గమనికలు సర్దుబాటు దీనిలో.

222
00:09:28,360 --> 00:09:30,540
>> కాబట్టి, ఈ సరళీకృతం చేయడానికి, యొక్క అని పిలవబడు ఆ

223
00:09:30,540 --> 00:09:32,220
మా మొదటి 4 నోడ్స్

224
00:09:32,220 --> 00:09:36,200
గమనికలు యొక్క గొలుసు ప్రాతినిధ్యం బాణాలు తో, A, B, C, D మరియు పిలుస్తారు

225
00:09:36,200 --> 00:09:38,070
నోడ్స్ కనెక్ట్.

226
00:09:38,070 --> 00:09:40,050
కాబట్టి, మేము మా కొత్త నోడ్ ఇన్సర్ట్ చేయాలి

227
00:09:40,050 --> 00:09:42,070
నోడ్స్ సి మరియు డి మధ్య

228
00:09:42,070 --> 00:09:45,060
ఇది కుడి క్రమంలో దీన్ని క్లిష్టమైన, మరియు నేను తెలియజేస్తాము.

229
00:09:45,060 --> 00:09:47,500
>> మొదటి దీన్ని తప్పుగా చూద్దాం.

230
00:09:47,500 --> 00:09:49,490
హేయ్, మేము కొత్త నోడ్ సి తరువాత వచ్చిన పొందింది,

231
00:09:49,490 --> 00:09:51,910
కాబట్టి యొక్క C యొక్క తదుపరి పాయింటర్ సెట్ తెలియజేయండి

232
00:09:51,910 --> 00:09:54,700
new_node మార్చాలి.

233
00:09:56,530 --> 00:09:59,180
All right, సరే ఉంది, మేము ఇప్పుడు ముగించడానికి కలిగి

234
00:09:59,180 --> 00:10:01,580
D కొత్త నోడ్ యొక్క తదుపరి పాయింటర్ విషయాన్ని,

235
00:10:01,580 --> 00:10:03,250
కానీ వేచి, ఎలా మేము చేయగలరు?

236
00:10:03,250 --> 00:10:05,170
D ఉన్న మాకు అని మాత్రమే కాదు,

237
00:10:05,170 --> 00:10:07,630
తదుపరి పాయింటర్ గతంలో, సి నిల్వ చేశారు

238
00:10:07,630 --> 00:10:09,870
కానీ మేము ఆ పాయింటర్ తిరిగి వ్రాసారు

239
00:10:09,870 --> 00:10:11,170
కొత్త నోడ్ సూచించడానికి,

240
00:10:11,170 --> 00:10:14,230
కాబట్టి మేము ఇకపై, D మెమరీలో ఉన్న ఏ క్లూ కలిగి

241
00:10:14,230 --> 00:10:17,020
మరియు మేము జాబితా మిగిలిన కోల్పోయి.

242
00:10:17,020 --> 00:10:19,000
అన్ని మంచి.

243
00:10:19,000 --> 00:10:21,090
>> కాబట్టి, మేము ఈ కుడి ఎలా చేయాలి?

244
00:10:22,360 --> 00:10:25,090
మొదటి, D. కొత్త నోడ్ యొక్క తదుపరి పాయింటర్ సూచించండి

245
00:10:26,170 --> 00:10:28,990
ఇప్పుడు, రెండు కొత్త నోడ్ యొక్క మరియు C యొక్క తదుపరి గమనికలు

246
00:10:28,990 --> 00:10:30,660
అదే నోడ్, D సూచించే ఉంటాయి,

247
00:10:30,660 --> 00:10:32,290
కానీ ఆ మంచిది.

248
00:10:32,290 --> 00:10:35,680
ఇప్పుడు మేము కొత్త నోడ్ వద్ద సి తరువాత పాయింటర్ సూచిస్తుంది.

249
00:10:37,450 --> 00:10:39,670
కాబట్టి, మేము ఏ డేటా కోల్పోకుండా ఇది చేసిన.

250
00:10:39,670 --> 00:10:42,280
కోడ్ లో, C ప్రస్తుత కణుపు

251
00:10:42,280 --> 00:10:45,540
ట్రావెర్సల్ పాయింటర్ క్రాలర్, కు సూచిస్తుంది ఆ

252
00:10:45,540 --> 00:10:50,400
మరియు D, ప్రస్తుత నోడ్ యొక్క తదుపరి రంగంలో ద్వారా చూపారు నోడ్ ప్రాతినిధ్యం వహిస్తుంది

253
00:10:50,400 --> 00:10:52,600
లేదా క్రాలర్ → తరువాతి.

254
00:10:52,600 --> 00:10:55,460
కాబట్టి, మేము మొదటి కొత్త నోడ్ యొక్క తదుపరి పాయింటర్ సెట్

255
00:10:55,460 --> 00:10:57,370
క్రాలర్ → తరువాతి సూచించడానికి,

256
00:10:57,370 --> 00:11:00,880
మేము new_node తరువాత పాయింటర్ భావించారు అదే విధంగా

257
00:11:00,880 --> 00:11:02,780
ఉదాహరణ D సూచించారు.

258
00:11:02,780 --> 00:11:04,540
అప్పుడు, మేము ప్రస్తుత నోడ్ యొక్క తదుపరి పాయింటర్ సెట్ చేయవచ్చు

259
00:11:04,540 --> 00:11:06,330
మా కొత్త నోడ్ కు,

260
00:11:06,330 --> 00:11:10,980
మేము డ్రాయింగ్ లో new_node కు సి మార్చాలి వేచి చేసినట్టుగానే.

261
00:11:10,980 --> 00:11:12,250
ఇప్పుడు ప్రతిదీ క్రమంలో ఉంది, మరియు మేము ఓడిపోలేదు

262
00:11:12,250 --> 00:11:14,490
ఏదైనా డేటా ట్రాక్, మరియు మేము కేవలం సాధించారు

263
00:11:14,490 --> 00:11:16,200
జాబితా మధ్యలో మా కొత్త నోడ్ కర్ర

264
00:11:16,200 --> 00:11:19,330
ఈ మొత్తం విషయం పునర్నిర్మాణ లేదా ఏదైనా మూలకాల బదిలీ లేకుండా

265
00:11:19,330 --> 00:11:22,490
మార్గం మేము ఒక స్థిర పొడవు శ్రేణి తో పేర్కొంది.

266
00:11:22,490 --> 00:11:26,020
>> కాబట్టి, అనుసంధాన జాబితాలు ఒక ప్రాథమిక, కానీ ముఖ్యమైన, డైనమిక్ డేటా నిర్మాణం ఉన్నాయి

267
00:11:26,020 --> 00:11:29,080
ఇది ప్రయోజనాలు మరియు అప్రయోజనాలు ఉన్నాయి

268
00:11:29,080 --> 00:11:31,260
శ్రేణుల మరియు ఇతర డేటా నిర్మాణాలు పోలిస్తే,

269
00:11:31,260 --> 00:11:33,350
మరియు, తరచుగా కంప్యూటర్ సైన్స్ లో కేసు

270
00:11:33,350 --> 00:11:35,640
ఇది ప్రతి సాధనం ఉపయోగించడానికి తెలుసుకోవడానికి ముఖ్యం

271
00:11:35,640 --> 00:11:37,960
కాబట్టి మీరు సరైన ఉద్యోగం కోసం కుడి సాధనం ఎంచుకోవచ్చు.

272
00:11:37,960 --> 00:11:40,060
>> మరింత సాధన కోసం, విధులు రాయడం ప్రయత్నించండి

273
00:11:40,060 --> 00:11:42,080
ఒక లింక్ జాబితా నుండి తొలగించండి నోడ్స్ -

274
00:11:42,080 --> 00:11:44,050
మీరు క్రమాన్ని ఏ క్రమంలో గురించి జాగ్రత్తగా గుర్తుంచుకోండి

275
00:11:44,050 --> 00:11:47,430
మీ జాబితా యొక్క ఒక భాగం కోల్పోతే లేదు నిర్ధారించడానికి మీ తదుపరి గమనికలు -

276
00:11:47,430 --> 00:11:50,200
లేదా అనుబంధ జాబితా లో నోడ్ లెక్కించడానికి ఒక ఫంక్షన్

277
00:11:50,200 --> 00:11:53,280
ఒక లింక్ జాబితాలో నోడ్స్ యొక్క అన్ని క్రమాన్ని రివర్స్ లేదా ఒక ఆహ్లాదకరమైన ఒక.

278
00:11:53,280 --> 00:11:56,090
>> నా పేరు జాక్సన్ STEINKAMP, ఈ CS50 ఉంది.