1
00:00:00,000 --> 00:00:02,730
[Powered by Google Translate] [విభాగం 6: తక్కువ సౌకర్యవంతమైన]

2
00:00:02,730 --> 00:00:05,040
[నేట్ Hardison] [హార్వర్డ్ విశ్వవిద్యాలయం]

3
00:00:05,040 --> 00:00:07,320
[ఈ CS50 ఉంది.] [CS50.TV]

4
00:00:07,320 --> 00:00:11,840
అన్ని కుడి. విభాగం 6 స్వాగతం.

5
00:00:11,840 --> 00:00:14,690
ఈ వారం, మేము, విభాగంలో డేటా నిర్మాణాలు గురించి మాట్లాడటం కావడం చేస్తున్నారు

6
00:00:14,690 --> 00:00:19,780
ఈ వారం యొక్క సమస్య మీద spellr సెట్ ప్రధానంగా

7
00:00:19,780 --> 00:00:24,410
వివిధ డేటా నిర్మాణం అన్వేషణ యొక్క మొత్తం బంచ్ చేస్తుంది.

8
00:00:24,410 --> 00:00:26,520
మీరు సమస్య సమితి వెళ్ళి వేర్వేరు మార్గాలను కొంత ఉన్నాయి

9
00:00:26,520 --> 00:00:31,570
మరియు మీరు గురించి మరింత డేటా నిర్మాణాలు, మీరు చేయవచ్చు మరింత మంచి విషయాలు.

10
00:00:31,570 --> 00:00:34,990
>> కాబట్టి యొక్క ప్రారంభించడానికి అనుమతిస్తాయి. మొదటి మేము, స్టాక్స్ గురించి మాట్లాడటానికి వెళుతున్న

11
00:00:34,990 --> 00:00:37,530
మేము మాట్లాడటానికి చూడాలని ఉద్దేశ్యంతో స్టాక్ మరియు క్యూ డేటా నిర్మాణాలు.

12
00:00:37,530 --> 00:00:40,560
మేము గ్రాఫ్లు గురించి మాట్లాడటం ప్రారంభించినప్పుడు స్టాక్స్ మరియు క్యూలు, నిజంగా సహాయకరమైతేనే

13
00:00:40,560 --> 00:00:44,390
మేము ఇప్పుడు హక్కు చాలా చేయబోవడం లేదు ఇది.

14
00:00:44,390 --> 00:00:52,820
కానీ వారు CS యొక్క పెద్ద ప్రాథమిక డేటా నిర్మాణాలు అర్థం మంచి ఉన్నాము.

15
00:00:52,820 --> 00:00:54,880
సమస్య సెట్ వివరణలో వివరణ,

16
00:00:54,880 --> 00:00:59,260
వంటిదని స్టాక్స్ గురించి మీరు పుల్ అప్ ఉంటే, చర్చలు

17
00:00:59,260 --> 00:01:05,239
మీరు ఆహారశాలలు వద్ద ఫలహారశాల కలిగి భోజన ట్రేలు యొక్క కుప్ప

18
00:01:05,239 --> 00:01:09,680
భోజన సిబ్బంది వచ్చి వారు వాటిని శుభ్రం చేసిన తర్వాత, భోజన ట్రేలు ఉంచుతారు అక్కడ

19
00:01:09,680 --> 00:01:12,000
వారు వాటిని ఇతర ఒకటిగా పేర్చడాన్ని.

20
00:01:12,000 --> 00:01:15,050
మరియు తర్వాత పిల్లలు, ఆహారం పొందడానికి వచ్చినప్పుడు

21
00:01:15,050 --> 00:01:19,490
వారు మొదటి టాప్ ఒకటి, ట్రేలు ఆఫ్ పుల్, అది క్రింద ఒక, ఆ క్రింద ఒక.

22
00:01:19,490 --> 00:01:25,190
కాబట్టి, ప్రభావం లో, భోజన సిబ్బంది అణిచివేసేందుకు ఆ మొదటి ట్రే నుండి తొలగించబడింది పొందే చివరి ఒకటి.

23
00:01:25,190 --> 00:01:32,330
భోజన సిబ్బంది మీద పెట్టే చివరి విందు కోసం తొలగించబడింది పొందే మొదటి ఒకటి.

24
00:01:32,330 --> 00:01:38,100
మీరు ఇప్పటికే కలిగి ఉంటే సమస్య సెట్ యొక్క వివరాలను, మీరు, ఇది డౌన్లోడ్ చేసుకోవచ్చు

25
00:01:38,100 --> 00:01:46,730
మేము ఈ రకమైన struct ఉపయోగించి స్టాక్ డేటా stucture నమూనా గురించి మాట్లాడండి.

26
00:01:46,730 --> 00:01:51,070
>> కాబట్టి మేము ఇక్కడ మేం ఏమి, ఈ, ఉపన్యాసంలో సమర్పించారు ఏ పోలి ఉంటుంది

27
00:01:51,070 --> 00:01:58,120
ఉపన్యాసంలో తప్ప మేము చార్ * s వ్యతిరేకంగా ints ఈ అందించింది.

28
00:01:58,120 --> 00:02:06,250
ఈ దుకాణాల్లో ఏమి ఒక స్టాక్ ఉండబోతుంది?

29
00:02:06,250 --> 00:02:09,009
డేనియల్? మేము ఈ స్టాక్ లో ఏం నిల్వ ఉంటాయి?

30
00:02:09,009 --> 00:02:15,260
[డేనియల్] స్ట్రింగ్స్? >> మేము ఖచ్చితంగా, ఈ స్టాక్ లో తీగలను నిల్వ ఉంటాయి.

31
00:02:15,260 --> 00:02:20,950
మీరు ఒక స్టాక్ సృష్టించడానికి అవసరం అన్ని ఒక శ్రేణి

32
00:02:20,950 --> 00:02:23,920
ఒక నిర్దిష్ట సామర్ధ్యం, ఈ సందర్భంలో ఇది,

33
00:02:23,920 --> 00:02:28,020
సామర్థ్యం అది స్థిరమైన ఎందుకంటే అన్ని CAPS లో అన్నారు.

34
00:02:28,020 --> 00:02:36,340
ఆపై శ్రేణి అదనంగా, మేము ట్రాక్ ఏమిటంటే శ్రేణి యొక్క ప్రస్తుత పరిమాణం.

35
00:02:36,340 --> 00:02:38,980
ఆ చల్లని రకంగా ఇక్కడ గమనించదగ్గ విషయం ఒకటి

36
00:02:38,980 --> 00:02:47,060
మేము మరొక డేటా నిర్మాణం, అర్రే ఒకటిగా అమర్చినట్లు డేటా నిర్మాణం ఏర్పడుతుంది చేస్తున్న ఉంది.

37
00:02:47,060 --> 00:02:50,110
స్టాక్స్ అమలు వివిధ మార్గాలు ఉన్నాయి.

38
00:02:50,110 --> 00:02:54,250
మేము, కానీ ఆశాజనక అనుసంధాన-జాబితా సమస్యలు చేసిన తర్వాత, చాలా ఇంకా అది చేయరు

39
00:02:54,250 --> 00:03:00,520
మీరు సులభంగా అలాగే అనుబంధ జాబితా పైన స్టాక్ అమలు ఎలా చూస్తారు.

40
00:03:00,520 --> 00:03:02,640
కానీ ఇప్పుడు కోసం, మేము శ్రేణుల అంటుకుని ఉంటుంది.

41
00:03:02,640 --> 00:03:06,350
మరలా, మేము అవసరం అన్ని ఒక శ్రేణి మరియు మేము కేవలం శ్రేణి యొక్క పరిమాణం ట్రాక్ అవసరం.

42
00:03:06,350 --> 00:03:09,850
[సామ్] క్షమించాలి, ఎందుకు మీరు స్టాక్ తీగల యొక్క అగ్ర చెప్పారు ఉంది?

43
00:03:09,850 --> 00:03:13,440
తీగలను స్టాక్ లోపల లాగ నాకు అది తెలుస్తుంది.

44
00:03:13,440 --> 00:03:16,790
[Hardison] అవును. మేము మా శ్రేణి డేటా నిర్మాణం వేస్తున్నాము, సృష్టిస్తున్నారు -

45
00:03:16,790 --> 00:03:22,130
ఒక గొప్ప ప్రశ్న. కాబట్టి ప్రశ్న, ఈ ఆన్లైన్ చూడటం వ్యక్తులు కోసం, ఎందుకు

46
00:03:22,130 --> 00:03:24,140
ఎందుకు మేము, స్టాక్ తీగలను పైన అని అంటున్నారు

47
00:03:24,140 --> 00:03:27,990
ఇక్కడ అది తీగలను స్టాక్ లోపల లేనట్లు? ఎందుకంటే

48
00:03:27,990 --> 00:03:31,050
ఏ పూర్తిగా విషయం.

49
00:03:31,050 --> 00:03:34,660
నేను ఈ విధంగా సూచించింది మేము వ్యూహం డేటా నిర్మాణం పొందారు ఉంది.

50
00:03:34,660 --> 00:03:39,290
మేము చార్ * s యొక్క వ్యూహం, తీగల యొక్క ఈ శ్రేణి, పొందారు

51
00:03:39,290 --> 00:03:45,300
మరియు మేము అమర్చినట్లు డేటా నిర్మాణం సృష్టించడానికి ఆ జోడించడానికి వెళ్తున్నారు.

52
00:03:45,300 --> 00:03:48,620
>> కాబట్టి ఒక స్టాక్ వ్యూహం కంటే కొద్దిగా క్లిష్టమైన ఉంది.

53
00:03:48,620 --> 00:03:51,890
మేము ఒక స్టాక్ నిర్మించడానికి వ్యూహం ఉపయోగించవచ్చు.

54
00:03:51,890 --> 00:03:55,810
మేము స్టాక్ వ్యూహం పై నిర్మించబడిన ఉంటుంది అని పేరు కాబట్టి ఆ.

55
00:03:55,810 --> 00:04:02,510
అలాగే, నేను ముందు చెప్పారు వంటి, మేము ఒక లింక్ జాబితా పైన స్టాక్ నిర్మించవచ్చు.

56
00:04:02,510 --> 00:04:04,960
బదులుగా మా అంశాలను పట్టుకుని వరుసను ఉపయోగించి యొక్క,

57
00:04:04,960 --> 00:04:10,070
మేము మా అంశాలను కలిగి మరియు చుట్టూ స్టాక్ నిర్మించడానికి అనుబంధ జాబితా ఉపయోగించవచ్చు.

58
00:04:10,070 --> 00:04:12,420
కొన్ని కోడ్ చూడటం, యొక్క ఉదాహరణలలో ఒక జంట నడవడానికి లెట్

59
00:04:12,420 --> 00:04:14,960
నిజానికి ఇక్కడ ఏం చూడటానికి.

60
00:04:14,960 --> 00:04:23,400
ఎడమ వైపు, నేను ఆ స్టాక్ struct మెమరీ ఎలా ఏ డౌన్ విసిరి చేసిన

61
00:04:23,400 --> 00:04:28,330
సామర్థ్యం # నాలుగు అని నిర్వచించారు ఉంటే.

62
00:04:28,330 --> 00:04:33,490
మేము మా నాలుగు మూలకం చార్ * శ్రేణి పొందారు.

63
00:04:33,490 --> 00:04:38,110
మేము తీగలను [0], తీగలు [1], తీగలు [2], తీగలు [3], పొందారు

64
00:04:38,110 --> 00:04:43,800
తరువాత మా పరిమాణం పూర్ణాంక కోసం చివరి స్పేస్.

65
00:04:43,800 --> 00:04:46,270
ఈ కోణంలో రాబడుతుంది? సరే.

66
00:04:46,270 --> 00:04:48,790
ఈ నేను ఏమి ఏమి, జరిగినప్పుడు ఉంది

67
00:04:48,790 --> 00:04:55,790
నా కోడ్ ఉంటుంది, ఇది కేవలం ఒక struct, s అనే అమర్చినట్లు struct ప్రకటించాలని ఉంది.

68
00:04:55,790 --> 00:05:01,270
ఈ మేము పొందుతారు. ఇది మెమరీ ఈ పాదముద్ర డౌన్ సూచిస్తుంది.

69
00:05:01,270 --> 00:05:05,590
ఇక్కడ మొదటి ప్రశ్న ఈ స్టాక్ struct విషయాలు ఏమి ఉంది?

70
00:05:05,590 --> 00:05:09,250
ప్రస్తుతం వారు ఏమీ, కానీ వారు పూర్తిగా ఏమీ లేదు.

71
00:05:09,250 --> 00:05:13,300
వారు చెత్త ఈ రకమైన ఉన్నారు. మేము ఏ ఆలోచన వాటిలో ఏది కలిగి ఉంటాయి.

72
00:05:13,300 --> 00:05:17,000
మేము స్టాక్ s డిక్లేర్ చేసినప్పుడు, మేము కేవలం మెమరీ పైన ఆ డౌన్ విసిరి చేస్తున్నారు.

73
00:05:17,000 --> 00:05:19,840
ఇది Int నేను ప్రకటించి మరియు ప్రారంభించడం లేదు వంటి రకమైన ఉంది.

74
00:05:19,840 --> 00:05:21,730
మీరు అక్కడ ఏమి తెలియదు. మీరు, అక్కడ లో చదవగలరు

75
00:05:21,730 --> 00:05:27,690
కానీ ఉపయోగపడిందా సూపర్ కాదు.

76
00:05:27,690 --> 00:05:32,680
మీరు ఎల్లప్పుడూ చేయడానికి గుర్తు విషయం initialized అవసరం ఏ ప్రారంభించడం ఉంది.

77
00:05:32,680 --> 00:05:35,820
ఈ సందర్భంలో, మనం, సున్నా పరిమాణం ప్రారంభించడం వెళుతున్న

78
00:05:35,820 --> 00:05:39,960
మాకు చాలా ముఖ్యమైన పరిణమించవచ్చు వెళుతున్న ఎందుకంటే.

79
00:05:39,960 --> 00:05:43,450
మేము ముందుకు వెళ్లి గమనికలు అన్ని అన్ని చార్ * s, ప్రారంభించడం కాలేదు

80
00:05:43,450 --> 00:05:49,670
బహుశా శూన్య కొన్ని అర్థం విలువ, అని.

81
00:05:49,670 --> 00:05:58,270
కానీ మేము అలా ఆ పూర్తిగా అవసరమైన కాదు.

82
00:05:58,270 --> 00:06:04,200
>> ఇప్పుడు, స్టాక్స్ రెండు ప్రధాన కార్యకలాపాలు ఉంటాయి?

83
00:06:04,200 --> 00:06:07,610
మిమ్మల్ని ఎవరైనా స్టాక్స్ ఏం ఉపన్యాసం నుండి గుర్తు? అవును?

84
00:06:07,610 --> 00:06:09,700
[స్టెల్లా] పుషింగ్ మరియు పాపింగ్? ఖచ్చితంగా >>.

85
00:06:09,700 --> 00:06:13,810
పుషింగ్ మరియు పాపింగ్ స్టాక్స్ రెండు ప్రధాన కార్యకలాపాలు ఉంటాయి.

86
00:06:13,810 --> 00:06:17,060
మరియు పుష్ ఏమి చేస్తుంది? >> ఇది టాప్ లో ఏదో ఉంచుతుంది

87
00:06:17,060 --> 00:06:19,300
స్టాక్, మరియు అప్పుడు పాపింగ్ ఇది ఆఫ్ పడుతుంది.

88
00:06:19,300 --> 00:06:23,150
[Hardison] ఖచ్చితంగా. కాబట్టి నెట్టడం స్టాక్ పైన ఏదో నెడుతుంది.

89
00:06:23,150 --> 00:06:27,700
ఇది కౌంటర్ ఒక డైనింగ్ ట్రే తీసిపారేయటం భోజన సిబ్బంది వంటిది.

90
00:06:27,700 --> 00:06:33,630
మరియు పాపింగ్ స్టాక్ యొక్క భోజన ట్రే ఆఫ్ తీసుకుంటోంది.

91
00:06:33,630 --> 00:06:36,460
లెట్ యొక్క ఏమి ఉదాహరణలు రెండు నడవడానికి

92
00:06:36,460 --> 00:06:39,720
మేము స్టాక్ను విషయాలు పుష్ ఉన్నప్పుడు.

93
00:06:39,720 --> 00:06:45,110
మేము మా స్టాక్ లో స్ట్రింగ్ 'హలో' పుష్ ఉన్నట్లయితే,

94
00:06:45,110 --> 00:06:49,760
ఈ మా రేఖాచిత్రం ఇప్పుడు ఎలా ఏ ఉంది.

95
00:06:49,760 --> 00:06:53,410
ఏమి చూడండి?

96
00:06:53,410 --> 00:06:56,530
మేము మా తీగలను శ్రేణి యొక్క మొదటి మూలకం నెట్టడం

97
00:06:56,530 --> 00:07:01,420
మరియు మేము 1 అని మా పరిమాణం COUNT upped.

98
00:07:01,420 --> 00:07:05,340
మేము రెండు స్లయిడ్లను మధ్య వ్యత్యాసం చూడండి అయితే, ఇక్కడ 0 చేశారు, ఇక్కడ పుష్ ముందు.

99
00:07:05,340 --> 00:07:08,690
ఇక్కడ పుష్ తరువాత.

100
00:07:08,690 --> 00:07:13,460
పుష్ ముందు, పుష్ తరువాత.

101
00:07:13,460 --> 00:07:16,860
ఇప్పుడు మేము మా స్టాక్ లో ఒక మూలకం ఉంది.

102
00:07:16,860 --> 00:07:20,970
ఇది స్ట్రింగ్ "హలో", మరియు అంతే.

103
00:07:20,970 --> 00:07:24,440
అర్రే లో మిగతావన్ని, మా తీగలను శ్రేణిలో, ఇప్పటికీ చెత్త ఉంది.

104
00:07:24,440 --> 00:07:27,070
మేము initialized లేదు.

105
00:07:27,070 --> 00:07:29,410
లెట్ యొక్క మేము మా స్టాక్ లో మరొక స్ట్రింగ్ పుష్ చెప్పారు.

106
00:07:29,410 --> 00:07:32,210
మేము ఈ సమయం "ప్రపంచం" పుష్ చూడాలని.

107
00:07:32,210 --> 00:07:35,160
కాబట్టి మీరు, "ప్రపంచం" ఇక్కడ "హలో" పైన వెళుతుంది చూడగలరు

108
00:07:35,160 --> 00:07:40,040
మరియు పరిమాణం COUNT 2 వరకు వెళుతుంది.

109
00:07:40,040 --> 00:07:44,520
ఇప్పుడు మేము "CS50", మరియు ఆ మళ్ళీ టాప్ కొనసాగుదాం వస్తాయి.

110
00:07:44,520 --> 00:07:51,110
మేము తిరిగి వెళ్లి, మీరు మేము స్టాక్ పైన విషయాలు నెట్టడం అయ్యారో చూడవచ్చు.

111
00:07:51,110 --> 00:07:53,320
ఇప్పుడు మేము పాప్ పొందండి.

112
00:07:53,320 --> 00:07:58,910
మేము స్టాక్ ఏదో ఆఫ్ popped చేసినప్పుడు, ఏమి జరిగింది?

113
00:07:58,910 --> 00:08:01,540
ఎవరైనా తేడా చూడండి? ఇది చాలా సున్నితమైన ఉంది.

114
00:08:01,540 --> 00:08:05,810
[స్టూడెంట్] పరిమాణం. >> అవును, పరిమాణం మార్చబడింది.

115
00:08:05,810 --> 00:08:09,040
>> ఏమి మీరు భావిస్తున్నారు ఉంది?

116
00:08:09,040 --> 00:08:14,280
చాలా [స్టూడెంట్] తీగలు. >> కుడి. చాలా తీగలు.

