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

2
00:00:01,000 --> 00:00:04,000
[రాబ్ బౌడెన్] [హార్వర్డ్ విశ్వవిద్యాలయం]

3
00:00:04,000 --> 00:00:09,000
[ఈ CS50 ఉంది.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> మేము ప్రశ్నలు మా విభాగం వెళ్ళవచ్చు.

5
00:00:11,000 --> 00:00:17,000
నేను ముందు స్పేస్ కోసం URL పంపారు.

6
00:00:17,000 --> 00:00:22,000
ప్రశ్నలు యొక్క విభాగం ప్రారంభం సే-

7
00:00:22,000 --> 00:00:26,000
స్పష్టంగా నేను చాలా సులభమైన ప్రశ్న unsick-ఉంటుంది పూర్తిగా కాదు

8
00:00:26,000 --> 00:00:28,000
valgrind మాత్రమే ఏమి?

9
00:00:28,000 --> 00:00:30,000
Valgrind ఏమి చేస్తుంది?

10
00:00:30,000 --> 00:00:34,000
ఎవరైనా valgrind ఏమి చెప్పాలనుకోవడం?

11
00:00:34,000 --> 00:00:36,000
[స్టూడెంట్] తనిఖీలను మెమరీ లీకేజ్.

12
00:00:36,000 --> 00:00:41,000
అవును, valgrind సాధారణ మెమరీ చెక్కర్ ఉంది.

13
00:00:41,000 --> 00:00:44,000
మీరు ఏ మెమరీ లీకేజ్ ఉంటె, చివరకు,, మీరు చెబుతుంది

14
00:00:44,000 --> 00:00:49,000
మీరు అనుకుంటే మేము ఎందుకంటే ఇది ఉపయోగించి ఏమి ఎక్కువగా ఉంది

15
00:00:49,000 --> 00:00:54,000
సమస్య సెట్ లో లేదా మీరు అనుకుంటే బాగా

16
00:00:54,000 --> 00:00:59,000
పెద్ద బోర్డు మీద వస్తుంది, మీ, ఎలాంటి మెమరీ లీకేజ్ కలిగి ఉండాలి

17
00:00:59,000 --> 00:01:01,000
మరియు ఒకవేళ మీరు, మీరు దొరకలేదా మెమొరీ లీక్ కలిగి

18
00:01:01,000 --> 00:01:04,000
మీరు ఒక ఫైల్ తెరిచిన ప్రతిసారి కూడా గుర్తుంచుకోండి

19
00:01:04,000 --> 00:01:07,000
మరియు మీరు దాన్ని మూసివేసి లేకపోతే, ఆ మెమొరీ లీక్ ఉంది.

20
00:01:07,000 --> 00:01:10,000
>> మంది వారు విడుదల చేస్తున్నట్లు కొన్ని నోడ్ శోధిస్తున్న

21
00:01:10,000 --> 00:01:15,000
ఉన్నప్పుడు నిజంగా, వారు మొట్టమొదటి దశలో నిఘంటువు దగ్గరగా లేదు.

22
00:01:15,000 --> 00:01:19,000
ఇది కూడా, మీరు ఏ చెల్లని ఉంటే చదివే మీరు చెబుతుంది లేదా రాశాడు

23
00:01:19,000 --> 00:01:22,000
మీరు ప్రయత్నించండి మరియు ఒక విలువ సెట్ చేస్తే అంటే

24
00:01:22,000 --> 00:01:26,000
ఆ కుప్ప ముగింపు మించి మరియు అది seg లోపం సంభవించవచ్చు లేదు

25
00:01:26,000 --> 00:01:30,000
కానీ valgrind, మీరు నిజంగా అక్కడ వ్రాయడం లేదు, ఇది పట్టుకొని

26
00:01:30,000 --> 00:01:33,000
మరియు మీరు ఖచ్చితంగా ఆ గాని ఏదీ లేదు.

27
00:01:33,000 --> 00:01:38,000
మీరు ఎలా valgrind ఉపయోగించగలను?

28
00:01:38,000 --> 00:01:42,000
మీరు ఎలా valgrind ఉపయోగించగలను?

29
00:01:42,000 --> 00:01:45,000
>> ఇది ఒక సాధారణ ప్రశ్న

30
00:01:45,000 --> 00:01:49,000
రకం అమలు మరియు అవుట్పుట్ చూడండి.

31
00:01:49,000 --> 00:01:51,000
అవుట్పుట్ సార్లు చాలా అధిక ఉంది.

32
00:01:51,000 --> 00:01:54,000
మీరు కొన్ని భయంకరమైన విషయం ఉంటే పేరు సరదాగా లోపాలు కూడా ఉన్నాయి

33
00:01:54,000 --> 00:01:59,000
ఒక లూప్ వస్తున్న, అది చివరికి ", వే చాలా లోపాలు యున్నది.

34
00:01:59,000 --> 00:02:03,000
నేను ఇప్పుడు లెక్కింపు ఆపడానికి వెళుతున్న. "

35
00:02:03,000 --> 00:02:08,000
ఇది ప్రాథమికంగా మీరు అన్వయించడం కలిగి పాఠ్య అవుట్పుట్ ఉంది.

36
00:02:08,000 --> 00:02:13,000
చివరకు, అది, మీరు ఏదైనా మెమరీ లీకేజ్ చెప్పడం కనిపిస్తుంది

37
00:02:13,000 --> 00:02:16,000
ఉపయోగకరమైన ఎన్ని బ్లాక్స్, ఉండవచ్చు ఎందుకంటే

38
00:02:16,000 --> 00:02:20,000
అది ఒక బ్లాక్ unfreed అది దానిని కనుగొనేందుకు సాధారణంగా సులభం

39
00:02:20,000 --> 00:02:23,000
1,000 బ్లాక్స్ unfreed కంటే.

40
00:02:23,000 --> 00:02:26,000
Unfreed 1,000 బ్లాక్స్ బహుశా మీరు ఉండండి లేదు అంటే

41
00:02:26,000 --> 00:02:30,000
సరిగ్గా లేదా ఏదో మీ లింక్ జాబితాలు.

42
00:02:30,000 --> 00:02:32,000
ఆ valgrind యొక్క.

43
00:02:32,000 --> 00:02:35,000
>> ఇప్పుడు మేము, ప్రశ్నలు మా విభాగం కూడా

44
00:02:35,000 --> 00:02:38,000
మీరు డౌన్లోడ్ లేదు.

45
00:02:38,000 --> 00:02:41,000
మీరు నా పేరు మీద క్లిక్ చేసి స్పేస్ వాటిని పుల్ అప్ చేయవచ్చు.

46
00:02:41,000 --> 00:02:44,000
ఇప్పుడు నా మీద క్లిక్ చేయండి.

47
00:02:44,000 --> 00:02:46,000
కూర్పుల 1 మేము మొదటి చేస్తున్నా ఇది స్టాక్ ఉంటుంది.

48
00:02:46,000 --> 00:02:55,000
కూర్పుల 2 క్యూ ఉంటుంది, మరియు కూర్పుల 3 ఒక్కొక్కటిగా లింక్ జాబితా ఉంటుంది.

49
00:02:55,000 --> 00:02:58,000
మా స్టాక్ తో ప్రారంభించడానికి.

50
00:02:58,000 --> 00:03:02,000
అది ఇక్కడ చెప్పినట్టుగా, ఒక స్టాక్ అత్యంత ప్రాధమిక ఒకటి

51
00:03:02,000 --> 00:03:07,000
కంప్యూటర్ సైన్స్ యొక్క ప్రధాన సమాచార నిర్మాణాలకు.

52
00:03:07,000 --> 00:03:11,000
చాలా ప్రాధమిక ఉదాహరణ

53
00:03:11,000 --> 00:03:13,000
భోజనశాలలో ట్రేలు యొక్క స్టాక్.

54
00:03:13,000 --> 00:03:16,000
మీరు ఒక స్టాక్ కు పరిచయం చేశారు ఎప్పుడు, ప్రధానంగా ఉంది

55
00:03:16,000 --> 00:03:20,000
ఎవరైనా, చెప్పడానికి అన్నారు "ట్రేలు ఒక స్టాక్ వలె, ఓహ్."

56
00:03:20,000 --> 00:03:22,000
మీరు ట్రేలు స్టేక్ అప్.

57
00:03:22,000 --> 00:03:24,000
అప్పుడు మీరు ఒక ట్రే తీసి వెళ్ళి,

58
00:03:24,000 --> 00:03:31,000
లాగి సంతరించుకోనుంది మొదటి ట్రే స్టాక్ ఉంచబడినది చివరి ఒకటి.

59
00:03:31,000 --> 00:03:34,000
అది కూడా వంటి స్టాక్ ఇక్కడ చెప్పారు

60
00:03:34,000 --> 00:03:37,000
మేము స్టాక్ అనే మెమరీ విభాగంలో ఉంటాయి.

61
00:03:37,000 --> 00:03:40,000
మరియు ఎందుకు స్టాక్ అంటారు?

62
00:03:40,000 --> 00:03:42,000
>> ఎందుకంటే ఒక స్టాక్ డేటా వంటి నిర్మాణం,

63
00:03:42,000 --> 00:03:46,000
ఇది స్టాక్ మీద స్టాక్ ఫ్రేములు నెడుతుంది మరియు బయటకు

64
00:03:46,000 --> 00:03:53,000
స్టాక్ ఫ్రేములు ఒక చర్య యొక్క ఒక నిర్దిష్ట కాల్ వంటి చోట.

65
00:03:53,000 --> 00:03:57,000
మరియు ఒక స్టాక్ వలె, మీరు ఎల్లప్పుడూ తిరిగి ఉంటుంది

66
00:03:57,000 --> 00:04:03,000
ఒక ఫంక్షన్ కాల్ మీరు మళ్ళీ తక్కువ స్టాక్ ఫ్రేములు దిగి పొందవచ్చు ముందు.

67
00:04:03,000 --> 00:04:08,000
మీరు ప్రధాన కాల్ foo కాల్ బార్ మరియు ప్రధాన నేరుగా బార్ తిరిగి పొందలేరు.

68
00:04:08,000 --> 00:04:14,000
ఇది ఎల్లప్పుడూ నెట్టడం మరియు పాపింగ్ సరైన స్టాక్ అనుసరించండి తీరవలసినదే.

69
00:04:14,000 --> 00:04:18,000
రెండు ప్రక్రియలు, నేను అన్నాడు వంటి పుష్ మరియు పాప్ ఉంటాయి.

70
00:04:18,000 --> 00:04:20,000
ఆ యూనివర్సల్ నిబంధనలు ఉన్నాయి.

71
00:04:20,000 --> 00:04:26,000
మీరు స్టాక్స్ నో మేటర్ వాట్ పరంగా పుష్ మరియు పాప్ తెలుసుకోవాలి.

72
00:04:26,000 --> 00:04:28,000
మేము క్యూలు వివిధ యొక్క ఒకరకమైన చూస్తారు.

73
00:04:28,000 --> 00:04:32,000
ఇది నిజంగా ఒక యూనివర్సల్ పదం లేదు, కానీ పుష్ మరియు పాప్ స్టాక్లకు సార్వత్రిక ఉంటాయి.

74
00:04:32,000 --> 00:04:34,000
పుష్ కేవలం స్టాక్ మీద పెట్టబడింది.

75
00:04:34,000 --> 00:04:37,000
పాప్ స్టాక్ టేకాఫ్ ఉంది.

76
00:04:37,000 --> 00:04:43,000
మరియు మేము, మేము మా typedef struct స్టాక్ కలిగి ఇక్కడ చూడండి

77
00:04:43,000 --> 00:04:46,000
కాబట్టి మేము చార్ ** తీగలు ఉంటాయి.

78
00:04:46,000 --> 00:04:51,000
ఏ ** భయపడ్డ పొందలేము.

79
00:04:51,000 --> 00:04:54,000
ఈ తీగలు యొక్క వ్యూహం మాదిరిగా ముగించారు అన్నారు

80
00:04:54,000 --> 00:04:58,000
అక్షరాలకు గమనికలు లేదా ఒక వరుస పేరు

81
00:04:58,000 --> 00:05:00,000
అక్షరాలకు గమనికలు తీగలు ఉంటాయి.

82
00:05:00,000 --> 00:05:05,000
ఇది తీగలను ఉండాలి, కానీ ఇక్కడ, వారు తీగలను మాత్రం చేస్తున్నారు.

83
00:05:05,000 --> 00:05:08,000
>> మేము తీగలను యొక్క వ్యూహం ఉంది.

84
00:05:08,000 --> 00:05:14,000
మేము స్టాక్ ప్రస్తుతం ఎన్ని అంశాలు సూచిస్తుంది ఒక పరిమాణం, కలిగి

85
00:05:14,000 --> 00:05:19,000
మరియు తర్వాత మేము స్టాక్ మీద ఎన్ని అంశాలు ఉంటుంది సామర్థ్యం కలిగి ఉంటాయి.

86
00:05:19,000 --> 00:05:22,000
సామర్థ్యం, ​​1 కంటే ఎక్కువ ఏదో ఆఫ్ ప్రారంభం కావాలి

87
00:05:22,000 --> 00:05:27,000
కానీ పరిమాణం 0 గా కాకుండా ప్రారంభించు అన్నారు.

88
00:05:27,000 --> 00:05:36,000
ఇప్పుడు, మీరు ఒక స్టాక్ ఆలోచించవచ్చు మూడు వేర్వేరు మార్గాల్లో ప్రధానంగా ఉన్నాయి.

89
00:05:36,000 --> 00:05:39,000
Well, అక్కడ బహుశా మరింత ఉంటాయి, కాని రెండు ప్రధాన మార్గాలు

90
00:05:39,000 --> 00:05:43,000
మీరు వరుసను ఉపయోగించి దాన్ని అమలు చేయవచ్చు, లేదా మీరు ఒక లింక్ జాబితా ద్వారా అమలు చేయవచ్చు.

91
00:05:43,000 --> 00:05:48,000
లింక్ జాబితాలు రకమైన నుండి స్టాక్స్ తయారు చిన్నవిషయం ఉంటాయి.

92
00:05:48,000 --> 00:05:51,000
ఇది అనుసంధాన జాబితాలు ఉపయోగించి స్టాక్ చేయడానికి చాలా సులభం

93
00:05:51,000 --> 00:05:55,000
ఇక్కడ, మేము, శ్రేణుల ఉపయోగించి స్టాక్ తయారు చేయబోతున్నామని

94
00:05:55,000 --> 00:05:59,000
మరియు తర్వాత వ్యూహాన్ని ఉపయోగిస్తాయి, మీరు దాని గురించి ఆలోచించటం రెండు మార్గాలు కూడా ఉన్నాయి.

95
00:05:59,000 --> 00:06:01,000
ముందు, నేను అన్నాడు, మేము, స్టాక్ కోసం సామర్ధ్యం కలిగి ఉంటుంది

96
00:06:01,000 --> 00:06:04,000
కాబట్టి మేము స్టాక్ మీద ఒక మూలకం ఇముడుతుంది.

97
00:06:04,000 --> 00:06:09,000
>> ఇది జరిగి ఒక మార్గం వెంటనే మీకు 10 అంశాలను హిట్, అప్పుడు మీరు పూర్తి చేసిన ఉంది.

98
00:06:09,000 --> 00:06:13,000
మీరు ప్రపంచంలో 10 విషయాలను కట్టుబడి ఒక ఉన్నత లేదు అని తెలిసిన

99
00:06:13,000 --> 00:06:16,000
మీరు, మీ స్టాక్ ఎక్కువ 10 విషయాల్లో ఎప్పటికీ ఆ

100
00:06:16,000 --> 00:06:20,000
ఈ సందర్భంలో మీరు మీ స్టాక్ పరిమాణం పైన కట్టుబడి ఒక ఉన్నత ఉండవచ్చు.

101
00:06:20,000 --> 00:06:23,000
లేదా మీరు, మీ స్టాక్ అపరిమితం కూడా కలిగి ఉండవచ్చు

102
00:06:23,000 --> 00:06:27,000
మీరు ఒక అర్రే చేస్తున్నా అయితే, ఆ, ప్రతి మీరు 10 అంశాలను హిట్ అంటే

103
00:06:27,000 --> 00:06:29,000
మీరు 20 అంశాలను కొట్టాడు అప్పుడు మీరు, 20 అంశాలను పెరగడం కొనసాగుతుందని, మరియు మీరు

104
00:06:29,000 --> 00:06:33,000
మీరు 30 అంశాలు లేదా 40 అంశాలను మీ శ్రేణి పెరగడం చూడాలని.

105
00:06:33,000 --> 00:06:37,000
మీరు ఇక్కడ మేము చేయబోతున్నామని ఏమి ఉంది సామర్థ్యం, ​​పెంచే అవసరతను చూడాలని.

106
00:06:37,000 --> 00:06:40,000
మేము, మా స్టాక్ గరిష్ట పరిమాణాన్ని చేరి ప్రతి సమయం

107
00:06:40,000 --> 00:06:46,000
మేము ఇంకా న ఏదో పుష్, మేము సామర్థ్యాన్ని అవసరం చూడాలని.

108
00:06:46,000 --> 00:06:50,000
ఇక్కడ, మనం పుష్ bool పుష్ (చార్ * STR) వంటి నిర్ధారించారు.

109
00:06:50,000 --> 00:06:54,000
చార్ * STR, మేము స్టాక్ పై నెట్టడం తీగ ఉంది

110
00:06:54,000 --> 00:06:58,000
మరియు bool కేవలం మేము విజయం లేదా విఫలమైంది అని చెప్పారు.

111
00:06:58,000 --> 00:07:00,000
>> మేము ఎలా విఫలం కావచ్చు?

112
00:07:00,000 --> 00:07:04,000
మీరు భావిస్తారు మాత్రమే పరిస్థితి ఏమిటి

113
00:07:04,000 --> 00:07:07,000
మేము తప్పుడు తిరిగి ఉంటుంది ఎక్కడ?

114
00:07:07,000 --> 00:07:09,000
అవును.

115
00:07:09,000 --> 00:07:12,000
[స్టూడెంట్] ఇది పూర్తి మరియు మేము ఒక సరిహద్దులో అమలు ఉపయోగిస్తున్నట్లయితే.

116
00:07:12,000 --> 00:07:17,000
అవును, కాబట్టి మేము ఎలా నిర్వచించాలి-అతను సమాధానం

117
00:07:17,000 --> 00:07:23,000
అది పూర్తి మరియు మేము ఒక పరిమిత అమలు ను ఉపయోగిస్తున్నట్లయితే.

118
00:07:23,000 --> 00:07:26,000
అప్పుడు మేము ఖచ్చితంగా తప్పుడు తిరిగి ఉంటుంది.

119
00:07:26,000 --> 00:07:31,000
వెంటనే మేము శ్రేణి లో 10 పనులను హిట్, మేము 11 సరిపోవు, మేము తప్పుడు తిరిగి కాబట్టి.

120
00:07:31,000 --> 00:07:32,000
అది అపరిమితం ఏమి? అవును.

121
00:07:32,000 --> 00:07:38,000
మీరు కొన్ని కారణాల కోసం శ్రేణి విస్తరణ పోతే.

122
00:07:38,000 --> 00:07:43,000
అవును, కాబట్టి మెమరీ, ఒక పరిమిత వనరు

123
00:07:43,000 --> 00:07:51,000
చివరకు, మేము మళ్ళీ మరియు పైగా స్టాక్ పై నెట్టడం విషయాలు ఉంటే,

124
00:07:51,000 --> 00:07:54,000
మేము సరిపోయే పెద్ద అర్రే ప్రయత్నించండి మరియు కేటాయించే వెళుతున్న

125
00:07:54,000 --> 00:07:59,000
ఇక్కడ పెద్ద సామర్థ్యం, ​​మరియు malloc లేదా ఎలాగైనా తప్పుడు తిరిగి అన్నారు.

126
00:07:59,000 --> 00:08:02,000
Well, malloc శూన్య చూపిస్తుంది.

127
00:08:02,000 --> 00:08:05,000
>> గుర్తుంచుకోండి, మీరు malloc కాల్ ప్రతి సారి, చూడటానికి తనిఖీ చేయాలి ఉంటే అది

128
00:08:05,000 --> 00:08:12,000
శూన్య తిరిగి లేదంటే ఒక సరి కోత ఉంది.

129
00:08:12,000 --> 00:08:17,000
మేము ఒక అపరిమితం స్టాక్ కావాలి కాబట్టి,

130
00:08:17,000 --> 00:08:21,000
మేము ప్రయత్నించినట్లయితే మేము తప్పుడు తిరిగి చూడాలని మాత్రమే సందర్భంలో

131
00:08:21,000 --> 00:08:26,000
సామర్థ్యం మరియు malloc పెంచడానికి లేదా తప్పుడు తిరిగి ఏ.

132
00:08:26,000 --> 00:08:30,000
అప్పుడు పాప్, ఎటువంటి వాదనలూ లేవు పడుతుంది

133
00:08:30,000 --> 00:08:37,000
మరియు అది స్టాక్ పైన అని స్ట్రింగ్ తిరిగి.

134
00:08:37,000 --> 00:08:41,000
ఏమైనప్పటికీ ఇటీవల స్టాక్ మీద వెళ్ళింది, తిరిగి ఏమి పాప్ ఉంది

135
00:08:41,000 --> 00:08:44,000
మరియు అది కూడా స్టాక్ నుంచి అది తొలగిస్తుంది.

136
00:08:44,000 --> 00:08:50,000
మరియు స్టాక్ మీద ఏమీ లేకపోతే అది శూన్య తిరిగి గుర్తించాము.

137
00:08:50,000 --> 00:08:53,000
ఇది స్టాక్ ఖాళీ అని ఎల్లప్పుడూ సాధ్యపడుతుంది.

138
00:08:53,000 --> 00:08:55,000
జావా, మీరు ఆ, లేదా ఇతర భాషలు ఉపయోగిస్తారు చేస్తుంటే,

139
00:08:55,000 --> 00:09:01,000
ఒక ఖాళీ స్టాక్ నుండి పాప్ ప్రయత్నిస్తున్న ఒక మినహాయింపు లేదా ఏదో వస్తుంది.

140
00:09:01,000 --> 00:09:09,000
>> కానీ సి లో, శూన్య మేము ఈ సమస్యలను ఎలా నిర్వహిస్తాయనే కేసులు చాలా యొక్క రకం.

141
00:09:09,000 --> 00:09:13,000
శూన్య తిరిగి మేము స్టాక్ ఖాళీ అని సూచిస్తుంది చూడాలని ఎలా ఉంది.

142
00:09:13,000 --> 00:09:16,000
మేము, మీ స్టాక్ యొక్క కార్యాచరణ పరీక్షించడానికి ఆ కోడ్ అందించిన

143
00:09:16,000 --> 00:09:19,000
పుష్ మరియు పాప్ అమలు.

144
00:09:19,000 --> 00:09:23,000
ఈ కోడ్ యొక్క చాలా ఉండదు.

145
00:09:23,000 --> 00:09:40,000
నేను రెడీ-నిజానికి, మేము అలా ముందు, సూచన, సూచనను-

146
00:09:40,000 --> 00:09:44,000
మీరు చూడని ఉంటే, malloc మాత్రమే క్రియ కాదు

147
00:09:44,000 --> 00:09:47,000
మీరు కోసం కుప్ప మెమరీ కేటాయించుకునే.

148
00:09:47,000 --> 00:09:51,000
Alloc ఫంక్షన్ల ఒక కుటుంబం ఉన్నాయి.

149
00:09:51,000 --> 00:09:53,000
మొదటి మీకు ఇది malloc, ఉంది.

150
00:09:53,000 --> 00:09:56,000
అప్పుడు malloc అదే విషయం చేస్తుంది ఇది calloc, లేదు

151
00:09:56,000 --> 00:09:59,000
కానీ మీరు అన్ని బయటకు సున్నాకి కనిపిస్తుంది.

152
00:09:59,000 --> 00:10:04,000
మీరు ఏదో mallocing తర్వాత శూన్యం ప్రతిదీ సెట్ కోరుకున్నామని చెప్తూ ఉంటే

153
00:10:04,000 --> 00:10:06,000
మీరు బదులుగా వ్రాసే మొదటి స్థానంలో calloc ఉపయోగించాలి

154
00:10:06,000 --> 00:10:09,000
మెమరీ మొత్తం బ్లాక్ అవుట్ సున్నాకి లూప్ ఒక.

155
00:10:09,000 --> 00:10:15,000
>> Realloc, malloc ఉంటుంది మరియు ప్రత్యేక సందర్భాలలో చాలా ఉంది

156
00:10:15,000 --> 00:10:19,000
కానీ ప్రాథమికంగా realloc ఏమి ఉంది

157
00:10:19,000 --> 00:10:24,000
ఇది ఇప్పటికే కేటాయించబడ్డాయి చేయబడిన ఒక పాయింటర్ పడుతుంది.

158
00:10:24,000 --> 00:10:27,000
Realloc మీరు ఇక్కడ దృష్టి పెట్టారు అనుకుంటే విధి.

159
00:10:27,000 --> 00:10:31,000
ఇది ఇప్పటికే malloc నుంచి తిరిగి చేయబడిన ఒక పాయింటర్ పడుతుంది.

160
00:10:31,000 --> 00:10:35,000
మీరు malloc నుండి 10 బైట్లు ఒక పాయింటర్ అభ్యర్థించవచ్చు చెప్పారు.

161
00:10:35,000 --> 00:10:38,000
తరువాత మీరు, మీరు 20 బైట్లు కోరుకున్నారు తెలుసుకుంటారు

162
00:10:38,000 --> 00:10:42,000
కాబట్టి మీరు, 20 బైట్లు ఆ పాయింటర్ ఆన్ realloc కాల్

163
00:10:42,000 --> 00:10:47,000
మరియు realloc స్వయంచాలకంగా మీ కొరకు అన్నిచోట్ల కాపీ చేస్తుంది.

164
00:10:47,000 --> 00:10:51,000
మీరు నేను 10 బైట్లు ఒక బ్లాక్ ఉన్నట్లు, మళ్ళీ malloc అని. ఉంటే

165
00:10:51,000 --> 00:10:53,000
ఇప్పుడు నేను 20 బైట్లు ఒక బ్లాక్, అవసరం

166
00:10:53,000 --> 00:10:58,000
నేను malloc 20 బైట్లు, అప్పుడు నేను మానవీయంగా మొదటి విషయం నుండి 10 బైట్లు పైగా కాపీ కలిగి

167
00:10:58,000 --> 00:11:01,000
మొదటి విషయం రెండవ విషయం మరియు తర్వాత ఫ్రీ.

168
00:11:01,000 --> 00:11:04,000
Realloc మీరు ఆ పోరాడతాను.

169
00:11:04,000 --> 00:11:11,000
>> సంతకం, శూన్యమైన * అని అన్నారు గమనించండి

170
00:11:11,000 --> 00:11:15,000
ఇది కేవలం, మెమరీ బ్లాక్ ఒక పాయింటర్ తిరిగి

171
00:11:15,000 --> 00:11:17,000
అప్పుడు తప్ప * PTR.

172
00:11:17,000 --> 00:11:22,000
మీరు ఒక సాధారణ పాయింటర్ గా తప్ప * యొక్క ఆలోచించవచ్చు.

173
00:11:22,000 --> 00:11:27,000
సాధారణంగా, మీరు, శూన్యమైన * తో వ్యవహరించే ఎప్పుడూ

174
00:11:27,000 --> 00:11:30,000
కానీ malloc ఒక గర్జన * తిరిగి, ఆపై ఇది వంటి ఉపయోగించబడిన

175
00:11:30,000 --> 00:11:34,000
ఇది నిజానికి ఒక చార్ * అని అన్నారు.

176
00:11:34,000 --> 00:11:37,000
malloc ద్వారా తిరిగి ఆ మునుపటి తప్ప *

177
00:11:37,000 --> 00:11:41,000
ఇప్పుడు పరిమాణం అప్పుడు realloc జారీ కావడం, మరియు

178
00:11:41,000 --> 00:11:49,000
మీరు కేటాయించే కావలసిన బైట్లు యొక్క కొత్త సంఖ్య, మీ కొత్త సామర్థ్యం ఉంది.

179
00:11:49,000 --> 00:11:57,000
నేను మీరు ఒక జంట నిమిషాల ఇవ్వడం, మరియు మా ప్రదేశంలో చేయును.

180
00:11:57,000 --> 00:12:02,000
కూర్పుల 1 ప్రారంభించండి.

181
00:12:16,000 --> 00:12:21,000
నేను, పుష్ అమలు తగినంత సమయం తర్వాత ఆశాజనక మీరు ఆపడానికి ఉంటాం

182
00:12:21,000 --> 00:12:24,000
మరియు నేను మీరు పాప్ చేయడానికి మరొక బ్రేక్ ఇస్తాను.

183
00:12:24,000 --> 00:12:27,000
కానీ నిజంగా అన్ని వద్ద ఎక్కువ కోడ్ కాదు.

184
00:12:27,000 --> 00:12:35,000
అత్యంత కోడ్ సామర్థ్యాన్ని పెంచుకుంటూ, బహుశా విస్తరించడం stuff ఉంది.

185
00:12:35,000 --> 00:12:39,000
సరే, పూర్తిగా చెయ్యటానికి ఎలాంటి ఒత్తిడి,

186
00:12:39,000 --> 00:12:47,000
కానీ కాలం మీరు కుడి మార్గంలో చేస్తున్నట్లు మీకు, ఆ మంచి.

187
00:12:47,000 --> 00:12:53,000
>> ఎవరైనా నన్ను పైకి లాగడం తో సుఖంగా ఏ కోడ్ కలిగి ఉందా?

188
00:12:53,000 --> 00:12:59,000
అవును, నేను రెడీ, కాని ఎవరైనా నేను పుల్ అప్ చేయవచ్చు ఏ కోడ్ కలిగి ఉన్నారు?

189
00:12:59,000 --> 00:13:05,000
సరే, మీరు ఇది ఏమైనా అది సేవ్, ప్రారంభించగలరు?

190
00:13:05,000 --> 00:13:09,000
నేను ఎప్పుడూ అడుగు మర్చిపోతే.

191
00:13:09,000 --> 00:13:15,000
సరే, పుష్ చూడటం,

192
00:13:15,000 --> 00:13:18,000
మీరు మీ కోడ్ వివరించేందుకు కోరుకుంటున్నారు?

193
00:13:18,000 --> 00:13:24,000
[స్టూడెంట్] అన్ని యొక్క మొదటి, నేను పరిమాణం పెరిగింది.

194
00:13:24,000 --> 00:13:28,000
నేను నేను ఆ-ఏమైనప్పటికీ ఉండాలి ఊహించడం, నేను, పరిమాణాన్ని

195
00:13:28,000 --> 00:13:31,000
అది సామర్థ్యం కంటే తక్కువగా ఉంటే నేను చూడండి.

196
00:13:31,000 --> 00:13:36,000
మరియు అది సామర్థ్యం కంటే తక్కువగా ఉంటే, మనం ఇప్పటికే ఆ శ్రేణి జోడించండి.

197
00:13:36,000 --> 00:13:42,000
అది కాదు ఉంటే, నేను, 2 సామర్థ్యం గుణిస్తారు

198
00:13:42,000 --> 00:13:50,000
ఇప్పుడు ఒక పెద్ద సామర్థ్యం పరిమాణం ఏదో కోసం తీగలను శ్రేణి reallocate.

199
00:13:50,000 --> 00:13:55,000
ఒకవేళ విఫలమైతే మరియు అప్పుడు, నేను యూజర్ చెప్పండి మరియు, తప్పుడు తిరిగి

200
00:13:55,000 --> 00:14:04,000
అది మంచిది ఉంటే, అప్పుడు నేను కొత్త స్పాట్ లో స్ట్రింగ్ ఉంచండి.

201
00:14:04,000 --> 00:14:07,000
>> [రాబ్ B.] ఇక్కడ మేము ఒక మంచి bitwise ఆపరేటర్లు ఉపయోగిస్తారు గమనించండి

202
00:14:07,000 --> 00:14:09,000
2 ద్వారా హెచ్చించాము కు.

203
00:14:09,000 --> 00:14:11,000
గుర్తుంచుకోండి, ఎడమ షిఫ్ట్ ఎల్లప్పుడూ 2 గుణించి అవతరిస్తుంది.

204
00:14:11,000 --> 00:14:15,000
మీరు అర్థం గుర్తుంచుకోవాలి వంటి కుడి Shift కాలం 2 విభజించబడిన

205
00:14:15,000 --> 00:14:18,000
2 ద్వారా విభజించబడింది పూర్ణాంకం లో 2 భాగాలుగా విభజించారు.

206
00:14:18,000 --> 00:14:20,000
ఇది ఇక్కడ లేదా అక్కడ ఒక 1 ఖండించు ఉండవచ్చు.

207
00:14:20,000 --> 00:14:26,000
కానీ 1 విడిచిపెట్టిన షిఫ్ట్ ఎప్పుడూ 2 గుణించి అవతరిస్తుంది

208
00:14:26,000 --> 00:14:32,000
మీరు ఓవర్ఫ్లో పూర్ణాంక యొక్క సరిహద్దులు తప్ప, మరియు అప్పుడు అది సాధ్యం కాదు.

209
00:14:32,000 --> 00:14:34,000
ఒక సైడ్ కామెంట్.

210
00:14:34,000 --> 00:14:39,000
నేను, ఏమి-ఈ ఏ విధంగా కోడింగ్ మార్చడానికి వెళ్ళడం లేదు మీరు

211
00:14:39,000 --> 00:14:48,000
కానీ నేను ఈ వంటి ఏదో చేయాలని.

212
00:14:48,000 --> 00:14:51,000
ఇది నిజానికి అది కొద్దిగా పొడవుగా సిధ్ధంగా ఉంటుంది.

213
00:15:04,000 --> 00:15:08,000
బహుశా ఈ, ఈ చూపించడానికి ఖచ్చితమైన కేసు కాదు

214
00:15:08,000 --> 00:15:14,000
కానీ నేను యొక్క ఈ ముక్కలుగా సెగ్మెంట్ ఇష్టపడతారని

215
00:15:14,000 --> 00:15:17,000
ఇది జరిగితే ఉంటే సరే,, అప్పుడు నేను, ఏదో ఒకటి వెళుతున్న

216
00:15:17,000 --> 00:15:19,000
ఆపై చర్య జరుగుతుంది.

217
00:15:19,000 --> 00:15:22,000
నేను ఫంక్షన్ డౌన్ నా కళ్ళు అన్ని మార్గం స్క్రోల్ లేదు

218
00:15:22,000 --> 00:15:25,000
ఇంకా తర్వాత ఏమి చూడటానికి.

219
00:15:25,000 --> 00:15:27,000
ఇది జరిగితే ఉంటే ఇది, అప్పుడు నేను తిరిగి.

220
00:15:27,000 --> 00:15:30,000
ఇది కూడా ఈ మించి ప్రతిదీ యొక్క నైస్ అదనపు ప్రయోజనం ఉంది

221
00:15:30,000 --> 00:15:33,000
ఇప్పుడు ఒకసారి ఎడమ మారిపోయి ఉంది.

222
00:15:33,000 --> 00:15:40,000
నేను ఇకపై కు-ఉంటే మీరు హాస్యాస్పదమైన దీర్ఘ పంక్తులు సమీపంలో అవసరం

223
00:15:40,000 --> 00:15:45,000
, అప్పుడు ఆ 4 బైట్లు సహాయపడుతుంది మరియు కూడా మరింత ఎడమ విషయం

224
00:15:45,000 --> 00:15:48,000
తక్కువ నాలాంటి ఓకే, నేను గుర్తు ఉంటే మీకు నిష్ఫలంగా

225
00:15:48,000 --> 00:15:53,000
నేను లూప్ ఒక యొక్క ఒక else లోపల లోపల కొంత లూప్ ప్రస్తుతం ఉన్నాను.

226
00:15:53,000 --> 00:15:58,000
ఎక్కడైనా మీరు నేను రకమైన వంటి వెంటనే ఈ తిరిగి చేయవచ్చు.

227
00:15:58,000 --> 00:16:05,000
ఇది పూర్తిగా ఇచ్చాపూరితం మరియు ఏ విధంగా అంచనా లేదు.

228
00:16:05,000 --> 00:16:12,000
>> [స్టూడెంట్] అక్కడ ఒక పరిమాణం ఉండాలి - ఫెయిల్ స్థితిలో?

229
00:16:12,000 --> 00:16:19,000
ఇక్కడ ఫెయిల్ పరిస్థితి మేము అవును, realloc విఫలమైంది ఉంది.

230
00:16:19,000 --> 00:16:22,000
చాలావరకు ఫెయిల్ పరిస్థితిలో ఎలా గమనించండి

231
00:16:22,000 --> 00:16:26,000
మేము ఉచిత స్టఫ్ తర్వాత తప్ప, మేము ఎల్లప్పుడూ విఫలం చూడాలని

232
00:16:26,000 --> 00:16:29,000
ఏదో కొట్టాలని ప్రయత్నించండి ఎన్ని సార్లు ఉన్నా.

233
00:16:29,000 --> 00:16:32,000
మేము నెట్టడం ఉంటే, మేము, పెంచడం పరిమాణం ఉంచడానికి

234
00:16:32,000 --> 00:16:36,000
మేము స్టాక్ లో ఏదైనా ఉంచడం లేదు అయినప్పటికీ.

235
00:16:36,000 --> 00:16:39,000
సాధారణంగా మేము వరకు పరిమాణం పెంచడం లేదు

236
00:16:39,000 --> 00:16:43,000
మేము విజయవంతంగా స్టాక్ ఉంచారు తరువాత.

237
00:16:43,000 --> 00:16:50,000
మేము గాని ఇక్కడ మరియు ఇక్కడ చెప్పడానికి, అది చేయరు.

238
00:16:50,000 --> 00:16:56,000
బదులుగా ≤ సామర్థ్యం s.size చెప్పడం మరియు అప్పుడు, సామర్థ్యం కంటే తక్కువగా

239
00:16:56,000 --> 00:17:01,000
ప్రతిదీ పేరు మేము తరలించారు మాత్రమే ఎందుకంటే.

240
00:17:01,000 --> 00:17:07,000
>> ఇంకా గుర్తుంచుకోండి, మేము బహుశా తప్పుడు మాత్రమే చోటు తిరిగి విధుల్లో

241
00:17:07,000 --> 00:17:14,000
realloc శూన్య వచ్చిన,, ఇక్కడ ఉంది

242
00:17:14,000 --> 00:17:19,000
మరియు మీరు ప్రామాణిక తప్పు గుర్తు జరిగితే,

243
00:17:19,000 --> 00:17:22,000
మీరు ప్రామాణిక దోషం ముద్రించడానికి ఎక్కడ బహుశా మీరు, ఈ కేసులో పరిగణించబడతారు

244
00:17:22,000 --> 00:17:26,000
బదులుగా కేవలం ప్రామాణిక అవుట్ నేరుగా ప్రింటింగ్ కాబట్టి fprintf stderr.

245
00:17:26,000 --> 00:17:31,000
మళ్లీ,, అంచనా కాదు, అయితే ఇది ఒక లోపం ఉంటే

246
00:17:31,000 --> 00:17:41,000
printf టైప్ చేసి, మీరు బదులుగా ప్రామాణిక అవుట్ యొక్క ప్రామాణిక లోపం ప్రింట్ తయారు చేయవచ్చు.

247
00:17:41,000 --> 00:17:44,000
>> ఎవరైనా గమనించండి వేరే ఏదైనా ఉందా? అవును.

248
00:17:44,000 --> 00:17:47,000
[స్టూడెంట్] మీరు [వినబడని] మీద వెళ్ళే?

249
00:17:47,000 --> 00:17:55,000
[రాబ్ B.] అవును, నిజమైన దానిని binariness లేదా ఏ అవునా?

250
00:17:55,000 --> 00:17:57,000
[స్టూడెంట్] కాబట్టి మీరు 2 ద్వారా గుణిస్తారు?

251
00:17:57,000 --> 00:17:59,000
[రాబ్ B.] అవును, ప్రధానంగా.

252
00:17:59,000 --> 00:18:11,000
బైనరీ భూమి, మేము ఎల్లప్పుడూ అంకెలు మా సెట్.

253
00:18:11,000 --> 00:18:22,000
కుడివైపు వద్ద ఇక్కడ ప్రధానంగా ఇన్సర్ట్ అది 1 ఈ ఎడమ షిఫ్టింగ్.

254
00:18:22,000 --> 00:18:25,000
ఈ కావడానికి, బైనరీ లో ప్రతిదీ గుర్తు

255
00:18:25,000 --> 00:18:28,000
, 2 యొక్క ఒక శక్తి ఉంటుంది, అందుచే 0 to 2 సూచిస్తుంది

256
00:18:28,000 --> 00:18:30,000
1 ఈ 2, ఈ 2 2.

257
00:18:30,000 --> 00:18:33,000
ఇప్పుడు కుడివైపు ఒక 0 చేర్చడం ద్వారా, మేము అన్నిచోట్ల ఉంచారు.

258
00:18:33,000 --> 00:18:38,000
ఏ 0 to 2 ఉపయోగిస్తున్నప్పుడు 2, ఇప్పుడు 2 1 2 ఉంది.

259
00:18:38,000 --> 00:18:41,000
మేము చేర్చబడ్డ ఆ కుడివైపు

260
00:18:41,000 --> 00:18:44,000
తప్పనిసరిగా 0 గా అంటే,

261
00:18:44,000 --> 00:18:46,000
ఇది అర్థవంతంగా ఉంటుంది.

262
00:18:46,000 --> 00:18:49,000
మీరు 2 అనేక గుణిస్తారు, అది, బేసి వదులుకోవడానికి మాత్రం కాదు

263
00:18:49,000 --> 00:18:54,000
కాబట్టి 0 స్థానానికి 2, 0 ఉండాలి

264
00:18:54,000 --> 00:18:59,000
మీరు మార్చేందుకు జరిగే లేకపోతే మరియు ఈ నేను సగం ఉంటుంది ముందు గురించి హెచ్చరించారు ఏమిటి

265
00:18:59,000 --> 00:19:01,000
పూర్ణాంకం లో బిట్స్ సంఖ్య దాటి,

266
00:19:01,000 --> 00:19:04,000
ఈ 1 షో ముగుస్తుంది అన్నారు.

267
00:19:04,000 --> 00:19:10,000
మీరు నిజంగా పెద్ద సామర్థ్యాలను వ్యవహరించే విధంగా జరిగితే మాత్రమే ఆందోళన ఉంది.

268
00:19:10,000 --> 00:19:15,000
కానీ ఆ సమయంలో, మీరు, విషయాలను బిలియన్ల యొక్క వ్యూహం వ్యవహరించే చేస్తున్నారు

269
00:19:15,000 --> 00:19:25,000
ఏమైనప్పటికీ మెమోరీలో సరిపోని విధంగా.

270
00:19:25,000 --> 00:19:31,000
>> ఇప్పుడు మేము కూడా సులభం ఇది పాప్, పొందవచ్చు.

271
00:19:31,000 --> 00:19:36,000
మీరు మొత్తం బంచ్ పాప్ జరిగితే మీరు, ఇది ఇష్టపడతారు కాలేదు

272
00:19:36,000 --> 00:19:38,000
ఇప్పుడు మీరు మళ్ళీ సగం సామర్థ్యం వద్ద ఉన్నారు.

273
00:19:38,000 --> 00:19:42,000
మీరు, మీరు మెమరీ మొత్తం తగ్గించడం realloc కాలేదు

274
00:19:42,000 --> 00:19:47,000
కానీ దాని గురించి ఆందోళన లేదు, అందుచే మాత్రమే realloc సందర్భంలో అన్నారు

275
00:19:47,000 --> 00:19:50,000
, మెమరీ తగ్గిపోతున్న ఎప్పుడూ, మెమరీ పెరుగుతున్న

276
00:19:50,000 --> 00:19:59,000
ఇది పాప్ సూపర్ సులభంగా అన్నారు.

277
00:19:59,000 --> 00:20:02,000
స్టాక్స్ వంటి ఉంటాయని నేను ఇది ఇప్పుడు క్యూలు,

278
00:20:02,000 --> 00:20:06,000
కానీ మీరు విషయాలు చేద్దామని ఆ క్రమాన్ని తలక్రిందులు ఉంది.

279
00:20:06,000 --> 00:20:10,000
ఒక క్యూ యొక్క ప్రాధమిక ఉదాహరణ, ఒక లైన్

280
00:20:10,000 --> 00:20:12,000
నేను మీరు ఇంగ్లీష్ అయితే ఊహించడం, నేను చెప్పి ఉండవచ్చు

281
00:20:12,000 --> 00:20:17,000
ఒక క్యూ ఒక ప్రాధమిక ఉదాహరణ ఒక క్యూ ఉంది.

282
00:20:17,000 --> 00:20:22,000
కాబట్టి ఒక లైన్ వలె, మీరు లైన్ లో మొదటి వ్యక్తి అయితే,

283
00:20:22,000 --> 00:20:24,000
మీరు లైన్ నుండి మొదటి వ్యక్తిగా భావిస్తున్నారు.

284
00:20:24,000 --> 00:20:31,000
మీరు లైన్ లో చివరి వ్యక్తి అయితే, మీరు సర్వీస్డ్ చివరి వ్యక్తి ఉంటాయని నేను.

285
00:20:31,000 --> 00:20:35,000
స్టాక్ ఎల్ఐఎఫ్ఓ నమూనా ఉంది అయితే మేము ఆ FIFO నమూనా కాల్.

286
00:20:35,000 --> 00:20:40,000
ఆ పదాలను అందంగా సార్వత్రిక ఉంటాయి.

287
00:20:40,000 --> 00:20:46,000
>> స్టాక్స్ వంటి మరియు శ్రేణుల కాకుండా, క్యూలు సాధారణంగా మధ్యలో అంశాలను నిర్వహించడానికి వీలు లేదు.

288
00:20:46,000 --> 00:20:50,000
ఇక్కడ, ఒక స్టాక్ మేము పుష్ మరియు పాప్ ఉన్నాయి.

289
00:20:50,000 --> 00:20:54,000
ఇక్కడ, మేము వాటిని ఎన్క్యూ మరియు dequeue పిలుపునిచ్చారు ఏం.

290
00:20:54,000 --> 00:20:58,000
నేను కూడా వాటిని మార్పు మరియు unshift అని విన్నాను.

291
00:20:58,000 --> 00:21:02,000
నేను ప్రజలు పుష్ మరియు పాప్ క్యూలు కూడా దరఖాస్తు నేను విన్నాను చేసిన.

292
00:21:02,000 --> 00:21:05,000
నేను, తొలగించడం ఇన్సర్ట్ విన్నాను

293
00:21:05,000 --> 00:21:11,000
కాబట్టి పుష్ మరియు మీరు స్టాక్స్ మాట్లాడుకుంటే, మీరు నెట్టడం మరియు పాపింగ్ ఉన్నాయి, పాప్.

294
00:21:11,000 --> 00:21:16,000
మీరు క్యూలు గురించి మాట్లాడుతూ ఉంటే, మీరు ఉపయోగించాలనుకుంటున్న పదాలు పొందగలిగేలా

295
00:21:16,000 --> 00:21:23,000
చొప్పించడం మరియు తొలగింపు కొరకు, దీనిని ఏ ఎటువంటి ఏకాభిప్రాయం ఉంది.

296
00:21:23,000 --> 00:21:27,000
కానీ ఇక్కడ, మేము ఎన్క్యూ మరియు dequeue ఉన్నాయి.

297
00:21:27,000 --> 00:21:37,000
ఇప్పుడు, struct స్టాక్ struct దాదాపు ఒకేలా ఉంటుంది.

298
00:21:37,000 --> 00:21:40,000
కానీ మేము తల ట్రాక్ ఉంటుంది.

299
00:21:40,000 --> 00:21:44,000
నేను దానిని ఎక్కడా ఇక్కడ చెప్పారు ఊహించడం, అయితే ఎందుకు తల చేయాలి?

300
00:21:53,000 --> 00:21:57,000
నమూనాలను పుష్ మరియు పాప్ ప్రధానంగా సమానంగా ఉంటాయి.

301
00:21:57,000 --> 00:21:59,000
మీరు పుష్ మరియు పాప్ గా కూడా ఆలోచించవచ్చు.

302
00:21:59,000 --> 00:22:08,000
మాత్రమే తేడా పాప్ ఉంది తిరిగి-బదులుగా గత యొక్క, అది మొదటి తిరిగి అని.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, లేదా ఏదో.

304
00:22:12,000 --> 00:22:14,000
మరియు ఇక్కడ ప్రారంభిద్దాం.

305
00:22:14,000 --> 00:22:17,000
మా క్యూ పూర్తిగా నిండినది, కాబట్టి అది నాలుగు అంశాలను ఉంది.

306
00:22:17,000 --> 00:22:21,000
మా క్యూ ముగింపు, ప్రస్తుతం 2

307
00:22:21,000 --> 00:22:24,000
మరియు ఇప్పుడు మేము ఏదో ఇన్సర్ట్ వెళ్ళండి.

308
00:22:24,000 --> 00:22:29,000
>> మేము స్టాక్ వెర్షన్ కోసం మేము ఏమి else విధి, ఇన్సర్ట్ చెయ్యడానికి ఉంటుంది

309
00:22:29,000 --> 00:22:36,000
మేము మెమరీ మా బ్లాక్ విస్తరించబడింది.

310
00:22:36,000 --> 00:22:40,000
ఈ తో సమస్య ఏమిటి?

311
00:22:40,000 --> 00:22:45,000
[స్టూడెంట్] మీరు 2 తరలించండి.

312
00:22:45,000 --> 00:22:51,000
నేను క్యూ ముగింపులో ముందు చెప్పారు, ఏమి

313
00:22:51,000 --> 00:22:57,000
ఈ, 1 వద్ద మేము ప్రారంభించండి సమంజసం అనిపించుకోదు

314
00:22:57,000 --> 00:23:01,000
అప్పుడు మేము అప్పుడు dequeue 3, dequeue 4, dequeue 1 అనుకుంటున్నారా

315
00:23:01,000 --> 00:23:05,000
అప్పుడు dequeue 2, అప్పుడు ఈ ఒక dequeue.

316
00:23:05,000 --> 00:23:08,000
మేము ఇప్పుడు realloc ఉపయోగించలేరు

317
00:23:08,000 --> 00:23:11,000
లేదా కనీసం, మీరు వేరే విధంగా realloc ఉపయోగించాలి.

318
00:23:11,000 --> 00:23:15,000
కానీ మీరు బహుశా కేవలం realloc ఉపయోగించరాదు.

319
00:23:15,000 --> 00:23:18,000
మీరు మానవీయంగా మీ మెమరీ కాపీ పొందబోతున్నారు.

320
00:23:18,000 --> 00:23:21,000
>> మెమరీ కాపీ రెండు విధులు ఉన్నాయి.

321
00:23:21,000 --> 00:23:25,000
Memcopy మరియు memmove ఉంది.

322
00:23:25,000 --> 00:23:29,000
నేను ప్రస్తుతం మీరు ఉపయోగించాలనుకుంటున్న చూడాలని ఇది ఒక చూడటానికి man పేజీలను వింటున్నాను.

323
00:23:29,000 --> 00:23:35,000
సరే, memcopy, తేడా

324
00:23:35,000 --> 00:23:38,000
memcopy మరియు memmove, ఒక సరిగ్గా కేసు చూడటానికి

325
00:23:38,000 --> 00:23:41,000
మీరు ప్రాంతంలో విస్త్రుతలతో జరిగినప్పుడు ఒక ప్రాంతంలో కాపీ ఎక్కడ

326
00:23:41,000 --> 00:23:46,000
మీరు నుండి కాపీ చేస్తున్నారు.

327
00:23:46,000 --> 00:23:50,000
Memcopy నిర్వహించేవి లేదు. Memmove చేస్తుంది.

328
00:23:50,000 --> 00:23:59,000
మీరు-సమస్య యొక్క ఆలోచించవచ్చు

329
00:23:59,000 --> 00:24:09,000
లెట్స్, నేను కాపీ అనుకుందాం

330
00:24:09,000 --> 00:24:13,000
ఈ వ్యక్తి ఈ నాలుగు.

331
00:24:13,000 --> 00:24:16,000
చివరకు, అర్రే ఇష్టం కనిపించాలి

332
00:24:16,000 --> 00:24:26,000
కాపీ తర్వాత 2, 1, 2, 1, 3, 4, మరియు చివరిలో కొన్ని అంశాలను తర్వాత.

333
00:24:26,000 --> 00:24:29,000
కానీ ఈ, మేము నిజంగా కాపీ ఏ క్రమంలో ఆధారపడి ఉంటుంది

334
00:24:29,000 --> 00:24:32,000
మేము ప్రాంతంలో మేము లోకి కాపీ చేసిన వాస్తవం గనుక నుండి

335
00:24:32,000 --> 00:24:35,000
భర్తీ మనం కాపీ చేసిన ఒక,

336
00:24:35,000 --> 00:24:46,000
అప్పుడు మేము, ఇక్కడ ప్రారంభించండి ఇష్టపడతారు మేము వెళ్లాలనుకుంటే స్థానంలో 2 కాపీ ఉండవచ్చు

337
00:24:46,000 --> 00:24:52,000
అప్పుడు ముందుకు మా గమనికలు తరలించండి.

338
00:24:52,000 --> 00:24:56,000
>> ఇప్పుడు మేము ఇక్కడ మరియు ఇక్కడ చూడాలని, మరియు ఇప్పుడు మేము కాపీ మీరు

339
00:24:56,000 --> 00:25:04,000
ఈ ఈ గై పైగా గై మరియు ముందుకు మా గమనికలు తరలించండి.

340
00:25:04,000 --> 00:25:07,000
మనం పొందడానికి వదులుకోవడానికి వెళుతున్న, 1, 2, 1, 2, 1 2

341
00:25:07,000 --> 00:25:10,000
బదులుగా తగిన 2 యొక్క, 1, 2, 1, 3, 4 ఎందుకంటే

342
00:25:10,000 --> 00:25:15,000
2, 1 Original 3, 4 overrode.

343
00:25:15,000 --> 00:25:19,000
Memmove సరిగ్గా ఆ నిర్వహిస్తోంది.

344
00:25:19,000 --> 00:25:23,000
ఈ సందర్భంలో, ప్రధానంగా కేవలం ఎల్లప్పుడూ memmove ఉపయోగించడానికి

345
00:25:23,000 --> 00:25:26,000
ఇది సరిగ్గా నిర్వహించే ఎందుకంటే.

346
00:25:26,000 --> 00:25:29,000
ఇది సాధారణంగా ఏ దారుణంగా చెయ్యదు.

347
00:25:29,000 --> 00:25:32,000
ఆలోచన బదులుగా నుండి ప్రారంభమై మరియు ఈ విధంగా కాపీ ఉంటుంది

348
00:25:32,000 --> 00:25:35,000
మేము ఇక్కడ చేశాడు, ఇది చివరి నుండి మొదలవుతుంది మరియు కాపీ

349
00:25:35,000 --> 00:25:38,000
మరియు ఆ సందర్భంలో, మీరు ఒక సమస్య ఎప్పుడూ.

350
00:25:38,000 --> 00:25:40,000
ఏ ప్రదర్శన ఉన్నాయి పోతుంది.

351
00:25:40,000 --> 00:25:47,000
ఎల్లప్పుడూ memmove ఉపయోగించండి. Memcopy గురించి ఆందోళన లేదు.

352
00:25:47,000 --> 00:25:51,000
ప్రత్యేకంగా మీరు memmove రెట్లు వెళుతున్న మరియు ఆ

353
00:25:51,000 --> 00:26:01,000
మీ క్యూ యొక్క చుట్టి-చుట్టూ భాగం.

354
00:26:01,000 --> 00:26:04,000
కంగారుపడవద్దు పూర్తిగా చేస్తే లేదు.

355
00:26:04,000 --> 00:26:10,000
స్టాకు, పుష్, మరియు పాప్ కన్నా ఎక్కువ కష్టం.

356
00:26:10,000 --> 00:26:15,000
>> ఎవరైనా మేము తో పనిచేసే ఏ కోడ్ ఉందా?

357
00:26:15,000 --> 00:26:21,000
పూర్తిగా అసంపూర్తిగా ఉంటే?

358
00:26:21,000 --> 00:26:23,000
[స్టూడెంట్] అవును, అది అయితే, పూర్తిగా అసంపూర్తిగా ఉంది.

359
00:26:23,000 --> 00:26:27,000
మేము మీరు పునర్విమర్శ సేవ్ వంటి పూర్తిగా అసంపూర్తిగా కాలం ఉత్తమంగా ఉంటుంది?

360
00:26:27,000 --> 00:26:32,000
నేను ఆ ప్రతి సమయం మర్చిపోతే.

361
00:26:32,000 --> 00:26:39,000
మేము విషయాలు పరిమాణాన్ని అవసరం వచ్చినప్పుడు సరే, దాన్ని విస్మరిస్తున్నారు జరుగుతుంది.

362
00:26:39,000 --> 00:26:42,000
పూర్తిగా పునఃపరిమాణం విస్మరించండి.

363
00:26:42,000 --> 00:26:49,000
ఈ కోడ్ వివరించండి.

364
00:26:49,000 --> 00:26:54,000
పరిమాణం అన్ని మొదటి కాపీని కంటే తక్కువ ఉంటే నేను మొదటి అన్ని యొక్క తనిఖీ చేస్తున్నాను

365
00:26:54,000 --> 00:27:01,000
మరియు ఆ తర్వాత, నేను ఇన్సర్ట్-I తల + పరిమాణం, పడుతుంది

366
00:27:01,000 --> 00:27:05,000
మరియు నేను, అది యెరే యొక్క సామర్థ్యం చుట్టూ మూటగట్టి నిర్ధారించుకోండి

367
00:27:05,000 --> 00:27:08,000
మరియు నేను ఆ స్థానంలో కొత్త స్ట్రింగ్ ఇన్సర్ట్.

368
00:27:08,000 --> 00:27:12,000
అప్పుడు నేను పరిమాణం పెంచడానికి మరియు నిజమైన తిరిగి.

369
00:27:12,000 --> 00:27:22,000
>> [రాబ్ B.] ఈ ఖచ్చితంగా మీరు mod ఉపయోగించి చేయండి వెళుతున్న ఆ సందర్భాలలో ఒకటి.

370
00:27:22,000 --> 00:27:25,000
మీరు చుట్టూ చుట్టడం అనుకుంటే మీరు,, చుట్టూ చుట్టడం చేసిన సందర్భంలో అయినా

371
00:27:25,000 --> 00:27:29,000
వెంటనే ఆలోచన mod ఉండాలి.

372
00:27:29,000 --> 00:27:36,000
శీఘ్ర సర్వోత్తమీకరణం /, మీ కోడ్ ఒక లైన్ తక్కువగా అనిపిస్తుంది

373
00:27:36,000 --> 00:27:42,000
మీరు లైన్ వెంటనే ఈ క్రింద అని గుర్తించలేకపోతే

374
00:27:42,000 --> 00:27:53,000
కేవలం పరిమాణం + +, కాబట్టి మీరు విలీనం ఈ లైను, పరిమాణం + +.

375
00:27:53,000 --> 00:27:58,000
డౌన్ ఇక్కడ ఇప్పుడు, మేము సందర్భాన్ని

376
00:27:58,000 --> 00:28:01,000
అక్కడ, తగినంత మెమరీ లేదు

377
00:28:01,000 --> 00:28:05,000
కాబట్టి మేము 2 మా సామర్థ్యం పెరుగుతుంది.

378
00:28:05,000 --> 00:28:09,000
నేను మీరు ఇక్కడ అదే సమస్య కాలేదు అంచనా, కానీ మేము ఇప్పుడు విస్మరించవచ్చు

379
00:28:09,000 --> 00:28:13,000
మీరు మీ సామర్థ్యాన్ని అయింది ఉంటే,

380
00:28:13,000 --> 00:28:18,000
అప్పుడు మీరు మళ్ళీ 2 ద్వారా మీ సామర్థ్యం తగ్గుతుంది మీరు చూడాలని.

381
00:28:18,000 --> 00:28:24,000
మరో చిన్న గమనిక మీరు చేయవచ్చు వలె ఉంటుంది + =,

382
00:28:24,000 --> 00:28:30,000
మీరు కూడా << = చేయవచ్చు.

383
00:28:30,000 --> 00:28:43,000
సమానం ముందు దాదాపు ఏదైనా కావచ్చు, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
చార్ * కొత్త మెమరీ మా కొత్త బ్లాక్ ఉంది.

385
00:28:52,000 --> 00:28:55,000
ఓహ్, ఇక్కడ పైగా.

386
00:28:55,000 --> 00:29:02,000
>> ప్రజలు మెమరీ మా కొత్త బ్లాక్ రకం గురించి ఏమి ఆలోచిస్తాడు?

387
00:29:02,000 --> 00:29:06,000
[స్టూడెంట్] ఇది చార్ ** ఉండాలి.

388
00:29:06,000 --> 00:29:12,000
ఇక్కడ మా struct తిరిగి థింకింగ్,

389
00:29:12,000 --> 00:29:14,000
తీగలను మేము reallocating ఏ ఉంది.

390
00:29:14,000 --> 00:29:21,000
మేము క్యూలో మూలకాల కోసం ఒక సంపూర్ణ నూతన డైనమిక్ నిల్వ చేస్తున్నాము.

391
00:29:21,000 --> 00:29:25,000
మనం మీ తీగలను కు కేటాయించి కావడం, మేము ప్రస్తుతం mallocing ఏమి ఉంది

392
00:29:25,000 --> 00:29:30,000
అందువలన కొత్త చార్ ** అని అన్నారు.

393
00:29:30,000 --> 00:29:34,000
ఇది తీగలను యొక్క వ్యూహం చేస్తాడు.

394
00:29:34,000 --> 00:29:38,000
అప్పుడు మేము తప్పుడు తిరిగి చూడాలని ఇది కింద కేసు ఏమిటి?

395
00:29:38,000 --> 00:29:41,000
[స్టూడెంట్] మేము చార్ * చేయడం ఉండాలా?

396
00:29:41,000 --> 00:29:44,000
[రాబ్ B.] అవును, మంచి కాల్.

397
00:29:44,000 --> 00:29:46,000
[స్టూడెంట్] ఏమిటి అని?

398
00:29:46,000 --> 00:29:49,000
[రాబ్ B.] మేము ఏ ఎందుకంటే చార్ * యొక్క పరిమాణం చేయాలనుకుంటున్నామని పొడవైన

399
00:29:49,000 --> 00:29:53,000
sizeof (చార్) 1 ఎందుకంటే ఇది నిజానికి ఒక చాలా పెద్ద సమస్య అవుతుంది.

400
00:29:53,000 --> 00:29:55,000
Sizeof చార్ *, 4 అవతరిస్తుంది

401
00:29:55,000 --> 00:29:58,000
కాబట్టి మీరు ints వ్యవహరించే చేసినప్పుడు సార్లు చాలా,

402
00:29:58,000 --> 00:30:01,000
మీరు దానిని దూరంగా ఉంటాయి ఎందుకంటే Int * యొక్క Int మరియు పరిమాణం పరిమాణం

403
00:30:01,000 --> 00:30:04,000
ఒక 32-bit వ్యవస్థ మీద ఇదే ఉంటాయని నేను.

404
00:30:04,000 --> 00:30:09,000
కానీ ఇక్కడ, sizeof (చార్) మరియు sizeof (చార్ *) ఇప్పుడు ఇదే ఉంటాయని నేను.

405
00:30:09,000 --> 00:30:15,000
>> మేము తప్పుడు తిరిగి పేరు పరిస్థితి ఏమిటి?

406
00:30:15,000 --> 00:30:17,000
[స్టూడెంట్] న్యూ NULL.

407
00:30:17,000 --> 00:30:23,000
కొత్త శూన్య ఉంటే అవును,, మేము, తప్పుడు తిరిగి

408
00:30:23,000 --> 00:30:34,000
మరియు నేను క్రింద త్రో వెళుతున్న ఇక్కడ

409
00:30:34,000 --> 00:30:37,000
[స్టూడెంట్] [వినబడని]

410
00:30:37,000 --> 00:30:39,000
[రాబ్ B.] అవును, ఈ ఉత్తమంగా ఉంటుంది.

411
00:30:39,000 --> 00:30:46,000
మీరు 2 సార్లు సామర్థ్యం లేదా సామర్థ్యం షిఫ్ట్ 1 మరియు అప్పుడు మాత్రమే ఇక్కడ లేదా అది డౌన్ సెట్ పని చేయడు.

412
00:30:46,000 --> 00:30:52,000
మేము అప్పుడు వంటి మేము చేస్తాము.

413
00:30:52,000 --> 00:30:56,000
సామర్థ్యం >> = 1.

414
00:30:56,000 --> 00:31:08,000
మరియు మీరు 1 స్థానాన్ని కోల్పోయిన గురించి ఆందోళన కొనసాగుతుందని ఎప్పుడూ చేస్తున్నారు

415
00:31:08,000 --> 00:31:12,000
మీరు 1 మారింది వదిలి కాబట్టి, 1 స్థానాన్ని, తప్పనిసరిగా ఒక 0

416
00:31:12,000 --> 00:31:16,000
కాబట్టి కుడి 1 మార్చటం, మీరు ఇప్పటికీ జరిమానా చూడాలని.

417
00:31:16,000 --> 00:31:19,000
[స్టూడెంట్] మీరు తిరిగి ముందు అలా చేయాలి?

418
00:31:19,000 --> 00:31:29,000
[రాబ్ B.] అవును, ఈ ఖచ్చితంగా అర్థవంతంగా ఉంటుంది.

419
00:31:29,000 --> 00:31:36,000
>> మేము చివర నిజమైన తిరిగి ముగుస్తుంది చూడాలని ఇప్పుడు భావిస్తాయి.

420
00:31:36,000 --> 00:31:39,000
మేము ఈ memmoves చేయబోతున్నామని మార్గం,

421
00:31:39,000 --> 00:31:45,000
మేము వాటిని ఎలా జాగ్రత్తగా ఉండాలి.

422
00:31:45,000 --> 00:31:50,000
ఎవరైనా మేము వాటిని ఎలా ఏ సలహాలను కలిగి ఉందా?

423
00:32:17,000 --> 00:32:21,000
ఇక్కడ మా ప్రారంభిద్దాం.

424
00:32:21,000 --> 00:32:28,000
అనివార్యంగా, మేము మళ్ళీ ప్రారంభంలో ప్రారంభం కావాలి

425
00:32:28,000 --> 00:32:35,000
అక్కడ నుండి మరియు కాపీ విషయాలు, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
మీరు ఎలా చేయాలి?

427
00:32:41,000 --> 00:32:52,000
మొదటి, నేను మళ్ళీ memmove కోసం మనిషి పేజీ చూడండి ఉంటుంది.

428
00:32:52,000 --> 00:32:57,000
Memmove, వాదనలు క్రమాన్ని చాలా ముఖ్యం.

429
00:32:57,000 --> 00:33:01,000
మేము మూల రెండవ, మూడవ పరిమాణం, మొదటి మా గమ్యం కావలసిన.

430
00:33:01,000 --> 00:33:06,000
మూల మరియు గమ్య రివర్స్ ఇది విధులను కూడా ఉన్నాయి.

431
00:33:06,000 --> 00:33:11,000
గమ్యం, మూల కొంతవరకు కలిగి ఉంటుంది.

432
00:33:17,000 --> 00:33:21,000
Move, అది ఏ తిరిగి?

433
00:33:21,000 --> 00:33:27,000
మీరు ఆ చేయవచ్చు కారణం ఏదైనా గమ్యానికి ఒక పాయింటర్ తిరిగి.

434
00:33:27,000 --> 00:33:32,000
నేను చదువుకోవచ్చు చిత్రం, కాని మేము మా గమ్యం కి కావలసిన.

435
00:33:32,000 --> 00:33:35,000
>> మా గమ్యం ఏమి జరుగుతుందో?

436
00:33:35,000 --> 00:33:37,000
[స్టూడెంట్] న్యూ.

437
00:33:37,000 --> 00:33:39,000
[రాబ్ B.] అవును, మరియు మేము నుండి కాపీ చేయబడతాయి?

438
00:33:39,000 --> 00:33:43,000
మేము కాపీ చేయబడతాయి మొదటి విషయం ఈ 1, 3, 4 ఉంటుంది.

439
00:33:43,000 --> 00:33:50,000
,, 4 3-ఈ 1 ఏమిటి.

440
00:33:50,000 --> 00:33:55,000
ఈ 1 యొక్క చిరునామా ఏమిటి?

441
00:33:55,000 --> 00:33:58,000
ఆ 1 యొక్క చిరునామా ఏమిటి?

442
00:33:58,000 --> 00:34:01,000
[స్టూడెంట్] [వినబడని]

443
00:34:01,000 --> 00:34:03,000
[రాబ్ B.] హెడ్ + మొదటి మూలకం యొక్క చిరునామా.

444
00:34:03,000 --> 00:34:05,000
మేము ఎలా యెరే నందలి మొదటి మూలకం వస్తుందా?

445
00:34:05,000 --> 00:34:10,000
[స్టూడెంట్] క్యూ.

446
00:34:10,000 --> 00:34:15,000
[రాబ్ B.] అవును, q.strings.

447
00:34:15,000 --> 00:34:20,000
గుర్తుంచుకోండి, ఇక్కడ, మా తల 1.

448
00:34:20,000 --> 00:34:24,000
అది రంధ్రాన్ని సరి చేయు. కేవలం ఇది అని మంత్రవిద్య

449
00:34:24,000 --> 00:34:29,000
ఇక్కడ, మా తల 1. నేను చాలా నా రంగు మార్చడానికి వెళుతున్న.

450
00:34:29,000 --> 00:34:36,000
మరియు ఇక్కడ తీగలను ఉంది.

451
00:34:36,000 --> 00:34:41,000
మేము ఇక్కడ పైగా వలె ఈ, మేము గాని అది రాయడం

452
00:34:41,000 --> 00:34:43,000
తో తలలు + q.strings.

453
00:34:43,000 --> 00:34:51,000
మంది కూడా వ్రాయుటకు & q.strings [తల].

454
00:34:51,000 --> 00:34:55,000
ఇది నిజంగా ఏ తక్కువ సామర్థ్యం లేదు.

455
00:34:55,000 --> 00:34:58,000
మీరు dereferencing ఆపై యొక్క చిరునామా పొందడానికి మీరు, ఆలోచించి ఉండవచ్చు

456
00:34:58,000 --> 00:35:04,000
కానీ కంపైలర్ q.strings + తల, ఎలాగైనా మేము ముందు ఏ దానిని అనువదించు అన్నారు.

457
00:35:04,000 --> 00:35:06,000
మీరు ఆలోచించి మీరు ఎలాగైనా.

458
00:35:06,000 --> 00:35:11,000
>> మరియు ఎన్ని బైట్లు మేము కాపీ అనుకుంటున్నారు?

459
00:35:11,000 --> 00:35:15,000
[స్టూడెంట్] కెపాసిటీ - తల.

460
00:35:15,000 --> 00:35:18,000
కెపాసిటీ - తల.

461
00:35:18,000 --> 00:35:21,000
ఆపై మీరు ఎల్లప్పుడూ ఒక ఉదాహరణను రాస్తుంది

462
00:35:21,000 --> 00:35:23,000
అది నిజం ఉంటే గుర్తించడానికి.

463
00:35:23,000 --> 00:35:26,000
[స్టూడెంట్] తర్వాత 2 ద్వారా విభజించబడింది అవసరం.

464
00:35:26,000 --> 00:35:30,000
అవును, నేను మేము పరిమాణం ఉపయోగించవచ్చు అంచనా.

465
00:35:30,000 --> 00:35:35,000
మేము ఇంకా పరిమాణం కలిగి ఉండటం-

466
00:35:35,000 --> 00:35:39,000
పరిమాణం ఉపయోగించి, మేము 4 సమానంగా పరిమాణంలో ఉంటాయి.

467
00:35:39,000 --> 00:35:42,000
మా పరిమాణం 4 ఉంటుంది. మా తల 1.

468
00:35:42,000 --> 00:35:46,000
ఈ 3 అంశాలు కాపీ మీరు.

469
00:35:46,000 --> 00:35:54,000
ఆ పవిత్రత ఆ పరిమాణం తనిఖీ ఉంది - తల సరిగ్గా 3.

470
00:35:54,000 --> 00:35:58,000
మేము ముందు చెప్పారు వంటి మరియు, ఇక్కడ తిరిగి వచ్చే

471
00:35:58,000 --> 00:36:00,000
మేము సామర్థ్యం ఉపయోగిస్తే, అప్పుడు మేము 2 విభజించడానికి భావిస్తాను

472
00:36:00,000 --> 00:36:04,000
మేము ఇప్పటికే మా సామర్థ్యాన్ని పెంచే చేసిన కాబట్టి, బదులుగా, మేము పరిమాణాన్ని ఉపయోగిస్తుంది చూడాలని.

473
00:36:11,000 --> 00:36:13,000
ఆ కాపీలు ఆ భాగం.

474
00:36:13,000 --> 00:36:18,000
ఇప్పుడు, మేము ఇతర భాగాన్ని ప్రారంభానికి వదిలేస్తే ఆ భాగాన్ని కాపీ అవసరం.

475
00:36:18,000 --> 00:36:28,000
>> ఏ స్థానం లో memmove వెళుతున్న?

476
00:36:28,000 --> 00:36:32,000
[స్టూడెంట్] ప్లస్ పరిమాణం - తల.

477
00:36:32,000 --> 00:36:38,000
అవును, కాబట్టి మేము ఇప్పటికే పరిమాణం కాపీ చేసినట్లు - తల బైట్లు,

478
00:36:38,000 --> 00:36:43,000
అందువలన మేము మిగిలిన బైట్లు కాపీ చోట కొత్త ఉంది

479
00:36:43,000 --> 00:36:48,000
ఆపై పరిమాణం మైనస్-బాగా, బైట్లు సంఖ్య మేము సైన్ కాపీ చేసిన

480
00:36:48,000 --> 00:36:52,000
మరియు తర్వాత అక్కడ నుండి కాపీ చేయబడతాయి?

481
00:36:52,000 --> 00:36:54,000
[స్టూడెంట్] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[రాబ్ B.] అవును, q.strings.

483
00:36:56,000 --> 00:37:02,000
మేము దానిని & q.strings [0]. కాలేదు

484
00:37:02,000 --> 00:37:05,000
ఈ కంటే తక్కువగా ఉంటుంది.

485
00:37:05,000 --> 00:37:14,000
అది కేవలం 0 చేస్తాడు, అప్పుడు మీరు q.strings భావిస్తున్నారు చేస్తాము.

486
00:37:14,000 --> 00:37:16,000
మనం కాపీ చేసిన పేర్కొంది.

487
00:37:16,000 --> 00:37:18,000
మేము కాపీ ఎన్ని బైట్లు వదిలి ఉందా? >> [స్టూడెంట్] 10.

488
00:37:18,000 --> 00:37:20,000
కుడి.

489
00:37:20,000 --> 00:37:25,000
[స్టూడెంట్] మేము 5 గుణిస్తారు కు ఉందా - 10 సార్లు బైట్లు లేదా ఏదో యొక్క పరిమాణం?

490
00:37:25,000 --> 00:37:30,000
అవును, ఈ పేరు అంటే సరిగ్గా మేము కాపీ చేయబడతాయి?

491
00:37:30,000 --> 00:37:32,000
[స్టూడెంట్] [వినబడని]

492
00:37:32,000 --> 00:37:34,000
మేము కాపీ చేసిన విషయం రకం ఏమిటి?

493
00:37:34,000 --> 00:37:36,000
[స్టూడెంట్] [వినబడని]

494
00:37:36,000 --> 00:37:41,000
వారి నుంచి వచ్చే అవును, చార్ * s మేము కాపీ చేస్తున్న కాబట్టి, మనం చెప్పలేము.

495
00:37:41,000 --> 00:37:47,000
Well, వారు సూచించే ఎక్కడ, తీగలు వలె మేము వరుసలో ఇది నెట్టడం ముగుస్తుంది

496
00:37:47,000 --> 00:37:49,000
లేదా వరుసలో enqueuing.

497
00:37:49,000 --> 00:37:51,000
వారి నుంచి వచ్చే, మేము సంఖ్య ఆలోచన ఉంది.

498
00:37:51,000 --> 00:37:56,000
మేము చార్ * s తమ ట్రాక్ అవసరం.

499
00:37:56,000 --> 00:38:00,000
తల బైట్లు - మేము పరిమాణం కాపీ లేదు.

500
00:38:00,000 --> 00:38:03,000
తల చార్ * s, - మేము పరిమాణం కాపీ మీరు

501
00:38:03,000 --> 00:38:11,000
కాబట్టి మేము sizeof (చార్ *) ద్వారా ఈ గుణిస్తారు చూడాలని.

502
00:38:11,000 --> 00:38:17,000
అదే డౌన్ ఇక్కడ, తల * sizeof (చార్ *).

503
00:38:17,000 --> 00:38:24,000
>> [స్టూడెంట్] దేని గురించి [వినబడని]?

504
00:38:24,000 --> 00:38:26,000
ఇక్కడ ఈ కుడి?

505
00:38:26,000 --> 00:38:28,000
[స్టూడెంట్] కాదు, ఆ క్రింద, పరిమాణం - తల.

506
00:38:28,000 --> 00:38:30,000
[రాబ్ B.] ఈ కుడి?

507
00:38:30,000 --> 00:38:32,000
పాయింటర్ అంకగణితం.

508
00:38:32,000 --> 00:38:35,000
అంక గణితానికి వెళ్లాలని ఎలా ఉంది

509
00:38:35,000 --> 00:38:40,000
అది స్వయంచాలకంగా వ్యవహరించే చేస్తున్న రకం పరిమాణం గుణించబడుతుంది.

510
00:38:40,000 --> 00:38:46,000
జస్ట్, ఇక్కడ పైగా వంటి కొత్త + (పరిమాణం - తల)

511
00:38:46,000 --> 00:38:56,000
& కొత్త [- తల పరిమాణం] సమానంగా ఉంటుంది

512
00:38:56,000 --> 00:39:00,000
మేము ఆ, సరిగ్గా పని అంచనా వరకు

513
00:39:00,000 --> 00:39:04,000
మేము ఒక పూర్ణాంకానికి శ్రేణి వ్యవహరించే మీరు నుండి, తర్వాత మేము ద్వారా Int-ఇండెక్స్ లేదు

514
00:39:04,000 --> 00:39:07,000
లోకి లేదా 5 యొక్క పరిమాణం మరియు మీరు 4 వ మూలకం కోరుకుంటే, మేము సూచిక

515
00:39:07,000 --> 00:39:10,000
Int శ్రేణి [4].

516
00:39:10,000 --> 00:39:14,000
మీరు don't-[4] Int యొక్క పరిమాణం *.

517
00:39:14,000 --> 00:39:21,000
ఈ కేసు స్వయంచాలకంగా నిర్వహిస్తుంది, మరియు

518
00:39:21,000 --> 00:39:29,000
సాహిత్యపరంగా సమానం, కాబట్టి బ్రాకెట్ సింటాక్స్

519
00:39:29,000 --> 00:39:34,000
కేవలం వెంటనే మీకు కంపైల్ ఈ లాగ అన్నారు.

520
00:39:34,000 --> 00:39:38,000
మీరు ఆ జాగ్రత్తగా ఉండాలి సమ్థింగ్ '

521
00:39:38,000 --> 00:39:42,000
మీరు పరిమాణం జోడించడం చేసినప్పుడు - తల

522
00:39:42,000 --> 00:39:45,000
మీరు ఒక బైట్ కాదు జోడిస్తున్నారు.

523
00:39:45,000 --> 00:39:53,000
మీరు ఒక బైట్లు లేదా ఎలాగైనా ఉండవచ్చు, ఒక చార్ * జోడించే.

524
00:39:53,000 --> 00:39:56,000
>> ఇతర ప్రశ్నలు?

525
00:39:56,000 --> 00:40:04,000
సరే, dequeue సులభంగా అన్నారు.

526
00:40:04,000 --> 00:40:11,000
నేను మీరు అమలు చేయడానికి ఒక నిమిషం ఇస్తాము.

527
00:40:11,000 --> 00:40:18,000
ఓహ్, నేను ఇదే పరిస్థితి అంచనా పేరు

528
00:40:18,000 --> 00:40:21,000
ఏ ఎన్క్యూ కేసు మేము శూన్య enqueuing చేస్తుంటే,

529
00:40:21,000 --> 00:40:24,000
బహుశా మేము అది నిర్వహించడానికి కావలసిన, బహుశా మేము లేదు.

530
00:40:24,000 --> 00:40:27,000
మేము ఇక్కడ మళ్ళీ ఇది, కాని మా స్టాక్ కేసు అదే కాదు.

531
00:40:27,000 --> 00:40:34,000
మేము శూన్య ఎన్క్యూ, దాన్ని మేము విస్మరించవచ్చు అనుకోవచ్చు.

532
00:40:34,000 --> 00:40:40,000
ఎవరైనా నేను పుల్ అప్ చేయవచ్చు కొన్ని కోడ్ ఉందా?

533
00:40:40,000 --> 00:40:45,000
[స్టూడెంట్] నేను dequeue ఉన్నాయి.

534
00:40:45,000 --> 00:40:56,000
వెర్షన్ 2 అని-సరే.

535
00:40:56,000 --> 00:40:59,000
మీరు వివరించేందుకు అనుకుంటున్నారా?

536
00:40:59,000 --> 00:41:01,000
[స్టూడెంట్] మొదట, మీరు క్యూలో విషయం ఏదైనా నిర్ధారించుకోండి

537
00:41:01,000 --> 00:41:07,000
మరియు పరిమాణం 1 గోయింగ్ డౌన్ ఆ.

538
00:41:07,000 --> 00:41:11,000
మీరు అలా అవసరం లేదు, మరియు అప్పుడు మీరు తల తిరిగి

539
00:41:11,000 --> 00:41:13,000
మరియు తర్వాత 1 అప్ తల తరలించండి.

540
00:41:13,000 --> 00:41:19,000
సరే, మేము పరిగణించాలి ఒక మూలలో ఆధారాలున్నాయి. అవును.

541
00:41:19,000 --> 00:41:24,000
[స్టూడెంట్], మీ తల గత మూలకం వద్ద ఉంటే

542
00:41:24,000 --> 00:41:26,000
అప్పుడు మీరు తల శ్రేణి వెలుపల మార్చాలి లేదు.

543
00:41:26,000 --> 00:41:29,000
>> అవును, కాబట్టి వెంటనే తల, మా శ్రేణి ముగింపు హిట్స్

544
00:41:29,000 --> 00:41:35,000
మేము dequeue ఉన్నప్పుడు, మా తల 0 తిరిగి modded చేయాలి.

545
00:41:35,000 --> 00:41:40,000
దురదృష్టవశాత్తు, మేము ఒక దశ లో అలా కాదు.

546
00:41:40,000 --> 00:41:44,000
నేను బహుశా అది పరిష్కరించడానికి కావలసిన విధంగా అంచనా

547
00:41:44,000 --> 00:41:52,000
ఈ, మేము తిరిగి ఏమి ఒక చార్ * అని అన్నారు

548
00:41:52,000 --> 00:41:55,000
మీ వేరియబుల్ పేరు చేయాలనుకుంటున్నారు ఏ.

549
00:41:55,000 --> 00:42:02,000
అప్పుడు మేము మా సామర్థ్యం ద్వారా తల MoD మీరు

550
00:42:02,000 --> 00:42:10,000
ఆపై Ret తిరిగి.

551
00:42:10,000 --> 00:42:14,000
ఇక్కడ మంది అవి-ఉండవచ్చు

552
00:42:14,000 --> 00:42:19,000
ఈ-you'll యొక్క సందర్భంలో ప్రజలు చూడగలరు ఉంటే తల

553
00:42:19,000 --> 00:42:29,000
సామర్థ్యం కంటే ఎక్కువగా తల చేయండి - సామర్థ్యం.

554
00:42:29,000 --> 00:42:36,000
మరియు కేవలం mod ఏమి చుట్టూ పనిచేస్తున్న.

555
00:42:36,000 --> 00:42:41,000
హెడ్ ​​mod = సామర్థ్యం చాలా శుభ్రంగా ఉంది

556
00:42:41,000 --> 00:42:51,000
సామర్థ్యం -. చుట్టూ సామర్థ్యం తల కంటే తల ఎక్కువ ఉంటే కంటే కట్టి యొక్క

557
00:42:51,000 --> 00:42:56,000
>> ప్రశ్నలు?

558
00:42:56,000 --> 00:43:02,000
సరే, మేము వదలి లాస్ట్ థింగ్ మా అనుబంధ జాబితా ఉంది.

559
00:43:02,000 --> 00:43:07,000
మీరు చేస్తే మీరు లింక్ జాబితా ప్రవర్తన యొక్క కొన్ని ఉపయోగించవచ్చు

560
00:43:07,000 --> 00:43:11,000
మీరు ఒక హాష్ పట్టిక, మీ హాష్ పట్టికలలో జాబితాలు లింక్.

561
00:43:11,000 --> 00:43:15,000
నేను గట్టిగా హాష్ పట్టిక సిఫార్సు చేస్తున్నాము.

562
00:43:15,000 --> 00:43:17,000
మీరు ఇప్పటికే ఒక trie చేసి ఉండవచ్చని

563
00:43:17,000 --> 00:43:23,000
కానీ ప్రయత్నాలు మరింత కష్టం.

564
00:43:23,000 --> 00:43:27,000
సిద్ధాంతంలో, వారు asymptotically మెరుగైన ఉన్నాము.

565
00:43:27,000 --> 00:43:30,000
కానీ, పెద్ద బోర్డు చూడండి

566
00:43:30,000 --> 00:43:35,000
మరియు బాగా ఎప్పటికీ ప్రయత్నిస్తుంది, మరియు వారు మరింత మెమరీ పడుతుంది.

567
00:43:35,000 --> 00:43:43,000
ప్రతిదీ గురించి మరింత పని నష్టం ఉండటం ముగుస్తుంది ప్రయత్నిస్తుంది.

568
00:43:43,000 --> 00:43:49,000
ఇది డేవిడ్ మలన్ యొక్క పరిష్కారం ఎప్పుడు ఏమిటి యొక్క

569
00:43:49,000 --> 00:43:56,000
అతను ఎప్పుడూ తన పోస్ట్స్ trie పరిష్కారం, మరియు ప్రస్తుతం ఉన్న యొక్క చూసేలా.

570
00:43:56,000 --> 00:44:00,000
అతను డేవిడ్ J, కింద ఏమిటి?

571
00:44:00,000 --> 00:44:06,000
అతను # 18 యొక్క, ఆ భయంకరమైన చెడు కాదు కాబట్టి

572
00:44:06,000 --> 00:44:09,000
మరియు ఉత్తమ ఒకటిగా జరగబోతోంది మీరు కూడా ఆలోచించవచ్చు ప్రయత్నిస్తుంది

573
00:44:09,000 --> 00:44:17,000
లేదా ఉత్తమ ఒక trie యొక్క ప్రయత్నిస్తుంది.

574
00:44:17,000 --> 00:44:23,000
అది తన అసలైన పరిష్కారం కూడా కాదు?

575
00:44:23,000 --> 00:44:29,000
Trie SOLUTIONS RAM వాడుక ఈ పరిధిలో మరింత ఉంటాయి అని నేను భావిస్తున్నాను.

576
00:44:29,000 --> 00:44:33,000
>> చాలా పైకి క్రిందికి వెళ్ళు, మరియు RAM వాడుక ఒకే అంకెలు ఉంది.

577
00:44:33,000 --> 00:44:36,000
దిగువ దిశగా డౌన్ వెళ్లి, మీరు ప్రయత్నిస్తుంది చూడడాన్ని ప్రారంభించడానికి

578
00:44:36,000 --> 00:44:41,000
మీరు ఖచ్చితంగా భారీ RAM వాడుక చోటే,

579
00:44:41,000 --> 00:44:45,000
మరియు ప్రయత్నాలు మరింత కష్టం.

580
00:44:45,000 --> 00:44:53,000
పూర్తిగా కానీ ఒక విద్యా అనుభూతిని విలువ మీరు ఒక చేస్తే.

581
00:44:53,000 --> 00:44:56,000
లాస్ట్ థింగ్, మా లింక్ జాబితా

582
00:44:56,000 --> 00:45:04,000
మరియు ఈ మూడు విషయాలు, స్టాక్స్, క్యూలు, మరియు అనుసంధాన జాబితాలు,

583
00:45:04,000 --> 00:45:09,000
మీరు కంప్యూటర్ సైన్స్ లో ఏమి భవిష్యత్తులో విషయం

584
00:45:09,000 --> 00:45:12,000
మీరు ఈ విషయాలు దగ్గిర ఉన్నాయి నష్టమని అంచనా.

585
00:45:12,000 --> 00:45:19,000
వారు ప్రతిదీ చేయడం పోషిస్తాయి.

586
00:45:19,000 --> 00:45:25,000
>> జాబితాలు లింక్, మరియు ఇక్కడ మేము ఒక ఒక్కొక్కటిగా లింక్ జాబితా మా అమలు ఉండబోతుంది ఉన్నాయి.

587
00:45:25,000 --> 00:45:34,000
ఒక్కొక్కటిగా ఏమిటి సంబంధం లేదు వంటి రెట్టింపైన లింక్ వ్యతిరేకంగా అర్థం? అవును.

588
00:45:34,000 --> 00:45:37,000
[స్టూడెంట్] ఇది మాత్రమే, తదుపరి పాయింటర్ కంటే గమనికలు పాయింతు

589
00:45:37,000 --> 00:45:39,000
అది తరువాత ఒక ముందు ఒక ఇష్టపడుతున్నారు.

590
00:45:39,000 --> 00:45:44,000
అవును, కాబట్టి చిత్రాన్ని ఫార్మాట్, నేను ఏం చేసావ్?

591
00:45:44,000 --> 00:45:48,000
నేను రెండు విషయాలు ఉన్నాయి. నేను చిత్రం మరియు చిత్రం కలిగి.

592
00:45:48,000 --> 00:45:51,000
చిత్రం ఫార్మాట్ లో, మా ఒక్కొక్కటిగా లింక్ జాబితాలు,

593
00:45:51,000 --> 00:45:57,000
అనివార్యంగా, మేము, మా జాబితా యొక్క తలపై పాయింటర్ రకమైన కలిగి

594
00:45:57,000 --> 00:46:02,000
తరువాత మా జాబితా లోపల, మనం కేవలం గమనికలు కలిగి

595
00:46:02,000 --> 00:46:05,000
మరియు ఇంకా ఈ పాయింట్లు శూన్యం కు.

596
00:46:05,000 --> 00:46:08,000
ఇది ఒక ఒక్కొక్కటిగా లింక్ జాబితా యొక్క మీ సాధారణ డ్రాయింగ్ చేస్తాడు.

597
00:46:08,000 --> 00:46:14,000
నటన ఎన్నటికీ లింక్ జాబితా, మీరు వెనుకకు వెళ్ళవచ్చు.

598
00:46:14,000 --> 00:46:19,000
నేను మీరు జాబితా ఏదైనా నోడ్ ఇవ్వాలని, అప్పుడు మీరు తప్పనిసరిగా పొందవచ్చు

599
00:46:19,000 --> 00:46:23,000
ఇతర నోడ్ జాబితాలో నటన ఎన్నటికీ లింక్ జాబితా ఉంది.

600
00:46:23,000 --> 00:46:27,000
కానీ, నేను మీరు జాబితాలో మూడవ నోడ్ పొందండి మరియు ఒక ఒక్కొక్కటిగా లింక్ జాబితా ఉంటే,

601
00:46:27,000 --> 00:46:30,000
మీరు మొదటి మరియు రెండవ నోడ్స్ ను చూడాలని. కాదు

602
00:46:30,000 --> 00:46:34,000
మరియు ప్రయోజనాలు మరియు నష్టాలు, మరియు ఒక స్పష్టమైన ఒక ఉంది

603
00:46:34,000 --> 00:46:42,000
మీరు మరింత పరిమాణం పడుతుంది, మరియు మీరు ఈ విషయాలు పై ఇక్కడ ట్రాక్ చేస్తుంది.

604
00:46:42,000 --> 00:46:49,000
కానీ మేము కేవలం ఒక్కొక్కటిగా లింక్ శ్రద్ధ.

605
00:46:49,000 --> 00:46:53,000
>> మేము అమలు చూడాలని కొన్ని విషయాలు.

606
00:46:53,000 --> 00:47:00,000
మీ typedef struct నోడ్, Int నేను: struct నోడ్ * తదుపరి నోడ్.

607
00:47:00,000 --> 00:47:09,000
ఆ typedef మీ మనస్సులలో లోకి బూడిద చేయాలని.

608
00:47:09,000 --> 00:47:14,000
Quiz 1, అనుబంధ జాబితా నోడ్ యొక్క ఒక typedef ఇవ్వాలని ఇష్టం చేయాలి

609
00:47:14,000 --> 00:47:18,000
మరియు మీరు వెంటనే ఆ డౌన్ ని విధంగా ఉండాలి

610
00:47:18,000 --> 00:47:22,000
దాని గురించి ఆలోచించకుండా.

611
00:47:22,000 --> 00:47:27,000
నేను ఒక జంట ప్రశ్నలు ఊహించడం, మనం ఇక్కడ struct చేయాలి?

612
00:47:27,000 --> 00:47:32,000
ఎందుకు మేము నోడ్ * చెప్పలేని?

613
00:47:32,000 --> 00:47:35,000
[స్టూడెంట్] [వినబడని]

614
00:47:35,000 --> 00:47:38,000
అవును.

615
00:47:38,000 --> 00:47:44,000
ఒక విషయం ఒక నోడ్ నిర్వచిస్తుంది మాత్రమే విషయం

616
00:47:44,000 --> 00:47:47,000
స్వయంగా typedef ఉంది.

617
00:47:47,000 --> 00:47:55,000
కానీ ఈ పాయింట్, మేము ఈ struct నోడ్ నిర్వచనం ద్వారా పార్సింగ్ రకమైన ఉన్నప్పుడు,

618
00:47:55,000 --> 00:48:01,000
మేము, typedef పూర్తి కాలేదు కాబట్టి నుండి, ఇంకా మా typedef పూర్తి చెయ్యలేదు

619
00:48:01,000 --> 00:48:05,000
నోడ్ లేదు.

620
00:48:05,000 --> 00:48:12,000
కానీ struct నోడ్ చేస్తుంది, మరియు ఈ నోడ్ ఇక్కడ,

621
00:48:12,000 --> 00:48:14,000
ఈ కూడా ఏదైనా చెప్పబడతాయి.

622
00:48:14,000 --> 00:48:16,000
ఈ n చెప్పబడతాయి.

623
00:48:16,000 --> 00:48:19,000
ఇది అనుబంధ జాబితా నోడ్ చెప్పబడతాయి.

624
00:48:19,000 --> 00:48:21,000
ఇది ఏదైనా చెప్పబడతాయి.

625
00:48:21,000 --> 00:48:26,000
కానీ ఈ struct నోడ్ ఈ struct నోడ్ అదే విషయం అని ఉంటుంది.

626
00:48:26,000 --> 00:48:29,000
మీరు ఈ కూడా ఇక్కడ ఉండాలి కాల్ ఏమిటి,

627
00:48:29,000 --> 00:48:32,000
మరియు కనుక ప్రశ్న రెండవ స్థానం సమాధానం

628
00:48:32,000 --> 00:48:37,000
ఎందుకు-ఒక మీరు structs మరియు structs యొక్క typedefs చూసినప్పుడు సార్లు చాలా, ఇది

629
00:48:37,000 --> 00:48:42,000
మీరు typedef struct చూస్తారు మీరు, అనామక structs చూస్తారు

630
00:48:42,000 --> 00:48:47,000
struct, నిఘంటువు లేదా ఎలాగైనా అమలు.

631
00:48:47,000 --> 00:48:51,000
>> ఎందుకు ఇక్కడ మేము నోడ్ సే చేయాలి?

632
00:48:51,000 --> 00:48:54,000
ఎందుకు అది ఒక అనామక struct ఉండకూడదు?

633
00:48:54,000 --> 00:48:56,000
ఇది దాదాపు అదే సమాధానం ఉంది.

634
00:48:56,000 --> 00:48:58,000
[స్టూడెంట్] మీరు struct లోపల అది చూడండి అవసరం.

635
00:48:58,000 --> 00:49:04,000
అవును, struct లో, struct కూడా చూడండి అవసరం.

636
00:49:04,000 --> 00:49:10,000
మీరు struct ఒక పేరు ఇచ్చి లేకపోతే అది ఒక అనామక struct అయితే, మీరు చూడండి కాదు.

637
00:49:10,000 --> 00:49:17,000
మరియు చివరి కాని తక్కువ ఈ అన్ని ఉండాలి కొంతవరకు సూటిగా లేదు,

638
00:49:17,000 --> 00:49:20,000
మీరు ఈ లిఖించడానికి అయితే వారు మీరు తెలుసుకుంటారు సహాయం చేయాలి

639
00:49:20,000 --> 00:49:24,000
విషయాలు ఈ రకమైన సమంజసం మీరు ఏదో తప్పు చేస్తున్న.

640
00:49:24,000 --> 00:49:28,000
చివరిది కానీ, ఎందుకు ఈ struct నోడ్ * ఉండాలి లేదు?

641
00:49:28,000 --> 00:49:34,000
ఎందుకు అది తర్వాతి నోడ్ struct సాధ్యం కాదు?

642
00:49:34,000 --> 00:49:37,000
తదుపరి struct కు [స్టూడెంట్] పాయింటర్.

643
00:49:37,000 --> 00:49:39,000
అంటే ఏమి అనివార్యంగా ఉంది.

644
00:49:39,000 --> 00:49:42,000
ఎందుకు తదుపరి struct నోడ్ ఎప్పటికీ కాలేదు?

645
00:49:42,000 --> 00:49:50,000
ఎందుకు అది * తర్వాత struct నోడ్ ఉండాలి లేదు? అవును.

646
00:49:50,000 --> 00:49:53,000
[స్టూడెంట్] ఇది ఒక అనంతమైన లూప్ వంటిది.

647
00:49:53,000 --> 00:49:55,000
అవును.

648
00:49:55,000 --> 00:49:57,000
[స్టూడెంట్] ఇది అన్నీ ఒకే ఉంటుంది.

649
00:49:57,000 --> 00:50:02,000
అవును, కేవలం మేము యొక్క పరిమాణం లేదా ఏదో ఒకటి ఎలా భావిస్తారు.

650
00:50:02,000 --> 00:50:08,000
ఒక struct పరిమాణం రప్పించింది + లేదా - ఇక్కడ లేదా అక్కడ కొన్ని నమూనా.

651
00:50:08,000 --> 00:50:15,000
ఇది ప్రాథమికంగా struct వస్తువుల పరిమాణాలు మొత్తం చేస్తాడు.

652
00:50:15,000 --> 00:50:18,000
ఇక్కడ ఈ కుడి, ఏదైనా మార్చకుండా, పరిమాణం సులభంగా అన్నారు.

653
00:50:18,000 --> 00:50:24,000
Struct నోడ్ యొక్క పరిమాణం తరువాతి నేను + పరిమాణం పరిమాణం అవతరిస్తుంది.

654
00:50:24,000 --> 00:50:27,000
నేను పరిమాణం 4 అని అన్నారు. తదుపరి పరిమాణం 4 అని అన్నారు.

655
00:50:27,000 --> 00:50:30,000
Struct నోడ్ యొక్క పరిమాణం 8 అని అన్నారు.

656
00:50:30,000 --> 00:50:34,000
మేము * లేకపోతే, sizeof ఆలోచన

657
00:50:34,000 --> 00:50:37,000
అప్పుడు sizeof (i) 4 అని అన్నారు.

658
00:50:37,000 --> 00:50:43,000
Struct నోడ్ యొక్క పరిమాణం తదుపరి తదుపరి struct నోడ్ యొక్క + పరిమాణం నేను పరిమాణం ఉండబోతుంది

659
00:50:43,000 --> 00:50:46,000
తదుపరి struct నోడ్ యొక్క నేను + పరిమాణం + పరిమాణం.

660
00:50:46,000 --> 00:50:55,000
ఇది నోడ్స్ యొక్క ఒక అనంత సూత్రం ఉంటుంది.

661
00:50:55,000 --> 00:51:00,000
ఈ విషయాలు ఉండాలి ఎలా ఎందుకు ఉంది.

662
00:51:00,000 --> 00:51:03,000
>> మళ్లీ, ఖచ్చితంగా, ఆ గుర్తు

663
00:51:03,000 --> 00:51:06,000
లేదా కనీసం మీరు వీటిని వీలుగా అది అర్థం

664
00:51:06,000 --> 00:51:12,000
అది ఎలా ఉండాలో ద్వారా కారణం.

665
00:51:12,000 --> 00:51:14,000
మేము అమలు చేయండి వెళుతున్న విషయాలు.

666
00:51:14,000 --> 00:51:18,000
ఉంటే పొడవు జాబితా-

667
00:51:18,000 --> 00:51:21,000
మీరు మోసం మరియు ఒక చుట్టూ కీపింగ్ చేయవచ్చు

668
00:51:21,000 --> 00:51:24,000
ప్రపంచ పొడవు లేదా ఏదో, కాని మేము ఆ పని చేస్తారో లేదు.

669
00:51:24,000 --> 00:51:28,000
మేము జాబితా పొడవు లెక్కించడానికి వెళుతున్న.

670
00:51:28,000 --> 00:51:34,000
మేము కలిగి ఉన్నాయి, ప్రాథమికంగా ఒక శోధన వంటిది కనుక

671
00:51:34,000 --> 00:51:41,000
కాబట్టి మేము ఈ పూర్ణాంక లింక్ జాబితాలో ఉంటే చూడటానికి పూర్ణాంకాల యొక్క లింక్ జాబితా.

672
00:51:41,000 --> 00:51:44,000
Prepend జాబితా ప్రారంభంలో ఇన్సర్ట్ అన్నారు.

673
00:51:44,000 --> 00:51:46,000
చేర్చు చివరిలో ఇన్సర్ట్ అన్నారు.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted జాబితాలో క్రమబద్ధీకరించబడతాయి స్థానం ఇన్సర్ట్ అన్నారు.

675
00:51:53,000 --> 00:52:01,000
యొక్క Insert_sorted రకమైన మీరు prepend ఉపయోగిస్తారు లేదా చెడు మార్గాల్లో జోడించు ఎప్పుడూ తెలుపుతాయి.

676
00:52:01,000 --> 00:52:09,000
>> మీరు అమలు చేసినప్పుడు insert_sorted-Insert_sorted

677
00:52:09,000 --> 00:52:13,000
లెట్స్ మేము మా లింక్ జాబితా చెప్పారు.

678
00:52:13,000 --> 00:52:18,000
ఇది ప్రస్తుతం 5, 4, 2, ఎలా ఉంటుంది.

679
00:52:18,000 --> 00:52:24,000
నేను, కాబట్టి కాలం జాబితా కూడా ఇప్పటికే క్రమబద్ధీకరించబడింది వంటి, 3 ఇన్సర్ట్ చెయ్యడానికి మీరు

680
00:52:24,000 --> 00:52:27,000
ఇది 3 చెందిన ఎక్కడ వెతకాలో సులభం.

681
00:52:27,000 --> 00:52:29,000
నేను 2 వద్ద ప్రారంభించండి.

682
00:52:29,000 --> 00:52:32,000
సరే, 3 2 కంటే ఎక్కువ, కాబట్టి నేను వెళ్ళడం ఉంచాలని.

683
00:52:32,000 --> 00:52:35,000
ఓహ్, 4 చాలా పెద్దది, నేను 3 2 మరియు 4 మధ్య వెళ్లి అన్నారు తెలుసు

684
00:52:35,000 --> 00:52:39,000
మరియు నేను గమనికలు మరియు అన్ని అంశాలను పరిష్కరించడానికి ఉన్నాయి.

685
00:52:39,000 --> 00:52:43,000
కానీ మేము ఖచ్చితంగా, insert_sorted ఉపయోగించడానికి పొతే

686
00:52:43,000 --> 00:52:50,000
ఇష్టం లెట్స్ కేవలం, నేను 6 prepend సే

687
00:52:50,000 --> 00:52:55,000
నా అనుబంధ జాబితా ఈ మారింది అన్నారు.

688
00:52:55,000 --> 00:53:01,000
ఇది ఇప్పుడు insert_sorted కోసం, మీరు పొందవచ్చు కనుక, అస్సలు అర్ధమే లేదు

689
00:53:01,000 --> 00:53:04,000
కార్యకలాపాలు ఉన్నాయి అయినప్పటికీ జాబితా, క్రమబద్ధీకరించబడింది ఆ

690
00:53:04,000 --> 00:53:09,000
అది వేరు కాదు కారణమవుతాయి, అంతే.

691
00:53:09,000 --> 00:53:20,000
ఆ మీరు అమలు చూడాలని ప్రధాన విషయాలు ఒక ఉపయోగపడిందా చొప్పించు-కాబట్టి కనుగొనండి.

692
00:53:20,000 --> 00:53:24,000
>> ప్రస్తుతం,, పొడవు చేయడానికి నిమిషం మరియు కలిగి

693
00:53:24,000 --> 00:53:30,000
మరియు ఆ చాలా త్వరగా ఉండాలి.

694
00:53:41,000 --> 00:53:48,000
ముగింపు సమయం సమీపంలో, కాబట్టి ఎవరైనా పొడవు కోసం ఏదైనా లేదా కలిగి?

695
00:53:48,000 --> 00:53:50,000
వారు దాదాపు ఒకేలా మాత్రం చేస్తున్నారు.

696
00:53:50,000 --> 00:53:57,000
[స్టూడెంట్] పొడవు.

697
00:53:57,000 --> 00:54:01,000
, చూడండి పునర్విమర్శ లెట్.

698
00:54:01,000 --> 00:54:04,000
సరే.

699
00:54:12,000 --> 00:54:15,000
మీరు వివరించేందుకు అనుకుంటున్నారా?

700
00:54:15,000 --> 00:54:21,000
[స్టూడెంట్] నేను పాయింటర్ నోడ్ సృష్టించడానికి మరియు మా గ్లోబల్ వేరియబుల్ ఇది మొదటి, దానిని ప్రారంభించటానికి,

701
00:54:21,000 --> 00:54:27,000
తరువాత నేను ఒక seg లోపం పొందండి మరియు ఒకవేళ 0 తిరిగి కాబట్టి అది శూన్య అయితే తనిఖీ చేయండి.

702
00:54:27,000 --> 00:54:34,000
లేకపోతే, నేను ద్వారా లూప్, పూర్ణాంక లోపల పర్యవేక్షించడం

703
00:54:34,000 --> 00:54:38,000
నేను జాబితా యొక్క తదుపరి మూలకం ప్రాప్తి మీరు ఎన్ని సార్లు

704
00:54:38,000 --> 00:54:43,000
మరియు అదే పెంపు ఆపరేషన్ లో కూడా, నిజమైన మూలకం యాక్సెస్

705
00:54:43,000 --> 00:54:47,000
మరియు నేను నిరంతరం, అది శూన్య అయితే చెక్ చూడండి చేయడానికి

706
00:54:47,000 --> 00:54:56,000
అది శూన్య అయితే మరియు, అది aborts మరియు కేవలం నేను ప్రాప్తి చేసిన అంశాల సంఖ్యను చూపిస్తుంది.

707
00:54:56,000 --> 00:55:01,000
>> [రాబ్ B.] ఎవరైనా ఏదైనా ఏ వ్యాఖ్యలు కలిగి ఉందా?

708
00:55:01,000 --> 00:55:06,000
ఈ జరిమానా సరి పద్ధతి ఉంది.

709
00:55:06,000 --> 00:55:10,000
[స్టూడెంట్] నేను మీరు నోడ్ == శూన్య అవసరం భావించడం లేదు.

710
00:55:10,000 --> 00:55:13,000
అవును, కాబట్టి నోడ్ ఉంటే == శూన్య తిరిగి 0.

711
00:55:13,000 --> 00:55:18,000
కానీ నోడ్ == శూన్య ఈ-OH, ఒక సరి సమస్య ఉంటే.

712
00:55:18,000 --> 00:55:23,000
ఇది నాకు తిరిగి చేస్తున్నారు, కానీ ఇప్పుడు అది పరిధిని కాదు.

713
00:55:23,000 --> 00:55:30,000
మీరు Int నేను అవసరం, కాబట్టి నేను = 0.

714
00:55:30,000 --> 00:55:34,000
నోడ్ శూన్య ఉంటే కానీ, అప్పుడు నేను ఇప్పటికీ 0 అవతరిస్తుంది

715
00:55:34,000 --> 00:55:39,000
మరియు మేము తిరిగి 0 చూడాలని, ఈ సందర్భంలో ఒకేలా ఉంటుంది.

716
00:55:39,000 --> 00:55:48,000
మరొక సాధారణ విషయం ప్రకటన ఉంచుకోవడం

717
00:55:48,000 --> 00:55:51,000
లూప్ యొక్క నోడ్ లోపలి.

718
00:55:51,000 --> 00:55:54,000
యు సే-OH కాలేదు ఏ.

719
00:55:54,000 --> 00:55:56,000
ఈ ఉంచేందుకు యొక్క లెట్.

720
00:55:56,000 --> 00:55:59,000
నేను బహుశా, Int i = 0 ఇక్కడ ఉంచుతాడు

721
00:55:59,000 --> 00:56:05,000
అప్పుడు నోడ్ * నోడ్ = ఇక్కడ మొదటి.

722
00:56:05,000 --> 00:56:11,000
మరియు ఈ ఇప్పుడు ఈ విమోచనం-పొందడానికి ఎలా కావచ్చు.

723
00:56:11,000 --> 00:56:14,000
ఈ నేను రాసిన ఎలా కావచ్చు.

724
00:56:14,000 --> 00:56:21,000
మీరు ఈ దాన్ని కూడా వైపు చూస్తున్న కాలేదు.

725
00:56:21,000 --> 00:56:25,000
ఇక్కడే లూప్ నిర్మాణం కోసం ఈ

726
00:56:25,000 --> 00:56:30,000
Int i = 0 కోసం మీ దాదాపు వంటి సహజ ఉండాలి

727
00:56:30,000 --> 00:56:33,000
నేను శ్రేణి యొక్క పొడవు కంటే తక్కువగా ఉంటుంది నేను + +.

728
00:56:33,000 --> 00:56:38,000
మీరు వ్యూహం మీద iterate ఎలా ఉంటే, ఈ మీరు ఒక లింక్ జాబితా పై iterate ఎలా ఉంది.

729
00:56:38,000 --> 00:56:45,000
>> ఈ సందర్భంలో రెండవ ప్రకృతి ఉండాలి.

730
00:56:45,000 --> 00:56:50,000
గ్రహించండి, ఈ దాదాపు అదే కాదు అన్నారు.

731
00:56:50,000 --> 00:56:57,000
మీరు అనుబంధ జాబితా పై iterate మీరు చూడాలని.

732
00:56:57,000 --> 00:57:02,000
ఉంటే నోడ్-I విలువ పిలవబడే సంఖ్య ఆలోచన ఉంది.

733
00:57:02,000 --> 00:57:04,000
నోడ్ నేను.

734
00:57:04,000 --> 00:57:15,000
ఆ నోడ్ వద్ద విలువ = i నిజమైన తిరిగి, అంతే ఉంటే.

735
00:57:15,000 --> 00:57:18,000
గమనికను మేము ఎప్పుడూ తప్పుడు తిరిగి ఏకైక మార్గం

736
00:57:18,000 --> 00:57:23,000
మేము మొత్తం లింక్ జాబితా పై iterate మరియు నిజమైన తిరిగి ఎప్పుడూ ఉంటుంది,

737
00:57:23,000 --> 00:57:29,000
కాబట్టి యొక్క ఈ ఏమి చేస్తుంది.

738
00:57:29,000 --> 00:57:36,000
ఒక వైపు గుర్తించదగిన మేము బహుశా కలపవచ్చు లేదా prepend కు అందదు.

739
00:57:36,000 --> 00:57:39,000
>> త్వరిత చివరి గమనించండి.

740
00:57:39,000 --> 00:57:52,000
మీరు స్టాటిక్ కీవర్డ్ చూసినట్లయితే, కాబట్టి, స్థిర Int COUNT = 0 అని పిలవబడు

741
00:57:52,000 --> 00:57:56,000
అప్పుడు మేము COUNT చేయండి + +, మీరు ప్రాథమికంగా ఒక భౌగోళిక వేరియబుల్ దానిని ఆలోచించవచ్చు,

742
00:57:56,000 --> 00:58:00,000
నేను ఈ మేము పొడవు అమలు చూడాలని ఎలా లేనని చెప్పాడు కూడా.

743
00:58:00,000 --> 00:58:06,000
నేను ఇక్కడ ఈ చేయడం మరియు తర్వాత + + COUNT చేస్తున్నాను.

744
00:58:06,000 --> 00:58:11,000
మేము మా COUNT పెంచడం ఉంటాయి మా అనుబంధ జాబితా ఒక నోడ్ ఎంటర్ విధంగా.

745
00:58:11,000 --> 00:58:15,000
ఈ పాయింట్ స్టాటిక్ కీవర్డ్ అంటే ఏమిటి.

746
00:58:15,000 --> 00:58:20,000
నేను Int COUNT కలిగి ఉంటే = రెగ్యులర్ పాత ప్రపంచ వేరియబుల్ అని 0.

747
00:58:20,000 --> 00:58:25,000
ఏ స్థిర Int COUNT అనగా ఈ ఫైల్ కోసం ప్రపంచ వేరియబుల్ ఉంటుంది.

748
00:58:25,000 --> 00:58:28,000
ఇది కొన్ని ఇతర ఫైల్ కోసం అసాధ్యం

749
00:58:28,000 --> 00:58:34,000
మీరు ప్రారంభించారు ఉంటే, pset 5 భావిస్తారు ఇష్టం.

750
00:58:34,000 --> 00:58:39,000
, మీరు రెండు speller.c కలిగి, మరియు మీరు dictionary.c కలిగి

751
00:58:39,000 --> 00:58:42,000
మరియు మీరు speller.c, అప్పుడు ఏదైనా ప్రపంచ ఒక ప్రకటించే విషయం ఉంటే

752
00:58:42,000 --> 00:58:45,000
dictionary.c మరియు తదనుగుణ్యాలను ప్రాప్తి చేయవచ్చు.

753
00:58:45,000 --> 00:58:48,000
గ్లోబల్ వేరియబుల్స్, ఏ. సి ఫైల్ ద్వారా అందుబాటులో ఉంటాయి

754
00:58:48,000 --> 00:58:54,000
కానీ స్టాటిక్ వేరియబుల్స్, ఫైలు లోపలే నుండి మాత్రమే అందుబాటులో ఉంటాయి

755
00:58:54,000 --> 00:59:01,000
కాబట్టి లోపల dictionary.c యొక్క స్పెల్ చెకర్ లేదా లోపల యొక్క,

756
00:59:01,000 --> 00:59:06,000
ఈ నా శ్రేణి యొక్క పరిమాణం నా వేరియబుల్ డిక్లేర్ ఎలా రకం

757
00:59:06,000 --> 00:59:10,000
లేదా నిఘంటువు పదాలు నా సంఖ్య పరిమాణాన్ని.

758
00:59:10,000 --> 00:59:15,000
నేను ఎవరికీ ఆక్సెస్ ఒక ప్రపంచ వేరియబుల్ ప్రకటించాలని మీరు కాబట్టి,

759
00:59:15,000 --> 00:59:18,000
నేను నిజంగా నా సొంత ప్రయోజనాల కోసం ఇది పట్టించుకోనట్లు.

760
00:59:18,000 --> 00:59:21,000
>> ఈ గురించి మంచి విషయం కూడా మొత్తం పేరు తాకిడి stuff ఉంది.

761
00:59:21,000 --> 00:59:27,000
కొన్ని ఇతర ఫైల్ COUNT పేరుతో ఒక అంతర్జాతీయ వేరియబుల్ ఉపయోగించడానికి ప్రయత్నిస్తే, విషయాలు చాలా తప్పు,

762
00:59:27,000 --> 00:59:33,000
, ఈ తగిలిన విషయాలను దూరంగా ఉంచుతుంది, మరియు మీరు దాన్ని ఆక్సెస్ చెయ్యవచ్చు

763
00:59:33,000 --> 00:59:38,000
మరియు ఎవరూ మరియు ఇతరులు COUNT పేరుతో ఒక అంతర్జాతీయ వేరియబుల్ ప్రకటించాడు ఉంటే,

764
00:59:38,000 --> 00:59:43,000
అప్పుడు లెక్కింపు అని పిలువబడుతుంది మీ స్టాటిక్ వేరియబుల్ జోక్యం లేదు.

765
00:59:43,000 --> 00:59:47,000
ఆ స్థిరమైనది ఏమిటి. ఇది ఒక ఫైల్ ప్రపంచ చరరాశి.

766
00:59:47,000 --> 00:59:52,000
>> ఏదైనా ప్రశ్నలకు?

767
00:59:52,000 --> 00:59:59,000
అన్ని సెట్. ఇక సెలవు.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]