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: OK, కాబట్టి
కోర్సు లో ఈ సమయంలో,

4
00:00:08,560 --> 00:00:15,300
మేము C. పునాదులను చాలా కవర్ చేసిన
మేము వేరియబుల్స్ శ్రేణుల గురించి చాలా తెలుసు

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
వ్యూహాలను కూడా మరొక బాధపడుతున్నారు
సమస్య, ఇది inflexibility ఉంది.

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 యూజర్ ఒక సంఖ్య 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 అవసరమైన, లేదా నేను x ప్లస్ 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, లేదా x ప్లస్ 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
struct 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
కాబట్టి అది ఒక తాత్కాలిక ఇవ్వడం
struct sllist పేరు

91
00:05:14,910 --> 00:05:18,540
నాకు అప్పుడు నేను ఒక అనుకుందాం అనుమతిస్తుంది
మరొక struct sllist పాయింటర్,

92
00:05:18,540 --> 00:05:24,690
ఒక struct 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
ఇక్కడ ఒక నిర్దేశకాన్ని పేరు లేదు.

99
00:05:39,390 --> 00:05:43,040
ఇది కేవలం, typedef struct చెబుతా
వంకర కలుపు తెరిచి, ఆపై నిర్వచించారు.

100
00:05:43,040 --> 00:05:45,620
మీరు అయితే struct నేనే ఉంది
నిర్దేశకం, ఈ ఒకటి గా,

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
>> All right, కాబట్టి మేము ఎలా తెలుసు
ఒక లింక్ జాబితా నోడ్ సృష్టించడానికి.

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
మరియు మేము వాటిని ఊహించడానికి ఎంతమేరకు,
ప్రత్యేకంగా pseudocode కోడ్ లో మాట్లాడటం.

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
Well, నేను మొదటి విషయం ఉన్నాను
చేయబోవడం డైనమిక్ ఉంది

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
Well, ఈ ఫంక్షన్ ఆధారంగా
నేను ఇక్కడ ఉపయోగించి వెబ్ కాల్

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
Well, మేము మొదటి విషయం ఉంది
మేము ఒక దిక్కుకు ఫిరంగిని త్రిప్పుట పాయింటర్ సృష్టించడానికి

193
00:10:04,250 --> 00:10:06,015
జాబితాలు తల ఎత్తి చూపుతుంది.

194
00:10:06,015 --> 00:10:08,890
Well, ఎందుకు ఆ, మేము ఇప్పటికే మేము చేస్తారు
జాబితాలు తల వద్ద ఒక పాయింటర్ కలిగి,

195
00:10:08,890 --> 00:10:10,974
ఎందుకు మేము చుట్టూ ఒక తరలించడానికి లేదు?

196
00:10:10,974 --> 00:10:13,140
Well, నేను కేవలం అన్నారు,
ఇది మాకు నిజంగా ముఖ్యం

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
శూన్య మేము ముగింపు చేరుకున్నారు
మరియు జాబితాలో లేదు.

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
Well, జాబితా గమనించవచ్చు
ఇక్కడ, మార్మికంగా భిన్నంగా ఉంటుంది

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
లేదా నా లింక్ జాబితా 25th మూలకం,
వాటికి సంబంధించిన ఏ ఇండెక్స్ ఉంది.

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
Well, మేము వద్ద మొదలు
ప్రారంభంలో, మేము, 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
Well, trav తదుపరి ద్వారా సూచించిన
అక్కడ ఎరుపు బాక్స్, NULL.

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
>> OK, ఎలా మేము ఒక కొత్త ఇన్సర్ట్ చెయ్యాలి
లింక్ జాబితా నోడ్?

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
కాబట్టి జగిత్యాల, సంసార
Val నోడ్ లోకి, ఉంది.

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 యొక్క O అవుతాడని
ఆపరేషన్, వెళుతున్నారు

297
00:15:04,140 --> 00:15:06,720
మా చర్చ
గణన సంక్లిష్టత.

298
00:15:06,720 --> 00:15:10,140
అది n ఆపరేషన్ పేరు ఒక O మారింది కావలసిన
జాబితా కంటే పెద్దది, మరియు పెద్ద వచ్చింది,

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
Well, మొదటి మేము స్థలాన్ని 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
జాబితా మిగిలిన అనాధల.

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
>> OK, కాబట్టి బావుంటుంది.

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
>> OK, కాబట్టి ఒక మరింత విషయం గురించి మాట్లాడటానికి.

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
Well, మేము ఏమి అనుకుంటున్నారు?

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
ఇక్కడ మా pseudocode కోడ్ ఉంది.

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
>> Well, 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
మీరు అన్ని తొలగించే వరకు వేచి
stuff, అప్పుడు తిరిగి వచ్చి నన్ను తొలగించండి.

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
>> అందువలన, ఊదా ఫ్రేమ్ వద్ద ఇప్పుడు ఉంది
క్రియాశీల ఫ్రేమ్ అని 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
>> కనుక ఇది నేను ఇప్పటికే సమయానికి చేసిన 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