117
00:08:14,280 --> 00:08:17,110
ఇది అవుతుంది మీరు దానిని ఈ విధంగా చేయడం చేసినప్పుడు,

118
00:08:17,110 --> 00:08:21,960
మేము మా స్టాక్ను అంశాలను కాపీ లేదు ఎందుకంటే,

119
00:08:21,960 --> 00:08:24,670
మేము నిజంగా ఏమీ లేదు; మేము పరిమాణం ఉపయోగించవచ్చు

120
00:08:24,670 --> 00:08:28,630
మా పరిధిలో విషయాలు సంఖ్య ట్రాక్

121
00:08:28,630 --> 00:08:33,780
కాబట్టి మేము మళ్ళీ పాప్ ఉన్నప్పుడు, మళ్ళీ మేము కేవలం 1 మా పరిమాణం డౌన్ తరుగుదల.

122
00:08:33,780 --> 00:08:39,440
వాస్తవానికి లో వెళ్ళి ఏదైనా ఓవర్రైట్ లేదు.

123
00:08:39,440 --> 00:08:41,710
అల్లరిగా రకం.

124
00:08:41,710 --> 00:08:46,520
ఇది చేయడానికి తక్కువ పని ఎందుకంటే మేము సాధారణంగా కేవలం ఒక్క విషయాలు విడిచి అవుతుంది.

125
00:08:46,520 --> 00:08:50,060
మేము తిరిగి వెళ్లి ఏదో ఓవర్రైట్ లేదు, అప్పుడు ఎందుకు చేయాలి?

126
00:08:50,060 --> 00:08:54,150
కాబట్టి మేము స్టాక్ రెండుసార్లు పాప్ ఉన్నప్పుడు, చేసే అన్ని పరిమాణం సార్లు రెండు తరుగుదల ఉంటుంది.

127
00:08:54,150 --> 00:08:59,120
మరియు తిరిగి, ఈ మేము మా స్టాక్ను విషయాలు కాపీ లేదు ఎందుకంటే ఉంది.

128
00:08:59,120 --> 00:09:01,320
అవును? దుస్తులు.

129
00:09:01,320 --> 00:09:04,460
[స్టూడెంట్, అపారదర్శక] >> ఆపై మీరు మళ్లీ ఏదో పుష్ ఏమి జరుగుతుంది?

130
00:09:04,460 --> 00:09:08,570
మీరు మళ్ళీ ఏదో పుష్, అది గడిచిపోయింది?

131
00:09:08,570 --> 00:09:12,390
ఎక్కడ అది బాసిల్ వెళ్లగలదు? తీగలను [1] లోకి >>? >> కుడి.

132
00:09:12,390 --> 00:09:14,530
ఎందుకు అది తీగలను [3] వెళ్ళాలని లేదు?

133
00:09:14,530 --> 00:09:19,410
[బాసిల్] ఇది ఏదైనా తీగలను లో ఉందని మర్చిపోయిన కారణంగా [1] మరియు [2]?

134
00:09:19,410 --> 00:09:24,040
[Hardison] ఖచ్చితంగా. మా స్టాక్, ముఖ్యంగా, ఇది ఏదైనా పట్టుకుని ఆ "మర్చిపోయాను"

135
00:09:24,040 --> 00:09:29,480
తీగలను లో [1] లేదా తీగలను [2], మేము "woot" పుష్ అప్పుడు

136
00:09:29,480 --> 00:09:36,670
ఇది తీగలను [1] వద్ద మూలకం ఆ ఉంచుతుంది.

137
00:09:36,670 --> 00:09:41,590
ఒక ప్రాథమిక స్థాయి వద్ద, ఎలా ఈ పనులు న ఏ ప్రశ్నలు?

138
00:09:41,590 --> 00:09:45,160
[సామ్] ఈ మొత్తం పరంగా, ఏ విధంగా డైనమిక్ కాదు

139
00:09:45,160 --> 00:09:47,620
లేదా స్టాక్ పరిమాణం పరంగా?

140
00:09:47,620 --> 00:09:56,750
[Hardison] ఖచ్చితంగా. ఈ - పాయింట్ ఈ ఒక డైనమిక్ growning స్టాక్ లేదు అని.

141
00:09:56,750 --> 00:10:02,850
ఇది చాలా నాలుగు విషయాలు చాలా, నాలుగు చార్ * s వద్ద, జరపవచ్చని ఒక కుప్ప ఉంది.

142
00:10:02,850 --> 00:10:07,580
మేము ఒక ఐదవ విషయం ప్రయత్నించండి మరియు కొట్టాలని ఉంటే, మీరు ఏం చేయాలి ఏమి ఆలోచిస్తాడు?

143
00:10:07,580 --> 00:10:11,870
[విద్యార్ధులు అపారదర్శక]

144
00:10:11,870 --> 00:10:14,600
[Hardison] ఖచ్చితంగా. జరిగిఉంటుంది ఆ విషయాలను ఉన్నాయి.

145
00:10:14,600 --> 00:10:19,330
ఇది బహుశా మేము దానిని బట్టి, తప్పు seg కాలేదు -

146
00:10:19,330 --> 00:10:22,530
ఎలా మేము బ్యాక్ ఎండ్ అమలు చేశారు.

147
00:10:22,530 --> 00:10:31,740
ఇది తిరిగి రాస్తుంది కాలేదు. ఇది మేము తరగతి లో మాట్లాడారు ఆ బఫర్ ఓవర్ఫ్లో చూపుతుంది.

148
00:10:31,740 --> 00:10:35,240
ఏ భర్తీ చేయగలిగే స్పష్టమైన విషయం ఉంటుంది

149
00:10:35,240 --> 00:10:42,370
మేము మా స్టాక్ మీద అదనపు విషయం పుష్ ప్రయత్నించాడు ఉంటే?

150
00:10:42,370 --> 00:10:44,550
కాబట్టి మీరు ఒక బఫర్ ఓవర్ఫ్లో పేర్కొన్నారు.

151
00:10:44,550 --> 00:10:47,870
న రాసి లేదా stomped జరుగుతుందని విషయం కావచ్చు ఏమిటి

152
00:10:47,870 --> 00:10:52,320
మేము ఒక అదనపు విషయం పుష్ ప్రయత్నిస్తున్న ద్వారా అనుకోకుండా ముంచివేసింది? ఉంటే

153
00:10:52,320 --> 00:10:54,730
[డేనియల్, అపారదర్శక] >> సాధ్యమైన.

154
00:10:54,730 --> 00:10:58,440
కానీ ముందుగా, ఏ సంభవిస్తుంది? మేము ఒక నాల్గవ విషయం పుష్ ప్రయత్నించారు ఏం?

155
00:10:58,440 --> 00:11:06,220
ఇది కనీసం మేము పొందారు ఈ మెమరీ రేఖాచిత్రం తో, పరిమాణం తిరిగి రాస్తుంది ఉండవచ్చు.

156
00:11:06,220 --> 00:11:10,880
>> సమస్య సెట్ వివరణలో, ఇది మేము నేడు అమలు కావడం ఏమి ఉంది

157
00:11:10,880 --> 00:11:16,030
మనం చెయ్యాలనుకుంటున్నారు కేవలం తప్పుడు తిరిగి ఉంటుంది.

158
00:11:16,030 --> 00:11:20,030
మా పుష్ పద్ధతి, ఒక బూలియన్ విలువ తిరిగి వెళ్తున్నారు

159
00:11:20,030 --> 00:11:22,920
పుష్ సఫలమైతే మరియు బూలియన్ విలువ నిజమైన ఉంటుంది

160
00:11:22,920 --> 00:11:29,730
మరియు తప్పుడు స్టాక్ పూర్తి ఎందుకంటే మేము మరింత ఏదైనా పుష్ ఉండదు.

161
00:11:29,730 --> 00:11:33,620
యొక్క ప్రస్తుతం ఆ కోడ్ యొక్క కొద్దిగా నడవడానికి లెట్.

162
00:11:33,620 --> 00:11:36,400
ఇక్కడ మా పుష్ ఫంక్షన్ ఉంది.

163
00:11:36,400 --> 00:11:40,380
ఒక స్టాక్ కోసం మా పుష్ ఫంక్షన్ స్టాక్ పరుగులు చేసి స్ట్రింగ్ లో తీసుకోవాలని అన్నారు.

164
00:11:40,380 --> 00:11:45,820
స్ట్రింగ్ విజయవంతంగా వెళ్ళింది అది నిజమైన తిరిగి వెళుతున్న

165
00:11:45,820 --> 00:11:51,820
స్టాక్ మరియు తప్పుడు లేకపోతే న.

166
00:11:51,820 --> 00:11:59,740
ఏం ఏదైనా సూచనలు ఇక్కడ చేసే మంచి మొదటి విషయం కావచ్చు?

167
00:11:59,740 --> 00:12:20,630
పరిమాణం సామర్థ్యం సమానం ఉంటే [సామ్] అప్పుడు తప్పుడు తిరిగి?

168
00:12:20,630 --> 00:12:23,320
[Hardison] బింగో. మంచి పని.

169
00:12:23,320 --> 00:12:26,310
పరిమాణం సామర్థ్యం ఉంటే, మేము తప్పుడు తిరిగి చూడాలని.

170
00:12:26,310 --> 00:12:29,270
మేము మా స్టాక్ మరింత ఏదైనా పెట్టి కాదు.

171
00:12:29,270 --> 00:12:36,900
లేకపోతే, మేము స్టాక్ పైన ఏదో ఉంచాలి కావలసిన.

172
00:12:36,900 --> 00:12:41,670
ప్రారంభంలో "స్టాక్ ఎగువ," ఏమిటి?

173
00:12:41,670 --> 00:12:43,650
[డేనియల్] సైజు 0? >> సైజు 0.

174
00:12:43,650 --> 00:12:49,990
స్టాక్ లో ఒక విషయము తర్వాత స్టాక్ ఎగువ ఏమిటి? మిస్సి, మీరు తెలుసు?

175
00:12:49,990 --> 00:12:52,720
[మిస్సి] వన్. >> సైజు సరిగ్గా, ఒకటి. మీరు పరిమాణం జోడించవచ్చు

176
00:12:52,720 --> 00:13:01,690
మరియు మీరు యెరే నందలి సూచిక పరిమాణంలో కొత్త మూలకం లో ఉంచడం చేసిన ప్రతిసారీ.

177
00:13:01,690 --> 00:13:05,470
భావన కల్పిస్తుంది ఉంటే, మేము ఒక లీనియర్ ఆ రకం దీన్ని చెయ్యవచ్చు.

178
00:13:05,470 --> 00:13:11,910
మేము మా తీగలను శ్రేణి పొందారు కాబట్టి, మేము, పరిమాణం సూచిక వద్ద ప్రాప్తి చూడాలని

179
00:13:11,910 --> 00:13:14,780
మరియు మేము అక్కడే మన చార్ * నిల్వ చూడాలని.

180
00:13:14,780 --> 00:13:19,340
ఏ తీగ కాపీ ఇక్కడ అక్కడ జరగబోతోంది ఎలా గమనించండి,

181
00:13:19,340 --> 00:13:29,680
మెమరీ లేదు డైనమిక్ కేటాయింపు?

182
00:13:29,680 --> 00:13:34,440
ఆపై మిస్సి, మేము ఇప్పుడు లేదు ఏమి పెరిగాడు

183
00:13:34,440 --> 00:13:40,570
మేము శ్రేణి తగిన స్థానంలో స్ట్రింగ్ నిల్వ చేసిన ఎందుకంటే,

184
00:13:40,570 --> 00:13:49,230
మరియు ఆమె మేము తదుపరి పుష్ కోసం సిద్ధంగా తద్వారా ఒక ద్వారా పరిమాణం పెంచడం లేదని చెప్పారు.

185
00:13:49,230 --> 00:13:53,950
కాబట్టి మేము s.size ఆ చేయవచ్చు + +.

186
00:13:53,950 --> 00:13:59,330
ఈ సమయంలో, మేము మా శ్రేణి నెట్టడం చేసిన. మేము లేదు లాస్ట్ థింగ్ ఏమిటి?

187
00:13:59,330 --> 00:14:10,110
[స్టూడెంట్] నిజమైన చూపించు. >> నిజమైన చూపించు.

188
00:14:10,110 --> 00:14:14,690
అది ఒక అందమైన సాధారణ కోడ్ అందంగా సులభం. కాదు చాలా.

189
00:14:14,690 --> 00:14:17,070
మీరు, స్టాక్ ఎలా పనిచేస్తుంది చుట్టూ మీ తల చుట్టి చేసిన

190
00:14:17,070 --> 00:14:21,910
ఈ అమలు అందంగా సులభం.

191
00:14:21,910 --> 00:14:26,390
>> ఇప్పుడు, ఈ యొక్క తదుపరి భాగం స్టాక్ స్ట్రింగ్ ఆఫ్ పాపింగ్ ఉంది.

192
00:14:26,390 --> 00:14:29,410
నేను మీరు అబ్బాయిలు ఈ కొద్దిగా పని కొంత సమయం ఇవ్వాలని వెళుతున్న.

193
00:14:29,410 --> 00:14:34,320
ఇది దాదాపు తప్పనిసరిగా మేము ఇక్కడ పుష్ లో చేసిన ఏమి రివర్స్ ఉంది.

194
00:14:34,320 --> 00:14:38,510
నేను చేసిన వాస్తవానికి - అయ్యో.

195
00:14:38,510 --> 00:14:48,160
నేను ఇక్కడ పైగా, మరియు పరికరంలోని ఒక ఉపకరణం అప్ బూట్ చేసిన

196
00:14:48,160 --> 00:14:53,600
నేను సమస్య 5 స్పెసిఫికేషన్ సెట్ పైకి లాగి చేసిన.

197
00:14:53,600 --> 00:15:02,560
మేము ఇక్కడ జూమ్ ఉంటే, మేము నేను cdn.cs50.net/2012/fall/psets/pset5.pdf వద్ద ఉన్నాను చూడగలరు.

198
00:15:02,560 --> 00:15:08,590
మీరు అబ్బాయిలు, ఇక్కడ section6.zip ఉన్న చేసే ఈ కోడ్ దిగుమతి?

199
00:15:08,590 --> 00:15:15,030
అన్ని కుడి. మీరు నిజంగా త్వరగా, ప్రస్తుతం ఆ, ఆ పూర్తి చెయ్యకపోతే.

200
00:15:15,030 --> 00:15:22,130
నా టెర్మినల్ విండో లో చేస్తాను.

201
00:15:22,130 --> 00:15:25,090
నిజానికి ఇక్కడ దానిని చేశాడు. అవును.

202
00:15:25,090 --> 00:15:34,730
అవును, సామ్? >> నేను ఎందుకు మీరు = STR పరిమాణం s.string 's బ్రాకెట్లలో అని పేర్కొన్నారు గురించి ప్రశ్న?

203
00:15:34,730 --> 00:15:42,910
STR ఏమిటి? ఆ ముందు ఎక్కడో నిర్వచించిన, లేదా - OH, చార్ * STR లో?

204
00:15:42,910 --> 00:15:47,160
[Hardison] అవును, సరిగ్గా. ఆ వాదన. >> ఓహ్, ఓకే. క్షమించాలి.

205
00:15:47,160 --> 00:15:49,470
[Hardison] మేము సైన్ కొట్టాలని స్ట్రింగ్ మీరు పేర్కొంటున్నట్టు

206
00:15:49,470 --> 00:15:55,220
మేము ఇక్కడ గురించి మాట్లాడను అని ఆలోచన చేసే ఇతర ప్రశ్న

207
00:15:55,220 --> 00:15:58,810
మేము s అనే ఈ వేరియబుల్ కలిగి మంజూరు కోసం మేము పట్టింది

208
00:15:58,810 --> 00:16:02,710
ఆ పరిధిని మరియు మాకు అందుబాటులో ఉంది.

209
00:16:02,710 --> 00:16:06,960
S ఈ స్టాక్ struct అని మంజూరు కోసం మేము పట్టింది.

210
00:16:06,960 --> 00:16:08,930
కాబట్టి, ఈ పుష్ కోడ్ వద్ద వెనక్కు తిరిగి చూస్తే

211
00:16:08,930 --> 00:16:13,450
మీరు మేము జారీ దట్ గాట్ ఈ స్ట్రింగ్ తో stuff చేస్తున్నా ఆ చూడగలరు

212
00:16:13,450 --> 00:16:19,210
కానీ అప్పుడు అకస్మాత్తుగా, మేము వంటి s.size యాక్సెస్, s పేరు నుండి వచ్చింది? చేస్తున్నారు

213
00:16:19,210 --> 00:16:23,020
మేము విభాగం ఆర్చీవ్ కు వెళుతున్న కోడ్ లో

214
00:16:23,020 --> 00:16:27,100
మరియు మీరు మీ సమస్య లో చేస్తూ ఉంటాను విషయం, సెట్స్

215
00:16:27,100 --> 00:16:32,440
మేము మా స్టాక్ ప్రపంచ వేరియబుల్ struct చేసిన

216
00:16:32,440 --> 00:16:36,380
మేము అన్ని మా వేర్వేరు విధులను లో ప్రాప్యత కలిగి తద్వారా

217
00:16:36,380 --> 00:16:40,630
మాన్యువల్గా దీన్ని చుట్టూ పాస్ మరియు సూచనగా అది పాస్ చేయకుండా,

218
00:16:40,630 --> 00:16:44,870
అది అంశాన్ని అన్ని ఆ రకమైన చేయండి.

219
00:16:44,870 --> 00:16:52,280
మేము NICER విషయాలు చేయడానికి, మీరు ఉంటే, కొద్దిగా మోసం చేస్తున్నారు.

220
00:16:52,280 --> 00:16:57,430
మరియు అది సరదాకి ఎందుకంటే మేము ఇక్కడ చేస్తున్నా ఏదో, అది సులభం.

221
00:16:57,430 --> 00:17:02,800
వారు ఒక పెద్ద డేటా నిర్మాణం ఉంటే తరచుగా, మీరు ప్రజలు దీన్ని చూస్తారు

222
00:17:02,800 --> 00:17:07,750
వారి కార్యక్రమం లో నిర్వహించబడే చేయబడిన.

223
00:17:07,750 --> 00:17:09,560
>> యొక్క ఉపకరణం కు తిరిగి వెళ్ళి తెలపండి.

224
00:17:09,560 --> 00:17:15,240
అందరూ విజయవంతంగా section6.zip వచ్చింది?

225
00:17:15,240 --> 00:17:20,440
అందరూ అన్జిప్ section6.zip ద్వారా అన్జిప్?

226
00:17:20,440 --> 00:17:27,200
మీరు విభాగం 6 డైరెక్టరీలో వెళ్ళి ఉంటే -

227
00:17:27,200 --> 00:17:29,220
ఆహ్, అన్ని చోట్ల -

228
00:17:29,220 --> 00:17:32,840
మరియు మీరు ఇక్కడ ఏది జాబితా, మీరు మూడు వేర్వేరు. సి ఫైళ్లను పొందారు చూడండి.

229
00:17:32,840 --> 00:17:38,350
మీరు ఒక్కొక్కటిగా లింక్డ్ జాబితా ఇది క్యూ, ఒక SLL, మరియు ఒక స్టాక్ పొందారు.

230
00:17:38,350 --> 00:17:44,600
మీరు stack.c అప్ తెరిస్తే,

231
00:17:44,600 --> 00:17:47,330
మీరు, మేము మాకు నిర్వచించవచ్చు ఈ struct పొందారు చూడగలరు

232
00:17:47,330 --> 00:17:51,330
మేము కేవలం స్లయిడ్లలో గురించి చర్చిస్తామని ఖచ్చితమైన struct.

233
00:17:51,330 --> 00:17:56,340
మేము, స్టాక్ కోసం మా గ్లోబల్ వేరియబుల్ పొందారు

234
00:17:56,340 --> 00:18:00,110
మేము, మా పుష్ ఫంక్షన్ పొందారు

235
00:18:00,110 --> 00:18:04,230
మరియు తర్వాత మేము మా పాప్ ఫంక్షన్ పొందారు.

236
00:18:04,230 --> 00:18:08,320
ఇక్కడ స్లయిడ్ తిరిగి అప్ పుష్ కోసం నేను, కోడ్ ఉంచుతాము

237
00:18:08,320 --> 00:18:10,660
కానీ నేను మీరు అబ్బాయిలు చేయాలని భావిస్తే, మీ సామర్థ్యం మేరకు ఉంది

238
00:18:10,660 --> 00:18:13,790
వెళ్ళి పాప్ ఫంక్షన్ అమలు.

239
00:18:13,790 --> 00:18:18,480
ఒకసారి మీరు అమలు చేసిన, మీరు, స్టాక్ తయారు ఈ సంకలనం చేయవచ్చు

240
00:18:18,480 --> 00:18:22,540
తరువాత, ఫలితంగా స్టాక్ ఎగ్జిక్యూటబుల్ను అమలు

241
00:18:22,540 --> 00:18:28,390
మరియు ఆ డౌన్ ఇక్కడ ప్రధాన ఉందని ఈ పరీక్ష కోడ్ అన్ని రన్ చేస్తుంది.

242
00:18:28,390 --> 00:18:31,060
మరియు ప్రధాన వాస్తవానికి పుష్ మరియు పాప్ కాల్స్ చేస్తూ జాగ్రత్త తీసుకుంటుంది

243
00:18:31,060 --> 00:18:33,220
మరియు అన్ని హక్కు ద్వారా వెళ్ళే చూసుకోవాలి.

244
00:18:33,220 --> 00:18:36,820
ఇది కూడా ఇక్కడే స్టాక్ పరిమాణం initializes

245
00:18:36,820 --> 00:18:39,780
కాబట్టి మీరు ఆ ప్రారంభించడం గురించి ఆందోళన లేదు.

246
00:18:39,780 --> 00:18:42,310
మీరు అది సరిగా initialized అయిన పొందవచ్చు

247
00:18:42,310 --> 00:18:48,000
మీరు పాప్ ఫంక్షన్ లో యాక్సెస్ ఆ సమయానికి.

248
00:18:48,000 --> 00:18:53,530
ఆ సమంజసం లేదు?

249
00:18:53,530 --> 00:19:00,100
కాబట్టి ఇక్కడ వెళ్ళండి. పుష్ కోడ్ ఉంది.

250
00:19:00,100 --> 00:19:13,210
నేను మీరు అబ్బాయిలు 5 లేదా 10 నిమిషాలు ఇస్తాము.

251
00:19:13,210 --> 00:19:15,690
మరియు మీరు కోడింగ్ ఉన్నప్పుడు తాత్కాలిక లో ఏవైనా ప్రశ్నలు ఉంటే,

252
00:19:15,690 --> 00:19:17,710
వాటిని బిగ్గరగా అడగండి.

253
00:19:17,710 --> 00:19:23,080
మీరు ఒక అభ్యంతరకర పాయింట్ ను అలా అయితే, కేవలం అడగండి.

254
00:19:23,080 --> 00:19:26,030
ఇంకా అందరూ తెలియజేయండి నాకు తెలియజేయండి.

255
00:19:26,030 --> 00:19:28,160
చాలా మీ పొరుగు పని.

256
00:19:28,160 --> 00:19:30,360
[డేనియల్] మేము ప్రస్తుతం పాప్ అమలు చేస్తున్నారు? >> జస్ట్ పాప్.

257
00:19:30,360 --> 00:19:34,200
మీరు కావాలనుకుంటే మీరు పుష్ అమలు కాపీ చేయవచ్చు

258
00:19:34,200 --> 00:19:37,780
పరీక్ష పని చేస్తుంది కాబట్టి.

259
00:19:37,780 --> 00:19:41,940
అది రావడము విషయాలు పరీక్షించడానికి కష్టం ఎందుకంటే -

260
00:19:41,940 --> 00:19:49,030
లేదా, అది లేదు స్టాక్ లో ఏదైనా అక్కడ లేకపోతే ఒక స్టాక్ పాపింగ్ విషయాలు పరీక్షించడానికి కష్టం.

261
00:19:49,030 --> 00:19:55,250
>> తిరిగి చేయవలసి పాప్ ఏమిటి? స్టాక్ నుంచి మూలకం.

262
00:19:55,250 --> 00:20:01,260
ఇది స్టాక్ ఎగువ యొక్క మూలకం ఆఫ్ పొందండి కోరుకుంటున్నాము యొక్క

263
00:20:01,260 --> 00:20:05,780
తరువాత, స్టాక్ యొక్క పరిమాణం తరుగుదల

264
00:20:05,780 --> 00:20:07,810
మరియు ఇప్పుడు మీరు పైన మూలకం కోల్పోయి.

265
00:20:07,810 --> 00:20:11,420
ఆపై మీరు పైన మూలకం తిరిగి.

266
00:20:11,420 --> 00:20:20,080
[స్టూడెంట్, అపారదర్శక]

267
00:20:20,080 --> 00:20:28,810
[Hardison] కాబట్టి మీరు అలా చేస్తే ఏమి జరుగుతుంది? [స్టూడెంట్, అపారదర్శక]

268
00:20:28,810 --> 00:20:34,000
అప్ ఫోజు ముగుస్తుంది అంటే మీరు బహుశా గాని ఆక్సెస్ చేస్తారు

269
00:20:34,000 --> 00:20:37,350
ఒక మూలకం ఇంకా initialized లేదు, కాబట్టి మీ లెక్కింపు

270
00:20:37,350 --> 00:20:39,990
గత మూలకం ఆఫ్ ఇక్కడ.

271
00:20:39,990 --> 00:20:46,260
మీరు గమనిస్తే ఇక్కడ, పుష్ లో, మేము s.size మూలకం వద్ద తీగలను ఆక్సెస్ చేస్తారు

272
00:20:46,260 --> 00:20:48,560
అది ఒక న్యూ సూచిక ఎందుకంటే.

273
00:20:48,560 --> 00:20:51,460
ఇది స్టాక్ క్రొత్త అగ్ర ఉంది.

274
00:20:51,460 --> 00:21:01,100
పాప్, అదే s.size, తదుపరి స్థలంలో అన్నారు

275
00:21:01,100 --> 00:21:05,210
మీ స్టాక్ అన్ని మూలకాల మీద ఉండే స్థలం.

276
00:21:05,210 --> 00:21:10,050
కాబట్టి టాప్ అత్యంత మూలకం, s.size కాదు

277
00:21:10,050 --> 00:21:14,930
కానీ, అది దాని కింద ఉంది.

278
00:21:14,930 --> 00:21:19,640
>> మీరు ఏమి ఇతర విషయం - పాప్ లో,

279
00:21:19,640 --> 00:21:22,030
మీరు పరిమాణం తరుగుదల ఉంటుంది పోవడమే.

280
00:21:22,030 --> 00:21:28,750
మీరు ఇక్కడ మా చిన్న రేఖాచిత్రం తిరిగి గుర్తుంచుకుంటే,

281
00:21:28,750 --> 00:21:30,980
నిజంగా, మేము సంభవించే చూసిన మాత్రమే విషయం మేము పాప్ అని ఉన్నప్పుడు

282
00:21:30,980 --> 00:21:36,150
ఈ పరిమాణం తర్వాత 1 కు, మొదటి 2, పడిపోయాయి ఉంది.

283
00:21:36,150 --> 00:21:42,620
అప్పుడు మేము ఒక కొత్త మూలకం ముందుకు, అది సరైన స్థానంలో పెట్టారు.

284
00:21:42,620 --> 00:21:49,610
[బాసిల్] s.size 2 ఉంటే, అది మూలకం 2 వెళ్ళండి కాదు,

285
00:21:49,610 --> 00:21:54,400
మరియు మీరు ఆ మూలకం ఆఫ్ పాప్ చేయాలనుకుంటున్నారా మీరు?

286
00:21:54,400 --> 00:21:59,510
మేము వెళ్లిన అయితే - >> మరలా ఈ దృష్టి చూద్దాం.

287
00:21:59,510 --> 00:22:07,730
ఈ ఈ సమయంలో మా స్టాక్ ఉంటే

288
00:22:07,730 --> 00:22:12,130
మరియు మేము, పాప్ కాల్

289
00:22:12,130 --> 00:22:16,150
ఇది వద్ద ఇండెక్స్ స్థానాన్ని అంశం?

290
00:22:16,150 --> 00:22:19,300
[బాసిల్] 2 వద్ద, కానీ 3 పాప్ జరగబోతోంది. >> కుడి.

291
00:22:19,300 --> 00:22:24,220
మా పరిమాణం 3 పేర్కొంది, కానీ మేము ఇండెక్స్ 2 వద్ద మూలకం పాప్ చేయాలనుకుంటున్నారా.

292
00:22:24,220 --> 00:22:29,900
మీరు శ్రేణుల యొక్క సున్నా-ఇండెక్సింగ్ తో కలిగి ఒకటి ఆఫ్ సామాన్య ఉంటాము.

293
00:22:29,900 --> 00:22:36,430
కాబట్టి మీరు మూడవ మూలకం పాప్ అనుకుంటున్నారు, కాని మూడవ మూలకం ఇండెక్స్ 3 వద్ద లేదు.

294
00:22:36,430 --> 00:22:39,430
మరియు మేము నెట్టడం చేసినప్పుడు ఆ మైనస్ 1 చేయడానికి లేదు కారణం

295
00:22:39,430 --> 00:22:44,120
ప్రస్తుతం ఎందుకంటే, మీరు ప్రకటన ఆ స్థానాన్ని మూలకం,

296
00:22:44,120 --> 00:22:47,600
మేము ఈ సమయంలో స్టాక్ లో ఏదో కొట్టాలని ఉంటే,

297
00:22:47,600 --> 00:22:50,360
మేము ఇండెక్స్ 3 వద్ద పుష్ అనుకుంటున్నారో.

298
00:22:50,360 --> 00:23:03,550
మరియు ఇది కేవలం కాబట్టి మీరు నెట్టడం చేసినప్పుడు పరిమాణం మరియు సూచికలు వరుసలో ఇలా జరిగింది.

299
00:23:03,550 --> 00:23:06,960
>> ఒక పని స్టాక్ అమలు సంపాదించి?

300
00:23:06,960 --> 00:23:09,690
మీరు ఒక పని స్టాక్ ఒక పొందారు. పాప్ ఇంకా మీరు పని ఉందా?

301
00:23:09,690 --> 00:23:11,890
[డేనియల్] అవును. నేను అలా అనుకుంటున్నాను.

302
00:23:11,890 --> 00:23:14,610
>> ప్రోగ్రామ్ అమలు మరియు భ్రంశం ఏర్పడుతుంది seg కాదు, అది ముద్రించిన యొక్క?

303
00:23:14,610 --> 00:23:17,520
మీరు దీన్ని అమలు అది "విజయం" ముద్రించాలా ఉందా?

304
00:23:17,520 --> 00:23:22,630
అవును. అది "విజయం" అవుట్ ముద్రిస్తుంది మరియు బూమ్ పోదు ఉంటే, స్టాక్ చేయండి అమలు,

305
00:23:22,630 --> 00:23:26,000
అప్పుడు అంతా మన మంచికే.

306
00:23:26,000 --> 00:23:34,070
అన్ని కుడి. యొక్క నిజంగా త్వరగా ఉపకరణం కు వెళ్ళి తెలపండి,

307
00:23:34,070 --> 00:23:46,100
మరియు మేము ఈ ద్వారా ఉంటాము.

308
00:23:46,100 --> 00:23:51,110
మేము పాప్ ఇక్కడ ఏం జరగబోతోంది చూడండి, ఉంటే

309
00:23:51,110 --> 00:23:55,220
డేనియల్, మీరు అని మొదటి విషయం ఏమిటి?

310
00:23:55,220 --> 00:23:58,850
[డేనియల్] s.size 0 కన్నా ఎక్కువ ఉంటే.

311
00:23:58,850 --> 00:24:03,120
[Hardison] సరే. మరియు మీరు ఎందుకు ఆ చేస్తారు?

312
00:24:03,120 --> 00:24:05,610
[డేనియల్] స్టాక్ లోపల ఏదో ఉంది నిర్థారించడానికి.

313
00:24:05,610 --> 00:24:10,950
[Hardison] రైట్. మీరు s.size 0 కన్నా ఎక్కువ అని నిర్ధారించడానికి పరీక్షించడానికి కావలసిన;

314
00:24:10,950 --> 00:24:13,280
లేకపోతే, మీరు ఏమి చేశారు ఏం కోరుకుంటున్నారు?

315
00:24:13,280 --> 00:24:16,630
[డేనియల్] రిటర్న్ శూన్య? >> రిటర్న్ శూన్య, సరిగ్గా.

316
00:24:16,630 --> 00:24:20,740
అయితే s.size 0 కంటే ఎక్కువగా ఉంటుంది. మేము అప్పుడు ఏమి వెళ్తున్నారు?

317
00:24:20,740 --> 00:24:25,890
స్టాక్ ఖాళీ లేకపోతే మేము ఏమి చేయాలి?

318
00:24:25,890 --> 00:24:31,210
[స్టెల్లా] మీరు పరిమాణం తరుగుదల? మీరు సరే, పరిమాణం తరుగుదల >>.

319
00:24:31,210 --> 00:24:34,440
కాబట్టి మీరు ఎలా చేస్తారు? >> S.size -.

320
00:24:34,440 --> 00:24:37,030
[Hardison] గ్రేట్. ఆపై మీరు ఏమి చేశారు?

321
00:24:37,030 --> 00:24:44,140
[స్టెల్లా] ఆ తరువాత తిరిగి s.string చెప్పారు [s.size].

322
00:24:44,140 --> 00:24:48,560
[Hardison] గ్రేట్.

323
00:24:48,560 --> 00:24:51,940
లేకపోతే మీరు శూన్య తిరిగి. అవును, సామ్?

324
00:24:51,940 --> 00:24:55,510
[సామ్] ఎందుకు అది + 1 s.size ఉండాలి లేదు?

325
00:24:55,510 --> 00:24:58,430
[Hardison] ప్లస్ 1? >> అవును. >> అర్థమైంది.

326
00:24:58,430 --> 00:25:00,980
మీరు 1 తీసుకున్న ఉన్నందున [సామ్] నేను, ఆలోచన

327
00:25:00,980 --> 00:25:04,290
అప్పుడు మీరు వారు అడిగారు ఒక తిరిగి చూడాలని.

328
00:25:04,290 --> 00:25:09,400
[Hardison] ఈ మేము 0 సూచీలు ఈ మొత్తం సమస్యకు గురించి మాట్లాడుతూ కేవలం ఏమిటి.

329
00:25:09,400 --> 00:25:11,380
కాబట్టి మేము ఇక్కడ పైగా తిరిగి జూమ్ ఉంటే.

330
00:25:11,380 --> 00:25:15,650
మేము ఇక్కడే ఈ గై చూడండి, మీరు, మేము పాప్ ఆ చూడగలరు

331
00:25:15,650 --> 00:25:19,340
మేము ఇండెక్స్ 2 వద్ద మూలకం పాపింగ్ చేస్తున్నారు.

332
00:25:19,340 --> 00:25:25,200
>> కాబట్టి మేము అప్పుడు మా పరిమాణం మా ఇండెక్స్ సరిపోతుంది, మొదటి మా పరిమాణాన్ని తగ్గించడానికి.

333
00:25:25,200 --> 00:25:39,650
మేము మొదటి పరిమాణం తరుగుదల లేదు, అప్పుడు మేము -1 ఆపై తరుగుదల పరిమాణం లేదు.

334
00:25:39,650 --> 00:25:45,270
గ్రేట్. అన్ని మంచి?

335
00:25:45,270 --> 00:25:47,530
ఈ ఏ ప్రశ్నలు?

336
00:25:47,530 --> 00:25:54,050
ఇది రాయడానికి వివిధ రకాలుగా ఉన్నాయి.

337
00:25:54,050 --> 00:26:03,290
నిజానికి, మేము కూడా ఏదో ఒకటి చెయ్యాలి - మేము ఒక లైనర్ చేయవచ్చు.

338
00:26:03,290 --> 00:26:05,770
మేము ఒక లైన్ తిరిగి చేయవచ్చు.

339
00:26:05,770 --> 00:26:12,980
మేము ఆ చేయడం ద్వారా తిరిగి ముందు మేము నిజంగా తరుగుదల ఉంటుంది.

340
00:26:12,980 --> 00:26:18,320
కాబట్టి ఉంచడం - s.size ముందు.

341
00:26:18,320 --> 00:26:22,060
ఆ రేఖ నిజంగా దట్టమైన చేస్తుంది.

342
00:26:22,060 --> 00:26:30,940
ఎక్కడ మధ్య వ్యత్యాసం -. S పరిమాణం మరియు s.size -

343
00:26:30,940 --> 00:26:40,130
అని ఈ పోస్ట్ఫిక్స్ నొటేషన్ - ఎందుకంటే వారు పోస్ట్ఫిక్స్ నొటేషన్ కాల్ - వచ్చిన తర్వాత s.size -

344
00:26:40,130 --> 00:26:47,430
s.size సూచిక కనుగొనే ప్రయోజనాల కోసం పరిశీలించిన దీని అర్థం

345
00:26:47,430 --> 00:26:50,410
ఈ లైన్ అమలు చేయబడినప్పుడు ప్రస్తుతం వంటి,

346
00:26:50,410 --> 00:26:54,290
మరియు ఈ - లైన్ అమలు అవుతుంది తర్వాత జరుగుతుంది.

347
00:26:54,290 --> 00:27:00,340
ఇండెక్స్ s.size వద్ద మూలకం యాక్సెస్ తరువాత.

348
00:27:00,340 --> 00:27:07,260
మేము తరుగుదల మొదటి ఏమి చేయాలనే ఎందుకంటే ఆ, మేము ఏమి కాదు.

349
00:27:07,260 --> 00:27:10,990
Othewise, మేము శ్రేణి ప్రాప్తి చేయడం చూడాలని, సమర్థవంతంగా, హద్దులు దాటింది.

350
00:27:10,990 --> 00:27:16,850
మేము నిజంగా యాక్సెస్ చేయడానికి కావలసిన ఒక పైన మూలకం ప్రాప్తి చేయడం చూడాలని.

351
00:27:16,850 --> 00:27:23,840
అవును, సామ్? >> వేగంగా లేదా ఒక లైన్ లేదా చేసే తక్కువ RAM వినియోగాన్ని?

352
00:27:23,840 --> 00:27:29,620
[Hardison] నిజాయితీగా, అది నిజంగా ఆధారపడి ఉంటుంది.

353
00:27:29,620 --> 00:27:34,220
[సామ్, అపారదర్శక] >> అవును, అది ఆధారపడి ఉంటుంది. మీరు కంపైలర్ ఉపాయాలు చేయవచ్చు

354
00:27:34,220 --> 00:27:41,580
గుర్తించటానికి కంపైలర్ పొందడానికి, సాధారణంగా, నేను ఊహించుకోండి.

355
00:27:41,580 --> 00:27:44,840
>> కాబట్టి మేము ఈ కంపైలర్ ఆప్టిమైజేషన్ విషయాల గురించి కొద్దిగా పేర్కొన్నారు చేసిన

356
00:27:44,840 --> 00:27:47,400
మీరు, కంపైల్ లో చేసే

357
00:27:47,400 --> 00:27:50,580
మరియు ఆ, ఒక కంపైలర్ గుర్తించడానికి చేయగలరు ఆ విషయం యొక్క రకంగా

358
00:27:50,580 --> 00:27:54,710
OH వంటి హే, నేను, ఒక కార్యకలాపాన్ని ఈ అన్ని చేయవచ్చు

359
00:27:54,710 --> 00:27:59,420
వంటి RAM నుండి పరిమాణం వేరియబుల్ లోడ్ వ్యతిరేకంగా,

360
00:27:59,420 --> 00:28:03,770
ఇది decrementing తిరిగి దాన్ని నిల్వ, ఆపై మళ్ళీ దాన్ని తిరిగి లోడ్

361
00:28:03,770 --> 00:28:08,000
ఈ ఆపరేషన్ మిగిలిన ప్రాసెస్.

362
00:28:08,000 --> 00:28:10,710
కానీ సాధారణంగా, ఏ, ఈ విషయం యొక్క విధమైన కాదు

363
00:28:10,710 --> 00:28:20,770
ఆ చాలా వేగంగా మీ ప్రోగ్రామ్ చేయడానికి జరగబోతోంది.

364
00:28:20,770 --> 00:28:26,000
స్టాక్స్ లో ప్రశ్నలేవీ?

365
00:28:26,000 --> 00:28:31,360
>> కాబట్టి నెట్టడం మరియు పాపింగ్. మీరు అబ్బాయిలు, హ్యాకర్ ఎడిషన్ ప్రయత్నించండి చేయాలనుకుంటే

366
00:28:31,360 --> 00:28:33,660
మనం హ్యాకర్ ఎడిషన్ లో చేసిన వాస్తవానికి వెళ్లిపోయిన

367
00:28:33,660 --> 00:28:37,670
మరియు ఈ స్టాక్ డైనమిక్ పెరుగుతాయి చేసింది.

368
00:28:37,670 --> 00:28:43,190
ఇక్కడ పుష్ ఫంక్షన్ లో ప్రధానంగా ఉంది సవాలు,

369
00:28:43,190 --> 00:28:48,820
ఆ శ్రేణి పెరిగే ఏ విధంగా గుర్తించడానికి

370
00:28:48,820 --> 00:28:52,450
మీరు స్టాక్ కు మరింత ఎక్కువగా అంశాలను నెట్టడం ఉంచేందుకు వంటి.

371
00:28:52,450 --> 00:28:56,000
ఇది నిజంగా చాలా అదనపు కోడ్ కాదు.

372
00:28:56,000 --> 00:29:00,080
మీరు సరిగ్గా అక్కడ malloc పిలుపు పొందడానికి గుర్తు పెట్టుకోవాలి, - కేవలం కాల్

373
00:29:00,080 --> 00:29:03,310
మీరు realloc కాల్ వెళ్లి చేసినప్పుడు మరియు అవుట్ చేసి చూడవచ్చు.

374
00:29:03,310 --> 00:29:06,090
మీకు ఆసక్తి ఉంటే ఒక సరదా సవాలు ఉంది.

375
00:29:06,090 --> 00:29:11,550
>> కానీ ప్రస్తుతానికి, యొక్క ముందుకు వివరించారు, క్యూలు గురించి మాట్లాడేందుకు లెట్స్.

376
00:29:11,550 --> 00:29:15,680
ఇక్కడ స్క్రోల్ ద్వారా.

377
00:29:15,680 --> 00:29:19,340
క్యూ స్టాక్ సన్నిహిత తోబుట్టువులు ఉంది.

378
00:29:19,340 --> 00:29:25,380
కాబట్టి స్టాక్ లో, ఆ విషయాలు గత పెట్టబడ్డాయి

379
00:29:25,380 --> 00:29:28,810
అప్పుడు తిరిగి మొదటి విషయాలు ఉన్నాయి.

380
00:29:28,810 --> 00:29:33,600
మేము క్రమంలో, ఈ, చివరి అవుట్ మొదటి, లేదా ఎల్ఐఎఫ్ఓ పొందారు.

381
00:29:33,600 --> 00:29:38,390
క్యూ లో అయితే, మీరు లైన్ లో నిలబడి చేసినప్పుడు నుండి ఆశించడం పెంచండి,

382
00:29:38,390 --> 00:29:41,980
లైన్ లో పొందడానికి మొదటి వ్యక్తి, క్యూ పొందడానికి మొదటి విషయం,

383
00:29:41,980 --> 00:29:47,630
క్యూ నుండి పొందబడింది పొందే మొదటి విషయం.

384
00:29:47,630 --> 00:29:51,490
మేము గ్రాఫ్లు వ్యవహరించే చేసినప్పుడు క్యూలు కూడా తరచుగా ఉపయోగిస్తారు

385
00:29:51,490 --> 00:29:55,560
మేము స్టాక్లతో క్లుప్తంగా గురించి మాట్లాడుకున్నారు, వంటి

386
00:29:55,560 --> 00:30:00,260
మరియు క్యూలు ఇతర విషయాలు కొంత కూడా సులభ ఉంటాయి.

387
00:30:00,260 --> 00:30:06,180
తరచుగా వచ్చే ఒక విషయం, ఉదాహరణకు, నిర్వహించడానికి ప్రయత్నిస్తున్న

388
00:30:06,180 --> 00:30:12,310
మూలకాల ఒక క్రమబద్ధీకరించబడతాయి జాబితా.

389
00:30:12,310 --> 00:30:17,650
మరియు మీరు ఒక అర్రే తో చేయవచ్చు. మీరు, వ్యూహంలో విషయాలను క్రమబద్ధీకరించబడతాయి జాబితా ఉంచుతుంది

390
00:30:17,650 --> 00:30:20,650
కానీ ఆ గమ్మత్తైన గెట్స్ అప్పుడు ఉన్న మీరు ఎల్లప్పుడూ కనుగొనేందుకు కలిగి

391
00:30:20,650 --> 00:30:26,160
తదుపరి విషయం ఇన్సర్ట్ చెయ్యడానికి సరైన స్థలం.

392
00:30:26,160 --> 00:30:28,250
మీరు 10 ద్వారా సంఖ్యల వ్యూహం, 1 కలిగి అయితే,

393
00:30:28,250 --> 00:30:31,630
మరియు తర్వాత మీరు, 100 ద్వారా అన్ని సంఖ్యలు 1 ఆ పొడిగంచాలనుకుంటున్నాను

394
00:30:31,630 --> 00:30:33,670
మరియు మీరు యాదృచ్ఛిక క్రమంలో ఈ సంఖ్యలు పొందడానికి మరియు ఒక్కటి ప్రయత్నిస్తున్న

395
00:30:33,670 --> 00:30:40,650
మీరు ద్వారా వెళ్ళి వంటి క్రమబద్ధీకరించిన మీరు బదిలీ యొక్క ఎన్నో ముగుస్తుంది.

396
00:30:40,650 --> 00:30:43,910
క్యూలు మరియు అంతర్లీన డేటా నిర్మాణాలు కొన్ని రకాల కొన్ని రకాల,

397
00:30:43,910 --> 00:30:46,670
మీరు దీన్ని సులభం ఉంచుకోవచ్చు.

398
00:30:46,670 --> 00:30:50,640
మీరు ఏదో జోడించి, మొత్తం విషయం ప్రతి సమయం స్థానచలనం లేదు.

399
00:30:50,640 --> 00:30:56,770
లేదా మీరు చుట్టూ అంతర్గత అంశాలను బదిలీ చాలా చేయాలి.

400
00:30:56,770 --> 00:31:02,990
మేము ఒక క్యూ చూడండి, మీరు చూస్తారు - కూడా queue.c విభాగంలో కోడ్ -

401
00:31:02,990 --> 00:31:10,950
మేము మీరు ఇచ్చిన చేసిన struct మేము ఒక స్టాక్ కోసం మీరు ఇచ్చిన struct నిజంగా పోలి ఉంటుంది.

402
00:31:10,950 --> 00:31:13,770
>> ఈ ఒక మినహాయింపు ఉంది, మరియు ఒక మినహాయింపు

403
00:31:13,770 --> 00:31:21,700
మేము తల అని ఈ అదనపు పూర్ణాంక కలిగి ఉంది,

404
00:31:21,700 --> 00:31:28,120
మరియు ఇక్కడ తల, క్యూ యొక్క తల యొక్క పర్యవేక్షించే ఉంది

405
00:31:28,120 --> 00:31:32,160
క్యూ లో లేదా మొదటి మూలకం.

406
00:31:32,160 --> 00:31:37,470
ఒక స్టాక్ తో, మేము తిరిగి గురించి అని మూలకం ట్రాక్ సాధించారు

407
00:31:37,470 --> 00:31:40,800
కేవలం పరిమాణం ఉపయోగించి స్టాక్ లేదా టాప్,

408
00:31:40,800 --> 00:31:44,220
ఒక క్యూ తో అయితే, మేము వ్యతిరేక చివర్లలో పరిష్కరించేందుకు సమస్య.

409
00:31:44,220 --> 00:31:49,000
మేము టాక్ చివరిలో విషయాలు ప్రయత్నిస్తున్న, కానీ ముందు నుండి విషయాలు తిరిగి చేస్తున్నారు.

410
00:31:49,000 --> 00:31:54,640
అది ప్రభావవంతంగా, తల తో, మేము, క్యూ ప్రారంభంలో యొక్క ఇండెక్స్ కలిగి

411
00:31:54,640 --> 00:31:58,920
మరియు పరిమాణం మాకు క్యూ యొక్క ముగింపు సూచిక ఇస్తుంది

412
00:31:58,920 --> 00:32:03,730
మేము తల నుండి విషయాలు తిరిగి మరియు తోక వరకు విషయాలు జోడించండి చేయవచ్చు.

413
00:32:03,730 --> 00:32:06,890
స్టాక్ తో అయితే, మేము మాత్రమే ఎప్పుడూ స్టాక్ ఎగువ వ్యవహరించే ఉన్నారు.

414
00:32:06,890 --> 00:32:08,900
మేము స్టాక్ దిగువన యాక్సెస్ వహించలేదు.

415
00:32:08,900 --> 00:32:12,220
మేము మాత్రమే టాప్ విషయాలను జోడించారు మరియు టాప్ యొక్క విషయాలను బయలుదేరాడు

416
00:32:12,220 --> 00:32:17,470
కాబట్టి మేము మా struct లోపల అదనపు ఫీల్డ్ అవసరం లేదు.

417
00:32:17,470 --> 00:32:20,590
ఆ సాధారణంగా సమంజసం లేదు?

418
00:32:20,590 --> 00:32:27,670
అన్ని కుడి. అవును, షార్లెట్? [షార్లెట్, అపారదర్శక]

419
00:32:27,670 --> 00:32:32,660
[Hardison] ఒక గొప్ప ప్రశ్న, మరియు ఆ ఉపన్యాసం లో వచ్చిన ఒకటి.

420
00:32:32,660 --> 00:32:36,290
బహుశా కొన్ని ఉదాహరణలు ద్వారా వాకింగ్ వర్ణించేందుకు ఎందుకు

421
00:32:36,290 --> 00:32:41,400
మేము తీగలను క్యూ అధిపతిగా [0] ఉపయోగించడానికి లేదు.

422
00:32:41,400 --> 00:32:46,770
>> కాబట్టి మేము మా క్యూ కలిగి ఊహించుకోండి, మేము అది క్యూ కాల్ చూడాలని.

423
00:32:46,770 --> 00:32:49,210
ప్రారంభంలో, మేము దానిని ఇన్స్టాన్షిఎట్ చేసినప్పుడు,

424
00:32:49,210 --> 00:32:53,330
మేము కేవలం ప్రకటించింది చేసినప్పుడు, మేము ఏదైనా initialized లేదు.

425
00:32:53,330 --> 00:32:56,790
అన్ని చెత్త ఉంది. కాబట్టి కోర్సు యొక్క మేము ప్రారంభించడం ఆ నిర్ధారించుకోవాలి

426
00:32:56,790 --> 00:33:00,950
పరిమాణం మరియు తల ఖాళీలను రెండు సహేతుకమైన 0, ఏదో ఒక.

427
00:33:00,950 --> 00:33:05,770
మేము కూడా ముందుకు వెళ్లి మా క్యూలో అంశాలు బయటకు శూన్యం కాలేదు.

428
00:33:05,770 --> 00:33:09,930
మరియు ఈ చిత్రంలో సరిపోయేలా చేయండి, ఇప్పుడు మా క్యూ మూడు అంశాలు కలిగి ఆ గమనించి;

429
00:33:09,930 --> 00:33:13,150
మా స్టాక్ నాలుగు అనువుగా ఉండేది, అయితే మా క్యూ మూడు పట్టుకోగలదు.

430
00:33:13,150 --> 00:33:18,680
ఆ చిత్రం సరిపోయేలా చేయండి కేవలం ఉంది.

431
00:33:18,680 --> 00:33:26,150
ఇక్కడ జరిగే మొదటి విషయం మేము "హాయ్" స్ట్రింగ్ ఎన్క్యూ ఉంది.

432
00:33:26,150 --> 00:33:30,380
మరియు కేవలం వంటి మేము స్టాక్ ద్వారా కూడా, ఇక్కడ భయంకరమైన వివిధ ఏదీ,

433
00:33:30,380 --> 00:33:39,230
మేము తీగలను వద్ద [0] మరియు 1 మా పరిమాణం పెంచడం పై స్ట్రింగ్ త్రో.

434
00:33:39,230 --> 00:33:42,720
మేము "బై" ఎన్క్యూ, ఇది ఉంచే.

435
00:33:42,720 --> 00:33:45,870
కాబట్టి ఈ అధిక భాగం ఒక స్టాక్ కనిపిస్తోంది.

436
00:33:45,870 --> 00:33:53,230
మేము ఇక్కడ కొత్త మూలకం, కొత్త మూలకం ప్రారంభించబడింది పరిమాణం రూపుదిద్దుకుంటున్నాయి ఉంచుతుంది.

437
00:33:53,230 --> 00:33:56,330
ఏదో dequeue మీరు ఏమి ఈ సమయంలో జరుగుతుంది?

438
00:33:56,330 --> 00:34:01,280
మేము dequeue మీరు ఎప్పుడు, ఇది మేము dequeue చేయదలిచిన అంశం?

439
00:34:01,280 --> 00:34:04,110
[బాసిల్] స్ట్రింగ్స్ [0]. >> జీరో. సరిగ్గా కుడి, బాసిల్.

440
00:34:04,110 --> 00:34:10,960
మేము మొదటి స్ట్రింగ్, ఈ ఒక "హాయ్" వదిలించుకోవటం మీరు.

441
00:34:10,960 --> 00:34:13,170
కాబట్టి మార్చిన ఇతర విషయం ఏమిటి?

442
00:34:13,170 --> 00:34:17,010
మేము స్టాక్ ఏదో ఆఫ్ popped ఉన్నప్పుడు గమనించి, మేము, పరిమాణం మార్చబడింది

443
00:34:17,010 --> 00:34:22,080
కానీ ఇక్కడ, మేము చేసే కొన్ని విషయాలను పొందారు.

444
00:34:22,080 --> 00:34:27,440
పరిమాణం మార్చు, కానీ తల మార్పులు లేదు మాత్రమే.

445
00:34:27,440 --> 00:34:31,020
ఈ ప్రారంభ షార్లెట్ పాయింట్ తిరిగి వెళ్తున్నారు:

446
00:34:31,020 --> 00:34:38,699
ఎందుకు మేము కూడా ఈ తల ఎందుకు చెయ్యాలి?

447
00:34:38,699 --> 00:34:42,110
ఇది ఇప్పుడు షార్లెట్ సమంజసం లేదు? యొక్క >> కైండ్.

448
00:34:42,110 --> 00:34:47,500
యొక్క [Hardison] కైండ్? మేము dequeued కనుక ఏమి జరిగింది?

449
00:34:47,500 --> 00:34:54,340
తల ఇప్పుడు ఆసక్తికరమైన అని ఏం చేసావ్?

450
00:34:54,340 --> 00:34:56,449
అది మార్చబడింది [షార్లెట్] ఓహ్, ఎందుకంటే - సరే. నేను చూడండి.

451
00:34:56,449 --> 00:35:02,090
ఎందుకంటే తల - తల నగర పరంగా మార్పులు సూచించే కౌంటీ.

452
00:35:02,090 --> 00:35:07,200
ఇది ఇకపై ఎల్లప్పుడూ సున్నా సూచిక ఒకటి. >> అవును, సరిగ్గా.

453
00:35:07,200 --> 00:35:17,660
అధిక మూలకం dequeueing ఉంటే ఏమి జరిగింది ఉంది

454
00:35:17,660 --> 00:35:20,590
జరిగింది మరియు మేము ఈ తల రంగంలో లేదు

455
00:35:20,590 --> 00:35:26,880
మేము ఎల్లప్పుడూ 0 సూచిక మా క్యూ యొక్క తల వద్ద ఈ స్ట్రింగ్ కాల్ ఎందుకంటే,

456
00:35:26,880 --> 00:35:30,170
అప్పుడు మేము క్యూ మిగిలిన డౌన్ మార్చేందుకు భావిస్తాను.

457
00:35:30,170 --> 00:35:36,010
మేము తీగలను నుండి "బై" [1] మారిపోయే [0] తీగలను కలిగి కావలసిన.

458
00:35:36,010 --> 00:35:38,760
మరియు తీగలను [2] డౌన్ కోసం తీగలను [1].

459
00:35:38,760 --> 00:35:43,050
మరియు మేము, మూలకాల యొక్క మొత్తం జాబితా ఇలా భావిస్తాను

460
00:35:43,050 --> 00:35:45,110
అంశాల మొత్త.

461
00:35:45,110 --> 00:35:50,490
మరియు మేము ఒక అర్రే ఈ చేస్తున్నా, ఆ నిజంగా ఖరీదైన పొందుతాడు.

462
00:35:50,490 --> 00:35:53,340
ఇక్కడ, అది ఒక పెద్ద ఒప్పందం కాదు. మేము మా పరిధిలో మూడు అంశాలను కలిగి ఉంటుంది.

463
00:35:53,340 --> 00:35:57,230
కానీ మేము వెయ్యి అంశాలు క్యూ లేదా ఒక మిలియన్ అంశాలను కలిగి ఉంటే,

464
00:35:57,230 --> 00:36:00,060
మరియు తర్వాత ఒక అకస్మాత్తుగా, మేము dequeue కొంత సంపాదించడం ప్రారంభించండి, ఒక లూప్ లో అన్ని కాల్స్

465
00:36:00,060 --> 00:36:03,930
వస్తువులు నిజంగా అది నిరంతరం ప్రతిదీ డౌన్ మార్పు చెందుతున్న వేగాన్ని వెళ్తున్నారు.

466
00:36:03,930 --> 00:36:07,320
మీకు తెలుసా, 1 షిఫ్ట్, 1 1, మార్పు ద్వారా, 1 షిఫ్ట్ ఉంచారు.

467
00:36:07,320 --> 00:36:13,650
ఇది నిజంగా ఒక పాయింటర్ కాదు అయినప్పటికీ బదులుగా, ఈ తల ఉపయోగించడానికి, మేము దీనిని "పాయింటర్" కాల్

468
00:36:13,650 --> 00:36:16,430
ఖచ్చితమైన భావాన్ని లో ఇది ఒక పాయింటర్ రకం కాదు.

469
00:36:16,430 --> 00:36:19,410
ఇది ఒక పూర్ణాంకానికి * లేదా ఒక చార్ * లేదా అలాంటిదే మాత్రం కాదు.

470
00:36:19,410 --> 00:36:28,930
కానీ పై లేదా మా క్యూ యొక్క తల సూచిస్తూ ఉంటుంది. Yeah?

471
00:36:28,930 --> 00:36:38,800
>> [స్టూడెంట్] కేవలం తల వద్ద ఉండే వస్తువు ఆఫ్ పాప్ ఎలా dequeue తెలుసా?

472
00:36:38,800 --> 00:36:43,620
[Hardison] ఎలా dequeue తల వద్ద ఉంది ఏ ఆఫ్ పాప్ ఎలా తెలుసు? >> కుడి, అవును.

473
00:36:43,620 --> 00:36:49,050
>> అంటే అది వద్ద ఆరాటపడుతుంది కు సెట్ కేవలం ఏ తల రంగం.

474
00:36:49,050 --> 00:36:52,710
మేము ఇక్కడ చూడండి ఈ మొదటి సందర్భంలో, ఉంటే,

475
00:36:52,710 --> 00:36:55,690
మా తల 0, ఇండెక్స్ 0. >> కుడి.

476
00:36:55,690 --> 00:37:00,500
[Hardison], ఇది కేవలం సరే, అలాగే, ఇండెక్స్ 0 వద్ద మూలకం, స్ట్రింగ్ "హాయ్" అని సో

477
00:37:00,500 --> 00:37:03,050
మా క్యూ యొక్క తల వద్ద మూలకం ఉంది.

478
00:37:03,050 --> 00:37:05,570
కాబట్టి మేము వ్యక్తివి dequeue చూడాలని.

479
00:37:05,570 --> 00:37:09,800
మరియు ఆ కాలర్ తిరిగి పొందే మూలకం ఉంటుంది.

480
00:37:09,800 --> 00:37:14,540
అవును, సాద్? >> కాబట్టి తల ప్రధానంగా అమర్చుతుంది - మీరు ఇండెక్స్ దానికి వెళుతున్న?

481
00:37:14,540 --> 00:37:17,750
అది ప్రారంభం ఏమిటి? >> అవును. సరే >>.

482
00:37:17,750 --> 00:37:22,900
[Hardison] మా శ్రేణి కోసం కొత్త ప్రారంభం కావడానికి యొక్క.

483
00:37:22,900 --> 00:37:28,930
కాబట్టి మీరు ఏదో dequeue, మీరు చేయాల్సిందల్లా, ఇండెక్స్ q.head వద్ద మూలకం యాక్సెస్ ఉంటుంది

484
00:37:28,930 --> 00:37:32,240
మరియు మీరు dequeue చేయదలిచిన మూలకం ఉంటుంది.

485
00:37:32,240 --> 00:37:34,930
మీరు పరిమాణం తరుగుదల ఉంటుంది.

486
00:37:34,930 --> 00:37:39,430
విషయాలు ఈ గల చిన్న గమ్మత్తైన చోటే మేము ఒక బిట్ లో చూస్తారు.

487
00:37:39,430 --> 00:37:46,520
మేము మళ్లీ ఎన్క్యూ ఉంటే, మేము, ఇప్పుడు dequeue, మరియు

488
00:37:46,520 --> 00:37:51,300
మేము పేరు ఎన్క్యూ చెయ్యాలి?

489
00:37:51,300 --> 00:37:55,000
ఎక్కడ తదుపరి మూలకం మా క్యూలో వెళ్ళి లేదు?

490
00:37:55,000 --> 00:37:57,980
మేము స్ట్రింగ్ "CS" ఎన్క్యూ అనుకుందాం.

491
00:37:57,980 --> 00:38:02,240
ఇది ఇండెక్స్ లోకి వెళ్తుంది? [స్టూడెంట్స్] స్ట్రింగ్స్ [2]. >> రెండు.

492
00:38:02,240 --> 00:38:04,980
ఎందుకు 2 మరియు 0?

493
00:38:04,980 --> 00:38:13,570
[బాసిల్] ఇప్పుడు తల 1 కాబట్టి, జాబితా ప్రారంభం వంటిది కనుక?

494
00:38:13,570 --> 00:38:21,220
[Hardison] రైట్. మరియు జాబితా యొక్క ముగింపు సూచిస్తుంది?

495
00:38:21,220 --> 00:38:23,290
మేము మా క్యూ ముగింపు సూచించడానికి ఉపయోగించారు చేశారు?

496
00:38:23,290 --> 00:38:25,970
తల మా క్యూ యొక్క తల, మా క్యూ యొక్క ప్రారంభం.

497
00:38:25,970 --> 00:38:29,530
మా క్యూ ముగింపు ఏమిటి? [స్టూడెంట్స్] సైజు. >> సైజు, సరిగ్గా.

498
00:38:29,530 --> 00:38:36,360
మా కొత్త అంశాలు పరిమాణంలో వెళ్లి, మరియు మేము తీసుకున్న అంశాలు ఆఫ్ తల వద్ద జరుగుట.

499
00:38:36,360 --> 00:38:45,390
రాబోయే మూలకం ఎన్క్యూ చేసినప్పుడు, మేము పరిమాణంలో లో ఉంచారు చేస్తున్నారు.

500
00:38:45,390 --> 00:38:48,530
[స్టూడెంట్] ముందు మీరు అయితే లో, పరిమాణం, కుడి, 1 అని ఉంచండి?

501
00:38:48,530 --> 00:38:55,690
[Hardison] రైట్. కాబట్టి చాలా పరిమాణం వద్ద. సైజు +, కాని +1, కానీ + తల.

502
00:38:55,690 --> 00:38:59,990
మేము తల మొత్తం ద్వారా ప్రతిదీ మారింది ఎందుకంటే.

503
00:38:59,990 --> 00:39:14,270
ఇక్కడ, ఇప్పుడు మేము ఇండెక్స్ 1 లో మొదలై 1 పరిమాణం ఒక క్యూ పొందారు.

504
00:39:14,270 --> 00:39:20,730
తోక సూచిక 2. అవును?

505
00:39:20,730 --> 00:39:25,780
>> [స్టూడెంట్] ఏం జరుగుతుందో మెమరీలో మీరు dequeue తీగలను [0], మరియు తీగలను 'స్లాట్లు

506
00:39:25,780 --> 00:39:29,420
కేవలం ప్రాథమికంగా, ఖాళీ పొందండి లేదా కేవలం మర్చిపోయారా?

507
00:39:29,420 --> 00:39:34,700
[Hardison] అవును. ఈ కోణంలో, మేము వాటిని మర్చిపోకుండా చేస్తున్నారు.

508
00:39:34,700 --> 00:39:42,640
మేము వాటిని యొక్క కాపీలు నిల్వ ఉన్నట్లయితే -

509
00:39:42,640 --> 00:39:46,310
అనేక డేటా నిర్మాణాలు తరచుగా మూలకాల యొక్క సొంత కాపీలు నిల్వ చేస్తుంది

510
00:39:46,310 --> 00:39:51,760
డేటా నిర్మాణం మేనేజింగ్ వ్యక్తి ఆందోళన లేదు కాబట్టి

511
00:39:51,760 --> 00:39:53,650
అన్ని గమనికలు వెళ్తున్నారు పేరు గురించి.

512
00:39:53,650 --> 00:39:56,000
డేటా నిర్మాణం అన్నింటికీ పట్టుకుని, అన్ని కాపీలు గట్టిగ పట్టుకుని

513
00:39:56,000 --> 00:39:59,580
ప్రతిదీ సరిగ్గా అలాగే నిర్ధారించాలి.

514
00:39:59,580 --> 00:40:03,140
అయితే, ఈ సందర్భంలో, ఈ డేటా నిర్మాణాలు కేవలం, సరళత కోసం,

515
00:40:03,140 --> 00:40:05,580
మేము వాటిని లో నిల్వ చేస్తున్న ఏదైనా యొక్క కాపీలు తయారు లేదు.

516
00:40:05,580 --> 00:40:08,630
[స్టూడెంట్] ఈ నిరంతర శ్రేణి -? >> అవును.

517
00:40:08,630 --> 00:40:14,350
మేము నిర్వచనం ఈ నిర్మాణం యొక్క గురించి తిరిగి చూడాలని, అది ఉంది.

518
00:40:14,350 --> 00:40:19,110
ఇది మీరు చూసిన వలె ఒక ప్రామాణిక అమరిక యొక్క

519
00:40:19,110 --> 00:40:24,280
చార్ * s యొక్క వ్యూహం.

520
00:40:24,280 --> 00:40:26,340
ఆ లేదు -? >> అవును, నేను కాదని జరిగినది

521
00:40:26,340 --> 00:40:29,130
మీరు చివరకు కొంత వరకూ, మెమరీ రన్నవుట్, మీరు ఉంటే

522
00:40:29,130 --> 00:40:32,330
మీరు మీ పరిధిలో ఈ ఖాళీ మచ్చలు ఉంటే?

523
00:40:32,330 --> 00:40:36,390
[Hardison] అవును, ఒక మంచి పాయింట్.

524
00:40:36,390 --> 00:40:41,530
>> మేము ఈ సమయంలో ఇప్పుడు జరిగిన ఏమి చూడండి, ఉంటే

525
00:40:41,530 --> 00:40:46,350
మేము మా క్యూ భర్తీ చేసిన, ఇది అలా కనిపిస్తుంది.

526
00:40:46,350 --> 00:40:50,390
కానీ మేము నిజంగా మా క్యూ భర్తీ చేయలేదు

527
00:40:50,390 --> 00:40:57,710
మేము పరిమాణం 2 అని ఒక క్యూ ఉంటుంది, కాని అది ఇండెక్స్ 1 ప్రారంభమవుతుంది ఎందుకంటే,

528
00:40:57,710 --> 00:41:02,160
మా తల పాయింటర్ అనేది ఎందుకంటే.

529
00:41:02,160 --> 00:41:08,400
మీరు చెబుతున్న ఉన్నాయి, ఆ తీగలను వద్ద మూలకం [0], ఇండెక్స్ 0 వద్ద, నిజంగా లేదు.

530
00:41:08,400 --> 00:41:10,450
ఇది ఇకపై మా క్యూ లో కాదు.

531
00:41:10,450 --> 00:41:16,460
అలా వెళ్లి మరియు మేము అది dequeued అది ఓవర్రైట్ ఇబ్బంది లేదు.

532
00:41:16,460 --> 00:41:18,700
కాబట్టి మేము మెమరీ రన్నవుట్ అనిపిస్తున్నది అయినప్పటికీ, మేము నిజంగా లేదు.

533
00:41:18,700 --> 00:41:23,270
మాకు ఉపయోగించడానికి ఆ స్థానాన్ని అందుబాటులో ఉంది.

534
00:41:23,270 --> 00:41:29,310
తగిన ప్రవర్తన, మేము dequeue ఏదో ప్రయత్నించండి మరియు మొదటి ఉన్నట్లయితే

535
00:41:29,310 --> 00:41:34,420
బై ఆఫ్ పాప్ అని, "బై" ఇష్టం.

536
00:41:34,420 --> 00:41:38,460
ఇప్పుడు మా క్యూ సూచిక 2 ప్రారంభమవుతుంది మరియు 1 పరిమాణం ఉంటుంది.

537
00:41:38,460 --> 00:41:42,240
మేము మళ్ళీ ఏదో ప్రయత్నించండి మరియు ఎన్క్యూ ఉంటే ఇప్పుడు, 50 సే

538
00:41:42,240 --> 00:41:47,880
50 ఇండెక్స్ 0 వద్ద ఈ స్పాట్ లో వెళ్ళాలి

539
00:41:47,880 --> 00:41:51,270
అది ఇప్పటికీ మాకు అందుబాటులో ఎందుకంటే. అవును, సాద్?

540
00:41:51,270 --> 00:41:53,630
[సాద్] ఆ స్వయంచాలకంగా ఏర్పడుతుందా?

541
00:41:53,630 --> 00:41:56,150
[Hardison] ఇది చాలా స్వయంచాలకంగా సంభవించదు. మీరు గణిత లేదు

542
00:41:56,150 --> 00:42:00,380
అది పని, అయితే తప్పనిసరిగా మనం చేసిన మేము చుట్టూ చుట్టి చేసిన చెప్పవచ్చు.

543
00:42:00,380 --> 00:42:04,070
ఇది మధ్యలో ఒక రంధ్రం ఉంటే [సాద్] మరియు ఓకే నా

544
00:42:04,070 --> 00:42:08,720
[Hardison] మేము గణిత సరిగా పని చేయవచ్చు ఉంటే ఇది.

545
00:42:08,720 --> 00:42:15,470
>> మరియు ఆ నిజానికి mod ఆపరేటర్లు తో ఆ హార్డు కాని అవుతుంది.

546
00:42:15,470 --> 00:42:20,040
కాబట్టి వలె మేము, సీజర్ మరియు crypto విషయాలలో చేశాడు

547
00:42:20,040 --> 00:42:25,190
mod ఉపయోగించి, మేము విషయాలు చుట్టూ పొందడానికి మరియు కొనసాగించడాన్ని చేయవచ్చు

548
00:42:25,190 --> 00:42:28,090
మా క్యూ చుట్టూ మరియు చుట్టూ మరియు చుట్టూ తో,

549
00:42:28,090 --> 00:42:32,180
ఆ తల పాయింటర్ చుట్టూ కదిలే చోటు చేసుకుంది.

550
00:42:32,180 --> 00:42:38,840
ఆ పరిమాణం గమనించండి ఎల్లప్పుడూ క్యూ లోపల వాస్తవానికి మూలకాల సంఖ్య గౌరవిస్తూ ఉంటుంది.

551
00:42:38,840 --> 00:42:43,110
అది ద్వారా సైకిల్ ఉంచుతుంది తల పాయింటర్ ఉంది.

552
00:42:43,110 --> 00:42:49,660
మేము ప్రారంభానికి తిరిగి వెళ్ళడానికి ఇక్కడ ఏమి జరుగుతుందో చూడండి, ఉంటే

553
00:42:49,660 --> 00:42:55,020
మరియు మీరు తల ఏమి చూడటానికి

554
00:42:55,020 --> 00:42:58,240
ఏదో ఎన్క్యూ ఉన్నప్పుడు, ఏమీ తల జరిగింది.

555
00:42:58,240 --> 00:43:00,970
మేము ఏదో వరుసలో ఉన్నప్పుడు, ఏమీ తల జరిగింది.

556
00:43:00,970 --> 00:43:04,130
ఏదో dequeued వెంటనే తల ఒకటి పెరుగుతుంది.

557
00:43:04,130 --> 00:43:06,600
మేము ఏదో వరుసలో, ఏమీ తల నిర్మాణము.

558
00:43:06,600 --> 00:43:11,060
ఏదో dequeue చేసినప్పుడు, ఆకస్మికంగా తల పెరిగిన తీర్చుకుంటాడు.

559
00:43:11,060 --> 00:43:14,660
ఏదో ఎన్క్యూ చేసినప్పుడు, ఏమీ తల నిర్మాణము.

560
00:43:14,660 --> 00:43:20,240
>> మేము మళ్ళీ ఏదో dequeue ఉన్నట్లయితే ఈ సమయంలో జరుగుతుంది?

561
00:43:20,240 --> 00:43:23,240
ఏదైనా ఆలోచనలు? ఏ తలపై జరుగుతుంది?

562
00:43:23,240 --> 00:43:27,190
తల ఏం చేయాలి అనే విషయాన్ని

563
00:43:27,190 --> 00:43:32,990
మేము ఏదో dequeue ఉన్నట్లయితే?

564
00:43:32,990 --> 00:43:35,400
తల ప్రస్తుతం, సూచిక 2 ఉంది

565
00:43:35,400 --> 00:43:38,920
ఇది క్యూ యొక్క తల తీగలను [2] అని అర్థం.

566
00:43:38,920 --> 00:43:44,280
[స్టూడెంట్] 0 చూపించే? >> ఇది 0 తిరిగి ఉండాలి. ఇది ఖచ్చితంగా, చుట్టూ తిరిగి వ్రాప్ ఉండాలి.

567
00:43:44,280 --> 00:43:48,440
ఇప్పటివరకు, మేము dequeue అని ప్రతిసారీ, మేము, తల ఒక జోడించడం చేసిన

568
00:43:48,440 --> 00:43:50,960
తల ఒక జోడించడానికి, తల ఒక జోడించడానికి, తల ఒక జోడించండి.

569
00:43:50,960 --> 00:43:58,400
ఆ తల పాయింటర్ మా శ్రేణి చివరి ఇండెక్స్ కు వస్తుంది, వెంటనే

570
00:43:58,400 --> 00:44:05,650
అప్పుడు మేము ప్రారంభానికి చుట్టూ తిరిగి మూసివేయాలని కలిగి, 0 తిరిగి వెళ్ళండి.

571
00:44:05,650 --> 00:44:09,900
[షార్లెట్] నా స్టాక్ లో క్యూ యొక్క సామర్థ్యం నిర్ణయిస్తుంది?

572
00:44:09,900 --> 00:44:13,120
[Hardison] ఈ సందర్భంలో, మనం కేవలం ఒక # నిర్వచించిన స్థిరంగా ఉపయోగిస్తున్నాను. సరే >>.

573
00:44:13,120 --> 00:44:19,590
[Hardison] వాస్తవ. సి ఫైలు, మీరు కొద్దిగా తో మరియు చెత్త వెళ్ళే

574
00:44:19,590 --> 00:44:21,710
మరియు అది పెద్ద లేదా మీకు కావలసిన తక్కువగా చేయండి.

575
00:44:21,710 --> 00:44:25,310
[షార్లెట్] కాబట్టి మీరు ఒక క్యూ చేస్తున్న సమయంలో, మీరు కంప్యూటర్ ఉంటావు ఉందని

576
00:44:25,310 --> 00:44:29,120
మీరు స్టాక్ ఉండాలనుకుంటున్నాను ఎంత పెద్దది?

577
00:44:29,120 --> 00:44:31,700
[Hardison] ఒక గొప్ప ప్రశ్న.

578
00:44:31,700 --> 00:44:34,800
రెండు మార్గాలు ఉన్నాయి. ఒక ముందు దానిని నిర్వచించి

579
00:44:34,800 --> 00:44:42,050
మరియు ఈ చెప్పడానికి 4 అంశాలు లేదా 50 అంశాలు లేదా 10,000 కలిగి క్యూ అని అన్నారు.

580
00:44:42,050 --> 00:44:45,430
ఇతర మార్గం హ్యాకర్ ఎడిషన్ వారిని ఎలా ఏమి చేయాలో

581
00:44:45,430 --> 00:44:52,310
మరియు మరిన్ని అంశాలను సైన్ జోడించబడుతుంది మీ క్యూ డైనమిక్ పెరుగుతాయి కలిగి ఫంక్షన్లను సృష్టించవచ్చు

582
00:44:52,310 --> 00:44:54,740
>> [షార్లెట్] కాబట్టి మొదటి ఎంపిక పనిచేయడానికి, మీరు ఏమి సింటాక్స్ ఉపయోగించగలను

583
00:44:54,740 --> 00:44:57,830
కార్యక్రమం చెప్పడం క్యూ యొక్క పరిమాణం ఏమిటి?

584
00:44:57,830 --> 00:45:04,780
[Hardison] ఆహ్. కాబట్టి యొక్క ఈ యొక్క అవుట్ తెలియజేయండి.

585
00:45:04,780 --> 00:45:12,650
నేను ఇక్కడ stack.c ఇప్పటికీ ఉన్నాను, నేను కేవలం ఇక్కడ టాప్ వరకు స్క్రోల్ వెళుతున్న.

586
00:45:12,650 --> 00:45:17,920
మీరు ఈ ఇక్కడే చూడగలరు? ఈ # సామర్థ్యం 10 నిర్వచించే ఉంది.

587
00:45:17,920 --> 00:45:24,600
మరియు ఈ మేము క్యూ కోసం దాదాపుగా ఖచ్చితమైన వాక్యనిర్మాణం.

588
00:45:24,600 --> 00:45:28,390
క్యూ లో తప్ప, మేము ఇక్కడ అదనపు struct రంగంలో పొందారు.

589
00:45:28,390 --> 00:45:32,760
[షార్లెట్] ఓహ్, నేను సామర్థ్యం స్ట్రింగ్ కోసం సామర్థ్యం అర్థం ఆలోచన.

590
00:45:32,760 --> 00:45:36,770
[Hardison] ఆహ్. పదం యొక్క గరిష్ట పొడవు అదే >>. >> అర్థమైంది.

591
00:45:36,770 --> 00:45:41,180
అవును. ఇక్కడ సామర్థ్యం - ఒక గొప్ప పాయింట్.

592
00:45:41,180 --> 00:45:44,000
మరియు ఈ గమ్మత్తైన ఏదో ఒకటి ఉంటుంది

593
00:45:44,000 --> 00:45:49,480
మనం ఇక్కడ ప్రకటించారు చేసిన చార్ * s యొక్క వ్యూహం ఉంది.

594
00:45:49,480 --> 00:45:52,770
గమనికలు యొక్క ఒక అమరిక.

595
00:45:52,770 --> 00:45:56,690
ఈ అక్షరాలు యొక్క వ్యూహం ఉంది.

596
00:45:56,690 --> 00:46:01,690
ఈ ఫైల్ కోసం మీ బఫర్సుకొరకు ప్రకటించారు చేసిన మీరు చూసిన కావచ్చు I / O,

597
00:46:01,690 --> 00:46:06,840
మీరు స్టాక్ న మానవీయంగా తీగలను సృష్టించారు చేసినప్పుడు.

598
00:46:06,840 --> 00:46:09,090
అయితే, మనం ఇక్కడ పొందారు చార్ * s యొక్క వ్యూహం ఉంది.

599
00:46:09,090 --> 00:46:13,400
కనుక ఇది గమనికలు యొక్క వ్యూహం ఉంది.

600
00:46:13,400 --> 00:46:18,350
అసలైన, మేము తిరిగి దూరంగా మరియు మేము ఇక్కడ ఏమి విషయంలో చూస్తే

601
00:46:18,350 --> 00:46:23,140
ప్రదర్శనలో, మీరు నిజమైన అంశాలు పాత్ర డేటా చూడండి

602
00:46:23,140 --> 00:46:26,180
అర్రే లోపలే నిల్వ చెయ్యబడదు.

603
00:46:26,180 --> 00:46:42,690
ఇక్కడికి మా శ్రేణి లోపల నిల్వ పాత్ర డేటా గమనికలు ఉన్నాయి.

604
00:46:42,690 --> 00:46:52,560
సరే. కాబట్టి మేము, క్యూ యొక్క పరిమాణం కేవలం స్టాక్ వలె ఎలా చూసిన

605
00:46:52,560 --> 00:46:58,670
పరిమాణం ఎల్లప్పుడూ క్యూలో మూలకాల సంఖ్య గౌరవిస్తుంది.

606
00:46:58,670 --> 00:47:02,720
2 enqueues తరువాత, పరిమాణం 2.

607
00:47:02,720 --> 00:47:07,110
ఒక dequeue తరువాత పరిమాణం ఇప్పుడు 1.

608
00:47:07,110 --> 00:47:09,330
మరొక ఎన్క్యూ తరువాత పరిమాణం 2 వరకు తిరిగి ఉంది.

609
00:47:09,330 --> 00:47:12,340
కాబట్టి పరిమాణం ఖచ్చితంగా, క్యూ లో మూలకాల సంఖ్య గౌరవిస్తుంది

610
00:47:12,340 --> 00:47:15,580
మరియు తర్వాత తల కేవలం సైక్లింగ్ ఉంచుతుంది.

611
00:47:15,580 --> 00:47:20,210
ఇది 0-1-2, 0-1-2, 0-1-2 నుండి వెళుతుంది.

612
00:47:20,210 --> 00:47:25,620
మరియు మేము dequeue కాల్ ప్రతిసారీ, తల పాయింటర్ తదుపరి ఇండెక్స్ కు పెరిగిన తీర్చుకుంటాడు.

613
00:47:25,620 --> 00:47:29,930
తలపై వెళ్ళడానికి గురించి ఉంటే మరియు అది తిరిగి చుట్టూ 0 to ఉచ్చులు.

614
00:47:29,930 --> 00:47:34,870
కాబట్టి ఆ, మేము dequeue ఫంక్షన్ వ్రాయగలవు.

615
00:47:34,870 --> 00:47:40,200
మరియు మేము మీరు అబ్బాయిలు బదులుగా అమలు కోసం ఎన్క్యూ ఫంక్షన్ విడిచి వెళుతున్న.

616
00:47:40,200 --> 00:47:45,880
>> మేము మా క్యూ యొక్క ఒక మూలకం అవుట్ dequeue చేసినప్పుడు,

617
00:47:45,880 --> 00:47:55,490
మేము స్టాక్లకు పాప్ ఫంక్షన్ రాయడం మొదలు డేనియల్ అని మొదటి విషయం ఏమిటి?

618
00:47:55,490 --> 00:48:00,490
నాకు ఇంకా మాట్లాడే వారు వీరు ఎవరైనా నుండి మాకు లెట్.

619
00:48:00,490 --> 00:48:06,710
, చూడండి సాద్ లెట్ మీరు డేనియల్ అతను పాప్ రాశారు మొదటి విషయం వంటి ఏమి గుర్తు లేదా?

620
00:48:06,710 --> 00:48:08,860
[సాద్], ఇది ఉంది జరిగినది - ఏదైనా పరీక్షించారు >>.

621
00:48:08,860 --> 00:48:12,140
[సాద్] పరిమాణం 0 కన్నా ఎక్కువ ఉంటే. ఖచ్చితంగా >>.

622
00:48:12,140 --> 00:48:14,390
మరియు ఆ పరీక్ష ఏమిటి?

623
00:48:14,390 --> 00:48:19,090
[సాద్] శ్రేణిలో ఏదైనా ఉంది లేదో పరీక్ష చేస్తుందని.

624
00:48:19,090 --> 00:48:23,210
[Hardison] అవును. సరిగ్గా. అది ఖాళీ చేస్తే మీరు స్టాక్ బయటకు ఏదైనా పాప్ కాదు.

625
00:48:23,210 --> 00:48:26,510
అది ఖాళీ ఉంటే అలాగే, మీరు ఒక వరుస నుంచి ఏదైనా dequeue కాదు.

626
00:48:26,510 --> 00:48:30,420
మేము ఇక్కడ మా dequeue ఫంక్షన్ చెయ్యాలి మొదటి విషయం ఏమిటి, మీరు అనుకుంటున్నారు?

627
00:48:30,420 --> 00:48:33,860
[సాద్] పరిమాణం 0 కన్నా ఎక్కువ ఉంటే? >> అవును.

628
00:48:33,860 --> 00:48:37,710
ఈ సందర్భంలో, నేను నిజానికి ఇది 0 ఉంటే చూడటానికి పరీక్షించి.

629
00:48:37,710 --> 00:48:42,240
అది 0 అయితే, మేము శూన్య తిరిగి రావచ్చు.

630
00:48:42,240 --> 00:48:45,280
కానీ ఖచ్చితమైన ఇదే తర్కం.

631
00:48:45,280 --> 00:48:49,110
మరియు యొక్క ఈ తో చెయ్యనివ్వండి.

632
00:48:49,110 --> 00:48:54,600
పరిమాణం 0 కాకపోతే, మేము dequeue చేయదలిచిన మూలకం ఎక్కడ ఉంది?

633
00:48:54,600 --> 00:48:58,550
[సాద్] తలపై? ఖచ్చితంగా >>.

634
00:48:58,550 --> 00:49:01,720
మేము మా క్యూ లో మొదటి మూలకం లో అక్కడ చేయవచ్చు

635
00:49:01,720 --> 00:49:07,040
తల వద్ద మూలకం ప్రాప్తి చేయడం ద్వారా.

636
00:49:07,040 --> 00:49:14,630
క్రేజీ ఏమీ లేదు.

637
00:49:14,630 --> 00:49:19,620
తరువాత, మనం ఏమి చెయ్యాలి? ఏమి ఉంటుంది?

638
00:49:19,620 --> 00:49:23,740
మేము dequeue లో మాట్లాడారు ఇతర విషయం ఏమిటి?

639
00:49:23,740 --> 00:49:28,130
మా క్యూ మారింది ఎందుకంటే రెండు విషయాలు, ఏమి ఉన్నాయి.

640
00:49:28,130 --> 00:49:35,640
[డేనియల్] పరిమాణాన్ని తగ్గించండి. >> మేము పరిమాణం తగ్గిస్తుంది, మరియు తల పెంచడానికి ఉందా? సరిగ్గా.

641
00:49:35,640 --> 00:49:40,600
తల పెంచడానికి, మేము గుడ్డిగా గుర్తుంచుకోండి తల పెరగదు.

642
00:49:40,600 --> 00:49:45,080
మేము queue.head లాగే కాదు + +.

643
00:49:45,080 --> 00:49:51,630
మేము కూడా సామర్థ్యం ద్వారా ఈ mod ఉన్నాయి ఉంటుంది.

644
00:49:51,630 --> 00:49:54,740
ఎందుకు మేము, సామర్థ్యం ద్వారా స్టెల్లా MoD చెయ్యాలి?

645
00:49:54,740 --> 00:49:58,680
[స్టెల్లా] ఇది చుట్టూ కలిగి ఉంటుంది. ఖచ్చితంగా >>.

646
00:49:58,680 --> 00:50:04,750
సామర్థ్యం ద్వారా మేము mod అది 0 to చుట్టూ తిరిగి మూసివేయాలని ఎందుకంటే.

647
00:50:04,750 --> 00:50:07,400
కాబట్టి ఇప్పుడు, ఈ సమయంలో, మేము డేనియల్ మాట్లాడుతూ చేయవచ్చు.

648
00:50:07,400 --> 00:50:12,700
మేము పరిమాణం తరుగుదల ఉంటుంది.

649
00:50:12,700 --> 00:50:29,170
మరియు తర్వాత మేము క్యూ ఎగువన అని మూలకం తిరిగి రావచ్చు.

650
00:50:29,170 --> 00:50:34,000
ఇది మొదటి వద్ద gnarly రకమైన కనిపిస్తోంది. మీరు ఒక ప్రశ్న కలిగి ఉండవచ్చు. క్షమించాలి?

651
00:50:34,000 --> 00:50:37,260
>> [సామ్] ఎందుకు క్యూ ఎగువన మొదటి ఏమిటి? ఆ గడిచిపోయింది?

652
00:50:37,260 --> 00:50:42,480
[Hardison] ఇది కింది నుంచి నాలుగో నుండి వస్తుంది.

653
00:50:42,480 --> 00:50:46,060
మేము మా క్యూ, ఖాళీగా లేదు నిర్ధారించుకోండి పరీక్ష తరువాత

654
00:50:46,060 --> 00:50:54,100
మేము మొదటి చార్ * లో అక్కడ, మేము తల సూచిక వద్ద కూర్చొని చేసే మూలకం వెలికితీసి

655
00:50:54,100 --> 00:50:58,680
మా శ్రేణి యొక్క, మా తీగలను అర్రే, >> మరియు కాల్ మొదటి యొక్క?

656
00:50:58,680 --> 00:51:04,500
[Hardison] మరియు ఇది మొదటి కాల్. అవును.

657
00:51:04,500 --> 00:51:09,850
ఆ న అనుసరించాల్సి, ఎందుకు మీరు మేము అలా వచ్చింది అనుకుంటున్నారు?

658
00:51:09,850 --> 00:51:18,270
[సామ్] ప్రతి మొదటి కేవలం q.strings తిరిగి [q.head]? >> అవును.

659
00:51:18,270 --> 00:51:23,830
>> మేము mod ఫంక్షన్ తో q.head ఈ మారుతున్న చేస్తున్నా కాబట్టి,

660
00:51:23,830 --> 00:51:27,810
మరియు కూడా తిరిగి లైన్ లో ఆ విధంగా చేయడానికి మార్గమే లేదు.

661
00:51:27,810 --> 00:51:31,640
[Hardison] ఖచ్చితంగా. మీరు స్పాట్ ఉన్నారు. సామ్ పూర్తిగా న గుర్తు.

662
00:51:31,640 --> 00:51:36,800
మేము మా క్యూ లో మొదటి మూలకం బయటకు లాగి వేరియబుల్ గా నిల్వ వచ్చింది కారణం

663
00:51:36,800 --> 00:51:43,030
మేము ఈ లైన్ q.head చేసిన ఎందుకంటే, ఉంది

664
00:51:43,030 --> 00:51:47,030
అక్కడ లో mod ఆపరేటర్లు మేము విషయం లేదు యొక్క

665
00:51:47,030 --> 00:51:51,230
మరియు అది లేకుండా తలపై ప్రభావితం చేసిన - ఒక లైన్ లో.

666
00:51:51,230 --> 00:51:54,480
మేము నిజంగా మొదటి మూలకం తీసివేస్తామని కలిగి ఉంటారు, అప్పుడు, తల సర్దుబాటు

667
00:51:54,480 --> 00:52:00,430
పరిమాణం సర్దుబాటు, మరియు అప్పుడు మేము వైదొలగిన ఆ మూలకం తిరిగి.

668
00:52:00,430 --> 00:52:02,680
మరియు ఈ మేము తరువాత ఆలోచన చూస్తారు విషయం

669
00:52:02,680 --> 00:52:04,920
లింక్ జాబితాలు, మేము వారితో చుట్టూ ప్లే వంటి.

670
00:52:04,920 --> 00:52:08,410
మీరు లింక్ జాబితాలు యొక్క విడుదల లేదా పారవేయడం చేస్తున్న ఎక్కువగా

671
00:52:08,410 --> 00:52:13,500
మీరు తదుపరి మూలకం, అనుబంధ జాబితా యొక్క తదుపరి పాయింటర్ గుర్తుంచుకోవాల్సిన అవసరం

672
00:52:13,500 --> 00:52:16,330
ప్రస్తుత ఒక పారవేసేందుకు ముందు.

673
00:52:16,330 --> 00:52:23,580
ఎందుకంటే లేకపోతే మీరు జాబితాలో వదిలి ఏది సమాచారం తీసివేసినట్లు.

674
00:52:23,580 --> 00:52:34,160
మీరు మీ ఉపకరణం వెళ్ళండి ఉంటే ఇప్పుడు, మీరు ఈ యొక్క queue.c--x అవుట్ అప్ తెరవండి.

675
00:52:34,160 --> 00:52:39,390
నేను queue.c ప్రారంభం చేస్తే, ఇక్కడ నాకు జూమ్ తెలియజేయండి

676
00:52:39,390 --> 00:52:44,970
మీరు ఒక ఒకేలా కనిపించే ఫైలు కలిగి చూస్తారు.

677
00:52:44,970 --> 00:52:49,200
మేము stack.c తో క్రితం ఏమి సారూప్య ఫైలు.

678
00:52:49,200 --> 00:52:54,690
మేము స్లయిడ్లను చూసిన వంటి కేవలం నిర్వచించిన క్యూ కోసం మా struct పొందారు.

679
00:52:54,690 --> 00:52:59,870
>> మేము మీరు కోసం ఇది మా ఎన్క్యూ చర్య.

680
00:52:59,870 --> 00:53:04,340
మరియు మేము ఇక్కడ dequeue చర్య.

681
00:53:04,340 --> 00:53:06,870
ఫైల్ లో dequeue ఫంక్షన్ అమలు కాలేదు ఉంది,

682
00:53:06,870 --> 00:53:13,230
మీరు కావాలనుకుంటే మీరు, లో టైపు చేయవచ్చు అయితే నేను PowerPoint తిరిగి ఏర్పాటు చేస్తాము.

683
00:53:13,230 --> 00:53:16,690
తరువాత 5 నిమిషాలు లేదా, మీరు అబ్బాయిలు ఎన్క్యూ పని

684
00:53:16,690 --> 00:53:22,570
ఇది దాదాపుగా dequeue వ్యతిరేకం.

685
00:53:22,570 --> 00:53:29,560
మీరు enqueueing చేసినప్పుడు తల సర్దుబాటు లేదు, కానీ మీరు సర్దుబాటు చెయ్యాలి?

686
00:53:29,560 --> 00:53:38,920
సైజు. కాబట్టి మీరు ఎన్క్యూ, తల బాధింపబడని ఉంటాయి ఉన్నప్పుడు, పరిమాణం మార్చబడింది తీర్చుకుంటాడు.

687
00:53:38,920 --> 00:53:46,920
అయితే కొంత సమయం పడుతుంది - మీరు ఆ mod తో చుట్టూ ప్లే ఉంటుంది

688
00:53:46,920 --> 00:53:57,560
కొత్త మూలకం వద్ద చొప్పించడానికి ఏ ఇండెక్స్ సరిగ్గా గుర్తించడానికి.

689
00:53:57,560 --> 00:54:03,080
నేను మీరు అబ్బాయిలు కొద్దిగా ఇస్తాము,, స్లయిడ్ తిరిగి అప్ dequeue ఉంచండి

690
00:54:03,080 --> 00:54:05,200
మరియు మీరు అబ్బాయిలు ప్రశ్నలు ఉంటే, తద్వారా మేము వాటిని అరవండి

691
00:54:05,200 --> 00:54:09,220
సమూహం వంటి వాటి గురించి అన్ని చర్చ.

692
00:54:09,220 --> 00:54:13,960
అలాగే, మీరు don't పరిమాణం తో - మీరు పరిమాణం సర్దుబాటు చేసినప్పుడు, మీరు ఎల్లప్పుడూ కాదు -

693
00:54:13,960 --> 00:54:18,720
మీరు పరిమాణం అంటే ఉన్నాయి? [డేనియల్] నం >> మీరు పరిమాణం MoD హక్కు లేదు.

694
00:54:18,720 --> 00:54:24,260
You're ఉంటే ఎందుకంటే పరిమాణం ఎల్లప్పుడూ ఉంటుంది - ఊహిస్తూ మీరు, తగిన విషయాలు మేనేజింగ్ చేస్తున్నారు

695
00:54:24,260 --> 00:54:30,840
పరిమాణం ఎల్లప్పుడూ 0 మరియు 3 మధ్య ఉంటుంది.

696
00:54:30,840 --> 00:54:38,680
ఎక్కడ మీరు ఎన్క్యూ చేయడం చేసినప్పుడు అంటే ఉన్నాయి?

697
00:54:38,680 --> 00:54:41,060
కేవలం తల [స్టూడెంట్]. కేవలం తల >>, సరిగ్గా.

698
00:54:41,060 --> 00:54:44,620
మీరు ఎందుకు ఎన్క్యూ అన్ని వద్ద MoD చేయాలి?

699
00:54:44,620 --> 00:54:48,830
మీరు అంటే కలిగి కోరుతున్న పరిస్థితి ఏమిటి?

700
00:54:48,830 --> 00:54:53,630
మీరు ప్రదేశాలలో stuff ఉంటే [స్టూడెంట్],, స్పేస్ 1 మరియు 2 వద్ద ఇష్టం

701
00:54:53,630 --> 00:54:55,950
మరియు తర్వాత మీరు 0 వద్ద ఏదో జోడించడానికి అవసరం.

702
00:54:55,950 --> 00:55:02,570
[Hardison] అవును, సరిగ్గా. మీ తల పాయింటర్ చివరిలో ఉంది కనుక

703
00:55:02,570 --> 00:55:14,210
లేదా మీ పరిమాణం అదనంగా మీ తల పెద్ద ఉంటే, లేదా, క్యూ చుట్టూ అన్నారు.

704
00:55:14,210 --> 00:55:17,830
>> కాబట్టి మేము ఇప్పుడు స్లయిడ్ న ఇక్కడ పొందారు ఈ పరిస్థితిలో,

705
00:55:17,830 --> 00:55:24,370
నేను, ప్రస్తుతం ఏదో ఎన్క్యూ అనుకుంటే

706
00:55:24,370 --> 00:55:31,110
మేము ఇండెక్స్ 0 వద్ద ఏదో ఎన్క్యూ మీరు.

707
00:55:31,110 --> 00:55:35,450
మీరు 50 వెళతాడు, అక్కడ చూడండి, మరియు నేను ఎన్క్యూ 50, కాల్ అయితే

708
00:55:35,450 --> 00:55:40,840
ఇది క్రింది వద్ద పని చెయ్యకపోతే. ఇది ఇండెక్స్ 0 వెళుతుంది.

709
00:55:40,840 --> 00:55:44,160
ఇది ఇప్పటికే dequeued ఆ 'హాయ్' తొలగించబడుతాయి.

710
00:55:44,160 --> 00:55:46,210
[డేనియల్] మీరు ఇప్పటికే dequeue ఆ యొక్క శ్రద్ధ వహించడానికి లేదా?

711
00:55:46,210 --> 00:55:50,550
ఎందుకు అది ఎన్క్యూ లో తల తో ఏదైనా చేస్తుంది?

712
00:55:50,550 --> 00:55:55,770
[Hardison] ఓహ్, కాబట్టి మీరు తల సవరించుట లేదు, క్షమించండి.

713
00:55:55,770 --> 00:56:02,310
కానీ మీరు ఆక్సెస్ చేసినప్పుడు mod ఆపరేటర్లు ఉపయోగించాలి

714
00:56:02,310 --> 00:56:04,250
మీరు ఆక్సెస్ చేసినప్పుడు ఎన్క్యూ చేయదలిచిన మూలకం

715
00:56:04,250 --> 00:56:06,960
మీ క్రమంలో తరువాతి మూలకం.

716
00:56:06,960 --> 00:56:10,960
[బాసిల్] నేను లేదు, మరియు నేను అక్కడ న "విజయం" వచ్చింది.

717
00:56:10,960 --> 00:56:13,370
[డేనియల్] ఓహ్, నేను మీరు ఏమి చెబుతున్నారో అర్థం.

718
00:56:13,370 --> 00:56:16,240
[Hardison] కాబట్టి మీరు didn't - మీరు q.size వద్ద చేశాడు?

719
00:56:16,240 --> 00:56:20,670
[బాసిల్] అవును. నేను మారుతాయి, నేను తల తో ఏమీ చేయలేదు.

720
00:56:20,670 --> 00:56:24,300
[Hardison] మీరు నిజంగా, ఏమీ తల రీసెట్ లేదు

721
00:56:24,300 --> 00:56:31,650
కానీ తీగలను శ్రేణి లోకి మీరు ఇండెక్స్,

722
00:56:31,650 --> 00:56:39,500
మీరు నిజంగా, ముందుకు వెళ్ళి, తరువాత మూలకం ఉన్న లెక్కించేందుకు కలిగి

723
00:56:39,500 --> 00:56:44,230
స్టాక్ withe ఎందుకంటే, మీ స్టాక్ తదుపరి మూలకం ఎప్పుడూ

724
00:56:44,230 --> 00:56:48,740
పరిమాణం సంబంధించి సూచిక వద్ద.

725
00:56:48,740 --> 00:56:55,850
మేము అప్ మా స్టాక్ పుష్ ఫంక్షన్ తిరిగి చూడాలని, ఉంటే

726
00:56:55,850 --> 00:57:03,100
మేము ఎల్లప్పుడూ సరైన సూచిక పరిమాణంలో మా కొత్త మూలకం లో plunk కాలేదు.

727
00:57:03,100 --> 00:57:06,710
క్యూ తో అయితే, మేము అలా కాదు

728
00:57:06,710 --> 00:57:10,340
మేము ఈ పరిస్థితి ఉన్నప్పుడు ఎందుకంటే,

729
00:57:10,340 --> 00:57:18,130
మేము వరుసలో ఉంటే 50 మా కొత్త స్ట్రింగ్ తీగలను [1] వద్ద కుడి పాటు

730
00:57:18,130 --> 00:57:20,540
ఇది నాకు ఇష్టం లేదు.

731
00:57:20,540 --> 00:57:41,200
మేము కొత్త స్ట్రింగ్ సూచిక 0 వద్ద వెళ్ళి కావాలి.

732
00:57:41,200 --> 00:57:44,320
>> డజ్ ఎవరైనా - అవును? [స్టూడెంట్] నేను ఒక ప్రశ్న కలిగి కానీ నిజంగా సంబంధించిన కాదు.

733
00:57:44,320 --> 00:57:48,160
ఎవరో ఇప్పుడే pred పాయింటర్ లాగ కాల్స్ అది అర్థం ఏమిటి?

734
00:57:48,160 --> 00:57:51,260
ఆ పేరు ఏమిటి కోసం చిన్న ఉంది? అది కేవలం ఒక పేరు నాకు తెలుసు.

735
00:57:51,260 --> 00:57:59,110
[Hardison] Pred పాయింటర్? యొక్క చూసేలా. ఏ సందర్భంలో?

736
00:57:59,110 --> 00:58:01,790
[స్టూడెంట్] చొప్పించు కోసం ఇది. మీరు అనుకుంటే నేను తరువాత మీరు అడగవచ్చు

737
00:58:01,790 --> 00:58:03,920
అది నిజంగా సంబంధించిన కాదు, అయితే నేను ఎందుకంటే -

738
00:58:03,920 --> 00:58:07,300
[Hardison] ఉపన్యాసం నుండి డేవిడ్ యొక్క ఇన్సర్ట్ కోడ్ నుండి?

739
00:58:07,300 --> 00:58:10,860
మేము ఆ పుల్ అప్ మరియు దాని గురించి మాట్లాడవచ్చు.

740
00:58:10,860 --> 00:58:15,550
మేము ఆ తర్వాత, ఒకసారి మేము అనుసంధాన జాబితాలు ను గురించి మాట్లాడదాము.

741
00:58:15,550 --> 00:58:21,440
>> కాబట్టి ఎన్క్యూ ఫంక్షన్ ఎలా చూడండి నిజంగా త్వరగా చూద్దాం.

742
00:58:21,440 --> 00:58:26,530
మీ ఎన్క్యూ లైన్ లో చేయడానికి ప్రయత్నించిన మొదటి విషయం ఏమిటి? ఈ క్యూ లోకి?

743
00:58:26,530 --> 00:58:29,960
మీరు నెట్టడం స్టాక్ కోసం ఏమి పోలి.

744
00:58:29,960 --> 00:58:32,080
మీరు స్టెల్లా, ఏం చేసావ్?

745
00:58:32,080 --> 00:58:35,050
[స్టెల్లా, అపారదర్శక]

746
00:58:35,050 --> 00:58:45,700
[Hardison] ఖచ్చితంగా. (== సామర్థ్యం q.size) ఉంటే -

747
00:58:45,700 --> 00:58:54,720
నేను స్థానంలో నా జంట కలుపులు ఉంచాలి - తప్పుడు తిరిగి.

748
00:58:54,720 --> 00:59:01,370
కొద్ది సేపట్లో జూమ్. సరే.

749
00:59:01,370 --> 00:59:03,800
ఇప్పుడు మేము వచ్చింది తర్వాత విషయం ఏమిటి?

750
00:59:03,800 --> 00:59:11,370
జస్ట్ స్టాక్ వలె, మరియు సరైన స్థలం వద్ద చేర్చబడుతుంది.

751
00:59:11,370 --> 00:59:16,010
అందువలన, ఇన్సర్ట్ చెయ్యడానికి సరైన స్థలం ఏమిటి?

752
00:59:16,010 --> 00:59:23,170
స్టాక్ తో అది లేదు చాలా ఆ ఈ తో, ఇండెక్స్ పరిమాణంలో.

753
00:59:23,170 --> 00:59:30,210
[డేనియల్] నేను q.head--లేదా - >> q.strings? >> అవును.

754
00:59:30,210 --> 00:59:40,470
q.strings [q.head + q.size mod సామర్థ్యం]?

755
00:59:40,470 --> 00:59:42,740
[Hardison] మేము ఈ చుట్టూ కుండలీకరణాలు ఉంచాలి కావలసిన

756
00:59:42,740 --> 00:59:48,830
మేము దారుణంగా cleart, అందుచే తగిన ప్రాధాన్యత పొందడం మరియు మీరు కనుక.

757
00:59:48,830 --> 00:59:55,800
మరియు సమాన సెట్? STR చేయడానికి >>? STR చేయడానికి >>. గ్రేట్.

758
00:59:55,800 --> 01:00:00,160
ఇప్పుడు మేము కలిగి లాస్ట్ థింగ్ ఏది?

759
01:00:00,160 --> 01:00:06,780
మేము స్టాక్ లో చేసినట్లుగా ఇష్టపడుతున్నారు. >> పరిమాణం పెంచడం? >> పరిమాణం పెంచడం.

760
01:00:06,780 --> 01:00:13,830
బూం. ఆపై, స్టార్టర్ కోడ్ నుండి కేవలం అప్రమేయంగా తప్పుడు తిరిగి

761
01:00:13,830 --> 01:00:27,460
మేము అన్ని గుండా వెళుతుంది మరియు అన్ని బాగా పోతే నిజమైన ఈ మార్చడానికి కావలసిన.

762
01:00:27,460 --> 01:00:33,050
అన్ని కుడి. ఆ విభాగానికి సమాచారం చాలా ఉంది.

763
01:00:33,050 --> 01:00:39,480
మేము చాలా పైగా లేదు. మేము ఒక్కొక్కటిగా లింక్డ్ జాబితాలు గురించి నిజంగా త్వరగా మాట్లాడు.

764
01:00:39,480 --> 01:00:44,010
నేను ఈ ఏర్పాటు చేస్తాము కనుక మేము తరువాత తిరిగి వెళ్ళవచ్చు.

765
01:00:44,010 --> 01:00:50,850
కానీ ఇంకా కొన్ని స్లయిడ్లను కోసం మా ప్రదర్శనను తిరిగి వదలి వేస్తారు.

766
01:00:50,850 --> 01:00:53,790
కాబట్టి ఎన్క్యూ TODO ఉంది, ఇప్పుడు మేము చేశాను.

767
01:00:53,790 --> 01:00:57,430
>> ఇప్పుడు ఒక్కొక్కటిగా లింక్డ్ జాబితాలు పరిశీలించి అనుమతిస్తుంది.

768
01:00:57,430 --> 01:01:00,040
మేము ఉపన్యాసంలో ఈ కొద్దిగా ఎక్కువ మాట్లాడారు.

769
01:01:00,040 --> 01:01:02,540
ప్రజలు కలిగి ఉన్న ఎన్ని మీరు guys యొక్క డెమో చూసిన

770
01:01:02,540 --> 01:01:08,220
వికారంగా ప్రతి ఇతర మరియు హోల్డింగ్ సంఖ్యలు సూచించే? >> నాకు ఉంది.

771
01:01:08,220 --> 01:01:16,620
>> మీరు అబ్బాయిలు ఏమనుకుంటున్నారు? అది, ఆశాజనక ఈ కొద్దిగా demystify?

772
01:01:16,620 --> 01:01:25,990
జాబితాను, అది మనం ఒక నోడ్ కాల్ చూడాలని ఉద్దేశ్యంతో ఈ రకం వ్యవహరించే అవుతుంది.

773
01:01:25,990 --> 01:01:32,520
క్యూ మరియు స్టాక్ తో అయితే మేము, మేము స్టాక్ లో క్యూ కాల్ భావిస్తున్నట్టు structs కలిగి

774
01:01:32,520 --> 01:01:34,860
మేము, స్టాక్ రకాల ఈ కొత్త క్యూ కలిగి

775
01:01:34,860 --> 01:01:39,240
ఇక్కడ ఒక జాబితా నిజంగా కేవలం నోడ్స్ యొక్క బంచ్ రూపొందించబడింది.

776
01:01:39,240 --> 01:01:45,920
తీగలను అక్షరాలు కేవలం కొంత అని అదే విధంగా అన్ని ప్రతి ఇతర పక్కన అతను ఆడాడు.

777
01:01:45,920 --> 01:01:50,650
అనుబంధ జాబితా ఒక నోడ్ మరియు మరొక నోడ్ మరియు మరొక నోడ్ మరియు మరొక నోడ్ ఉంది.

778
01:01:50,650 --> 01:01:55,080
మరియు బదులుగా కలిసి అన్ని ముక్కలు నోడ్స్ మరియు పక్కపక్కన వాటిని నిల్వ కంటే

779
01:01:55,080 --> 01:01:58,090
మెమరీ ప్రతి ఇతర హక్కు అన్ని తరువాత,

780
01:01:58,090 --> 01:02:04,470
ఈ తదుపరి పాయింటర్ కలిగి మాకు యాదృచ్ఛికంగా, నోడ్స్ ఎక్కడ నిల్వ అనుమతిస్తుంది.

781
01:02:04,470 --> 01:02:10,500
ఆపై WIRE రకం వాటిని అన్ని కలిసి ఒక నుంచి మరో మార్చాలి.

782
01:02:10,500 --> 01:02:15,850
>> మరియు ఈ వ్యూహం కలిగి పెద్ద ప్రయోజనం?

783
01:02:15,850 --> 01:02:21,680
నిల్వ అన్నిచోట్ల పక్కపక్కన కేవలం ఒకదాని తరువాత కష్టం?

784
01:02:21,680 --> 01:02:24,190
మీరు గుర్తు? Yeah? >> డైనమిక్ మెమరీ కేటాయింపు?

785
01:02:24,190 --> 01:02:27,220
ఏ కోణంలో >> డైనమిక్ మెమరీ కేటాయింపు?

786
01:02:27,220 --> 01:02:31,780
మీరు అది పెద్ద మరియు మీరు మీ మొత్త తరలించడానికి లేదు తయారు ఉంచుకోవచ్చు ఆ [స్టూడెంట్]?

787
01:02:31,780 --> 01:02:40,940
[Hardison] ఖచ్చితంగా. కాబట్టి వ్యూహం తో, మీరు దాని మధ్య ఒక కొత్త మూలకం ఉంచేందుకు ఉంటుంది,

788
01:02:40,940 --> 01:02:45,320
మీరు స్థలాన్ని ప్రతిదీ మార్చేందుకు ఉన్నాయి.

789
01:02:45,320 --> 01:02:47,880
మరియు వంటి మేము, క్యూ తో మాట్లాడారు

790
01:02:47,880 --> 01:02:50,080
మేము ఆ తల పాయింటర్ ఉంచడానికి ఎందుకు ఆ,

791
01:02:50,080 --> 01:02:52,050
మేము నిరంతరం విషయాలు బదిలీ లేదు కాబట్టి.

792
01:02:52,050 --> 01:02:54,520
మీరు ఒక పెద్ద అర్రే పొందారు ఉంటే ఆ ఖరీదైన గెట్స్ ఎందుకంటే

793
01:02:54,520 --> 01:02:57,130
మరియు మీరు ఎప్పుడు ఈ యాదృచ్చిక ప్రక్షిప్తాలు చేయుచున్నారు.

794
01:02:57,130 --> 01:03:00,820
జాబితాను అయితే, మీరు చేయాల్సిందల్లా, ఒక కొత్త నోడ్ మీద త్రో ఉంది

795
01:03:00,820 --> 01:03:06,330
గమనికలు సర్దుబాటు, మరియు మీరు పూర్తి చేసిన.

796
01:03:06,330 --> 01:03:10,940
ఈ గురించి సక్స్?

797
01:03:10,940 --> 01:03:16,830
మరోప్రక్క అది వ్యూహం పని చేయడం సులభం కాదు వాస్తవం నుంచి? Yeah?

798
01:03:16,830 --> 01:03:22,980
[డేనియల్] Well, నేను లింక్ జాబితాలో ఒక ప్రత్యేక ఎలిమెంట్ యాక్సెస్ చాలా కష్టం ఊహించడానికి?

799
01:03:22,980 --> 01:03:30,470
[Hardison] మీరు మీ లింక్ జాబితా మధ్యలో ఏకపక్ష మూలకం వెళ్లగలదు కాదు.

800
01:03:30,470 --> 01:03:33,800
ఎలా మీరు బదులుగా దీన్ని ఎందుకు చేయాలి? మీరు మొత్తం విషయం ద్వారా అడుగు కలిగి >>.

801
01:03:33,800 --> 01:03:35,660
[Hardison] అవును. మీరు ఒక సమయంలో ఒక, ఒక సమయంలో ఒక ద్వారా వెళ్ళాలి.

802
01:03:35,660 --> 01:03:38,480
ఇది ఒక భారీ - అది ఒక బాధాకరమైన వ్యక్తి.

803
01:03:38,480 --> 01:03:41,550
ఇతర ఏమిటి - ఈ మరొక దురదృష్టం ఉంది.

804
01:03:41,550 --> 01:03:45,340
[బాసిల్] మీరు ముందుకు మరియు వెనక్కి వెళ్ళి కాదు? మీరు ఒక దిశలో వెళ్ళాలి?

805
01:03:45,340 --> 01:03:48,570
[Hardison] అవును. కాబట్టి మేము ఎలా కొన్నిసార్లు, ఆ పరిష్కారం లేదు?

806
01:03:48,570 --> 01:03:53,370
[బాసిల్] జాబితాలు రెట్టింపైన-లింక్? ఖచ్చితంగా >>. రెట్టింపైన-లింక్ జాబితాలు ఉన్నాయి.

807
01:03:53,370 --> 01:03:55,540
కూడా ఉన్నాయి - క్షమించాలి?

808
01:03:55,540 --> 01:03:57,620
>> [సామ్] ఆ pred విషయం ఉపయోగించి కూడా లేదు -

809
01:03:57,620 --> 01:04:01,090
నేను జ్ఞాపకం, pred విషయం కోసం అదే కాదు?

810
01:04:01,090 --> 01:04:05,850
కాదు రెట్టింపైన మరియు ఒక్కొక్కటిగా మధ్య?

811
01:04:05,850 --> 01:04:10,020
తాను చేస్తున్న సరిగ్గా అదే సమయంలో [Hardison] లెట్స్ లుక్.

812
01:04:10,020 --> 01:04:15,760
కాబట్టి ఇక్కడ వెళ్ళండి. ఇక్కడ జాబితా కోడ్ యొక్క.

813
01:04:15,760 --> 01:04:25,620
ఇక్కడ మేము ఇక్కడ, predptr ఉన్నాయి. మీరు గురించి మాట్లాడుతూ ఈ ఉంది?

814
01:04:25,620 --> 01:04:30,750
కాబట్టి ఈ ఉన్నారు - ఇందులో జాబితా విడుదల చేసిన మరియు అతను అది ఒక పాయింటర్ నిల్వ ప్రయత్నిస్తున్నాడు.

815
01:04:30,750 --> 01:04:35,000
ఈ రెట్టింపైన, ఒక్కొక్కటిగా లింక్-జాబితాలు కాదు.

816
01:04:35,000 --> 01:04:40,090
ఈ మాట్లాడుతున్నారో నుండి మేము జాబితా విడుదల గురించి తరువాత దీని గురించి మరింత మాట్లాడవచ్చు

817
01:04:40,090 --> 01:04:42,900
మరియు నేను మొదటి కొన్ని ఇతర అంశాలు చూపాలనుకుంటున్న.

818
01:04:42,900 --> 01:04:51,480
కానీ అది కేవలం - అది PTR విలువ గుర్తు యొక్క

819
01:04:51,480 --> 01:04:54,170
[స్టూడెంట్] ఓహ్, ఇది preceeding పాయింటర్ ఉంది? >> అవును.

820
01:04:54,170 --> 01:05:04,070
మేము అప్పుడు predptr ఉంది అప్పుడు ఉచిత ముందు PTR కూడా పెంచడం చేయవచ్చు.

821
01:05:04,070 --> 01:05:09,130
మేము అప్పుడు ఉచిత PTR మరియు కాల్ PTR = PTR తరువాత, కుడి? కాదు ఎందుకంటే

822
01:05:09,130 --> 01:05:11,260
ఆ చెడు ఉంటుంది.

823
01:05:11,260 --> 01:05:20,940
కాబట్టి ఈ గై కు, యొక్క చూసేలా.

824
01:05:20,940 --> 01:05:23,900
>> జాబితాలు గురించి ఇతర చెడ్డ విషయం అని వ్యూహం తో అయితే

825
01:05:23,900 --> 01:05:26,520
మేము, తాము ప్రతి ఇతర పక్కన అమర్చినట్లు అన్ని మూలకాలు

826
01:05:26,520 --> 01:05:29,050
ఇక్కడ మేము కూడా ఈ పాయింటర్ ప్రవేశపెట్టారు.

827
01:05:29,050 --> 01:05:34,060
కాబట్టి మేము ఉపయోగించడానికి సమస్య ఆ మెమరీ అదనపు భాగం ఉంది

828
01:05:34,060 --> 01:05:37,910
మేము మా జాబితాలో నిల్వ చేస్తున్న ప్రతి మూలకం కోసం.

829
01:05:37,910 --> 01:05:40,030
మేము వశ్యత పొందుతారు కాని అది ఖర్చుతో వస్తుంది.

830
01:05:40,030 --> 01:05:42,230
ఇది ఈ సమయం ధర వస్తుంది

831
01:05:42,230 --> 01:05:45,270
మరియు ఇది చాలా ఈ మెమరీ ధర వస్తుంది.

832
01:05:45,270 --> 01:05:47,800
మేము ఇప్పుడు యెరే నందలి ప్రతి మూలకం ద్వారా వెళ్ళాలి కోణంలో సమయం

833
01:05:47,800 --> 01:05:58,670
ఇండెక్స్ 10 వద్ద ఒకటి, లేదా ఆ వ్యూహంలో ఇండెక్స్ 10 ఉండేది కనుగొనేందుకు.

834
01:05:58,670 --> 01:06:01,230
>> జస్ట్ నిజంగా త్వరగా, మేము రేఖాచిత్రం ఈ జాబితాలు,

835
01:06:01,230 --> 01:06:05,980
సాధారణంగా మేము జాబితా యొక్క తల లేదా జాబితా యొక్క మొదటి పాయింటర్ పట్టు

836
01:06:05,980 --> 01:06:08,010
మరియు ఈ నిజమైన పాయింటర్ గా గమనించండి.

837
01:06:08,010 --> 01:06:11,100
ఇది కేవలం 4 బైట్లు ఉంది. ఇది ఒక వాస్తవ నోడ్ కూడా కాదు.

838
01:06:11,100 --> 01:06:17,120
కాబట్టి మీరు ఇది ఏ Int విలువ, అది రాబోయే పాయింటర్ కలిగి చూడండి.

839
01:06:17,120 --> 01:06:20,790
ఇది అక్షరాలా ఒక పాయింటర్ ఉంది.

840
01:06:20,790 --> 01:06:23,550
ఇది ఒక వాస్తవ నోడ్ struct అని ఏదో సూచించడానికి జరగబోతోంది.

841
01:06:23,550 --> 01:06:28,480
[సామ్] కణుపు అని పిలిచే ఒక పాయింటర్? >> ఈ - ఏ. ఈ రకం నోడ్ యొక్క ఏదో ఒక పాయింటర్ ఉంది.

842
01:06:28,480 --> 01:06:32,540
ఇది ఒక నోడ్ struct ఒక పాయింటర్ ఉంది. >> ఓహ్, ఓకే.

843
01:06:32,540 --> 01:06:36,870
ఎడమ వైపున, కోడ్ న రేఖాచిత్రం.

844
01:06:36,870 --> 01:06:42,190
మేము ప్రారంభించడానికి ఒక మంచి మార్గం ఇది శూన్య, దానిని సెట్ చేయవచ్చు.

845
01:06:42,190 --> 01:06:49,850
మీరు రేఖాచిత్రం ఇది ఆ విధంగా మీరు గాని అది శూన్య వ్రాయండి లేదా మీరు ద్వారా లైన్ ఉంచండి.

846
01:06:49,850 --> 01:06:53,910
>> జాబితాలు పని సులభమైన మార్గాలు ఒకటి,

847
01:06:53,910 --> 01:06:57,430
మరియు మేము, మీరు రెండు prepend లేదు అడగండి రెండు మధ్య తేడాలు చూడటానికి జోడించు

848
01:06:57,430 --> 01:07:01,320
కానీ prepending ఖచ్చితంగా సులభం.

849
01:07:01,320 --> 01:07:05,790
పేరు మీరు prepend, ఈ ఉంది - మీరు prepend (7),

850
01:07:05,790 --> 01:07:10,050
మీరు నోడ్ struct వెళ్ళి సృష్టించడానికి

851
01:07:10,050 --> 01:07:13,870
మరియు మీరు, ఇప్పుడు మేము ఇది prepended నుండి, ఇది సూచించడానికి మొదటి సెట్

852
01:07:13,870 --> 01:07:17,240
ఇది జాబితా ప్రారంభంలో చేస్తాడు.

853
01:07:17,240 --> 01:07:22,540
మేము మరొక నోడ్ సృష్టిస్తుంది prepend (3), కానీ ఇప్పుడు 3 7 ముందు వస్తుంది ఉంటే.

854
01:07:22,540 --> 01:07:31,130
కాబట్టి మేము తప్పనిసరిగా మా జాబితా లో విషయాలను నెట్టడం చేస్తున్నారు.

855
01:07:31,130 --> 01:07:34,720
ఇప్పుడు, మీరు, prepend, కొన్నిసార్లు దీన్ని పుష్ కాల్ ఆ చూడగలరు

856
01:07:34,720 --> 01:07:39,600
ఎందుకంటే మీరు మీ జాబితా లో కొత్త మూలకం నెట్టడం చేస్తున్నారు.

857
01:07:39,600 --> 01:07:43,270
ఇది ఒక జాబితా ముందు వద్ద తొలగించడానికి కూడా సులభం.

858
01:07:43,270 --> 01:07:45,650
కాబట్టి ప్రజలు తరచుగా ఆ పాప్ కాల్ చేస్తుంది.

859
01:07:45,650 --> 01:07:52,200
ఆ విధంగా, మీరు ఒక లింక్ జాబితా ఉపయోగించి స్టాక్ అనుకరిస్తుంది.

860
01:07:52,200 --> 01:07:57,880
అయ్యో. క్షమించాలి, ఇప్పుడు మేము append లోకి చేస్తున్నారు. కాబట్టి ఇక్కడ మేము prepend (3) ఇప్పుడు, (7) prepended.

861
01:07:57,880 --> 01:08:02,600
మేము prepended మేము (4), ఈ జాబితా లో ఏదో prepended,

862
01:08:02,600 --> 01:08:06,540
అప్పుడు మేము 4 ఉంటాయి మరియు తరువాత 3 మరియు తరువాత 7 మీరు.

863
01:08:06,540 --> 01:08:14,220
కాబట్టి అప్పుడు మేము పాప్ మరియు తీసివేయి 3, 4 తొలగించండి, 7 తొలగించండి.

864
01:08:14,220 --> 01:08:16,500
తరచుగా ఈ ఆలోచించడానికి మరింత స్పష్టమైన మార్గం append తో ఉంది.

865
01:08:16,500 --> 01:08:20,310
నేను దాన్ని ఇక్కడ జోడించు తో వంటి చూస్తారు ఏమిటో రేఖాచిత్రించబడింది చేసిన.

866
01:08:20,310 --> 01:08:23,380
ఇక్కడ, అనుబంధంగా (7) ఏ వివిధ కనిపించడం లేదు

867
01:08:23,380 --> 01:08:25,160
ఎందుకంటే జాబితా మాత్రమే మూలకం ఉంది.

868
01:08:25,160 --> 01:08:28,620
మరియు అనుమతిస్తూ (3) చివరలో దానిని.

869
01:08:28,620 --> 01:08:31,020
బహుశా మీరు ప్రస్తుతం append తో ట్రిక్ చూడగలరు

870
01:08:31,020 --> 01:08:36,600
ఆ, జాబితా ప్రారంభం ఉన్న మేము మాత్రమే తెలుసు కాబట్టి

871
01:08:36,600 --> 01:08:39,450
మీరు జాబితా ద్వారా అన్ని మార్గం నడిచిన కలిగి జాబితాను జోడించే

872
01:08:39,450 --> 01:08:46,500
చివరికి ను ఆపడానికి, అప్పుడు మీ నోడ్ మరియు డౌన్ plunk ప్రతిదీ నిర్మించడానికి.

873
01:08:46,500 --> 01:08:50,590
అన్ని అంశాలను అప్ WIRE.

874
01:08:50,590 --> 01:08:55,170
కాబట్టి prepend తో, వంటి, మనం కేవలం నిజంగా త్వరగా ఈ ద్వారా ఆవిర్భవించినది

875
01:08:55,170 --> 01:08:58,170
మీరు ఒక జాబితాకు prepend, అది చాలా సులభం.

876
01:08:58,170 --> 01:09:02,960
>> మీరు మీ కొత్త నోడ్ తయారు, కొన్ని డైనమిక్ మెమరీ కేటాయింపు వంటివి.

877
01:09:02,960 --> 01:09:09,830
కాబట్టి ఇక్కడ malloc ఉపయోగించి ఒక నోడ్ struct మీరు చేస్తున్నారు.

878
01:09:09,830 --> 01:09:14,710
Malloc కాబట్టి ఆ తర్వాత మాకు మెమరీ పక్కన పెట్టింది చేస్తాము ఎందుకంటే ఇక్కడ

879
01:09:14,710 --> 01:09:20,350
మేము ఈ అనుకుంటున్న ఎందుకంటే - ఈ మెమరీ ఎక్కువ కాలం అంటిపెట్టుకుని మీరు.

880
01:09:20,350 --> 01:09:25,350
మరియు మేము కేవలం కేటాయింపుకు మెమరీలో స్పేస్ ఒక పాయింటర్ పొందండి.

881
01:09:25,350 --> 01:09:29,260
మేము నోడ్ యొక్క పరిమాణాన్ని ఉపయోగిస్తుంది, మేము ఖాళీలను సంకలనం లేదు.

882
01:09:29,260 --> 01:09:31,899
మేము మాన్యువల్గా, బైట్లు సంఖ్య ఉత్పత్తి లేదు

883
01:09:31,899 --> 01:09:39,750
బదులుగా మేము మేము బైట్లు సరైన సంఖ్య చేస్తున్నారు తెలుసు కాబట్టి sizeof ఉపయోగించండి.

884
01:09:39,750 --> 01:09:43,660
మేము మా malloc కాల్ విజయవంతమైన పరీక్షించడానికి నిర్ధారించుకోండి.

885
01:09:43,660 --> 01:09:47,939
మీరు సాధారణంగా చేయాలనుకుంటున్నారా విషయం.

886
01:09:47,939 --> 01:09:52,590
ఆధునిక యంత్రాల్లో, మెమరీ నడుస్తున్న సులభం విషయం కాదు

887
01:09:52,590 --> 01:09:56,610
మీరు stuff ఒక టన్ను పెడుతోంది మరియు భారీ జాబితా చేస్తున్న తప్ప,

888
01:09:56,610 --> 01:10:02,220
కానీ మీరు ఒక ఐఫోన్ లేదా ఒక Android వంటి సే,, విషయాలను నిర్మించడం చేస్తుంటే,

889
01:10:02,220 --> 01:10:05,230
మీరు తీవ్రమైన ఏదో చేస్తున్నా ముఖ్యంగా మీరు, పరిమిత మెమరీ వనరులు ఉన్నాయి.

890
01:10:05,230 --> 01:10:08,300
కాబట్టి ఆచరణలో పొందడానికి మంచి ఇది.

891
01:10:08,300 --> 01:10:10,510
>> నేను ఇక్కడ ఒక జంట వేర్వేరు విధులను ఉపయోగిస్తారు చేసిన గమనించండి

892
01:10:10,510 --> 01:10:12,880
మీరు కొత్త రకం అని చూసిన ఆ.

893
01:10:12,880 --> 01:10:15,870
కాబట్టి fprintf కేవలం printf వంటిది

894
01:10:15,870 --> 01:10:21,320
మొదటి వాదన తప్ప మీరు ముద్రించడానికి చేయండి స్ట్రీమ్ ఉంది.

895
01:10:21,320 --> 01:10:23,900
ఈ సందర్భంలో, మనం ప్రామాణిక తప్పు స్ట్రింగ్ ముద్రించవచ్చు మీరు

896
01:10:23,900 --> 01:10:29,410
ఇది ప్రామాణిక outstream భిన్నంగా ఉంటుంది.

897
01:10:29,410 --> 01:10:31,620
అప్రమేయంగా ఒకే స్థానంలో కనిపిస్తుంది.

898
01:10:31,620 --> 01:10:34,600
ఇది టెర్మినల్ కు ముద్రిస్తుంది, కానీ మీరు కాదు -

899
01:10:34,600 --> 01:10:38,790
ఆ ఆదేశాలను ఉపయోగించి మీరు గురించి, దారిమళ్ళింపు పద్ధతులు నేర్చుకున్నాడు

900
01:10:38,790 --> 01:10:42,290
మీరు సమస్య సెట్ 4 కోసం టామీ యొక్క వీడియో లో నేర్చుకున్న, మీరు ఇది ప్రత్యక్ష చేయవచ్చు

901
01:10:42,290 --> 01:10:47,900
వేర్వేరు ప్రాంతాల్లో; అప్పుడు నిష్క్రమిస్తుంది మీ ప్రోగ్రామ్, ఇక్కడ, నిష్క్రమించి.

902
01:10:47,900 --> 01:10:50,440
ఇది ప్రధాన నుండి తిరిగి వంటి తప్పనిసరిగా ఉంది

903
01:10:50,440 --> 01:10:53,600
ఇక్కడ తిరిగి ఏమీ లేదు ఎందుకంటే మేము నిష్క్రమణ ఉపయోగించడానికి తప్ప.

904
01:10:53,600 --> 01:10:57,140
మేము ప్రధాన లేదు, కాబట్టి తిరిగి మేము మీరు వంటి కార్యక్రమ నిష్క్రమించడానికి లేదు.

905
01:10:57,140 --> 01:11:03,020
కాబట్టి మేము నిష్క్రమణ క్రియాశీలతను ఉపయోగించదు మరియు ఇది ఒక లోపం కోడ్ ఇస్తుంది.

906
01:11:03,020 --> 01:11:11,890
ఇక్కడ మేము నేను సమానంగా కొత్త నోడ్ యొక్క విలువ రంగంలో, దాని i రంగంలో సెట్, మరియు అప్పుడు మేము దానిని వైర్.

907
01:11:11,890 --> 01:11:15,530
మేము, మొదటి సూచించడానికి కొత్త నోడ్ యొక్క తదుపరి పాయింటర్ సెట్

908
01:11:15,530 --> 01:11:20,460
మరియు తర్వాత మొదటి ఇప్పుడు కొత్త నోడ్ కు ఆకర్షిస్తాయి.

909
01:11:20,460 --> 01:11:25,120
కోడ్ యొక్క ఈ మొదటి లైన్లు, మేము నిజంగా కొత్త నోడ్ నిర్మించడం చేస్తున్నారు.

910
01:11:25,120 --> 01:11:27,280
ఈ చర్యను చివరి రెండు పంక్తులు కానీ మొదటి వ్యక్తులతోపాటు.

911
01:11:27,280 --> 01:11:30,290
మీరు అసలైన helper ఫంక్షన్ లో, ఒక ఫంక్షన్ లో వెలికితీసి చేయవచ్చు.

912
01:11:30,290 --> 01:11:32,560
తరచుగా నేను చేసేది, నేను, ఒక ఫంక్షన్ లో వెలికితీసి

913
01:11:32,560 --> 01:11:36,040
నేను బిల్డ్ నోడ్ లో లాగ, కాల్

914
01:11:36,040 --> 01:11:40,410
మరియు ఆ prepend ఫంక్షన్ అందంగా చిన్న ఉంచుతుంది, అది కేవలం 3 లైన్లు తర్వాత ఉంది.

915
01:11:40,410 --> 01:11:48,710
నా బిల్డ్ నోడ్ కు కాల్, మరియు పైకి నేను WIRE ప్రతిదీ.

916
01:11:48,710 --> 01:11:51,970
>> నేను మీరు చూపాలనుకుంటున్న చివరి విషయం,

917
01:11:51,970 --> 01:11:54,030
మరియు నేను, మీరు మీ స్వంత append మరియు అన్ని అలా తెలియజేస్తాము

918
01:11:54,030 --> 01:11:57,500
జాబితా పై iterate ఎలా.

919
01:11:57,500 --> 01:12:00,780
జాబితా పై iterate వివిధ మార్గాల్లో అక్కడ చాలా ఉన్నాయి.

920
01:12:00,780 --> 01:12:03,140
ఈ సందర్భంలో, మనం ఒక జాబితా పొడవు కనుగొనేందుకు వెళుతున్న.

921
01:12:03,140 --> 01:12:06,570
కాబట్టి మేము పొడవు = 0 ప్రారంభం.

922
01:12:06,570 --> 01:12:11,580
ఈ స్ట్రింగ్ కోసం strlen రాయడం చాలా పోలి ఉంటుంది.

923
01:12:11,580 --> 01:12:17,780
ఈ నేను ఇక్కడ లూప్ ఈ, మీరు చూపాలనుకుంటున్న ఏమిటి.

924
01:12:17,780 --> 01:12:23,530
ఇది ఎంతో అల్లరిగా ఉంది; ఇది సాధారణమైన కాదు Int i = 0, i <ఏమైనా + +.

925
01:12:23,530 --> 01:12:34,920
దానికి జాబితా ప్రారంభమని మా వేరియబుల్ n ప్రారంభించడం యొక్క.

926
01:12:34,920 --> 01:12:40,620
మా ఇటెరేటర్ వేరియబుల్ శూన్య కాదు మరియు తరువాత, మేము కొనసాగించడాన్ని.

927
01:12:40,620 --> 01:12:46,340
సాంప్రదాయకంగా, మా జాబితా ముగింపు శూన్య ఉంటుంది, ఎందుకంటే.

928
01:12:46,340 --> 01:12:48,770
ఆపై, బదులుగా + + చేయడం కంటే, పెంచడం

929
01:12:48,770 --> 01:12:57,010
+ యొక్క లింక్ జాబితా సమానమైన + n = N-> తదుపరి ఉంది.

930
01:12:57,010 --> 01:13:00,410
>> మేము సమయం లేదు ఎందుకంటే నేను మీరు ఇక్కడ ఖాళీని పూరించడానికి తెలియజేస్తాము.

931
01:13:00,410 --> 01:13:09,300
మీరు మీ spellr psets పని కానీ ఈ విషయాన్ని మనస్సులో ఉంచుకోవాలి.

932
01:13:09,300 --> 01:13:11,650
లింక్ జాబితాలు, మీరు ఒక హాష్ పట్టిక అమలు చేస్తుంటే,

933
01:13:11,650 --> 01:13:14,010
ఖచ్చితంగా చాలా ఉపయోగకరంగా ఉండగలదో.

934
01:13:14,010 --> 01:13:21,780
మరియు విషయాలు మీద మళ్ళీ వెతికినా ఈ జాతీయం కలిగి ఆశాజనక, చాలా సులభంగా జీవితం చేస్తుంది.

935
01:13:21,780 --> 01:13:25,910
ఏదైనా ప్రశ్నలు, త్వరగా?

936
01:13:25,910 --> 01:13:28,920
[సామ్] మీరు పూర్తి SLL మరియు SC అవుట్ పంపుతుంది?

937
01:13:28,920 --> 01:13:38,360
[Hardison] అవును. నేను పూర్తి స్లైడ్లు మరియు పూర్తి SLL స్టాక్ మరియు queue.cs అవుట్ పంపుతాము.

938
01:13:38,360 --> 01:13:41,360
[CS50.TV]