1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [వీక్ 6]

2
00:00:02,000 --> 00:00:04,000
[డేవిడ్ J. మలన్] [హార్వర్డ్ విశ్వవిద్యాలయం]

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

4
00:00:08,000 --> 00:00:12,000
>> , ఈ CS50, మరియు ఈ వారం 6 ప్రారంభంలో ఉంది

5
00:00:12,000 --> 00:00:16,000
కాబట్టి కొత్త పనిముట్లను జతగా, ఇప్పుడు మీరు లాభం పొందడానికి అందుబాటులో ఉన్నాయి

6
00:00:16,000 --> 00:00:19,000
ఇది మొదటి CS50 శైలి అంటారు.

7
00:00:19,000 --> 00:00:22,000
మీరు నా టీచింగ్ సభ్యుల ఏదైనా, వంటి అయితే ఆడ్స్ ఉంటాయి

8
00:00:22,000 --> 00:00:26,000
మీరు బహుశా వీరి శైలి ఈ వంటి కొంత కనిపిస్తోంది ఒక కార్యక్రమం చూసిన.

9
00:00:26,000 --> 00:00:30,000
, బహుశా మీరు అర్థరాత్రి కొన్ని మూలల్లో కటింగ్ ప్రారంభించాలి లేదా తర్వాత మీరు వ్యవహరించే చేస్తాము

10
00:00:30,000 --> 00:00:32,000
మరియు తర్వాత ఒక TF లేదా CA కార్యాలయం గంటల సమయంలో వస్తాడు.

11
00:00:32,000 --> 00:00:34,000
మాకు చదవడానికి అప్పుడు కష్టం.

12
00:00:34,000 --> 00:00:38,000
Well, ఈ కోడు వాక్యనిర్మాణపరంగా సరియైనది, మరియు అది కంపైల్ కనిపిస్తుంది, మరియు నిజానికి రన్ చేస్తుంది.

13
00:00:38,000 --> 00:00:40,000
కానీ ఖచ్చితంగా శైలి కోసం ఒక 5 కాదు.

14
00:00:40,000 --> 00:00:45,000
>> కానీ ఇప్పుడు, మేము ఈ డైరెక్టరీలో వెళ్ళి ఉంటే ఇక్కడ

15
00:00:45,000 --> 00:00:48,000
మరియు నేను కలిగి conditions2.c ప్రకటన

16
00:00:48,000 --> 00:00:55,000
మరియు నేను, Enter, ఈ ఫైల్ conditions2.c ఈ కొత్త ఆదేశం, style50, అమలు

17
00:00:55,000 --> 00:00:57,000
అది అందమైన ఉంది నాకు సమాచారం చేసే గమనిస్తారు.

18
00:00:57,000 --> 00:01:00,000
Gedit, ఫైలు డిస్కులో మార్చబడింది గమనించాడు

19
00:01:00,000 --> 00:01:08,000
నేను రీలోడ్ క్లిక్ చేస్తే మరియు, మీ అన్ని సమస్యలు ఇప్పుడు స్వయంచాలకంగా ఉంటాయి.

20
00:01:08,000 --> 00:01:15,000
[చప్పట్లు]

21
00:01:15,000 --> 00:01:17,000
అంటే ఈ వారాంతంలో చేసిన విషయాలు ఒకటి.

22
00:01:17,000 --> 00:01:20,000
కొన్ని కోడ్ ఉన్నాయి ఎందుకంటే అది అసంపూర్ణ అని రియలైజ్

23
00:01:20,000 --> 00:01:23,000
అది ఖచ్చితంగా stylize చేయగలరు, కాదని

24
00:01:23,000 --> 00:01:26,000
కాని ఈ ఇప్పుడు మీరు పొందగలరు ఉపకరణం

25
00:01:26,000 --> 00:01:33,000
మాత్రమే మరింత errantly ఉంచుతారు వంకర జంట కలుపులు యొక్క అప్ చక్కనైన కొన్ని మరియు ఇష్టపడితే.

26
00:01:33,000 --> 00:01:36,000
>> కానీ మరింత ఖచ్చితంగా ఇప్పుడు CS50 చెక్ ఉంది.

27
00:01:36,000 --> 00:01:39,000
CS50 చెక్, మీరు ఒకే సరి పరీక్షలు చేయవచ్చు

28
00:01:39,000 --> 00:01:42,000
టీచింగ్ సభ్యులు చేయగల మీ స్వంత కోడ్ న.

29
00:01:42,000 --> 00:01:44,000
ఈ పరికరంలోని ఇప్పుడు వచ్చే ఒక కమాండ్ లైన్ సదుపాయం

30
00:01:44,000 --> 00:01:46,000
వెంటనే మీకు ప్రకారం ఒక update50 చేస్తాను

31
00:01:46,000 --> 00:01:49,000
pset 4 లక్షణాలు, మరియు మీరు ఈ తప్పనిసరిగా దాన్ని ఉపయోగించండి.

32
00:01:49,000 --> 00:01:51,000
మీరు కమాండ్ check50 అమలు.

33
00:01:51,000 --> 00:01:56,000
అప్పుడు మీకు ఒక కమాండ్ లైన్ వాదన లో పాస్, లేదా సాధారణంగా ఒక స్విచ్ లేదా పతాకం అని పిలుస్తారు.

34
00:01:56,000 --> 00:01:58,000
సాధారణంగా, హైపన్ కలిగి వస్తువులు స్విచ్ అంటారు

35
00:01:58,000 --> 00:02:02,000
ఒక కమాండ్ లైన్ కార్యక్రమం, తద్వారా-c నిర్దేశిస్తుంది

36
00:02:02,000 --> 00:02:04,000
మీరు అమలు చేయడానికి కావలసిన తనిఖీ చేస్తుంది.

37
00:02:04,000 --> 00:02:07,000
>> మీరు అమలు చేయడానికి కావలసిన పరీక్షలు, ప్రత్యేకంగా ఈ స్ట్రింగ్ ద్వారా గుర్తించబడతాయి

38
00:02:07,000 --> 00:02:10,000
2012/pset4/resize.

39
00:02:10,000 --> 00:02:13,000
ఇతర మాటలలో, కేవలం ఏకపక్ష కానీ ప్రత్యేక స్ట్రింగ్ యొక్క

40
00:02:13,000 --> 00:02:18,000
మేము ప్రత్యేకంగా pset 4 యొక్క సరి పరీక్షలు గుర్తించడానికి ఉపయోగించే.

41
00:02:18,000 --> 00:02:21,000
మరియు మీరు అప్లోడ్ చేయాలనుకున్న ఫైళ్ళను స్పేస్ వేరు జాబితాని పేర్కొనడానికి

42
00:02:21,000 --> 00:02:24,000
విశ్లేషణ కోసం CS50 పొందవచ్చు.

43
00:02:24,000 --> 00:02:29,000
ఉదాహరణకు, నేను ఇక్కడ నా పరిష్కారం వెళ్ళాలని ఉంటే resize.c-

44
00:02:29,000 --> 00:02:31,000
నాకు పెద్ద టెర్మినల్ విండో అప్ తెరిచి తెలియజేయండి

45
00:02:31,000 --> 00:02:42,000
మరియు నేను ముందుకు వెళ్లి లెట్స్ అమలు check50-c 2012/pset4/resize సే,

46
00:02:42,000 --> 00:02:46,000
మరియు నేను, ముందుకు వెళ్ళి, ఫైళ్ళ పేర్లు పేర్కొనండి

47
00:02:46,000 --> 00:02:49,000
resize.c, మరియు అప్పుడు కంప్రెస్, Enter నొక్కండి

48
00:02:49,000 --> 00:02:53,000
అది అప్లోడ్లు, అది వెతుకుతుంది, మరియు నేను పరీక్షలను మొత్తం బంచ్ విఫలమైంది.

49
00:02:53,000 --> 00:02:59,000
ఎడమ ఎగువన Red లో ఒక resize.c మరియు bmp ఉనికిలో చెప్పారు.

50
00:02:59,000 --> 00:03:01,000
ఆ పరీక్ష. అంటే అడిగారు ప్రశ్న.

51
00:03:01,000 --> 00:03:04,000
సమాధానం తప్పు, ఎందుకంటే అది సంతోషంగా ఉంది.

52
00:03:04,000 --> 00:03:08,000
ఈ కింది వైట్ టెక్స్ట్ ఉందని bmp.h అంచనా అన్నారు, మరియు ఆ కేవలం నా తప్పు.

53
00:03:08,000 --> 00:03:11,000
, నేను అప్లోడ్ మర్చిపోయాను, నేను రెండు ఫైళ్లను అప్ లోడ్ చెయ్యడానికి

54
00:03:11,000 --> 00:03:14,000
resize.c మరియు bmp.h.

55
00:03:14,000 --> 00:03:17,000
వారు అమలు చెయ్యలేదు ఎందుకంటే కానీ ఇప్పుడు ఇతర పరీక్షలు అన్ని పసుపు గమనించి,

56
00:03:17,000 --> 00:03:21,000
అతను చంపడు లేదా హ్యాపీ విచారంగా ఎందుకంటే అందువలన స్మైలీ ముఖం, నిలువు

57
00:03:21,000 --> 00:03:25,000
కానీ మేము ఆ ఇతర తనిఖీలు అమలు ముందుగా Red లో ఆ సమస్యను మార్పులు ఉంటాయి.

58
00:03:25,000 --> 00:03:27,000
>> దీన్ని పరిష్కరించడానికి నాకు లెట్.

59
00:03:27,000 --> 00:03:30,000
కూడా bmp.h తో, నాకు దూరంగా మరియు ఈ తిరిగి ఈ సమయంలో లెట్

60
00:03:30,000 --> 00:03:34,000
అన్ని బాగా పోతే ఆదేశ, ఇప్పుడు నమోదు చేసి,

61
00:03:34,000 --> 00:03:38,000
మీ యొక్క కలిగి ఫలితంగా తనిఖీ తరువాత తిరిగి వెళుతున్న శ్వాస-

62
00:03:38,000 --> 00:03:42,000
నేను ఇప్పటివరకు pset 4 న నిజంగా బాగా చేస్తున్నాను అంటే అన్ని ఆకుపచ్చ,.

63
00:03:42,000 --> 00:03:44,000
మీరు ఇక్కడ చూడండి మరియు వివరణాత్మక టెక్స్ట్ నుండి ప్రతిపాదించే చేయవచ్చు

64
00:03:44,000 --> 00:03:47,000
అది మేము పరీక్షిస్తారు సరిగ్గా అదే.

65
00:03:47,000 --> 00:03:49,000
మేము మొదటి ఫైళ్లు ఉన్నాయి పరీక్షించారు?

66
00:03:49,000 --> 00:03:51,000
మేము అప్పుడు resize.c కంపైల్ చేస్తుంది పరీక్షించారు?

67
00:03:51,000 --> 00:03:58,000
అప్పుడు మేము n, పునఃపరిమాణం అంశం, 1 ఉన్నప్పుడు అది ఒక 1x1-పిక్సెల్ BMP పరిమాణాన్ని లేదు పరీక్షించారు.

68
00:03:58,000 --> 00:04:01,000
మీరు n అంటే ఏమిటో తెలియదు ఉంటే ఇప్పుడు, మీరు ఒకసారి మీరు, pset 4 ప్రవేశిస్తాడు కనిపిస్తుంది

69
00:04:01,000 --> 00:04:04,000
కానీ ఆ కేవలం మీరు పునఃపరిమాణం లేదు నిర్ధారించుకోండి ఒక పవిత్రత తనిఖీ ఉంది

70
00:04:04,000 --> 00:04:08,000
పునఃపరిమాణం ఫాక్టర్ 1 ఉంటే అన్ని వద్ద ఒక చిత్రం.

71
00:04:08,000 --> 00:04:14,000
దీనికి విరుద్ధంగా, ఇది సరిగ్గా 2x2 ఒక 1x1 పిక్సెల్ BMP ఒక 1x1 పిక్సెల్ resizes ఉంటే

72
00:04:14,000 --> 00:04:19,000
n 2 ఉన్నప్పుడు, అప్పుడు అదేవిధంగా, గని అనుగుణంగా ఉంది.

73
00:04:19,000 --> 00:04:22,000
>> చిన్న లో, ఈ ఒక, అర్థం, దాటే వేళ్లు పడుతుంది

74
00:04:22,000 --> 00:04:25,000
మీకు ముందు సమీకరణం నుండి మీ pset submit.

75
00:04:25,000 --> 00:04:28,000
మీరు మీ TF వెంటనే తెలుస్తుంది సరిగ్గా ఏమి ఉంటుంది

76
00:04:28,000 --> 00:04:30,000
మీరు ఈ సమస్య సెట్లు కొన్ని సమర్పించడం గురించి అనుకుంటే,

77
00:04:30,000 --> 00:04:34,000
మరియు బోధనకు ప్రేరణ ఉంచాలి నిజంగా ఉంది

78
00:04:34,000 --> 00:04:37,000
మీరు ఒక ఊహాకల్పిత తెలుసు కనుక మీరు ముందు అవకాశం

79
00:04:37,000 --> 00:04:39,000
మీ కోడ్ దోషాలు మరియు పాస్ కాదు పరీక్షలు, అక్కడ

80
00:04:39,000 --> 00:04:43,000
ఆ సమస్యలను పరిష్కరించటానికి ముందు అప్ మరింత సమర్థవంతమైన సమయంలో ఉంచవచ్చు

81
00:04:43,000 --> 00:04:45,000
పాయింట్లను కోల్పోతారు కంటే, మీ TF నుండి ఫీడ్ బ్యాక్ పొందడానికి

82
00:04:45,000 --> 00:04:48,000
మరియు నేను ఆ కనుగొన్నారు వుండాలి వంటి ", Ahh", వెళ్ళండి.

83
00:04:48,000 --> 00:04:50,000
ఇప్పుడు కనీసం మీరు ఆ కనుగొనడానికి సహాయం ఒక సాధనం ఉంది.

84
00:04:50,000 --> 00:04:52,000
ఇది బగ్ ఉన్న అభిప్రాయపడుతున్నారు మాత్రం కాదు, కాని అది ఇత్సెల్ఫ్

85
00:04:52,000 --> 00:04:54,000
ఇది చిహ్నంగా ఏమిటి.

86
00:04:54,000 --> 00:04:57,000
>> ఇప్పుడు పరీక్షలు తప్పనిసరిగా సమగ్రంగా ఉన్నాయి తెలుసుకుంటారు.

87
00:04:57,000 --> 00:04:59,000
మీరు ఆకుపచ్చ స్మైలీ ముఖాల పూర్తి స్క్రీన్ పొందండి వలన

88
00:04:59,000 --> 00:05:02,000
మీ కోడ్ ఖచ్చితమైన అని అర్ధం కాదు, కానీ అర్ధం లేదు

89
00:05:02,000 --> 00:05:06,000
అది నిర్దేశ సూచించిన కొన్ని పరీక్షలు దాటింది ఆ.

90
00:05:06,000 --> 00:05:08,000
కొన్నిసార్లు మేము తనిఖీలు విడుదల కాదు.

91
00:05:08,000 --> 00:05:10,000
ఉదాహరణకు, హూడన్ఇట్, pset 4 అంశాలు ఒకటి,

92
00:05:10,000 --> 00:05:15,000
మేము మీరు నిరాశ రకం ఇవ్వాలని ఉంటే

93
00:05:15,000 --> 00:05:18,000
అది ఏమిటో, మరియు బహిర్గతం రకాలుగా ఉంది వంటి సమాధానం

94
00:05:18,000 --> 00:05:21,000
వ్యక్తి ఎరుపు శబ్దం ఎవరు.

95
00:05:21,000 --> 00:05:24,000
స్పెక్ ఎల్లప్పుడూ pset 5 ముందుకు కోసం భవిష్యత్తులో తెలుపుతుంది

96
00:05:24,000 --> 00:05:26,000
మీరు కోసం ఉనికిలో వెతుకుతుంది ఏ.

97
00:05:26,000 --> 00:05:28,000
మీరు క్రింద ఈ వైట్ URL లేదు మీరు గమనించవచ్చు.

98
00:05:28,000 --> 00:05:30,000
ఇప్పుడు, ఈ కేవలం విశ్లేషణ అవుట్పుట్ ఉంది.

99
00:05:30,000 --> 00:05:33,000
మీరు ఆ URL సందర్శించండి, మీరు వెర్రి, గుప్తమైన సందేశాల మొత్తం బంచ్ పొందుతారు

100
00:05:33,000 --> 00:05:36,000
మీరు ద్వారా రూపానికి స్వాగతం, కానీ అది సిబ్బంది ఎక్కువగా ఉండే

101
00:05:36,000 --> 00:05:41,000
కాబట్టి మేము నిర్ధారించడానికి మరియు check50 స్వయంగా దోషాలు డీబగ్ చేసే.

102
00:05:41,000 --> 00:05:46,000
>> అవి లేకుండా, మేము యొక్క వదిలి పేరు కొనసాగండి తెలియజేయండి.

103
00:05:46,000 --> 00:05:48,000
కొన్ని వారాల మంజూరు కోసం మేము పట్టింది CS50 లైబ్రరీ,

104
00:05:48,000 --> 00:05:52,000
కానీ అప్పుడు గత వారం, మేము ఇది పొరల యొక్క ఒక తిరిగి పొట్టు ప్రారంభించారు.

105
00:05:52,000 --> 00:05:55,000
మేము బదులుగా ఏమి అనుకూలంగా స్ట్రింగ్ పక్కన పెట్టటం ప్రారంభించాడు?

106
00:05:55,000 --> 00:05:57,000
[స్టూడెంట్స్] చార్.

107
00:05:57,000 --> 00:05:59,000
ఈ సమయంలో ఒక చార్ * ఉంది చార్ *,,

108
00:05:59,000 --> 00:06:03,000
కానీ ఇప్పుడు మేము ఇది ఒక వాస్తవ డేటా రకం స్ట్రింగ్ అని నటిస్తాడు లేదు.

109
00:06:03,000 --> 00:06:06,000
అయితే,, చార్ * కొరకు అన్నిరకాల పర్యాయపదంగా ఉన్నారు

110
00:06:06,000 --> 00:06:09,000
మరియు ఒక స్ట్రింగ్, అక్షరాలు ఒక వరుస క్రమం

111
00:06:09,000 --> 00:06:14,000
కాబట్టి ఎందుకు చార్ * s వంటి తీగలను ప్రాతినిధ్యం సమంజసం లేదు?

112
00:06:14,000 --> 00:06:20,000
ఒక చార్ * స్ట్రింగ్ యొక్క ఈ భావన యొక్క సందర్భం లో ఏం ప్రాతినిధ్యం లేదు?

113
00:06:20,000 --> 00:06:23,000
అవును. >> [స్టూడెంట్] మొదటి పాత్ర.

114
00:06:23,000 --> 00:06:25,000
గుడ్, మొదటి అక్షరం, కానీ చాలా మొదటి పాత్ర.

115
00:06:25,000 --> 00:06:27,000
ఇది-[స్టూడెంట్స్] చిరునామా ఉంది.

116
00:06:27,000 --> 00:06:29,000
గుడ్, మొదటి అక్షరం యొక్క చిరునామా.

117
00:06:29,000 --> 00:06:33,000
ఒక కంప్యూటర్ యొక్క మెమరీ లో ఒక స్ట్రింగ్ ప్రాతినిధ్యం అందరికీ

118
00:06:33,000 --> 00:06:36,000
కేవలం దాని మొట్టమొదటి బైట్ యొక్క ఏకైక చిరునామా.

119
00:06:36,000 --> 00:06:38,000
మీరు కూడా ఇది ఎంత తెలుసు లేదు

120
00:06:38,000 --> 00:06:42,000
ఎలా మీరు డైనమిక్ ఆ గుర్తించడానికి ఎందుకంటే?

121
00:06:42,000 --> 00:06:44,000
[స్టూడెంట్] స్ట్రింగ్ పొడవు.

122
00:06:44,000 --> 00:06:48,000
మీరు స్ట్రింగ్ పొడవు, అద్భుతమైన, కాని ఎలా స్ట్రింగ్ పొడవు పని చేస్తుంది కాల్ చేయవచ్చు?

123
00:06:48,000 --> 00:06:50,000
ఇది ఏమి చేస్తుంది? అవును.

124
00:06:50,000 --> 00:06:52,000
[స్టూడెంట్] మీరు శూన్య పాత్ర వచ్చేవరకు కొనసాగించడాన్ని.

125
00:06:52,000 --> 00:06:54,000
అవును, సరిగ్గా, అది కేవలం అయితే లూప్, లూప్ ఒక తో iterates

126
00:06:54,000 --> 00:06:57,000
* నుండి చివరి వరకు ఏ, మరియు ముగింపు ప్రాతినిధ్యం ఉంది

127
00:06:57,000 --> 00:07:01,000
\ 0 ద్వారా, అని పిలవబడే nul పాత్ర nul,

128
00:07:01,000 --> 00:07:05,000
ఒక పాయింటర్ ఉంది శూన్య, పోలి ఉంటాయి కాదు

129
00:07:05,000 --> 00:07:07,000
ఈ రోజు మళ్ళీ సంభాషణ లో వస్తారు.

130
00:07:07,000 --> 00:07:11,000
>> , మేము తిరిగి GetInt ఒక పొర ఒలిచిన, మరియు అప్పుడు మేము GetString వద్ద చూడటం జరిగింది

131
00:07:11,000 --> 00:07:14,000
మరియు, ఆ విధులు రెండు, లేదా నిజంగా రీకాల్

132
00:07:14,000 --> 00:07:18,000
GetString, ఒక నిర్దిష్ట చర్యను ఉపయోగించటం ఉంది

133
00:07:18,000 --> 00:07:21,000
వాస్తవానికి అన్వయించడం, వినియోగదారు యొక్క ఇన్పుట్ లేదా చదవండి విశ్లేషించడానికి అని.

134
00:07:21,000 --> 00:07:25,000
ఆ కొత్త ఫంక్షన్ ఏమిటి?

135
00:07:25,000 --> 00:07:27,000
Scanf లేదా sscanf. ఇది నిజానికి కొన్ని విభిన్న రుచులు వస్తుంది.

136
00:07:27,000 --> 00:07:31,000
Scanf ఉన్నాయి, sscanf ఉంది, fscanf ఉంది.

137
00:07:31,000 --> 00:07:35,000
ఇప్పుడు కోసం, అయినప్పటికీ, యొక్క అతి సులువుగా చిత్రించారు దృష్టి తెలియజేయండి

138
00:07:35,000 --> 00:07:38,000
మరియు నాకు ముందుకు వెళ్లి పరికరంలోని ప్రారంభం తెలియజేయండి

139
00:07:38,000 --> 00:07:41,000
ఈ వంటి ఫైలు, scanf1.c.

140
00:07:41,000 --> 00:07:43,000
ఇది ఒక సూపర్ సాధారణ ప్రోగ్రామ్

141
00:07:43,000 --> 00:07:46,000
కానీ మేము ఎన్నడూ లేని ఏదో చేస్తుంది

142
00:07:46,000 --> 00:07:48,000
CS50 లైబ్రరీ సహాయం లేకుండా.

143
00:07:48,000 --> 00:07:51,000
ఈ వినియోగదారు నుండి ఒక పూర్ణాంకానికి పొందుతాడు. అది ఎలా పనిచేస్తుంది?

144
00:07:51,000 --> 00:07:53,000
Well, మార్గం కూడా 16 లో,

145
00:07:53,000 --> 00:07:56,000
మేము ఒక పూర్ణాంకానికి అని x డిక్లేర్ అని గుర్తించలేకపోతే, మరియు కథ ఈ సమయంలో,

146
00:07:56,000 --> 00:07:58,000
x యొక్క విలువ ఏమిటి?

147
00:07:58,000 --> 00:08:00,000
[వినబడని విద్యార్థి ప్రతిస్పందన]

148
00:08:00,000 --> 00:08:02,000
[డేవిడ్ M.] కుడి, తెలిసిన, కొన్ని చెత్త విలువ సమర్థవంతంగా, కాబట్టి 17 లో, మేము వినియోగదారు చెప్పండి

149
00:08:02,000 --> 00:08:06,000
దయచేసి, నాకు అనేక ఇస్తుంది మరియు ఇది ఆసక్తికరమైన గెట్స్ పేరు స్టెప్ 18 ఉంది.

150
00:08:06,000 --> 00:08:11,000
Scanf అది కోట్స్ లో ఈ ఫార్మాట్ సంకేతాలు ఉపయోగించే లో printf నుండి ఒక ఆలోచన ఋణం తెలుస్తోంది.

151
00:08:11,000 --> 00:08:13,000
% D కోర్సు యొక్క దశాంశ సంఖ్య.

152
00:08:13,000 --> 00:08:21,000
కానీ నేను & x బదులుగా కేవలం x అక్కడ వున్నాను?

153
00:08:21,000 --> 00:08:24,000
మాజీ సరైనది. అవును.

154
00:08:24,000 --> 00:08:26,000
[వినబడని విద్యార్థి ప్రతిస్పందన]

155
00:08:26,000 --> 00:08:31,000
సరిగ్గా, ఈ కార్యక్రమం యొక్క లక్ష్యం, ఫంక్షన్ GetInt కూడా వంటి,

156
00:08:31,000 --> 00:08:34,000
యూజర్ నుండి ఒక పూర్ణాంకానికి పొందడానికి నేను విధులు పాస్ కాదు

157
00:08:34,000 --> 00:08:38,000
అన్ని విషయాల్లోనూ నేను కావాలి, కాని నేను సూచన వాటిని పాస్ లేకపోతే

158
00:08:38,000 --> 00:08:41,000
లేదా పాయింటర్ చిరునామా ద్వారా లేదా, నేటి ప్రయోజనాల కోసం అన్ని పర్యాయపదంగా,

159
00:08:41,000 --> 00:08:46,000
ఆ ఫంక్షన్ ఆ వేరియబుల్ విషయాలు మార్చుకునే సామర్థ్యం కలిగి ఉంది.

160
00:08:46,000 --> 00:08:49,000
ఇది స్వాప్ బగ్గీ సంస్కరణ వలె కాపీని లో చేరుతుందని

161
00:08:49,000 --> 00:08:51,000
మేము ఇప్పుడు కొన్ని సార్లు మాట్లాడుకున్నారు చేసిన.

162
00:08:51,000 --> 00:08:54,000
>> కానీ బదులుగా, చేయడం & x ద్వారా, నేను అక్షరాలా ఏ అక్కడ నేను?

163
00:08:54,000 --> 00:08:57,000
[స్టూడెంట్] చిరునామా. X యొక్క చిరునామా >>.

164
00:08:57,000 --> 00:09:01,000
ఇది scanf అని ఫంక్షన్కు ఒక పటం గీయడం మరియు ఇక్కడ చెప్పడం వంటిది

165
00:09:01,000 --> 00:09:04,000
ఈ కంప్యూటర్ లో మెమరీ భాగం ఆదేశాలను ఉంటాయి

166
00:09:04,000 --> 00:09:07,000
మీరు కొన్ని పూర్ణాంక నిల్వ వెళ్ళే ఆ

167
00:09:07,000 --> 00:09:10,000
క్రమంలో sscanf కోసం ఇప్పుడు ఆ విధంగా చేయడానికి

168
00:09:10,000 --> 00:09:13,000
ఏ ఆపరేటర్లు, వాక్యనిర్మాణం యొక్క ఏ భాగాన్ని దానిని ఉపయోగించడానికి అన్నారు

169
00:09:13,000 --> 00:09:19,000
ఎవరో ఈ ఫంక్షన్ రాశారు ఎందుకంటే మేము దీనిని చూడలేరు అయినప్పటికీ?

170
00:09:19,000 --> 00:09:21,000
ఇతర మాటలలో - ఆ ఏది?

171
00:09:21,000 --> 00:09:23,000
[స్టూడెంట్] X చదవండి.

172
00:09:23,000 --> 00:09:27,000
అక్కడ కొన్ని పఠనం మాత్రం, కానీ ఇక్కడ x సంబంధించి ఉంటుంది.

173
00:09:27,000 --> 00:09:30,000
Scanf x యొక్క చిరునామా జారీ ఉంది ఉంటే,

174
00:09:30,000 --> 00:09:35,000
పదము, ఏ ఆపరేటర్లు ఎక్కడో ఇమిడిపోగలదని

175
00:09:35,000 --> 00:09:38,000
లోపల scanf యొక్క అమలు తద్వారా scanf

176
00:09:38,000 --> 00:09:42,000
నిజానికి ఆ చిరునామా ఒక సంఖ్య 2 వ్రాయగలరు?

177
00:09:42,000 --> 00:09:44,000
అవును, కాబట్టి *.

178
00:09:44,000 --> 00:09:47,000
* తప్పనిసరిగా అక్కడ వెళ్ళి అంటే మా dereference ఆపరేటర్లు, అని గుర్తు.

179
00:09:47,000 --> 00:09:50,000
>> కేసు ఇక్కడ ఉంది మీరు,, ఒక చిరునామా అప్పగించారు చేసిన

180
00:09:50,000 --> 00:09:53,000
scanf మేము నిజానికి దాని మూల చుట్టూ చూస్తూ బహుశా-ఉంటే కోడ్

181
00:09:53,000 --> 00:09:59,000
* x లేదా వాస్తవానికి ఆ చిరునామాకు వెళ్ళి అక్కడ కొన్ని విలువ ఉంచాలి సమానమైన చేస్తోంది.

182
00:09:59,000 --> 00:10:02,000
ఇప్పుడు scanf కీబోర్డ్ నుండి ఇన్పుట్ గెట్స్ ఎలా,

183
00:10:02,000 --> 00:10:04,000
మేము ఈ రోజు మా చేతులు బయటకు దుర్చాల్సిన చేస్తాము.

184
00:10:04,000 --> 00:10:07,000
జస్ట్ ఆపరేటింగ్ సిస్టమ్ మాట్లాడటానికి sscanf అనుమతిస్తుంది భావిస్తాయి

185
00:10:07,000 --> 00:10:11,000
యూజర్ యొక్క కీబోర్డ్, కానీ ఇప్పుడు లైన్ 19 ఈ సమయంలో,

186
00:10:11,000 --> 00:10:14,000
మేము కేవలం x ముద్రించాలా, అది కేస్ ఉంది

187
00:10:14,000 --> 00:10:17,000
ఆ scanf x ఒక Int విధించింది.

188
00:10:17,000 --> 00:10:19,000
ఖచ్చితంగా scanf ఎలా పని చేస్తుందో, మరియు గత వారం రీకాల్

189
00:10:19,000 --> 00:10:25,000
ఆ ఎలా GetString మరియు GetInt మరియు కార్యకలాపాల యొక్క ఇతర కుటుంబం

190
00:10:25,000 --> 00:10:28,000
చివరికి, sscanf వంటి కొంచెం తేడాలో ఉన్నప్పటికీ, పనిచేస్తుంది

191
00:10:28,000 --> 00:10:31,000
ఇది బదులుగా కీబోర్డ్ యొక్క స్ట్రింగ్ స్కాన్ అర్థం.

192
00:10:31,000 --> 00:10:33,000
కానీ యొక్క ఈ చిన్న భేదము పరిశీలించి అనుమతిస్తుంది.

193
00:10:33,000 --> 00:10:37,000
Scanf2 లో, నిజానికి అప్ చిత్తు చేశాడు.

194
00:10:37,000 --> 00:10:42,000
ఏం తప్పు-మరియు నేను వివరిస్తూ చాలా-వ్యాఖ్యను దాచిపెట్టు చేస్తాము

195
00:10:42,000 --> 00:10:47,000
వెర్షన్ 2, ఈ కార్యక్రమం సమస్య ఏమిటి?

196
00:10:47,000 --> 00:10:55,000
ఈ సమయంలో వీలైనంత సాంకేతిక ఉండండి.

197
00:10:55,000 --> 00:10:57,000
ఇది చాలా బాగుంది.

198
00:10:57,000 --> 00:11:03,000
ఇది చక్కగా ఇండెంట్, కాని చేసిన

199
00:11:03,000 --> 00:11:07,000
సరే, ఎలా యొక్క చిన్న ప్రశ్నలు దాన్ని ఎండు ద్రాక్ష తెలియజేయండి?

200
00:11:07,000 --> 00:11:17,000
లైన్ 16. ఖచ్చితమైన కాని సాంకేతిక ఆంగ్ల చేయడం లైన్ 16 ఏమిటి?

201
00:11:17,000 --> 00:11:20,000
కొద్దిగా ఇబ్బందికరమైన తెలుసుకోవచ్చు. అవును, మైఖేల్.

202
00:11:20,000 --> 00:11:25,000
[స్టూడెంట్] ఇది ఒక స్ట్రింగ్ యొక్క మొదటి అక్షరం సూచించే యొక్క.

203
00:11:25,000 --> 00:11:27,000
>> సరే, దగ్గరగా. నాకు ఒక చిన్న bit సర్దుబాటు లెట్.

204
00:11:27,000 --> 00:11:33,000
ఒక స్ట్రింగ్ యొక్క మొదటి అక్షరం సూచించే, మీరు ఒక వేరియబుల్ అని బఫర్ ప్రకటించారు ఉంటాయి

205
00:11:33,000 --> 00:11:36,000
ఆ, ఒక తీగ యొక్క మొదటి చిరునామాకు ఆకర్షిస్తాయి

206
00:11:36,000 --> 00:11:39,000
లేదా, మరింత ప్రత్యేకంగా ఒక చార్ కు ఆకర్షిస్తాయి.

207
00:11:39,000 --> 00:11:42,000
ఏ అప్పగించిన ఆపరేటర్లు లేదు ఎందుకంటే ఇది వాస్తవానికి ఎక్కడైనా పై కాదు నోటీసు.

208
00:11:42,000 --> 00:11:46,000
ఏ సమాన సైన్ ఉంది, మేము చేస్తున్నా అన్ని వేరియబుల్ అని బఫర్ పెడుతోంది ఉంటుంది.

209
00:11:46,000 --> 00:11:49,000
అది ఒక పాయింటర్ ఎందుకంటే, 32 బిట్స్ నిర్మాణము

210
00:11:49,000 --> 00:11:52,000
మరియు బఫర్ యొక్క కంటెంట్లను బహుశా చివరకు

211
00:11:52,000 --> 00:11:57,000
ఒక చార్ యొక్క చిరునామాను కలిగి ఉంటుంది, కానీ ఇప్పుడు కోసం, బఫర్ ఏమి ఉంది?

212
00:11:57,000 --> 00:11:59,000
కొన్ని బోగస్, తెలిసిన, కొన్ని చెత్త విలువ,

213
00:11:59,000 --> 00:12:03,000
మేము స్పష్టంగా ఇది initialized లేదు కాబట్టి, మేము ఏదైనా పరిగణించలేము.

214
00:12:03,000 --> 00:12:06,000
సరే, ఇప్పుడు లైన్ 17-ఏది కారణం లైన్ 17 చేస్తుంది?

215
00:12:06,000 --> 00:12:08,000
బహుశా ఈ వేడెక్కాల్సిన కనిపిస్తుంది.

216
00:12:08,000 --> 00:12:10,000
ఇది కుడి, ఒక స్ట్రింగ్ ముద్రిస్తుంది?

217
00:12:10,000 --> 00:12:12,000
ఇది స్ట్రింగ్ దయచేసి ముద్రిస్తుంది.

218
00:12:12,000 --> 00:12:15,000
>> లైన్ 18 మేము ఈ ఒక వైవిధ్యం కనిపించింది ఇప్పుడు సుపరిచితమే రకం

219
00:12:15,000 --> 00:12:18,000
కానీ భిన్న కోడ్, కాబట్టి లైన్ 18 లో,

220
00:12:18,000 --> 00:12:23,000
మేము ఇక్కడ scanf చెప్పుకుంటున్నారు మెమరీ భాగం యొక్క చిరునామా.

221
00:12:23,000 --> 00:12:27,000
నేను, మీరు% s సూచించినట్లు, ఒక స్ట్రింగ్ లో రింగ్ మీరు

222
00:12:27,000 --> 00:12:32,000
కానీ సమస్య మేము ఇక్కడ కొన్ని విషయాలను చేయలేదు అని.

223
00:12:32,000 --> 00:12:35,000
సమస్యలు ఒకటి ఏమిటి?

224
00:12:35,000 --> 00:12:38,000
[స్టూడెంట్] ఇది dereference ఒక నల్ పాయింటర్ ప్రయత్నిస్తున్నాడు.

225
00:12:38,000 --> 00:12:41,000
గుడ్, శూన్య లేదా తెలియలేదు పాయింటర్లు.

226
00:12:41,000 --> 00:12:45,000
మీరు scanf ఒక చిరునామా ఇవ్వడానికి, కానీ మీరు ఒక క్షణం క్రితం చెప్పారు

227
00:12:45,000 --> 00:12:49,000
మేము నిజంగా, ఏదైనా దానిని కేటాయించలేరు ఎందుకంటే ఆ చిరునామా కొన్ని చెత్త విలువ ఆ

228
00:12:49,000 --> 00:12:53,000
మరియు మీరు, scanf సమర్థవంతంగా ఇక్కడ ఒక స్ట్రింగ్ ఉంచారు వెళ్ళి చెప్పుకుంటున్నారు

229
00:12:53,000 --> 00:12:56,000
ఇక్కడ ఇంకా కానీ మేము, మాకు తెలియదు

230
00:12:56,000 --> 00:12:59,000
కాబట్టి మేము నిజంగా బఫర్ కోసం మెమరీ కేటాయించింది లేదు.

231
00:12:59,000 --> 00:13:03,000
అంతేకాకుండా, మీరు కూడా scanf చెప్పట్లేదు కూడా ఏవి?

232
00:13:03,000 --> 00:13:06,000
ఈ మెమరీ భాగం, ఇది, ఒక చెత్త విలువ కాదు ఒకవేళ

233
00:13:06,000 --> 00:13:09,000
కానీ మీరు ఇంకా scanf ముఖ్యమైన దానిని చెప్పటానికి లేదు.

234
00:13:09,000 --> 00:13:12,000
[స్టూడెంట్] సహజంగా ఎక్కడ, ఆంపర్సండ్ చిహ్నం.

235
00:13:12,000 --> 00:13:15,000
ఎమ్పారసన్డ్, కాబట్టి ఈ విషయంలో, సరైందే.

236
00:13:15,000 --> 00:13:18,000
బఫర్ ఇప్పటికే పాయింటర్ గా ప్రకటించింది ఎందుకంటే

237
00:13:18,000 --> 00:13:22,000
సింటెక్స్ * వస్తువు, మేము ఆంపర్సండ్ చిహ్నం ఉపయోగించడానికి అవసరం లేదు

238
00:13:22,000 --> 00:13:25,000
ఎందుకంటే అది ఇప్పటికే ఒక చిరునామా, కానీ నేను ఇక్కడ అది విన్న నేను భావిస్తున్నాను.

239
00:13:25,000 --> 00:13:27,000
[స్టూడెంట్] ఇది ఎలా పెద్దది?

240
00:13:27,000 --> 00:13:29,000
గుడ్, మేము, ఈ బఫర్ ఎంత పెద్ద scanf చెప్పటం లేదు

241
00:13:29,000 --> 00:13:32,000
ఇది బఫర్ ఒక పాయింటర్ కూడా ఉంటే అర్థం

242
00:13:32,000 --> 00:13:35,000
మేము, scanf చెప్పడం ఇక్కడ ఒక స్ట్రింగ్ ఉంచారు చేస్తున్నారు

243
00:13:35,000 --> 00:13:38,000
కానీ ఇక్కడ 2 బైట్లు ఉంటుంది, ఇది 10 బైట్లు ఉంటుంది, ఇది ఒక మెగాబైట్ ఉంటుంది.

244
00:13:38,000 --> 00:13:41,000
Scanf తెలియదు, మరియు ఈ మెమరీ భాగం ఎందుకంటే

245
00:13:41,000 --> 00:13:43,000
బహుశా, ఇది ఇంకా ఒక స్ట్రింగ్ కాదు.

246
00:13:43,000 --> 00:13:48,000
మీరు అక్షరాలు మరియు మెమరీ ఆ భాగం ఒక \ 0 వ్రాయడానికి మాత్రమే అది స్ట్రింగ్ ఉంది.

247
00:13:48,000 --> 00:13:51,000
ఇప్పుడు అది కేవలం మెమరీ కొన్ని భాగం ఉంది.

248
00:13:51,000 --> 00:13:55,000
Scanf ఆ చిరునామాకు టు స్టాప్ రైటింగ్ సమయంలో తెలియదు.

249
00:13:55,000 --> 00:13:59,000
>> మీరు నేను యాదృచ్ఛికంగా కీబోర్డుపై టైప్ పేరు గతంలో కొన్ని ఉదాహరణలు గుర్తు ఉంటే

250
00:13:59,000 --> 00:14:03,000
ఓవర్ఫ్లో ఒక బఫర్ ప్రయత్నిస్తున్న, మరియు మేము ఖచ్చితంగా గురించి శుక్రవారం మాట్లాడారు.

251
00:14:03,000 --> 00:14:07,000
శత్రువులు ఏదో మీ కార్యక్రమంపై ఒక పెద్ద పదం పంపిస్తారు ఉంటే

252
00:14:07,000 --> 00:14:10,000
లేదా వాక్యం లేదా పదబంధం మీరు ఆక్రమిత చేయవచ్చు ఆశించారు

253
00:14:10,000 --> 00:14:13,000
చెడు పరిణామాలకు ఇది మెమరీ భాగం,

254
00:14:13,000 --> 00:14:15,000
మొత్తం కార్యక్రమం కూడా చేపట్టడం ఇష్టపడుతున్నారు.

255
00:14:15,000 --> 00:14:17,000
మేము ఏదో ఈ పరిష్కరించడానికి అవసరం.

256
00:14:17,000 --> 00:14:20,000
నాకు దూరంగా మరియు ఈ ప్రోగ్రామ్ యొక్క వర్షన్ 3 వెళ్ళి తెలపండి.

257
00:14:20,000 --> 00:14:22,000
ఒక చిన్న bit మంచి పని.

258
00:14:22,000 --> 00:14:24,000
ఈ సంస్కరణలో, తేడా గమనించవచ్చు.

259
00:14:24,000 --> 00:14:27,000
లైన్ 16, నేను మళ్లీ ఒక వేరియబుల్ అని బఫర్ ప్రకటించారు చేస్తున్నాను

260
00:14:27,000 --> 00:14:29,000
కానీ ఇప్పుడు ఏమిటి?

261
00:14:29,000 --> 00:14:33,000
ఇది 16 అక్షరాలు యొక్క వ్యూహం ఉంది.

262
00:14:33,000 --> 00:14:36,000
నేను ఇప్పుడు scanf తెలియజేయవచ్చు దీనర్థం ఎందుకంటే ఈ మంచి ఉంది

263
00:14:36,000 --> 00:14:39,000
ఇక్కడ మెమరీ యొక్క ఒక వాస్తవ భాగం ఉంది.

264
00:14:39,000 --> 00:14:42,000
మీరు దాదాపు, ఇప్పుడు గమనికలు గా శ్రేణుల యొక్క ఆలోచించవచ్చు

265
00:14:42,000 --> 00:14:44,000
వారు వాస్తవానికి సమానం కాదు ఉన్నప్పటికీ.

266
00:14:44,000 --> 00:14:47,000
వారు వివిధ సందర్భాల్లో భిన్నంగా ప్రవర్తించేందుకు చేస్తాము.

267
00:14:47,000 --> 00:14:50,000
కానీ అది ఖచ్చితంగా బఫర్ సూచిస్తూ ఆ కేస్

268
00:14:50,000 --> 00:14:53,000
16 వరుస అక్షరాలు ఆ ఏమి వ్యూహం ఎందుకంటే

269
00:14:53,000 --> 00:14:55,000
మరియు ఇప్పుడు కొన్ని వారాలు ఉంది.

270
00:14:55,000 --> 00:14:59,000
>> ఇక్కడ, నేను ఇక్కడ scanf చెప్పడం am మెమరీ భాగం ఉంది.

271
00:14:59,000 --> 00:15:01,000
ఈ సమయంలో, ఇది నిజానికి మెమరీ భాగం యొక్క

272
00:15:01,000 --> 00:15:07,000
కానీ ఎందుకు ఈ కార్యక్రమం ఇప్పటికీ ప్రమాదకర ఉంది?

273
00:15:07,000 --> 00:15:11,000
ఇప్పటికీ తప్పు ఏమిటి?

274
00:15:11,000 --> 00:15:14,000
నా 16 బైట్లు కానీ-ఇవ్వాలని చెప్పారు చేసిన

275
00:15:14,000 --> 00:15:16,000
[స్టూడెంట్] ఇతరులు కంటే ఎక్కువ 16 లో టైప్ చేస్తే?

276
00:15:16,000 --> 00:15:20,000
సరిగ్గా, ఏ 17 అక్షరాలు లేదా 1700 అక్షరాలు వినియోగదారు రకాల ఉంటే?

277
00:15:20,000 --> 00:15:23,000
నిజానికి, ఇప్పుడు మేము ఈ తప్పు మీద యాత్ర పోతే యొక్క చూసేలా.

278
00:15:23,000 --> 00:15:25,000
ఇది మంచి కాని ఖచ్చితమైన కాదు.

279
00:15:25,000 --> 00:15:28,000
నాకు ముందుకు వెళ్లి ఈ కార్యక్రమం తయారు చేసుకుని scanf3 తయారు అమలు అయ్యేలా అనుమతించండి.

280
00:15:28,000 --> 00:15:34,000
హలో, మరియు మేము ఓకే అనిపిస్తుంది: స్ట్రింగ్, నాకు scanf3 అమలు చేయండి లెట్.

281
00:15:34,000 --> 00:15:37,000
నాకు హలో అక్కడ, కొద్దిగా పొడవుగా ప్రయత్నించండి లెట్.

282
00:15:37,000 --> 00:15:42,000
సరే, నమోదు, నేడు మీరు ఎలా ఉన్నారు అక్కడ హలో యొక్క మనం.

283
00:15:42,000 --> 00:15:54,000
ఇక్కడ లక్కీ రకం పొందడం, లెట్స్ ఎలా ఉన్నావు అక్కడ హలో చెప్పండి.

284
00:15:54,000 --> 00:15:56,000
అది డామన్.

285
00:15:56,000 --> 00:16:03,000
సరే, మేము లక్కీ వచ్చింది. మేము దీన్ని పరిష్కరించడానికి కాదు లేదో యొక్క చూసేలా.

286
00:16:03,000 --> 00:16:06,000
కాదు, అది నన్ను కాపీ వీలు మాత్రం కాదు.

287
00:16:06,000 --> 00:16:09,000
యొక్క మళ్ళీ ప్రయత్నించండి లెట్.

288
00:16:09,000 --> 00:16:12,000
All right, నిలిపాడు.

289
00:16:12,000 --> 00:16:20,000
మేము నాకు ఇప్పటికీ ఈ చేసేటప్పుడు దృష్టి నటిస్తారు ఎలా దీర్ఘ చూస్తారు.

290
00:16:20,000 --> 00:16:23,000
అది డామన్. వాస్తవానికి, బదులుగా సరైనది.

291
00:16:23,000 --> 00:16:26,000
అక్కడ మేము వెళ్ళి.

292
00:16:26,000 --> 00:16:30,000
పాయింట్ చేసింది.

293
00:16:30,000 --> 00:16:34,000
>> ఈ, అది కూడా ఉన్నప్పటికీ, ఇబ్బందులు కూడా గొప్ప గందరగోళం మూలాలు ఒకటి

294
00:16:34,000 --> 00:16:38,000
వారు తమను తాము వ్యక్తం ఎందుకంటే దోషాలు కలిగి కార్యక్రమాలు రాసేటప్పుడు

295
00:16:38,000 --> 00:16:40,000
ఒక్కసారి మాత్రమే కొన్నిసార్లు కొద్దిసేపట్లో.

296
00:16:40,000 --> 00:16:43,000
రియాలిటీ, మీ కోడ్ పూర్తిగా విభజించబడింది ఉంటే ఉంది

297
00:16:43,000 --> 00:16:46,000
అది మాత్రమే పూర్తిగా కొద్దిసేపట్లో ఒకసారి విచ్ఛిన్నం చేయవచ్చు

298
00:16:46,000 --> 00:16:49,000
కొన్నిసార్లు, ముఖ్యంగా ఏమి జరుగుతుందనే ఆపరేటింగ్ సిస్టమ్ కేటాయించుకునే ఎందుకంటే

299
00:16:49,000 --> 00:16:52,000
మీరు కంటే కొద్దిగా ఎక్కువ మెమొరీ వాస్తవానికి, కారణము ఏదైనప్పటికీ అవసరం

300
00:16:52,000 --> 00:16:57,000
అందువలన ఎవరూ, కుడి 16 అక్షరాలు మీ భాగం తర్వాత మెమరీ ఉపయోగిస్తుంది

301
00:16:57,000 --> 00:17:01,000
మీరు 17, 18, 19, ఏ, ఇటువంటి పెద్ద ఒప్పందంలో కాదు వెళ్ళండి చేస్తున్నాను.

302
00:17:01,000 --> 00:17:04,000
ఇప్పుడు, కంప్యూటర్, అది ఆ సమయంలో క్రాష్ లేదు కూడా,

303
00:17:04,000 --> 00:17:09,000
చివరకు ఏదో కోసం బైట్ సంఖ్య 17 లేదా 18 లేదా 19 ఉపయోగించుకునే,

304
00:17:09,000 --> 00:17:14,000
ఇది వద్ద అధికంగా పొడవుగా అయితే మీరు అక్కడ ఉంచిన మీ డేటా పాయింట్

305
00:17:14,000 --> 00:17:18,000
కొన్ని ఇతర చర్య ద్వారా సమర్థవంతంగా భర్తీ పొందడానికి అన్నారు.

306
00:17:18,000 --> 00:17:21,000
ఇది తప్పనిసరిగా చెక్కుచెదరకుండా ఉన్నాయి మాత్రం కాదు

307
00:17:21,000 --> 00:17:23,000
కానీ అది తప్పనిసరిగా ఒక seg లోపం కారణం కాదు.

308
00:17:23,000 --> 00:17:26,000
కానీ ఈ సందర్భంలో, చివరికి నేను తగినంత అక్షరాలు అందించిన

309
00:17:26,000 --> 00:17:29,000
నేను తప్పనిసరిగా మెమరీ నా విభాగంలో అధిగమించింది మరియు మోసం చేయు ఆ

310
00:17:29,000 --> 00:17:33,000
ఆపరేటింగ్ సిస్టమ్ "క్షమించాలి, ఏ మంచి, సెగ్మెంటేషన్ తప్పు.", అన్నాడు

311
00:17:33,000 --> 00:17:38,000
>> మరియు నా ఇక్కడ ఉంది ఉంటే ఇప్పుడు చూద్దాం డైరెక్టరీ-

312
00:17:38,000 --> 00:17:40,000
నేను ఇక్కడ కోర్ ఈ ఫైలు మేము గుర్తించాము.

313
00:17:40,000 --> 00:17:42,000
మళ్ళీ ఒక కోర్ డంప్ అని గమనించండి.

314
00:17:42,000 --> 00:17:46,000
ఇది తప్పనిసరిగా మీ ప్రోగ్రామ్ యొక్క మెమరీ కంటెంట్ కలిగి ఫైల్

315
00:17:46,000 --> 00:17:48,000
అది క్రాష్ దశలో వద్ద,

316
00:17:48,000 --> 00:17:51,000
మరియు కేవలం ఇక్కడ ఒక చిన్న ఉదాహరణ ప్రయత్నించండి నన్ను ఇక్కడ వీడలేదు

317
00:17:51,000 --> 00:17:57,000
మరియు, కోర్ అనే మూడవ వాదన పేర్కొనండి అప్పుడు scanf3 న GDB అమలు మరియు

318
00:17:57,000 --> 00:18:01,000
మరియు ఇక్కడ గమనించవచ్చు నేను కోడ్ జాబితా ఉంటే,

319
00:18:01,000 --> 00:18:06,000
మేము, ఈ కార్యక్రమం ద్వారా వాకింగ్ ప్రారంభించడానికి GDB సాధారణంగా వంటి చేయగలరు

320
00:18:06,000 --> 00:18:10,000
మరియు నేను వంటి హిట్ గా అడుగు ఆదేశంతో వెంటనే అమలు చేయవచ్చు మరియు GDB-

321
00:18:10,000 --> 00:18:13,000
నేను ఒక పెద్ద స్ట్రింగ్ లో టైప్ తర్వాత సమర్థవంతంగా బగ్గీ లైన్ హిట్, వెంటనే

322
00:18:13,000 --> 00:18:16,000
నిజానికి ఇక్కడ అది గుర్తించడానికి చేయగలరు.

323
00:18:16,000 --> 00:18:19,000
మరిన్ని ఈ, అయితే, కోర్ డంపుల పరంగా విభాగంలో

324
00:18:19,000 --> 00:18:22,000
మరియు మీరు నిజంగానే కోర్ డంప్ లోపలి చుట్టూ దూర్చు తద్వారా ఇష్టం

325
00:18:22,000 --> 00:18:27,000
మరియు ప్రోగ్రామ్ మీరు విఫలమైంది ఏ పంక్తిలో చూడండి.

326
00:18:27,000 --> 00:18:32,000
గమనికలు మరియు చిరునామాలను అప్పటి ఏదైనా ప్రశ్నలు?

327
00:18:32,000 --> 00:18:36,000
నేటి ఎందుకంటే, మేము ఈ విషయాలు ఉన్నాయి అని మంజూరు కోసం ఆరంభిస్తాయి చూడాలని

328
00:18:36,000 --> 00:18:40,000
మరియు మేము వారు ఖచ్చితంగా తెలుసు.

329
00:18:40,000 --> 00:18:42,000
అవును.

330
00:18:42,000 --> 00:18:46,000
>> [స్టూడెంట్] ఎలా మీరు పక్కన ఒక ఆంపర్సండ్ చిహ్నం ఉంచాలి లేదు వచ్చి పార్ట్

331
00:18:46,000 --> 00:18:48,000
ప్రశ్న గుడ్.

332
00:18:48,000 --> 00:18:51,000
నేను గతంలో వలె పాత్ర శ్రేణి తరువాత ఒక ఆంపర్సండ్ చిహ్నం ఉంచాలి లేదు వచ్చి

333
00:18:51,000 --> 00:18:53,000
మా ఉదాహరణ ఎక్కువగా?

334
00:18:53,000 --> 00:18:55,000
చిన్న సమాధానం శ్రేణుల కొద్దిగా ప్రత్యేక ఉంటాయి.

335
00:18:55,000 --> 00:18:59,000
మీరు దాదాపు, వాస్తవానికి ఒక చిరునామా గా బఫర్ ఆలోచించవచ్చు

336
00:18:59,000 --> 00:19:03,000
మరియు ఇది కేవలం కాబట్టి సందర్భంలో చేసేట్టు చదరపు బ్రాకెట్ సంజ్ఞామానం

337
00:19:03,000 --> 00:19:06,000
మేము బ్రాకెట్ 0, బ్రాకెట్ 1, వెళ్ళాలని విధంగా సౌలభ్యం ఉంది

338
00:19:06,000 --> 00:19:10,000
* నోటేషన్ ను ఉపయోగిస్తాయి చేయకుండా బ్రాకెట్ 2.

339
00:19:10,000 --> 00:19:13,000
ఒక వైట్ అబద్ధం ఒక బిట్ ఎందుకంటే శ్రేణుల మరియు గమనికలు

340
00:19:13,000 --> 00:19:17,000
నిజానికి, కొద్దిగా భిన్నంగా ఉంటాయి, అయితే వారు ఎల్లప్పుడూ పరస్పరం ఉపయోగించవచ్చు.

341
00:19:17,000 --> 00:19:21,000
చెప్పాలంటే, ఒక ఫంక్షన్ మెమరీ భాగం ఒక పాయింటర్ ఆశిస్తున్న సమయంలో,

342
00:19:21,000 --> 00:19:24,000
మీరు గాని, అది malloc ద్వారా తిరిగి ఒక చిరునామా తరలిస్తారు

343
00:19:24,000 --> 00:19:29,000
మరియు మేము దీర్ఘ ముందు malloc చూస్తారు, లేదా మీరు వ్యూహం యొక్క పేరు పాస్ చేయవచ్చు.

344
00:19:29,000 --> 00:19:32,000
వారు ఉన్నారు కాబట్టి మీరు శ్రేణితో ఆంపర్సండ్ చిహ్నం ఏమి లేదు

345
00:19:32,000 --> 00:19:34,000
ముఖ్యంగా చిరునామాలను ఇష్టం.

346
00:19:34,000 --> 00:19:36,000
ఒక మినహాయింపు పేర్కొంది.

347
00:19:36,000 --> 00:19:39,000
చదరపు బ్రాకెట్లలో వాటిని ప్రత్యేక చేయండి.

348
00:19:39,000 --> 00:19:41,000
>> మీరు బఫర్ పక్కన ఒక ఆంపర్సండ్ చిహ్నం ఉంచారు కాలేదు?

349
00:19:41,000 --> 00:19:43,000
ఈ సందర్భంలో.

350
00:19:43,000 --> 00:19:46,000
ఈ మూలలో కేసులో, ఎందుకంటే, మళ్లీ పనిచేయవు

351
00:19:46,000 --> 00:19:49,000
పేరు శ్రేణుల చాలా వాస్తవానికి చిరునామాలు కావు.

352
00:19:49,000 --> 00:19:54,000
కానీ మేము బహుశా ఇతర ఉదాహరణలు తో చాలా కాలం క్రితమే వచ్చి చేస్తాము.

353
00:19:54,000 --> 00:19:56,000
యొక్క ఇక్కడ ఒక సమస్యను పరిష్కరించడానికి ప్రయత్నించండి లెట్.

354
00:19:56,000 --> 00:20:00,000
మేము వ్యూహం తెలిసిన కొంత సమయం ఉపయోగించిన చేసిన ఒక డేటా ఆకృతి.

355
00:20:00,000 --> 00:20:02,000
పాయింట్ కేస్, మేము కేవలం కలిగి ఏమి.

356
00:20:02,000 --> 00:20:04,000
కానీ శ్రేణుల కొన్ని చేయబడనపుడు మరియు దుష్ప్రభావాలు ఉంటాయి.

357
00:20:04,000 --> 00:20:06,000
వ్యూహాలను nice ఎందుకు ఉన్నాయి?

358
00:20:06,000 --> 00:20:11,000
మీరు నుంచి ఒక్క విషయము మీరు శ్రేణుల శ్రేణుల గురించి ఇష్టం మేరకు ఏమిటి?

359
00:20:11,000 --> 00:20:13,000
ఏ వాటి గురించి అనుకూలమైన ఏమిటి? బలవంతపు ఏమిటి?

360
00:20:13,000 --> 00:20:18,000
ఎందుకు మేము మొదటి స్థానంలో వాటిని పరిచయం చేశారు?

361
00:20:18,000 --> 00:20:20,000
అవును.

362
00:20:20,000 --> 00:20:27,000
[స్టూడెంట్] వారు డేటా చాలా నిల్వ చేయవచ్చు, మరియు మీరు ఒక పూర్తి విషయం ఉపయోగించడానికి లేదు.

363
00:20:27,000 --> 00:20:29,000
మీరు ఒక విభాగాన్ని ఉపయోగించవచ్చు.

364
00:20:29,000 --> 00:20:32,000
గుడ్, మీరు దత్తాంశ నిల్వ చేయవచ్చు వ్యూహం తో,

365
00:20:32,000 --> 00:20:35,000
మరియు, మీరు తప్పనిసరిగా అది అన్ని ఉపయోగించడానికి లేదు, కాబట్టి మీరు overallocate చేయవచ్చు

366
00:20:35,000 --> 00:20:39,000
ఎలా అంచనా ఏదో అనేక మీరు ముందుగానే తెలియకపోతే అనుకూలమైన అయి ఉండవచ్చు.

367
00:20:39,000 --> 00:20:41,000
>> GetString ఒక ఖచ్చితమైన ఉదాహరణ.

368
00:20:41,000 --> 00:20:44,000
మాకు రాసిన GetString, ఆశించడం ఎన్ని అక్షరాలు తెలియదు

369
00:20:44,000 --> 00:20:48,000
కాబట్టి మేము ఆనుకొని మెమరీ భాగాలుగా కేటాయించాలని ఉండటం మంచిది.

370
00:20:48,000 --> 00:20:51,000
వ్యూహాలను కూడా ఇప్పుడు మాకు ఒక జంట వారాల క్రితం చూసిన ఒక సమస్యను పరిష్కరించడానికి

371
00:20:51,000 --> 00:20:54,000
మీ కోడ్ చాలా పేలవంగా రూపొందించిన దానిని బదిలీ మొదలవుతుంది పేరు.

372
00:20:54,000 --> 00:20:57,000
నేను డేవిడ్ అనే విద్యార్థి నిర్మాణం సృష్టించిన రీకాల్

373
00:20:57,000 --> 00:21:00,000
మరియు ఆ, అయితే, వాస్తవానికి ఒక ప్రత్యామ్నాయ ఉంది

374
00:21:00,000 --> 00:21:04,000
ఒక వేరియబుల్ అని పేరు మరియు, నేను అనుకుంటున్నాను, హౌస్ అని మరొక వేరియబుల్ కలిగి,

375
00:21:04,000 --> 00:21:08,000
మరియు ఆ కథలో నేను ఏదో పరిచయం కావాలి కనుక ID అనే మరొక వేరియబుల్

376
00:21:08,000 --> 00:21:11,000
కార్యక్రమంలో రాబ్ వలె చాలా అప్పుడు నేను, ఒక నిమిషం వేచి నిర్ణయించుకుంది

377
00:21:11,000 --> 00:21:13,000
నేను ఈ చరరాశులు పేరు అవసరం.

378
00:21:13,000 --> 00:21:16,000
లెట్ యొక్క గని NAME1, ID1, house1 కాల్.

379
00:21:16,000 --> 00:21:20,000
లెట్ యొక్క రాబ్ యొక్క NAME2, house2, ID2 కాల్.

380
00:21:20,000 --> 00:21:22,000
కానీ ఏమి టామీ గురించి ఒక నిమిషం వేచి ఉండండి,?

381
00:21:22,000 --> 00:21:24,000
అప్పుడు మేము మూడు కంటే ఎక్కువ విషయాలు ఉన్నారు.

382
00:21:24,000 --> 00:21:27,000
మేము ఎవరో, వేరియబుల్స్ యొక్క నాలుగు సెట్లలో పరిచయం.

383
00:21:27,000 --> 00:21:30,000
వరల్డ్, చాలా త్వరగా దారుణంగా పొందడానికి ప్రారంభించారు

384
00:21:30,000 --> 00:21:33,000
కాబట్టి మేము structs పరిచయం, మరియు ఒక struct గురించి నిర్బంధిత?

385
00:21:33,000 --> 00:21:39,000
ఒక సి struct మీరు ఏమి వీలు లేదు?

386
00:21:39,000 --> 00:21:42,000
ఇది నేడు నిజంగా ఇబ్బందికరమైన ఉంది.

387
00:21:42,000 --> 00:21:44,000
ఏం? >> [వినబడని విద్యార్థి ప్రతిస్పందన]

388
00:21:44,000 --> 00:21:47,000
అవును, ప్రత్యేకంగా, typedef మీరు, ఒక కొత్త రకం డేటా సృష్టించడానికి అనుమతిస్తుంది

389
00:21:47,000 --> 00:21:51,000
మరియు struct, struct కీవర్డ్, మీరు మాత్రం అనుమతిస్తుంది

390
00:21:51,000 --> 00:21:54,000
కలిసి డేటా సంభావితంగా సంబంధించిన ముక్కలు

391
00:21:54,000 --> 00:21:56,000
మరియు తరువాత వాటిని ఒక విద్యార్థి వలె ఏదో కాల్.

392
00:21:56,000 --> 00:21:58,000
>> ఇప్పుడు మేము నమూనా ఎందుకంటే మంచి ఉంది

393
00:21:58,000 --> 00:22:03,000
ఒక వేరియబుల్ ఒక విద్యార్థి యొక్క యొక్క మరింత విధమైన సంభావితంగా స్థిరమైన భావన

394
00:22:03,000 --> 00:22:07,000
కాకుండా ఏకపక్ష మొదలైనవి స్ట్రింగ్ ఒకటి, ఒక ID కోసం ఒక కలిగి, మరియు.

395
00:22:07,000 --> 00:22:10,000
వారు మా కోడ్ శుభ్రం ప్రారంభం అనుమతిస్తాయి వ్యూహాలను nice ఉంటాయి.

396
00:22:10,000 --> 00:22:13,000
కాని ఒక శ్రేణిని ఇప్పుడు వ్యతిరేక స్థితి ఉంది?

397
00:22:13,000 --> 00:22:15,000
మీరు ఏమి చేయలేరు? అవును.

398
00:22:15,000 --> 00:22:17,000
[స్టూడెంట్] మీరు ఎంత పెద్ద తెలుసుకోవలసి ఉంటుంది.

399
00:22:17,000 --> 00:22:19,000
మీరు ఎంత పెద్ద తెలుసుకోవలసి ఉంటుంది, ఇది ఒక నొప్పి రకం కాబట్టి.

400
00:22:19,000 --> 00:22:21,000
మీరు ఆ ముందు ప్రోగ్రామింగ్ అనుభవం మీకు భాషలు చాలా లో,

401
00:22:21,000 --> 00:22:24,000
జావా వంటి, మీరు మెమరీ భాగం, ప్రత్యేకించి ఒక వరుస అడగవచ్చు

402
00:22:24,000 --> 00:22:28,000
ఎంత పెద్ద మీరు మాట్లాడటానికి పొడవు, ఆస్తి, కలిగి ఉంటుంది, మరియు ఇది నిజంగా అనుకూలమైన ఉంది.

403
00:22:28,000 --> 00:22:32,000
సి, మీరు కూడా ఒక సాధారణ శ్రేణి న strlen కాల్ చెయ్యలేరు

404
00:22:32,000 --> 00:22:35,000
పదం కాబట్టి strlen ఎందుకంటే, మాత్రమే తీగలను కోసం

405
00:22:35,000 --> 00:22:39,000
మరియు మీరు ఎందుకంటే ఈ మానవ కన్వెన్షన్ యొక్క స్ట్రింగ్ యొక్క పొడవు గుర్తించడానికి చేయవచ్చు

406
00:22:39,000 --> 00:22:43,000
ఒక \ 0, కానీ వ్యూహం కలిగి, ఎక్కువ సామాన్యముగా, కేవలం మెమరీ భాగం ఉంది.

407
00:22:43,000 --> 00:22:46,000
అది ints యొక్క వ్యూహం అయితే, కొన్ని ప్రత్యేక పాత్ర ఉన్నట్లు మాత్రం కాదు

408
00:22:46,000 --> 00:22:48,000
చివరిలో మీరు కోసం వేచి ఉంది.

409
00:22:48,000 --> 00:22:50,000
మీరు వ్యూహం యొక్క పొడవు గుర్తుంచుకోండి.

410
00:22:50,000 --> 00:22:54,000
వ్యూహం మరో ఇబ్బంది కూడా GetString లో తల పెంచిన.

411
00:22:54,000 --> 00:22:59,000
వ్యూహం యొక్క మరొక స్థితి ఏమిటి?

412
00:22:59,000 --> 00:23:01,000
సర్, మీరు మరియు నాకు ఈ రోజు.

413
00:23:01,000 --> 00:23:04,000
[వినబడని విద్యార్థి ప్రతిస్పందన] >> ఇది ఏమిటి?

414
00:23:04,000 --> 00:23:06,000
ఇది స్టాక్ న ప్రకటించబడిన.

415
00:23:06,000 --> 00:23:09,000
సరే, స్టాక్ న ప్రకటించింది. ఎందుకు మీరు ఆ ఇష్టం లేదు?

416
00:23:09,000 --> 00:23:13,000
[స్టూడెంట్] దానిని తిరిగి వాడతారు అవుతుంది కాబట్టి.

417
00:23:13,000 --> 00:23:15,000
ఇది తిరిగి ఉంటుంది.

418
00:23:15,000 --> 00:23:18,000
సరే, మీరు మెమరీని కేటాయించాల్సిన వ్యూహం ఉపయోగిస్తే,

419
00:23:18,000 --> 00:23:21,000
ఇది స్టాక్ న ఎందుకంటే మీరు, ఉదాహరణకు, ఇది తిరిగి కాదు.

420
00:23:21,000 --> 00:23:23,000
సరే, ఒక ప్రతికూలత ఉంది.

421
00:23:23,000 --> 00:23:25,000
ఎలా వ్యూహం ఇతర గురించి?

422
00:23:25,000 --> 00:23:28,000
మీరు కేటాయించే ఒకసారి, మీరు మరింత ఖాళీ కావాలంటే రకమైన చిత్తు చేశాడు ఉన్నారు

423
00:23:28,000 --> 00:23:30,000
ఆ శ్రేణి కంటే.

424
00:23:30,000 --> 00:23:34,000
>> అప్పుడు మేము, మాకు డైనమిక్ మెమరీ కేటాయించే సామర్థ్యం ఇచ్చింది రీకాల్ malloc, పరిచయం.

425
00:23:34,000 --> 00:23:37,000
కానీ మేము పూర్తిగా వేరే ప్రపంచం ఏ ప్రయత్నించారు ఉంటే?

426
00:23:37,000 --> 00:23:40,000
మేము ఆ సమస్యలను పరిష్కరించేందుకు జంట కోరుకుంది ఏం

427
00:23:40,000 --> 00:23:45,000
కాబట్టి మేము బదులుగా-నా కలం ఇక్కడ నిద్రలో పడిపోయింది

428
00:23:45,000 --> 00:23:51,000
మనం బదులుగా ముఖ్యంగా ఈ వంటి గడువు ముగిసిన ప్రపంచ సృష్టించడానికి కోరుకుంటే?

429
00:23:51,000 --> 00:23:56,000
ఈ వ్యూహం, మరియు, వాస్తవానికి, ఈ రకమైన, ఒకసారి మేము శ్రేణి ముగింపు హిట్ క్షీణిస్తూ వస్తుంది

430
00:23:56,000 --> 00:24:00,000
ఇప్పుడు ఇక మరొక పూర్ణాంకం లేదా మరొక పాత్ర కోసం ఖాళీ.

431
00:24:00,000 --> 00:24:03,000
మేము విధమైన preemptively బాగా చెప్పుకోవాలంటే, ఎందుకు మేము విశ్రాంతి విషయమేమిటంటే

432
00:24:03,000 --> 00:24:07,000
మెమరీ ఈ రాళ్లను, వెనుకకు తిరిగి దగ్గరగా ఈ అవసరం

433
00:24:07,000 --> 00:24:10,000
మరియు నేను ఒక పూర్ణాంకానికి లేదా చార్ అవసరం వచ్చినప్పుడు లేదు,

434
00:24:10,000 --> 00:24:12,000
వాటిని ఒక కోసం ఖాళీ ఇవ్వాలని?

435
00:24:12,000 --> 00:24:14,000
నేను మరొక అవసరం వచ్చినప్పుడు, నాకు మరొక స్థలం ఇవ్వండి

436
00:24:14,000 --> 00:24:16,000
మరియు నేను మరొక అవసరం వచ్చినప్పుడు నాకు మరొక స్థలం ఇవ్వండి.

437
00:24:16,000 --> 00:24:19,000
ఇది ప్రయోజనాన్ని ఇప్పుడు ఆ ఉంటే ఇతరుల ఉంది

438
00:24:19,000 --> 00:24:21,000
ఇక్కడ పైగా మెమరీ, ఏ పెద్ద ఒప్పందం పడుతుంది.

439
00:24:21,000 --> 00:24:25,000
నేను ఇక్కడ మరియు ఈ ఒక మెమరీ ఈ అదనపు భాగం తీసుకొని వెళ్తాము.

440
00:24:25,000 --> 00:24:28,000
>> ఇప్పుడు, ఇక్కడ మాత్రమే క్యాచ్ నేను ఉన్నట్లు ఈ దాదాపు భావించే ఉంది

441
00:24:28,000 --> 00:24:30,000
వివిధ వేరియబుల్స్ యొక్క మొత్తం బంచ్.

442
00:24:30,000 --> 00:24:33,000
ఈ సమర్థవంతంగా ఐదు వేర్వేరు వేరియబుల్స్ అనుకుని.

443
00:24:33,000 --> 00:24:36,000
కానీ మేము తీగలను నుండి ఒక ఆలోచన ఏమి దొంగతనం ఉంటే

444
00:24:36,000 --> 00:24:41,000
నేను ఈ చేస్తే వస్తే మేము ఏదో సంభావితంగా కలిసి ఈ విషయాలు లింక్, మరియు?

445
00:24:41,000 --> 00:24:44,000
ఈ నా అతి తక్కువగా డ్రా బాణం ఉంది.

446
00:24:44,000 --> 00:24:46,000
కానీ అనుకుందాం ఆ మెమరీ ఈ రాళ్లను ప్రతి

447
00:24:46,000 --> 00:24:52,000
ఇతర చూపారు, మరియు ఈ వ్యక్తి, తన కుడి ఎటువంటి తోబుట్టువులు ఉంది,

448
00:24:52,000 --> 00:24:54,000
అటువంటి బాణం లేదు.

449
00:24:54,000 --> 00:24:56,000
ఈ అనుబంధ జాబితా అని ఏమి నిజానికి ఉంది.

450
00:24:56,000 --> 00:25:00,000
ఇది మాకు మెమరీ భాగం కేటాయించే అనుమతించే ఒక కొత్త డేటా నిర్మాణం

451
00:25:00,000 --> 00:25:03,000
అప్పుడు మరొక, అప్పుడు మరొక, అప్పుడు మరొక, ఏ సమయంలో మేము మీరు

452
00:25:03,000 --> 00:25:07,000
ఒక ప్రోగ్రామ్ సమయంలో, మరియు మేము వారు అన్ని ఏదో సంబంధిత ఉన్నట్లు గుర్తు

453
00:25:07,000 --> 00:25:11,000
సాహిత్యపరంగా కూర్పికం కలిసి వారిని, మరియు మేము చిత్రాల ఇక్కడ బాణం ఆ చేశాడు.

454
00:25:11,000 --> 00:25:15,000
కానీ కోడ్, ఏమిటి, మీరు ఏదో కనెక్ట్ చేసే ద్వారా విధానం ఉంటుంది

455
00:25:15,000 --> 00:25:20,000
దాదాపు స్క్రాచ్ వంటి మరొక భాగం ఒక భాగం?

456
00:25:20,000 --> 00:25:22,000
మేము, ఒక పాయింటర్ కుడి ఉపయోగించవచ్చు?

457
00:25:22,000 --> 00:25:25,000
ఎందుకంటే పైన ఎడమ స్క్వేర్ నుండి జరగబోతోంది ఆ నిజంగా బాణం,

458
00:25:25,000 --> 00:25:31,000
ఈ ఒక ఇక్కడ ఈ గై, ఈ చతురస్రం యొక్క లోపల కలిగి కాలేదు

459
00:25:31,000 --> 00:25:34,000
కేవలం కొన్ని ints, కొన్ని చార్ లేదు, కానీ నిజానికి కేటాయించింది ఏమి

460
00:25:34,000 --> 00:25:37,000
తద్వారా ఇప్పుడు కొద్దిగా అదనపు ఖాళీ,

461
00:25:37,000 --> 00:25:41,000
ఈ నాకు ఖర్చు అన్నారు అయినప్పటికీ మెమరీ నా భాగాలుగా ప్రతి,

462
00:25:41,000 --> 00:25:45,000
ఇప్పుడు కొంచెం దీర్ఘచతురస్రాకార కనిపిస్తోంది పేరు మెమరీ భాగాలుగా ఒకటి

463
00:25:45,000 --> 00:25:47,000
అనేక ఉపయోగిస్తారు, సంఖ్య 1 వంటి,

464
00:25:47,000 --> 00:25:50,000
మరియు ఈ వ్యక్తి, సంఖ్య 2 నిల్వ ఉంటే

465
00:25:50,000 --> 00:25:52,000
మెమరీ ఈ ఇతర భాగం, ఒక బాణం కోసం ఉపయోగిస్తారు

466
00:25:52,000 --> 00:25:54,000
లేదా మరింత concretely, ఒక పాయింటర్.

467
00:25:54,000 --> 00:25:59,000
మరియు, నేను ఈ వ్యక్తివి దశలో ఉపయోగిస్తున్నారు నేను ఇక్కడ పైగా సంఖ్య 3 నిల్వ అనుకుందాం

468
00:25:59,000 --> 00:26:02,000
మరియు ఇప్పుడు ఈ గై, యొక్క నేను మాత్రమే మెమరీ మూడు భాగాలుగా కావలసిన అనుకుందాం తెలియజేయండి.

469
00:26:02,000 --> 00:26:05,000
నేను శూన్య సూచిస్తుంది ఆ ద్వారా లైన్ గీయడం చేస్తాము.

470
00:26:05,000 --> 00:26:07,000
అదనపు పాత్ర ఉంది.

471
00:26:07,000 --> 00:26:10,000
>> నిజానికి, ఈ మేము అమలు గురించి వెళ్ళండి ఎలా ఉంది

472
00:26:10,000 --> 00:26:12,000
అనుబంధ జాబితా అని ఏదో.

473
00:26:12,000 --> 00:26:18,000
అనుబంధ జాబితా ఒక కొత్త డేటా నిర్మాణం, మరియు అది వైపు ఒక పునాది రాయి

474
00:26:18,000 --> 00:26:21,000
సమస్యలను పరిష్కరించటానికి ప్రారంభం ఎక్కువ ఫ్యాన్సియెర్స్ డేటా నిర్మాణాలు

475
00:26:21,000 --> 00:26:23,000
Facebook-రకం సమస్యలు లైన్లు మరియు Google-రకం సమస్యలు పాటు

476
00:26:23,000 --> 00:26:26,000
మీరు భారీ డేటా సమితుల కలిగి, మరియు అది కట్స్ ఇకపై పేరు

477
00:26:26,000 --> 00:26:29,000
పక్కపక్కన ఏదైనా నిల్వ మరియు సరళ శోధన లాగ ఉపయోగించడానికి

478
00:26:29,000 --> 00:26:31,000
బైనరీ శోధన వంటి లేదా ఏదో.

479
00:26:31,000 --> 00:26:33,000
మీరు కూడా మంచి నడుస్తున్న కాలంలో మీరు.

480
00:26:33,000 --> 00:26:37,000
నిజానికి, పవిత్ర గ్రైల్స్ ఒకటి మేము తరువాత ఈ వారం లేదా తర్వాత గురించి మాట్లాడదాము

481
00:26:37,000 --> 00:26:41,000
దీని అమలు సమయం స్థిరాంకం ఒక అల్గోరిథం.

482
00:26:41,000 --> 00:26:44,000
ఇతర మాటలలో, ఇది ఎల్లప్పుడూ సమయం యొక్క అదే మొత్తం ఉన్నా పడుతుంది

483
00:26:44,000 --> 00:26:47,000
ఇన్పుట్, మరియు ఆ నిజానికి ఖచ్చితంగా ఉంటుంది ఎంత పెద్ద

484
00:26:47,000 --> 00:26:49,000
మరింత ఎక్కువగా సంవర్గమాన ఏదో కంటే.

485
00:26:49,000 --> 00:26:51,000
ఇక్కడ ఈ తెరపై ఏమిటి?

486
00:26:51,000 --> 00:26:55,000
దీర్ఘ చతురస్రాలు ప్రతి నేను చేతితో ఆకర్షించింది ఏమి ఖచ్చితంగా ఉంది.

487
00:26:55,000 --> 00:26:59,000
కానీ ఎడమ అన్ని మార్గం విషయం ప్రత్యేక చరరాశి.

488
00:26:59,000 --> 00:27:02,000
ఎందుకంటే ఒక gotcha ఇది ఒక పాయింటర్ చేస్తాడు

489
00:27:02,000 --> 00:27:04,000
ఒక లింక్ జాబితాను, ఈ విషయాలు అంటారు వంటి,

490
00:27:04,000 --> 00:27:09,000
మీరు లింక్ జాబితా యొక్క ఒక చివరి వేల్లాడుతారు చేసేది ఉంటుంది.

491
00:27:09,000 --> 00:27:13,000
>> ఒక స్ట్రింగ్ వలె, మీరు మొదటి చార్ యొక్క చిరునామా తెలుసుకోవలసి ఉంటుంది.

492
00:27:13,000 --> 00:27:15,000
అనుసంధాన జాబితాలు అదే ఒప్పందం.

493
00:27:15,000 --> 00:27:19,000
మీరు మెమరీ మొదటి భాగం యొక్క చిరునామా తెలుసుకోవలసి ఉంటుంది

494
00:27:19,000 --> 00:27:25,000
అక్కడ నుండి ఎందుకంటే, మీరు ప్రతి ఇతర ఒక చేరతాయి.

495
00:27:25,000 --> 00:27:27,000
ఇబ్బంది.

496
00:27:27,000 --> 00:27:30,000
మేము ఒక డైనమిక్ కలిగి ఈ సర్వతోముఖ ఏ ధర చెల్లిస్తున్న

497
00:27:30,000 --> 00:27:34,000
తగుమాత్రమైన డేటా నిర్మాణాన్ని మేము మరింత మెమరీ అవసరం ఉంటే, జరిమానా,

498
00:27:34,000 --> 00:27:37,000
కేవలం ఒక భాగం మరింత కేటాయించాలి మరియు ఒక పాయింటర్ నుండి డ్రా

499
00:27:37,000 --> 00:27:39,000
జాబితా యొక్క కొత్త తోక పాత?

500
00:27:39,000 --> 00:27:41,000
అవును.

501
00:27:41,000 --> 00:27:43,000
[స్టూడెంట్] ఇది సుమారు రెండు రెట్లు ఎక్కువ స్థలం పడుతుంది.

502
00:27:43,000 --> 00:27:45,000
ఇది ఖచ్చితంగా వ్యతిరేక స్థితి, అందుచే, రెట్టింపు స్థలం పడుతుంది, మరియు మేము ఈ చూసిన

503
00:27:45,000 --> 00:27:48,000
టైమ్ అండ్ స్పేస్ మరియు వశ్యత మధ్య ముందు బేరీజుగా

504
00:27:48,000 --> 00:27:51,000
ఇప్పుడు ద్వారా, మేము ఈ సంఖ్యలు ప్రతి 32 బిట్స్ అవసరం పేరు.

505
00:27:51,000 --> 00:27:57,000
మమ్మల్ని పాయింటర్ కోసం 64, సంఖ్య 32 మరియు 32 అవసరం.

506
00:27:57,000 --> 00:27:59,000
కానీ హే, నేను RAM యొక్క 2 గిగాబైట్ల ఉన్నాయి.

507
00:27:59,000 --> 00:28:02,000
ఇక్కడ మరియు ఇక్కడ మరొక 32 బిట్స్ కలుపుతోంది ఒప్పందం యొక్క పెద్ద కనిపించడం లేదు.

508
00:28:02,000 --> 00:28:05,000
కానీ పెద్ద డేటా సమితుల కొరకు, అది ఖచ్చితంగా సాహిత్యపరంగా కంటే రెట్టింపు వరకు జతచేస్తుంది.

509
00:28:05,000 --> 00:28:09,000
ప్రస్తుతం మరొక స్థితి, లేదా మేము, ఏ ఫీచర్ ఇవ్వవలసిందిగా లేదు

510
00:28:09,000 --> 00:28:12,000
మేము ఒక లింక్ జాబితా మరియు అర్రే కాదు తో విషయాల జాబితాలు ప్రాతినిధ్యం? ఉంటే

511
00:28:12,000 --> 00:28:14,000
[స్టూడెంట్] మీరు వెనక్కి అది దాటటానికి కాదు.

512
00:28:14,000 --> 00:28:16,000
మీరు వెనక్కి అది దాటటానికి కాదు, మీరు వాకింగ్ మీకు రకమైన చిత్తు చేశాడు ఉన్నారు కాబట్టి

513
00:28:16,000 --> 00:28:19,000
ఎడమ నుండి కుడికి లూప్ లేదా కొంత లూప్ ఒక ఉపయోగించి

514
00:28:19,000 --> 00:28:21,000
మరియు తర్వాత మీరు "ఓహ్, నేను జాబితా యొక్క ప్రారంభానికి తిరిగి వెళ్లాలనుకుంటే.", తెలుసుకుంటారు

515
00:28:21,000 --> 00:28:26,000
బాణాలు సూచిస్తున్నాయి మీరు ఈ గమనికలు మాత్రమే ఎడమ నుండి కుడి వెళ్ళండి కాదు ఎందుకంటే.

516
00:28:26,000 --> 00:28:29,000
>> ఇప్పుడు, మీరు మరొక వేరియబుల్ తో జాబితా ప్రారంభం గుర్తు

517
00:28:29,000 --> 00:28:31,000
కానీ గుర్తుంచుకోండి ఒక సంక్లిష్టత ఉంటుంది.

518
00:28:31,000 --> 00:28:35,000
ఒక అమరిక, మీరు ఎంతవరకు ఉన్నా, మీరు ఎల్లప్పుడూ మైనస్ మైనస్, మైనస్ చేయండి, మైనస్ చేయవచ్చు

519
00:28:35,000 --> 00:28:37,000
మరియు మీరు వచ్చింది whence నుండి తిరిగి వెళ్ళండి.

520
00:28:37,000 --> 00:28:40,000
మరొక స్థితి ఇక్కడ ఏముంది? అవును.

521
00:28:40,000 --> 00:28:43,000
[వినబడని విద్యార్థి ప్రశ్న]

522
00:28:43,000 --> 00:28:47,000
మీరు, కాబట్టి మీరు నిజానికి, నటన ఎన్నటికీ లింక్ జాబితా అనే డేటా నిర్మాణం ప్రతిపాదించిన చేసిన కాలేదు

523
00:28:47,000 --> 00:28:50,000
నిజానికి, మీరు ఈ దీర్ఘ చతురస్రాలు ప్రతి మరొక పాయింటర్ కలుపుతాయి

524
00:28:50,000 --> 00:28:53,000
ఇతర దిశలో వెళతాడు, పైకి ఇది యొక్క

525
00:28:53,000 --> 00:28:55,000
మీరు, ముందుకు వెనుకకు ప్రయాణించి ఇప్పుడు ఉంది

526
00:28:55,000 --> 00:28:59,000
మనం వంటి ఇది యొక్క కిందవైపు ఇప్పుడు మీరు మెమరీని మూడు రెట్లు ఉపయోగించే ఉంది

527
00:28:59,000 --> 00:29:04,000
మరియు మీరు కుడి అది పొందడానికి రాయడానికి కలిగి కోడ్ పరంగా సంక్లిష్టతను జోడించడం.

528
00:29:04,000 --> 00:29:08,000
తిరగ చాలా ముఖ్యం అయితే ఈ అన్ని బహుశా చాలా సమంజసమైన tradeoffs ఉంటాయి.

529
00:29:08,000 --> 00:29:10,000
అవును.

530
00:29:10,000 --> 00:29:12,000
[స్టూడెంట్] మీరు ఒక 2D అనుబంధ జాబితా ఉండకూడదు.

531
00:29:12,000 --> 00:29:16,000
గుడ్, మీరు నిజంగా 2D లింక్ జాబితా ఉండకూడదు.

532
00:29:16,000 --> 00:29:18,000
మీరు ఉంటారు. ఇది వ్యూహం దాదాపు సులభం కాదు.

533
00:29:18,000 --> 00:29:21,000
వ్యూహం వలె, మీరు ఓపెన్ బ్రాకెట్, క్లోజ్డ్ బ్రాకెట్, ఓపెన్ బ్రాకెట్, బ్రాకెట్ మూసివేయబడింది, చేయండి

534
00:29:21,000 --> 00:29:23,000
మరియు మీరు కొన్ని 2-కోణ నిర్మాణం పొందండి.

535
00:29:23,000 --> 00:29:26,000
మీరు ఒక 2 డైమెన్షనల్ లింక్ జాబితా అమలు కాలేదు

536
00:29:26,000 --> 00:29:29,000
మీరు add-వంటి మీరు ఈ విషయాలు ప్రతి మూడవ పాయింటర్-ప్రతిపాదిత, లేకపోతే

537
00:29:29,000 --> 00:29:34,000
మీరు మరొక జాబితా గురించి అనుకుంటే మీరు వద్ద 3D శైలి వస్తున్న

538
00:29:34,000 --> 00:29:40,000
స్క్రీన్ నుండి మాకు అన్ని, ఇది కేవలం కొన్ని రకాల మరొక గొలుసు ఉంది.

539
00:29:40,000 --> 00:29:45,000
మేము దీనిని, కానీ ఓపెన్ బ్రాకెట్, చదరపు బ్రాకెట్ టైప్ వంటి సాధారణ కాదు. అవును.

540
00:29:45,000 --> 00:29:48,000
[వినబడని విద్యార్థి ప్రశ్న]

541
00:29:48,000 --> 00:29:50,000
గుడ్, ఈ నిజమైన kicker ఉంది.

542
00:29:50,000 --> 00:29:54,000
>> మేము బైనరీ శోధన, OH వంటి మీద pined చేసిన ఈ అల్గోరిథంలను,

543
00:29:54,000 --> 00:29:57,000
మీరు బోర్డు మీద సంఖ్యల వ్యూహం శోధించవచ్చు

544
00:29:57,000 --> 00:30:01,000
లేదా ఒక ఫోన్ బుక్ చాలా త్వరగా మీరు ఉపయోగిస్తే విభజించి జయించటానికి

545
00:30:01,000 --> 00:30:05,000
మరియు ఒక బైనరీ శోధన అల్గోరిథం, కానీ బైనరీ శోధన రెండు అంచనాలు అవసరం.

546
00:30:05,000 --> 00:30:09,000
డేటా క్రమబద్ధీకరించబడతాయి అని ఒకటి,.

547
00:30:09,000 --> 00:30:11,000
ఇప్పుడు మేము బహుశా, ఈ విభజించిన ఉంచుకోవచ్చు

548
00:30:11,000 --> 00:30:14,000
కాబట్టి బహుశా ఒక ఆందోళన కాదు, అయితే బైనరీ శోధన కూడా చేపట్టారు

549
00:30:14,000 --> 00:30:18,000
మీరు, సంఖ్యలు జాబితాలో రాండమ్ యాక్సెస్ కలిగి

550
00:30:18,000 --> 00:30:21,000
మరియు ఒక శ్రేణి, మీరు రాండమ్ యాక్సెస్ అనుమతిస్తుంది, మరియు రాండమ్ యాక్సెస్ ద్వారా

551
00:30:21,000 --> 00:30:24,000
నేను మీరు వ్యూహం ఇచ్చిన లేకుంటే, మీరు ఎంత సమయం పడుతుంది అర్థం

552
00:30:24,000 --> 00:30:26,000
బ్రాకెట్ 0 చెయ్యడానికి?

553
00:30:26,000 --> 00:30:29,000
ఒక ఆపరేషన్, మీరు [0] ఉపయోగించడానికి మరియు మీరు అక్కడే ఉన్నారు.

554
00:30:29,000 --> 00:30:33,000
నగర 10 ను ఎలా పొందాలో అనేక దశలు అది పడుతుంది?

555
00:30:33,000 --> 00:30:36,000
ఒక దశ, మీరు మరియు మీరు అక్కడ ఉన్నారు [10] కు వెళ్ళండి.

556
00:30:36,000 --> 00:30:40,000
దీనికి విరుద్ధంగా, ఎలా మీరు ఒక లింక్ జాబితాలో 10 వ ఇంటీజర్ కు వస్తుందా?

557
00:30:40,000 --> 00:30:42,000
మీరు మాత్రమే గుర్తు ఎందుకంటే మీరు ప్రారంభంలో ప్రారంభించడానికి కలిగి

558
00:30:42,000 --> 00:30:45,000
ఒక స్ట్రింగ్ వంటి అనుబంధ జాబితా ప్రారంభం జ్ఞాపకం ఉంది

559
00:30:45,000 --> 00:30:48,000
మొదటి చార్ యొక్క చిరునామా ద్వారా, మరియు ఆ 10 Int కనుగొనేందుకు

560
00:30:48,000 --> 00:30:53,000
లేదా ఒక స్ట్రింగ్ లో 10 వ పాత్ర మీరు మొత్తం భీకర విషయం అన్వేషణ ఉంటుంది.

561
00:30:53,000 --> 00:30:55,000
>> మళ్లీ, మేము మా సమస్యలను పరిష్కరించడానికి అన్ని లేదు.

562
00:30:55,000 --> 00:31:00,000
మేము కొత్త వాటిని పరిచయం చేస్తున్నాము, కాని అది నిజంగా మీరు రూపకల్పన ప్రయత్నిస్తున్న దానిపై ఆధారపడి ఉంటుంది.

563
00:31:00,000 --> 00:31:04,000
ఈ అమలు పరంగా, ఆ విద్యార్థి నిర్మాణం నుండి ఒక ఆలోచన రుణాలు తీసుకునే.

564
00:31:04,000 --> 00:31:07,000
వాక్యనిర్మాణం ఇప్పుడు తప్ప, దాదాపు సమానంగా ఉంటుంది, ఆలోచన కొంచెం ఆబ్స్ట్రాక్ట్

565
00:31:07,000 --> 00:31:09,000
కంటే హౌస్ మరియు పేరు మరియు ID.

566
00:31:09,000 --> 00:31:13,000
కానీ మనం సి ఒక డేటా నిర్మాణం కలిగి ప్రతిపాదించారు

567
00:31:13,000 --> 00:31:17,000
నోడ్ అని, స్లయిడ్ న చివరి పదం సూచిస్తుంది వంటి

568
00:31:17,000 --> 00:31:21,000
ఒక నోడ్ యొక్క లోపల, మరియు ఒక నోడ్ కేవలం కంప్యూటర్ సైన్స్ లో ఒక కంటైనర్ ఉంది.

569
00:31:21,000 --> 00:31:25,000
ఇది సాధారణంగా ఒక సర్కిల్ లేదా మేము చేసిన ఒక చతురస్రాకార లేదా దీర్ఘ చతురస్రం వలె డ్రా మాత్రమే.

570
00:31:25,000 --> 00:31:27,000
మరియు ఈ డేటాను నిర్మాణం, మేము ఒక Int, n కలిగి

571
00:31:27,000 --> 00:31:29,000
కాబట్టి నేను నిల్వ మీరు సంఖ్య ఉంది.

572
00:31:29,000 --> 00:31:36,000
కానీ ఈ రెండో లైన్, struct నోడ్ * తర్వాత ఏమిటి?

573
00:31:36,000 --> 00:31:40,000
ఎందుకు, ఇది సరైన, లేదా పాత్ర ఈ విషయం ఆట ఏమి

574
00:31:40,000 --> 00:31:42,000
అది మొదటి చూపులో కొంచెం గుప్తమైన యొక్క అయినప్పటికీ?

575
00:31:42,000 --> 00:31:44,000
అవును.

576
00:31:44,000 --> 00:31:46,000
[వినబడని విద్యార్థి ప్రతిస్పందన]

577
00:31:46,000 --> 00:31:50,000
సరిగ్గా, కాబట్టి ఇది కొన్ని రకాల ఒక పాయింటర్ కుళ్ళిపోయిన యొక్క * విధమైన అని.

578
00:31:50,000 --> 00:31:53,000
ఈ పాయింటర్ యొక్క పేరు, ఏకపక్ష తదుపరి

579
00:31:53,000 --> 00:32:00,000
కానీ మేము అది మేము మీరు ఏదైనా అని ఉండవచ్చు, కానీ ఈ పాయింటర్ పాయింట్ ఏమి చేస్తుంది?

580
00:32:00,000 --> 00:32:03,000
[స్టూడెంట్] మరొక నోడ్. >> ఖచ్చితంగా ఇది మరో నోడ్ సూచిస్తుంది.

581
00:32:03,000 --> 00:32:05,000
>> ఇప్పుడు, ఈ C. ఒక ఆసక్తి యొక్క విధమైన ఉంది

582
00:32:05,000 --> 00:32:09,000
, సి ఎడమ, క్రింద ఒక కంపైలర్ టాప్ ద్వారా వినిపించే రీకాల్

583
00:32:09,000 --> 00:32:13,000
ఇది మేము విద్యార్థి తో చేసిన నుండి కొద్దిగా భిన్నంగా ఉంటుంది అర్థం.

584
00:32:13,000 --> 00:32:16,000
మేము ఒక విద్యార్థి నిర్వచించిన, మేము నిజంగా అక్కడ ఒక పదం పెట్టలేదు.

585
00:32:16,000 --> 00:32:18,000
ఇది కేవలం typedef చెప్పారు.

586
00:32:18,000 --> 00:32:20,000
అప్పుడు మేము Int id, స్ట్రింగ్ పేరు, స్ట్రింగ్ హౌస్ కలిగి

587
00:32:20,000 --> 00:32:23,000
ఆపై struct దిగువన విద్యార్థి.

588
00:32:23,000 --> 00:32:26,000
ఈ ప్రకటన కొద్దిగా భిన్నంగా ఉంటుంది, ఎందుకంటే

589
00:32:26,000 --> 00:32:28,000
మళ్ళీ, C కంపైలర్ కొద్దిగా మూగ ఉంది.

590
00:32:28,000 --> 00:32:30,000
ఇది మాత్రమే, పైనుంచి చదవడానికి జరగబోతోంది

591
00:32:30,000 --> 00:32:33,000
అది ఇక్కడ 2nd లైన్ చేరుకునే అయితే

592
00:32:33,000 --> 00:32:37,000
తదుపరి డిక్లేర్డ్ మరియు అది చూసే కౌంటీ, OH, ఇక్కడ తదుపరి అనే వేరియబుల్.

593
00:32:37,000 --> 00:32:39,000
ఇది ఒక struct నోడ్ ఒక పాయింటర్ ఉంది.

594
00:32:39,000 --> 00:32:42,000
కంపైలర్ ఒక struct కణుపు అనేదానికి ఉండబోతుంది?

595
00:32:42,000 --> 00:32:44,000
నేను, ముందు ఈ విషయం గురించి తెలియకపోవచ్చు చేసిన

596
00:32:44,000 --> 00:32:47,000
పదం నోడ్ లేకపోతే కనిపించదు కాబట్టి

597
00:32:47,000 --> 00:32:49,000
దిగువ వరకు, ఈ పునరుక్తి ఉంది.

598
00:32:49,000 --> 00:32:53,000
మీరు తరువాత చిన్నదిగా, ఇది ఇక్కడ struct నోడ్ చెప్పే

599
00:32:53,000 --> 00:32:56,000
డౌన్ ఇక్కడ typedef కృతజ్ఞతలు, కానీ ఈ ఎందుకంటే

600
00:32:56,000 --> 00:33:02,000
మేము లోపల నిర్మాణం యొక్క నిర్మాణం కూడా సూచిస్తూ ఉంటాయి.

601
00:33:02,000 --> 00:33:05,000
ఆ అక్కడ ఒక gotcha ఉంది.

602
00:33:05,000 --> 00:33:07,000
>> కొన్ని ఆసక్తికరమైన సమస్యలు తలెత్తే వెళ్తున్నారు.

603
00:33:07,000 --> 00:33:09,000
మేము సంఖ్యల జాబితా పొందారు. మేము దీనిని ఎలా ఇన్సర్ట్ చెయ్యాలి?

604
00:33:09,000 --> 00:33:11,000
మేము ఎలా సెర్చ్ చెయ్యాలి? మేము దాని నుండి ఎలా తొలగించాలి?

605
00:33:11,000 --> 00:33:13,000
ముఖ్యంగా ఇప్పుడు మేము ఈ గమనికలు అన్ని నిర్వహించడానికి కలిగి.

606
00:33:13,000 --> 00:33:15,000
మీరు గమనికలు మనస్సు-వంచి యొక్క విధమైన ఆలోచన

607
00:33:15,000 --> 00:33:17,000
మీరు ఉన్నప్పుడు వాటిని ఒకటి దానికి ఒక పూర్ణాంకానికి చదవడానికి ప్రయత్నించడంలో.

608
00:33:17,000 --> 00:33:20,000
ఇప్పుడు మేము పూర్తి జాబితా యొక్క విలువ సర్దుబాటు చేయాలి.

609
00:33:20,000 --> 00:33:22,000
ఎందుకు మేము ఇక్కడ మా 5 నిమిషాల విరామం లేదు, మరియు అప్పుడు మేము తీసుకుని చేస్తాము

610
00:33:22,000 --> 00:33:34,000
దశ లో కొన్ని వారిని ఖచ్చితంగా ఆ విధంగా చేయడానికి.

611
00:33:34,000 --> 00:33:36,000
>> సి అది పనిచేయకుండా ఎప్పుడు చాలా సరదాగా ఉంటుంది.

612
00:33:36,000 --> 00:33:39,000
ఎవరు అక్షరాలా మొదటి ఉండాలని కోరుకుంటారు?

613
00:33:39,000 --> 00:33:41,000
సరే, అప్ న వస్తాయి. మీరు మొదటి ఉంటాయి.

614
00:33:41,000 --> 00:33:44,000
ఎవరు 9 ఉండాలని కోరుకుంటారు? సరే, 9.

615
00:33:44,000 --> 00:33:46,000
ఎలా 9? 17?

616
00:33:46,000 --> 00:33:51,000
ఇక్కడ ఒక చిన్న జట్టు. ఆ ముందు వరుసగా 22 మరియు 26.

617
00:33:51,000 --> 00:33:53,000
ఆపై గురించి అక్కడ ఎంత చూపారు అవుతోంది.

618
00:33:53,000 --> 00:33:57,000
మీరు 34 ఉన్నాయి. సరే, మీద 34, వస్తాయి.

619
00:33:57,000 --> 00:33:59,000
మొదటి అక్కడ ఉంది. సరే, మీరు అబ్బాయిలు అన్ని నాలుగు.

620
00:33:59,000 --> 00:34:01,000
మరియు మేము 9 ఎవరు అని పేర్కొన్నారు?

621
00:34:01,000 --> 00:34:04,000
మా 9 ఎవరు?

622
00:34:04,000 --> 00:34:07,000
ఎవరు నిజంగా 9 చేయాలనుకుంటున్నారు? All right, 9 ఉంటుంది, న వస్తాయి.

623
00:34:07,000 --> 00:34:10,000
ఇక్కడ మేము వెళ్ళండి.

624
00:34:10,000 --> 00:34:13,000
34, మేము అక్కడ మీరు పైగా కలుద్దాం.

625
00:34:13,000 --> 00:34:17,000
మొదటి భాగం నిన్ను నీవు వలె కనిపించేలా ఉంది.

626
00:34:17,000 --> 00:34:21,000
26, 22, 17, మంచి.

627
00:34:21,000 --> 00:34:25,000
మేము ఒక క్షణంలో మీరు malloc చూడాలని ఎందుకంటే మీరు, ప్రక్కగా నిలబడి ఉంటే.

628
00:34:25,000 --> 00:34:29,000
>> మంచి, మంచి.

629
00:34:29,000 --> 00:34:32,000
సరే, అద్భుతమైన, కాబట్టి యొక్క ఇక్కడ ప్రశ్నలు రెండు అడగండి తెలపండి.

630
00:34:32,000 --> 00:34:34,000
మరియు వాస్తవానికి, మీ పేరు ఏమిటి? >> అనిత.

631
00:34:34,000 --> 00:34:37,000
అనిత, సరే, ఇక్కడ కమ్ ఆన్ ఓవర్.

632
00:34:37,000 --> 00:34:41,000
అనిత, మాకు విధమైన మొదటి ఒక నిరాడంబర ప్రశ్న పరిష్కరించడంలో సహాయంగా అన్నారు

633
00:34:41,000 --> 00:34:44,000
ఇది ఎలా మీరు ఒక విలువను జాబితా ఉంది లేదో కనుగొనేందుకు పోవడమే?

634
00:34:44,000 --> 00:34:48,000
ఇప్పుడు, మొదటి, ఇక్కడ లుకాస్ ద్వారా ప్రాతినిధ్యం అని గుర్తించలేకపోతే

635
00:34:48,000 --> 00:34:52,000
కొద్దిగా భిన్నంగా ఉంటుంది, అందువలన కాగితం అతని భాగాన్ని ఉద్దేశపూర్వకంగా పక్కకి ఉంది

636
00:34:52,000 --> 00:34:55,000
ఇది చాలా వంటి పొడవైన కాదు మరియు అనేక బిట్స్ వంటి పడుతుంది కాబట్టి

637
00:34:55,000 --> 00:34:58,000
అయినప్పటికీ సాంకేతికంగా అతను తిప్పడం కాగితం ఒకే పరిమాణాన్ని కలిగి ఉంది.

638
00:34:58,000 --> 00:35:01,000
అయితే ఒక పాయింటర్ మాత్రమే 32 బిట్స్ అని ఒక చిన్న విభిన్నమైనది

639
00:35:01,000 --> 00:35:05,000
మరియు ఈ కుర్రాళ్ళు అన్ని ఒక పాయింటర్ వీటిలో సగం నిధులు సంఖ్య సగం మంది 64 బిట్స్, ఉన్నాయి.

640
00:35:05,000 --> 00:35:08,000
కానీ పాయింటర్ కాబట్టి, వర్ణించబడలేదు మీరు అబ్బాయిలు అనుకొనుట కొంతవరకు వికారంగా ఉంటే

641
00:35:08,000 --> 00:35:12,000
మీరు పక్కన వ్యక్తి సమయంలో మీ ఎడమ చేతి ఉపయోగించండి.

642
00:35:12,000 --> 00:35:14,000
మరియు మీరు సంఖ్య 34 ఉన్నాము. మీ పేరు ఏమిటి?

643
00:35:14,000 --> 00:35:16,000
అరి.

644
00:35:16,000 --> 00:35:19,000
అరి, కాబట్టి నిజంగా, మీ కుడి చేతిలో కాగితం కలిగి, మరియు ఎడమ చేతి నేరుగా పని చెయ్యకపోతే.

645
00:35:19,000 --> 00:35:21,000
మీరు ఎడమ న శూన్య సూచిస్తాయి.

646
00:35:21,000 --> 00:35:24,000
>> ఇప్పుడు మా మానవ చిత్ర చాలా స్థిరంగా ఉంటుంది.

647
00:35:24,000 --> 00:35:26,000
ఈ గమనికలు పని ఎలా నిజానికి ఉంది.

648
00:35:26,000 --> 00:35:29,000
మరియు మీ విధంగా నేను కాదు కాబట్టి మీరు కొద్దిగా ఈ విధంగా scrunch లేదో.

649
00:35:29,000 --> 00:35:34,000
ఇక్కడ అనిత, నాకు సంఖ్య 22 కనుగొనడానికి

650
00:35:34,000 --> 00:35:40,000
కానీ మానవులు కాగితపు ముక్కల అప్ ఉంచుకోకుండా ఒక నిరోధ ఊహించుకోవటం,

651
00:35:40,000 --> 00:35:43,000
కానీ ఈ జాబితా, మరియు మీరు మాత్రమే లుకాస్ తో ప్రారంభించడానికి కలిగి

652
00:35:43,000 --> 00:35:46,000
అతను అక్షరాలా మొదటి పాయింటర్ ఉంది.

653
00:35:46,000 --> 00:35:51,000
మీరే ఒక పాయింటర్, మరియు అందువల్ల మీరు కూడా ఏదో సమయంలో సామర్ధ్యాన్ని కలిగి ఉంటాయి అనుకుందాం.

654
00:35:51,000 --> 00:35:56,000
ఎందుకు మీరు లుకాస్ వద్ద సూచించబడిన వేటి వద్ద గురిపెట్టి ప్రారంభం లేదు?

655
00:35:56,000 --> 00:35:58,000
గుడ్, మరియు నాకు ఇక్కడ ఈ అవ్ట్ చేయాలని తెలియజేయండి.

656
00:35:58,000 --> 00:36:04,000
జస్ట్ చర్చ కొరకు, నాకు ఇక్కడ ఒక ఖాళీ పేజీ పుల్ అప్ తెలియజేయండి.

657
00:36:04,000 --> 00:36:06,000
ఎలా మీరు మీ పేరు స్పెల్లింగ్ చెయ్యాలి? >> అనిత.

658
00:36:06,000 --> 00:36:08,000
సరే, అనిత.

659
00:36:08,000 --> 00:36:18,000
లెట్ యొక్క నోడ్ * అనిత = లుకాస్ చెప్పారు.

660
00:36:18,000 --> 00:36:22,000
Well, మేము మీరు లుకాస్ కాల్ లేదు. మీరు మొదటి పిలవాలి.

661
00:36:22,000 --> 00:36:25,000
ఎందుకు ఈ ఇక్కడ రియాలిటీ స్థిరంగా నిజానికి?

662
00:36:25,000 --> 00:36:27,000
ఒకటి, మొదటి ఇప్పటికే ఉంది.

663
00:36:27,000 --> 00:36:30,000
మొదటి ఎక్కడో అప్ ఇక్కడ బహుశా కేటాయించింది చేయబడింది.

664
00:36:30,000 --> 00:36:35,000
నోడ్ * మొదటి, మరియు అది ఎలానో జాబితా కేటాయించింది పేర్కొన్నాడు.

665
00:36:35,000 --> 00:36:37,000
నేను అదంతా తెలియదు. తరగతి ప్రారంభించారు ముందు జరిగింది.

666
00:36:37,000 --> 00:36:40,000
మానవులు ఈ లింక్ జాబితా సృష్టించబడింది.

667
00:36:40,000 --> 00:36:44,000
ఇప్పుడు కథ ఈ అన్ని స్పష్టంగా Facebook జరుగుతుందో ఈ సమయంలో తరువాత

668
00:36:44,000 --> 00:36:49,000
కథ ఈ సమయంలో, అనిత, మొదటి కు సమానమైనది initialized చేయబడింది

669
00:36:49,000 --> 00:36:51,000
ఇది లుకాస్ వద్ద అనిత పాయింట్లు అర్థం కాదు.

670
00:36:51,000 --> 00:36:53,000
అయితే, ఆమె అతను వద్ద చూపాడు ఏమి చూపాడు

671
00:36:53,000 --> 00:36:57,000
ఎందుకంటే లుకాస్ యొక్క 32 బిట్ల లోపల అదే చిరునామా - 1, 2, 3 -

672
00:36:57,000 --> 00:37:01,000
1, 2, 3 - ఇప్పుడు కూడా లోపల అనిత యొక్క 32 బిట్ల ఉంది.

673
00:37:01,000 --> 00:37:05,000
>> ఇప్పుడు 22 కనుగొనండి. మీరు ఈ చేయడం గురించి పాటు?

674
00:37:05,000 --> 00:37:07,000
ఏ ఆ? >> పాయింట్ ఏమిటి.

675
00:37:07,000 --> 00:37:11,000
ఏ ఎక్కడుందో, కాబట్టి ముందుకు సాగి మీరు ఇక్కడ సరిగా గా పోషిస్తాను.

676
00:37:11,000 --> 00:37:15,000
, మంచి, మరియు ఇప్పుడు మీరు పై చేసిన వద్ద-మీ పేరు 22 ఉన్నది?

677
00:37:15,000 --> 00:37:18,000
రామోన్. >> రామోన్, రామోన్ 22 ఎత్తి చూపుతూ ఉంటుంది.

678
00:37:18,000 --> 00:37:20,000
మీరు ఇప్పుడు ఒక చెక్ చేశాను.

679
00:37:20,000 --> 00:37:24,000
అయితే రామోన్ == 22, మరియు, ఉదాహరణకు, మేము నిజమైన తిరిగి లేదు.

680
00:37:24,000 --> 00:37:26,000
నాకు-సమయంలో లెట్ ఈ కుర్రాళ్ళు వికారంగా-కొంతవరకు ఇక్కడ నిలబడి

681
00:37:26,000 --> 00:37:32,000
కనుగొనడానికి నాకు bool వంటి త్వరగా ఏదో ఒకటి అనుమతిస్తాయి.

682
00:37:32,000 --> 00:37:37,000
నేను (నోడ్ * జాబితా, Int n) ముందుకు వెళ్లి చెప్పే వెళుతున్న.

683
00:37:37,000 --> 00:37:39,000
నేను మీరు అబ్బాయిలు సరైన తిరిగి ఉంటాం. నేను కొన్ని కోడ్ వ్రాయడానికి కలిగి ఉంటాయి.

684
00:37:39,000 --> 00:37:45,000
ఇప్పుడు నేను ముందుకు వెళ్లి ఈ, నోడ్ * అనిత = జాబితా చేయ బోతున్నాను.

685
00:37:45,000 --> 00:37:51,000
నేను ముందుకు వెళ్లి చెప్పే వెళుతున్న సమయంలో (అనిత! = NULL).

686
00:37:51,000 --> 00:37:57,000
>> ఇక్కడ రూపకం కొద్దిగా విస్తరించి పెరిగిపోతుంది, కానీ (అనిత! = NULL), నేను ఏమి అనుకుంటున్నారు అయితే?

687
00:37:57,000 --> 00:38:03,000
నేను సూచిస్తూ కొన్ని మార్గం అవసరం

688
00:38:03,000 --> 00:38:05,000
అనిత వద్ద సూచించబడిన ఆ పూర్ణాంక.

689
00:38:05,000 --> 00:38:08,000
గతంలో మేము ఒక నోడ్ ఇది నిర్మాణాలు ఉన్నప్పుడు,

690
00:38:08,000 --> 00:38:11,000
మేము డాట్ సంజ్ఞామానం ఉపయోగిస్తారు, మరియు మేము ఏదో వంటి చెబుతా

691
00:38:11,000 --> 00:38:15,000
ఇక్కడ anita.n, కానీ సమస్య అనిత ఒక struct కేవలంగా కాదు.

692
00:38:15,000 --> 00:38:17,000
ఆమె అంటే ఏమిటి?

693
00:38:17,000 --> 00:38:21,000
మేము ఈ డాట్ ను ఉపయోగించడానికి ఆమె అలా నిజంగా, ఒక పాయింటర్ నొటేషన్-

694
00:38:21,000 --> 00:38:23,000
మరియు ఈ ఉద్దేశపూర్వకంగా చిన్న చూడండి అన్నారు గుప్తమైన-

695
00:38:23,000 --> 00:38:28,000
మేము ఏ అనిత యొక్క ఎడమ చేతి వెళ్ళండి లాగ లేదు వద్ద సూచించబడిన

696
00:38:28,000 --> 00:38:31,000
ఆపై n అనే field పొందండి.

697
00:38:31,000 --> 00:38:35,000
అనిత ఒక పాయింటర్, కానీ * అనిత ఏమిటి?

698
00:38:35,000 --> 00:38:38,000
మీరు అనిత వద్ద సూచించబడిన వాటికి అనుకుంటే మీరు ఏమి కనుక్కుంటారు?

699
00:38:38,000 --> 00:38:42,000
ఒక struct, ఒక కణుపు, మరియు ఒక నోడ్, రీకాల్, n అనే ఫీల్డ్ ఉంది

700
00:38:42,000 --> 00:38:47,000
ఇది గుర్తు ఎందుకంటే, ఈ 2 ఖాళీలను, తదుపరి మరియు n,

701
00:38:47,000 --> 00:38:50,000
మేము ఇక్కడ ఒక క్షణం క్రితం జరిగింది.

702
00:38:50,000 --> 00:38:53,000
>> వాస్తవానికి, కోడ్ ఈ అనుకరించడం

703
00:38:53,000 --> 00:39:02,000
మేము దీన్ని మరియు చెప్పడానికి అని ((* అనిత). n == n), నేను చూస్తున్నాను ఆ n.

704
00:39:02,000 --> 00:39:04,000
ఫంక్షన్ నేను శ్రద్ధ సంఖ్య జారీ చేయబడిన ప్రకటన.

705
00:39:04,000 --> 00:39:10,000
అప్పుడు నేను నిజమైన తిరిగి లాగ ముందుకు వెళ్లి చేయవచ్చు.

706
00:39:10,000 --> 00:39:12,000
ఆ సందర్భంలో లేకుంటే ఎల్స్, నేను ఏమి అనుకుంటున్నారు?

707
00:39:12,000 --> 00:39:19,000
నేను అనిత జాబితా ద్వారా వాకింగ్ అలా intuitively చేసిన కోడ్ అనువదించు చెయ్యాలి?

708
00:39:19,000 --> 00:39:26,000
నేను అనిత ఎడమ, ఎడమ ఆ దశల ఆ దశ తీసుకొని అనుకరించేందుకు ఇక్కడికి అప్ చెయ్యాలి?

709
00:39:26,000 --> 00:39:28,000
[వినబడని విద్యార్థి ప్రతిస్పందన] >> ఆ ఏమిటి?

710
00:39:28,000 --> 00:39:30,000
[వినబడని విద్యార్థి ప్రతిస్పందన]

711
00:39:30,000 --> 00:39:34,000
, ఒక చెడ్డ ఆలోచన, కానీ గతంలో మేము ఇది చేసిన సమయంలో, మేము మంచి చేసిన అనిత + +

712
00:39:34,000 --> 00:39:37,000
ఆ అనిత కు సంఖ్య 1 జోడించండి ఎందుకంటే,

713
00:39:37,000 --> 00:39:40,000
ఇది సాధారణంగా, రామోన్ వంటి తదుపరి వ్యక్తి సమయంలో ఉంటుంది

714
00:39:40,000 --> 00:39:44,000
లేదా అతని పక్కన వ్యక్తి, లేదా వ్యక్తి డౌన్ లైన్ అతని పక్కన.

715
00:39:44,000 --> 00:39:49,000
ఈ విషయం మెమరీ ఎలా ఎందుకంటే కానీ ఇక్కడ చాలా మంచి కాదు?

716
00:39:49,000 --> 00:39:54,000
కాదు. మేము ఆ డిజేబుల్.

717
00:39:54,000 --> 00:40:00,000
నేను 1 మరియు 2 మరియు 3 ఒకదాని తర్వాత ఒకటి, డ్రా చేసిన అయినప్పటికీ మెమరీలో ఈ కనిపిస్తోంది, మరియు

718
00:40:00,000 --> 00:40:03,000
మేము నిజంగా చైతన్య ఇంకా అదే ప్రజలకు పై మీరు,, అబ్బాయిలు ఈ-CAN

719
00:40:03,000 --> 00:40:07,000
మీరు కొన్ని యాదృచ్చిక దశల తిరిగి ముందుకు మీరు కొన్ని యాదృచ్చిక దశల పడుతుంది?

720
00:40:07,000 --> 00:40:10,000
>> ఈ మెస్, ఇప్పటికీ ఒక అనుసంధాన జాబితా

721
00:40:10,000 --> 00:40:13,000
కానీ ఈ కుర్రాళ్ళు, ఎక్కడైనా మెమరీలో ఉంటుంది

722
00:40:13,000 --> 00:40:15,000
కాబట్టి అనిత + + ఎందుకు పని ఉండదని?

723
00:40:15,000 --> 00:40:19,000
నగర అనిత వద్ద ఏమిటి + +?

724
00:40:19,000 --> 00:40:21,000
ఎవరు తెలుసు.

725
00:40:21,000 --> 00:40:24,000
ఇది కేవలం కాబట్టి interposed నిర్మాణము కొన్ని ఇతర విలువ ఏమిటి

726
00:40:24,000 --> 00:40:28,000
అవకాశం ద్వారా ఈ నోడ్స్ అన్ని మధ్య ఎందుకంటే మేము వరుసను ఉపయోగించి లేదు.

727
00:40:28,000 --> 00:40:30,000
మేము వ్యక్తిగతంగా ఈ నోడ్స్ యొక్క ప్రతి కేటాయించింది.

728
00:40:30,000 --> 00:40:32,000
సరే, మీరు అబ్బాయిలు నిన్ను నీవు అప్ తిరిగి శుభ్రం చెయ్యగలిగితే.

729
00:40:32,000 --> 00:40:37,000
నాకు బదులుగా అనిత + +, మేము బదులుగా ఏమి అనిత యొక్క ప్రతిపాదించారు లెట్ గెట్స్-

730
00:40:37,000 --> 00:40:42,000
అలాగే, మేము అప్పుడు అనిత వద్ద గురిపెట్టి ఏమైనా వెళ్ళండి మరియు దీనిని ఎందుకు. తదుపరి?

731
00:40:42,000 --> 00:40:45,000
ఇతర మాటల్లో చెప్పాలంటే, సంఖ్య 22 పట్టుకొని ఎవరు రామోన్,, వెళ్ళండి

732
00:40:45,000 --> 00:40:51,000
అనిత అతని ఎడమ చేతి చూపుడు కాపీ ఉన్నప్పటికీ వంటి ఆపై. పక్కనే ఉంది.

733
00:40:51,000 --> 00:40:54,000
మేము 22 ఏకీభవించలేదు కానీ ఆమె రామోన్ కంటే మరింత లోతుగా కాదు.

734
00:40:54,000 --> 00:40:56,000
కానీ ఆ ఆలోచన ఉంటుంది. ఇప్పుడు, ఈ దేవుని భయంకర మెస్ ఉంది.

735
00:40:56,000 --> 00:40:59,000
నిజాయితీగా, ఎవరూ కూడా ఎప్పుడూ, కాబట్టి కృతజ్ఞతగా ఈ వాక్యనిర్మాణం గుర్తుంచుకోండి మరియు కనిపిస్తుంది

736
00:40:59,000 --> 00:41:04,000
నిజానికి కొంచెం ఉద్దేశపూర్వక-OH, మీరు నిజంగా నేను వ్రాసిన చూడటానికి లేదు ఉంది.

737
00:41:04,000 --> 00:41:08,000
మీరు చేస్తే ఈ మరింత ఖచ్చితంగా ఉంటుంది. Voila!

738
00:41:08,000 --> 00:41:10,000
>> తెర వెనుక, నేను సమస్య ఈ విధంగా పరిష్కార జరిగినది.

739
00:41:10,000 --> 00:41:14,000
అనిత, ఎడమ ఆ దశకు వెళ్లడానికి,

740
00:41:14,000 --> 00:41:18,000
మొదటి, మేము అనిత వద్ద సూచించబడిన ఆ చిరునామా వెళ్ళండి లేదు

741
00:41:18,000 --> 00:41:23,000
మరియు ఆమె మాత్రమే మేము పోలిక కోసమని తనిఖీ ఇది n, కనుగొంటారు

742
00:41:23,000 --> 00:41:25,000
కానీ మీరు కూడా తదుపరి కనుగొంటారు - ఈ సందర్భంలో,

743
00:41:25,000 --> 00:41:28,000
రామోన్ యొక్క ఎడమ చేతి జాబితా తదుపరి నోడ్ సూచించే.

744
00:41:28,000 --> 00:41:32,000
కానీ ఈ, ఇది నేను గతంలో సూచిస్తారు దేవుని-భయంకర మెస్ ఉంది

745
00:41:32,000 --> 00:41:34,000
సి మాకు ఈ సులభతరం అనుమతిస్తుంది అవుట్ కానీ మారుతుంది.

746
00:41:34,000 --> 00:41:40,000
బదులుగా రచన (* అనిత), మేము బదులుగా కేవలం, అనిత-> n రాయడం

747
00:41:40,000 --> 00:41:45,000
మరియు, ఇది ఖచ్చితమైన విషయం, కానీ చాలా సహజమైన ఉంది

748
00:41:45,000 --> 00:41:48,000
మరియు అది మేము డ్రాయింగ్ చేసిన ఆ చిత్రం తో చాలా స్థిరంగా ఉంది

749
00:41:48,000 --> 00:41:50,000
ఈ సమయంలో బాణాలు ఉపయోగించి.

750
00:41:50,000 --> 00:41:57,000
>> చివరగా, మేము ఈ కార్యక్రమం చివరిలో ఏమి చేయాలి?

751
00:41:57,000 --> 00:42:00,000
మిగిలిన కోడ్ ఒకటి గీత ఉంది.

752
00:42:00,000 --> 00:42:02,000
ఏ తిరిగి?

753
00:42:02,000 --> 00:42:05,000
ఫాల్స్, ఎందుకంటే మేము మొత్తం ద్వారా వస్తే, అయితే లూప్

754
00:42:05,000 --> 00:42:10,000
మరియు అనితా నిజానికి, శూన్య, ఆమె జాబితా ముగింపు వరకు వెళ్ళారు, ఉంది

755
00:42:10,000 --> 00:42:12,000
ఆమె పై జరిగిన వద్ద-మీ పేరు యొక్క మళ్లీ?

756
00:42:12,000 --> 00:42:15,000
శూన్య ఇది ​​అరి. >> ఆరి యొక్క ఎడమ చేతికి.

757
00:42:15,000 --> 00:42:18,000
అనిత ఇప్పుడు శూన్య ఉంది, మరియు నేను మీరు లింబో లో వికారంగా ఇక్కడ నిలబడి చేస్తున్న తెలుసుకుంటారు

758
00:42:18,000 --> 00:42:21,000
నేను ఇక్కడ ఒక ప్రకటన మీద ఆఫ్ వెళుతున్న ఎందుకంటే,

759
00:42:21,000 --> 00:42:23,000
కానీ మేము కేవలం ఒక నిమిషంలో మళ్ళీ మీరు కలిగి ఉంటుంది.

760
00:42:23,000 --> 00:42:27,000
అనిత కథలో ఆ సమయంలో శూన్య ఉంది, అయితే లూప్ ఆగిపోతుంది కాబట్టి

761
00:42:27,000 --> 00:42:30,000
మరియు మేము తప్పుడు తిరిగి ఉంటాయి, ఎందుకంటే ఆమె ఆరి యొక్క నల్ పాయింటర్ వరకు వస్తే

762
00:42:30,000 --> 00:42:34,000
అప్పుడు ఆమె జాబితాలో కోరింది ఏ సంఖ్య ఉంది.

763
00:42:34,000 --> 00:42:39,000
మేము చాలా అప్ ఈ శుభ్రం, కానీ ఈ అప్పుడు ఒక అందమైన మంచి అమలు

764
00:42:39,000 --> 00:42:43,000
ఒక ట్రావెర్సల్ పనితీరు, ఒక అనుబంధ జాబితా కోసం ఫంక్షన్ కనుగొనండి.

765
00:42:43,000 --> 00:42:48,000
ఇప్పటికీ సరళ శోధన, అయితే + + ఒక పాయింటర్ వలె సాధారణ కాదు

766
00:42:48,000 --> 00:42:52,000
లేదా + + ఒక i వేరియబుల్ ఇప్పుడు మేము ఊహించడం కాదు ఎందుకంటే

767
00:42:52,000 --> 00:42:54,000
ఈ నోడ్స్ యొక్క ప్రతి మెమరీలో పేరు ఉన్నాయి.

768
00:42:54,000 --> 00:42:57,000
మేము, మరింత ప్రత్యేకంగా, సాహిత్యపరంగా breadcrumbs ట్రయిల్ ఆఫ్ అనుసరించాలని లేదా

769
00:42:57,000 --> 00:43:00,000
ఒక నోడ్ నుండి మరొక పొందడానికి గమనికలు.

770
00:43:00,000 --> 00:43:02,000
>> ఇప్పుడు మరొక ప్రయత్నించండి తెలియజేయండి. అనిత, మీరు తిరిగి ఇక్కడికి వచ్చి అనుకుంటున్నారు?

771
00:43:02,000 --> 00:43:06,000
ఎందుకు మేము ముందుకు వెళ్లి, ప్రేక్షకుల నుండి మరొక వ్యక్తి కేటాయించాలని లేదు?

772
00:43:06,000 --> 00:43:08,000
Malloc-మీ పేరు ఏమిటి? >> రెబెక్కా.

773
00:43:08,000 --> 00:43:10,000
రెబెక్కా. రెబెక్కా, ప్రేక్షకుల నుండి malloced చేయబడింది

774
00:43:10,000 --> 00:43:13,000
మరియు ఆమె ఇప్పుడు సంఖ్య 55 నిల్వ.

775
00:43:13,000 --> 00:43:17,000
అనిత ఇన్సర్ట్ చెయ్యడానికి మరియు చేతి వద్ద గోల్ ఇప్పుడు

776
00:43:17,000 --> 00:43:22,000
దాని సరైన స్థానంలో ఇక్కడ లింక్ జాబితాలో రెబెక్కా.

777
00:43:22,000 --> 00:43:24,000
ఒక క్షణం ఇక్కడ కమ్ ఆన్ ఓవర్.

778
00:43:24,000 --> 00:43:28,000
నేను ఈ వంటి ఏదో చేసారు.

779
00:43:28,000 --> 00:43:32,000
నేను నోడ్ * చేసారు. మరియు మీ పేరు ఏమిటి మళ్ళీ?

780
00:43:32,000 --> 00:43:34,000
రెబెక్కా. >> రెబెక్కా, సరే.

781
00:43:34,000 --> 00:43:41,000
రెబెక్కా malloc (sizeof (నోడ్)) వచ్చింది.

782
00:43:41,000 --> 00:43:44,000
జస్ట్ వంటి మేము గతంలో విద్యార్థులు మరియు whatnot వంటి వాటిని కేటాయించింది చేశారు

783
00:43:44,000 --> 00:43:46,000
మేము నోడ్ యొక్క పరిమాణం అవసరం, కాబట్టి ఇప్పుడు రెబెక్కా

784
00:43:46,000 --> 00:43:49,000
ఏమి సూచిస్తుంది?

785
00:43:49,000 --> 00:43:52,000
రెబెక్కా 55 అందులో ఒకటి తన లోపలి రెండు ఖాళీలను కలిగి ఉంది.

786
00:43:52,000 --> 00:43:55,000
తెలియజేసేలా ఏది రెబెక్కా-> = 55.

787
00:43:55,000 --> 00:44:00,000
కానీ రెబెక్కా-> తదుపరి ప్రస్తుతం లాగా ఉండాలి, ఆమె చేతిని తెలిసిన రకం?

788
00:44:00,000 --> 00:44:03,000
అలా ఎందుకు మంచి కొలత కోసం లేదు, కొన్ని చెత్త విలువ వద్ద గురిపెట్టి యొక్క

789
00:44:03,000 --> 00:44:07,000
ఎడమ చేతి ఇప్పుడు తన పక్కన కాబట్టి మేము కనీసం దీన్ని.

790
00:44:07,000 --> 00:44:09,000
ఇప్పుడు అనిత, ఇక్కడ నుంచి తీసుకెళ్లు.

791
00:44:09,000 --> 00:44:11,000
మీరు రెబెక్కా కేటాయింపు కలిగి ఉన్నాయి.

792
00:44:11,000 --> 00:44:20,000
కొనసాగి, మేము రెబెక్కా ఉంచారు ఎక్కడ చూడండి.

793
00:44:20,000 --> 00:44:25,000
మంచి, మంచి.

794
00:44:25,000 --> 00:44:28,000
, సరే, మంచి, మరియు ఇప్పుడు మేము మీరు దిశలో ఒక బిట్ అందించాలి

795
00:44:28,000 --> 00:44:30,000
కాబట్టి మీరు ఆరి చేరుకున్నారు.

796
00:44:30,000 --> 00:44:33,000
, అతని ఎడమ చేతి శూన్య, కానీ రెబెక్కా స్పష్టంగా కుడి చెందిన

797
00:44:33,000 --> 00:44:36,000
కాబట్టి మేము ఎలా లింక్ జాబితా మార్చడానికి ఉన్నాయి

798
00:44:36,000 --> 00:44:38,000
సరైన స్థలం లో రెబెక్కా ఇన్సర్ట్ చెయ్యడానికి?

799
00:44:38,000 --> 00:44:42,000
మీరు వాచ్యంగా అవసరమైన మంది యొక్క ఎడమ చేయి తరలించడానికి చేయగలిగితే,

800
00:44:42,000 --> 00:44:48,000
మేము ఆ విధంగా సమస్య పరిష్కరించడానికి ఉంటాం.

801
00:44:48,000 --> 00:44:52,000
సరే, మంచి, మరియు అదే సమయంలో, రెబెక్కా ఎడమ చేతి వైపు ఆమె ద్వారా ఇప్పుడు ఉంది.

802
00:44:52,000 --> 00:44:54,000
>> అది చాలా సులభం.

803
00:44:54,000 --> 00:44:57,000
లెట్ యొక్క, దాదాపు పూర్తి పెడుతోంది-మేము 20 ప్రయత్నించండి.

804
00:44:57,000 --> 00:44:59,000
సరే, అప్ న వస్తాయి.

805
00:44:59,000 --> 00:45:04,000
20 కేటాయింపు, అందుచే నాకు ముందుకు వెళ్లి ఇక్కడ మళ్ళీ అని పిలవబడు

806
00:45:04,000 --> 00:45:07,000
మేము కేవలం నోడ్ * సాద్ చేసిన.

807
00:45:07,000 --> 00:45:11,000
మేము (sizeof (నోడ్)) malloc ఉన్నాయి.

808
00:45:11,000 --> 00:45:16,000
మేము అప్పుడు, మేము 20 కోసం ముందు వలె అదే ఖచ్చితమైన సింటాక్స్ చేయండి

809
00:45:16,000 --> 00:45:20,000
మరియు నేను తరువాత = NULL చేస్తాను, మరియు ఇప్పుడు అది అనిత ఇష్టం

810
00:45:20,000 --> 00:45:23,000
మీరు ఆ ఖచ్చితమైన పాత్రను అని మీరు లింక్ జాబితా ఇన్సర్ట్ చెయ్యడానికి.

811
00:45:23,000 --> 00:45:30,000
అమలు.

812
00:45:30,000 --> 00:45:32,000
సరే, మంచి.

813
00:45:32,000 --> 00:45:38,000
మీరు చుట్టూ ఎడమ చేతులు కదులుతూ ముందు ఇప్పుడు జాగ్రత్తగా ఆలోచించండి.

814
00:45:38,000 --> 00:45:46,000
మీరు ఇప్పటివరకు నేడు అత్యంత ఇబ్బందికరమైన పాత్ర దక్కింది.

815
00:45:46,000 --> 00:45:59,000
ఎవరి వైపు మొదటి మారుతూ ఉండాలి?

816
00:45:59,000 --> 00:46:02,000
ఓకే, నేను కొన్ని సంఖ్య యొక్క విన్న నేను, వేచి.

817
00:46:02,000 --> 00:46:07,000
కొన్ని వారిని మర్యాదగా ఇక్కడ ఒక ఇబ్బందికరమైన పరిస్థితి పరిష్కరించడంలో సహాయంగా అనుకుంటే.

818
00:46:07,000 --> 00:46:11,000
ఎవరి ఎడమ చేతి మొదటి బహుశా అప్డేట్ చేయాలి? అవును.

819
00:46:11,000 --> 00:46:13,000
[స్టూడెంట్] సాద్ యొక్క.

820
00:46:13,000 --> 00:46:15,000
సరే, సాద్ యొక్క, ఎందుకు, అయితే?

821
00:46:15,000 --> 00:46:17,000
[వినబడని విద్యార్థి ప్రతిస్పందన]

822
00:46:17,000 --> 00:46:19,000
గుడ్, ఎందుకంటే మేము తరలించడానికి-ఏం మీ పేరు ఏమిటి? >> మార్షల్.

823
00:46:19,000 --> 00:46:22,000
మార్షల్, మేము శూన్యం మొదటి డౌన్ చేతిలో తరలిస్తే,

824
00:46:22,000 --> 00:46:25,000
ఇప్పుడు మేము వాచ్యంగా ఈ జాబితాలో నలుగురు అనాథ ఉన్నాయి

825
00:46:25,000 --> 00:46:29,000
అతను రామోన్ మరియు ఎడమ ప్రతి ఒక్కరి వద్ద గురిపెట్టి ఒకే ఒక విషయం ఎందుకంటే

826
00:46:29,000 --> 00:46:31,000
కాబట్టి ఆ పాయింటర్ నవీకరించడాన్ని బాగా లేదు.

827
00:46:31,000 --> 00:46:33,000
యొక్క ఆ దిద్దుబాటు రద్దుచెయ్యి లెట్.

828
00:46:33,000 --> 00:46:37,000
గుడ్, మరియు ఇప్పుడు ముందుకు వెళ్లి రామోన్ వద్ద గురిపెట్టి తగిన ఎడమ చేతి తరలించండి.

829
00:46:37,000 --> 00:46:39,000
ఈ చిన్న అనవసరమైన భావిస్తాడు.

830
00:46:39,000 --> 00:46:41,000
ఇప్పుడు అక్కడ రామోన్ వద్ద గురిపెట్టి ఇద్దరు వ్యక్తులు, కానీ ఆ మంచిది

831
00:46:41,000 --> 00:46:43,000
ఎందుకంటే ఇప్పుడు ఎలా else మేము జాబితా అప్డేట్ చెయ్యాలి?

832
00:46:43,000 --> 00:46:48,000
ఏ ఇతర చేతి తరలించడానికి ఉంది?

833
00:46:48,000 --> 00:46:53,000
అద్భుతమైన, ఇప్పుడు మేము ఏ మెమరీ కోల్పోయారు?

834
00:46:53,000 --> 00:46:57,000
లేదు, సో గుడ్, మేము ఈ సారి బ్రేక్ కాదు లేదో యొక్క చూసేలా.

835
00:46:57,000 --> 00:47:00,000
>> , సంఖ్య 5 చివరిసారిగా Mallocing.

836
00:47:00,000 --> 00:47:04,000
తిరిగి అన్ని మార్గం, కం ఆన్ డౌన్.

837
00:47:04,000 --> 00:47:08,000
అది చాలా ఉద్వేగాన్ని కలిగిస్తోంది.

838
00:47:08,000 --> 00:47:15,000
[చప్పట్లు]

839
00:47:15,000 --> 00:47:17,000
మీ పేరు ఏమిటి? >> రాన్.

840
00:47:17,000 --> 00:47:19,000
రాన్, సరే, మీరు సంఖ్య 5 వంటి malloced ఉంటాయి.

841
00:47:19,000 --> 00:47:23,000
మేము ఈ దాదాపు ఒకేలా ఉండే కోడ్ అమలు చేసిన

842
00:47:23,000 --> 00:47:26,000
వేరొక పేరుతో.

843
00:47:26,000 --> 00:47:28,000
అద్భుతమైన.

844
00:47:28,000 --> 00:47:38,000
ఇప్పుడు, అనిత, అదృష్టం ఇప్పుడు జాబితాలో సంఖ్య 5 ఇన్సర్ట్.

845
00:47:38,000 --> 00:47:43,000
గుడ్, మరియు?

846
00:47:43,000 --> 00:47:47,000
అద్భుతమైన, కాబట్టి ఇది నిజంగా మూడు మొత్తం కేసుల్లో మూడవ ఉంది.

847
00:47:47,000 --> 00:47:49,000
మేము మొదటి రెబెక్కా, చివర ఎవరైనా ఉంది.

848
00:47:49,000 --> 00:47:51,000
మేము అప్పుడు మధ్యలో ఎవరైనా ఉంది.

849
00:47:51,000 --> 00:47:53,000
ఇప్పుడు మేము కూడా మొదట్లో మరియు ఈ ఉదాహరణలో వారివి

850
00:47:53,000 --> 00:47:56,000
మేము ఇప్పుడు మొదటిసారి లుకాస్ అప్డేట్ వచ్చింది

851
00:47:56,000 --> 00:48:00,000
జాబితాలో మొదటి మూలకం ఇప్పుడు ఒక కొత్త నోడ్ దశలో ఉంది ఎందుకంటే,

852
00:48:00,000 --> 00:48:03,000
ఎవరు, క్రమంగా, నోడ్ సంఖ్య 9 వద్ద సూచించబడిన.

853
00:48:03,000 --> 00:48:06,000
>> ఈ అత్యంత ఇబ్బందికరమైన ప్రదర్శనకు, నేను ఖచ్చితంగా ఉన్నాను,

854
00:48:06,000 --> 00:48:08,000
కాబట్టి ఈ కుర్రాళ్ళు చప్పట్లు పెద్ద రౌండ్ మీరు చేస్తే.

855
00:48:08,000 --> 00:48:11,000
చక్కగా చేసారు.

856
00:48:11,000 --> 00:48:17,000
అంతే. మీరు కొద్దిగా స్మృతి వంటి కాగితం మీ ముక్కలు ఉండేందుకు కారణమవుతుంది.

857
00:48:17,000 --> 00:48:22,000
ఇది కోడ్ ఇలా ఆ అవుతుంది

858
00:48:22,000 --> 00:48:26,000
కేవలం చుట్టూ చేతులు కదులుతూ చాలా సులభమైనది కాదు

859
00:48:26,000 --> 00:48:28,000
మరియు వివిధ విషయాలను వద్ద గమనికలు పై.

860
00:48:28,000 --> 00:48:31,000
కానీ ఇలా అమలు సమయం వచ్చినప్పుడు గుర్తించలేరు

861
00:48:31,000 --> 00:48:34,000
మీరు నిజంగా దృష్టి ఉంటే అనుబంధ జాబితా లేదా దాని రూపాంతరం

862
00:48:34,000 --> 00:48:38,000
ఈ ప్రాథమిక ఫండమెంటల్స్, నేను గుర్తించడానికి కలిగి కాటు పరిమాణం సమస్యలు,

863
00:48:38,000 --> 00:48:43,000
ఈ చేతి లేదా ఈ ముల్లు, ఏ లేకపోతే పూర్తి క్లిష్టమైన కార్యక్రమం గుర్తించలేరు

864
00:48:43,000 --> 00:48:47,000
నిజానికి, ఈ వంటి చాలా సులభమైన నిర్మాణ ఇటుకలు కు తగ్గించవచ్చు.

865
00:48:47,000 --> 00:48:51,000
>> ఇంకా మరింత అధునాతన దిశలో విషయాలు తీసుకుని చూద్దాం.

866
00:48:51,000 --> 00:48:53,000
మేము ఇప్పుడు లింక్ జాబితా భావన ఉంది.

867
00:48:53,000 --> 00:48:57,000
తిరిగి సలహా అక్కడ-నటన ఎన్నటికీ లింక్ జాబితాకు మేము కూడా కలిగి-ధన్యవాదాలు,

868
00:48:57,000 --> 00:49:01,000
ఇది దాదాపు అదే కనిపిస్తుంది, కానీ ఇప్పుడు మేము struct లోపలి రెండు పాయింటర్లు కలిగి

869
00:49:01,000 --> 00:49:05,000
ఒకటి బదులు, మరియు మేము బహుశా ఆ గమనికలు మునుపటి మరియు తదుపరి కాల్ కాలేదు

870
00:49:05,000 --> 00:49:08,000
లేదా ఎడమ లేదా కుడి, కాని మేము నిజానికి, వాటిలో రెండు అవసరం.

871
00:49:08,000 --> 00:49:10,000
కోడ్ కొంచెం పాల్గొంటాడు.

872
00:49:10,000 --> 00:49:12,000
అనిత వేదికపై ఇక్కడ మరింత పని చేయడానికి ఉండేవి.

873
00:49:12,000 --> 00:49:15,000
కానీ మేము ఖచ్చితంగా నిర్మాణం ఆ రకమైన అమలు కాలేదు.

874
00:49:15,000 --> 00:49:19,000
అమలు సమయం పరంగా, అయితే, ఏ రన్నింగ్ సమయం ఉంటుంది

875
00:49:19,000 --> 00:49:24,000
ఇప్పుడు ఒక లింక్ జాబితాలో అనేక n కనుగొనే అనిత కోసం?

876
00:49:24,000 --> 00:49:27,000
N యొక్క స్టిల్ పెద్ద O, కాబట్టి ఇది దీర్ఘ శోధన కంటే ఉత్తమం.

877
00:49:27,000 --> 00:49:29,000
మేము మళ్లీ అయితే, బైనరీ శోధన చెయ్యలేరు.

878
00:49:29,000 --> 00:49:34,000
కేసులో ఎందుకు ఉంది? మీ చుట్టూ జంప్ కాదు.

879
00:49:34,000 --> 00:49:36,000
మేము ఖచ్చితంగా దశ అన్ని మానవులు, చూడండి ఉన్నప్పటికీ

880
00:49:36,000 --> 00:49:39,000
మరియు అనితా ", ఇక్కడ జాబితా యొక్క మధ్య భాగం" అది eyeballed మరియు మాట్లాడుతూ, కాలేదు

881
00:49:39,000 --> 00:49:42,000
ఆమె కంప్యూటర్ ప్రోగ్రామ్ అయితే ఆమె ఆ అర్థం కాదు

882
00:49:42,000 --> 00:49:47,000
ఆమె మాత్రమే విషయం అంశంలో ప్రారంభంలో లో తలుపునకు వేయు గడియ ఎందుకంటే

883
00:49:47,000 --> 00:49:50,000
మొదటి పాయింటర్ అయిన లుకాస్ ఉంది.

884
00:49:50,000 --> 00:49:53,000
ఆమె తప్పనిసరిగా ఆ లింక్లను అనుసరించండి వుంటుంది

885
00:49:53,000 --> 00:49:56,000
ఆమె సుమారు మధ్య కనిపించే వరకు ఆమె మార్గం లెక్కింపు,

886
00:49:56,000 --> 00:49:58,000
మరియు అది కూడా, ఆమె మధ్య స్థానాన్ని పొందింది అయినప్పుడు నాకు మాత్రం కాదు

887
00:49:58,000 --> 00:50:01,000
ఆమె, ఎన్ని గుర్తించడానికి ముగింపు వరకు వెళుతుంది తప్ప

888
00:50:01,000 --> 00:50:05,000
మీరు అయితే తప్ప అప్పుడు వెళుతుంది, మరియు ఆ చాలా హార్డ్ ఉంటుంది

889
00:50:05,000 --> 00:50:07,000
కొన్ని రకాల నటన ఎన్నటికీ లింక్ జాబితా.

890
00:50:07,000 --> 00:50:10,000
>> నేడు కొన్ని సమస్యలను పరిష్కరించడం, కాని ఇతరులు పరిచయం.

891
00:50:10,000 --> 00:50:12,000
వేరే డేటా నిర్మాణం పూర్తిగా గురించి ఏమిటి?

892
00:50:12,000 --> 00:50:15,000
ఈ, మాథుర్ హౌస్ ట్రేలు ఒక ఫోటో

893
00:50:15,000 --> 00:50:19,000
మరియు ఈ సందర్భంలో, మనం కూడా రకం ఇప్పటికే గురించి ఆలోచిస్తున్నాము ఒక డేటా ఆకృతి.

894
00:50:19,000 --> 00:50:22,000
మేము, మెమరీ సందర్భంలో ఒక స్టాక్ గురించి మాట్లాడారు

895
00:50:22,000 --> 00:50:26,000
మరియు ఆ విధమైన ఉద్దేశపూర్వకంగా అనే ఎందుకంటే మెమరీ పరంగా ఒక స్టాక్

896
00:50:26,000 --> 00:50:31,000
సమర్థవంతంగా దాని పైభాగంలో లేయర్డ్ మరింత stuff కలిగి డేటా నిర్మాణం.

897
00:50:31,000 --> 00:50:35,000
కానీ స్టాక్ గురించి ఆసక్తికరమైన విషయం, వంటి, వాస్తవానికి సందర్భంలో

898
00:50:35,000 --> 00:50:38,000
అది డేటా నిర్మాణం యొక్క ఒక ప్రత్యేక తరహా అని ఉంది.

899
00:50:38,000 --> 00:50:42,000
ఇది ఒక డేటా నిర్మాణ వస్తే మొదటి మూలకం

900
00:50:42,000 --> 00:50:46,000
గత మూలకం ముగిసింది.

901
00:50:46,000 --> 00:50:50,000
మీరు, స్టాక్ లో పెట్టడానికి మొదటి ట్రే ఉంటే

902
00:50:50,000 --> 00:50:53,000
మీరు, దురదృష్టవశాత్తు స్టాక్ ఆఫ్ తీసుకోవాలి గత ట్రే ఉంటుంది చూడాలని

903
00:50:53,000 --> 00:50:55,000
మరియు ఒక మంచి విషయం అవసరం లేదు.

904
00:50:55,000 --> 00:50:58,000
దీనికి విరుద్ధంగా, మీరు, ఇతర మార్గం చుట్టూ దాని గురించి ఆలోచించవచ్చు

905
00:50:58,000 --> 00:51:02,000
చివరి మొదటి ముగిసింది.

906
00:51:02,000 --> 00:51:05,000
>> ఇప్పుడు, ఏ సందర్భాల్లో ఒక స్టాక్ కలిగి ఉన్న స్ఫురణకు వచ్చారా

907
00:51:05,000 --> 00:51:08,000
మీరు లక్షణాన్ని కలిగి ఉన్నాయి పేరు డేటా నిర్మాణం

908
00:51:08,000 --> 00:51:13,000
మొదటి అవ్ట్, చివరి యొక్క, నిజానికి ఖచ్చితంగా ఉంది?

909
00:51:13,000 --> 00:51:16,000
ఒక మంచి విషయం? ఒక చెడ్డ విషయం?

910
00:51:16,000 --> 00:51:19,000
ట్రేలు అన్ని సారూప్యత ఉన్నట్లయితే ఇది ఖచ్చితంగా మంచిది

911
00:51:19,000 --> 00:51:21,000
మరియు వారు, అన్ని ప్రత్యేక వివిధ రంగులు లేదా whatnot ఉన్నాయి

912
00:51:21,000 --> 00:51:24,000
మరియు మీకు కావలసిన రంగు దిగువన అన్ని మార్గం.

913
00:51:24,000 --> 00:51:26,000
అయితే, మీరు గొప్ప ప్రయత్నం లేకుండా ఆ పొందలేము.

914
00:51:26,000 --> 00:51:28,000
మీరు ఎగువ నుండి ప్రారంభం మరియు మీ మార్గం డౌన్ పని ఉంటుంది.

915
00:51:28,000 --> 00:51:31,000
అదేవిధంగా, మీరు ఈ అభిమాని బాయ్స్ ఒకటి ఏం

916
00:51:31,000 --> 00:51:34,000
ఎవరు అప్ ఒక ఐఫోన్ మరియు పంక్తులు పొందడానికి ప్రయత్నిస్తున్న రాత్రి వరకు వేచి

917
00:51:34,000 --> 00:51:36,000
ఈ వంటి ప్రదేశంలో?

918
00:51:36,000 --> 00:51:40,000
ఇది నీస్ కాదు ఉంటే ఆపిల్ స్టోర్

919
00:51:40,000 --> 00:51:42,000
ఒక స్టాక్ డేటా నిర్మాణం ఉన్నాయి?

920
00:51:42,000 --> 00:51:44,000
అవును? కాదు?

921
00:51:44,000 --> 00:51:47,000
ఇది చివరి నిమిషంలో చూపించే వ్యక్తులకు మాత్రమే మంచి

922
00:51:47,000 --> 00:51:50,000
మరియు తర్వాత క్యూ ఆఫ్ తెమ్పబడిన కలుగుతుంది.

923
00:51:50,000 --> 00:51:52,000
నిజానికి, నేను ప్రేరిత వాస్తవానికి క్యూ సే

924
00:51:52,000 --> 00:51:56,000
, మేము ఈ రకమైన డేటా నిర్మాణం యొక్క కాల్ ఏ తో వాస్తవానికి స్థిరంగా ఉంటుంది

925
00:51:56,000 --> 00:51:59,000
ఆర్డర్ అవసరం పేరు వాస్తవానికి ఒక,

926
00:51:59,000 --> 00:52:02,000
మరియు మీరు మొదటి ఒక మొదటి ఒకటి ఉండాలనుకుంటున్నాను

927
00:52:02,000 --> 00:52:04,000
మానవ న్యాయము కొరకు మాత్రమే.

928
00:52:04,000 --> 00:52:07,000
మేము సాధారణంగా క్యూ డేటా నిర్మాణాన్ని పిలుస్తాను.

929
00:52:07,000 --> 00:52:11,000
>> ఇది లింక్ జాబితాలు పాటు, మేము ఈ అదే ప్రాథమిక ఆలోచనలు ఉపయోగించి ప్రారంభించవచ్చు అవుతుంది

930
00:52:11,000 --> 00:52:15,000
మరియు సమస్యలకు పరిష్కారాలను యొక్క కొత్త మరియు వివిధ రకాల సృష్టిని ప్రారంభించేందుకు.

931
00:52:15,000 --> 00:52:19,000
ఉదాహరణకు, ఒక స్టాక్ విషయంలో, మేము ఒక స్టాక్ ప్రాతినిధ్యం వహిస్తుంది

932
00:52:19,000 --> 00:52:22,000
ఈ వంటి డేటా నిర్మాణం ఉపయోగించి చెప్పిన ప్రతిపాదనలను చేస్తుంది.

933
00:52:22,000 --> 00:52:26,000
ఈ సందర్భంలో, నేను ఒక struct డిక్లేర్డ్, నేను ఈ నిర్మాణం లోపల చెప్పారు చేసిన

934
00:52:26,000 --> 00:52:30,000
సంఖ్యల వ్యూహం మరియు తరువాత వేరియబుల్ అని పరిమాణం, ఉంది

935
00:52:30,000 --> 00:52:33,000
మరియు నేను ఈ విషయం ఒక స్టాక్ కాల్ నేను.

936
00:52:33,000 --> 00:52:35,000
ఇప్పుడు, ఈ వాస్తవానికి పని లేదు ఎందుకు?

937
00:52:35,000 --> 00:52:43,000
ఒక స్టాక్ విషయంలో, నేను వ్యూహం తెరపై ఈ సమర్థవంతంగా గీయవచ్చు.

938
00:52:43,000 --> 00:52:47,000
ఇక్కడ నా స్టాక్ ఉంది. ఆ నా సంఖ్యలు.

939
00:52:47,000 --> 00:52:50,000
మరియు మేము, ఈ, ఈ, ఈ ఈ ఈ వారిని డ్రా చేస్తాము.

940
00:52:50,000 --> 00:52:53,000
మరియు నేను, ఇక్కడ కొన్ని ఇతర డేటా సభ్యుడు కలిగి

941
00:52:53,000 --> 00:52:58,000
పరిమాణం అంటారు, అయితే, ఈ పరిమాణం, మరియు ఈ సంఖ్యలను

942
00:52:58,000 --> 00:53:02,000
మరియు సమిష్టిగా, ఇక్కడ మొత్తం ఐప్యాడ్ ఒక స్టాక్ నిర్మాణం సూచిస్తుంది.

943
00:53:02,000 --> 00:53:07,000
ఇప్పుడు, డిఫాల్ట్గా, పరిమాణం చాలావరకు 0 to initialized చేయడానికి కలిగియున్నది

944
00:53:07,000 --> 00:53:11,000
మరియు ప్రారంభంలో సంఖ్యల శ్రేణి యొక్క లోపల ఏముంది

945
00:53:11,000 --> 00:53:14,000
నేను మొదటి వ్యూహం కేటాయించాలని ఉన్నప్పుడు?

946
00:53:14,000 --> 00:53:16,000
గార్బేజ్. ఎవరు తెలుసు? మరియు అది నిజానికి పట్టింపు లేదు.

947
00:53:16,000 --> 00:53:20,000
ఇది పూర్తిగా యాదృచ్చికంగా, ఈ 1, 2, 3, 4, 5 ఉంటే పట్టింపు లేదు

948
00:53:20,000 --> 00:53:25,000
నా నిర్మాణం నిల్వ దురదృష్టం అలా నేను తెలిసిన ఎందుకంటే ఆ స్టాక్ యొక్క పరిమాణం

949
00:53:25,000 --> 00:53:29,000
0, అప్పుడు నేను programmatically తెలుసు, అర్రే లో అంశాల ఏ దృష్టి లేదు.

950
00:53:29,000 --> 00:53:31,000
అక్కడ ఏమి పట్టింపు లేదు.

951
00:53:31,000 --> 00:53:34,000
0 ఒక పరిమాణం యొక్క సూత్రప్రాయంగా ఉంటుంది, వాటి దృష్టి లేదు.

952
00:53:34,000 --> 00:53:38,000
>> కానీ నేను ముందుకు వెళ్లి స్టాక్ను ఏదో ఇన్సర్ట్ ఇప్పుడు అనుకుందాం.

953
00:53:38,000 --> 00:53:42,000
నేను సంఖ్య 5 ఇన్సర్ట్ చెయ్యడానికి మీరు, నేను ఇక్కడ సంఖ్య 5 ఉంచండి

954
00:53:42,000 --> 00:53:45,000
మరియు నేను ఇక్కడ ఏమి డౌన్ ఉంచగలను?

955
00:53:45,000 --> 00:53:48,000
ఇప్పుడు నేను నిజానికి, పరిమాణానికి 1 డౌన్ ఉంచుతాడు

956
00:53:48,000 --> 00:53:50,000
మరియు ఇప్పుడు స్టాక్ 1 పరిమాణం ఉంటుంది.

957
00:53:50,000 --> 00:53:53,000
నేను ముందుకు వెళ్లి సంఖ్య ఇన్సర్ట్ ఉంటే, ఏ లెట్స్ 7 తరువాత, చెబుతారా?

958
00:53:53,000 --> 00:53:57,000
ఈ అప్పుడు 2 కు నవీకరించబడింది, ఇక అప్పుడు మేము, 9 చేస్తాను

959
00:53:57,000 --> 00:54:02,000
మరియు ఈ 3 కు నవీకరించబడింది తీర్చుకుంటాడు.

960
00:54:02,000 --> 00:54:05,000
కానీ ఈ స్టాక్ ఇప్పుడు ఆసక్తికరమైన ఫీచర్ అని

961
00:54:05,000 --> 00:54:09,000
నేను పాప్ అనుకుంటే ఇది మూలకం తొలగించు కోరుకుంటున్నాము నేను

962
00:54:09,000 --> 00:54:12,000
స్టాక్ ఏదో ఆఫ్, మాట్లాడటానికి?

963
00:54:12,000 --> 00:54:14,000
9 వెళ్ళి మొదటి విషయం ఉంటుంది.

964
00:54:14,000 --> 00:54:18,000
నేను స్టాక్ ఆఫ్ ఒక మూలకం పాప్ అనుకుంటే ఎలా చిత్రం, మార్చాలి

965
00:54:18,000 --> 00:54:20,000
చాలా మాథుర్ ఒక ట్రే అనుకుంటున్నారా?

966
00:54:20,000 --> 00:54:22,000
అవును. 2 >> [స్టూడెంట్] సెట్ పరిమాణం.

967
00:54:22,000 --> 00:54:27,000
సరిగ్గా, నేను అన్ని 2 పరిమాణం సెట్, మరియు నేను శ్రేణి తో ఏమి చేస్తారు?

968
00:54:27,000 --> 00:54:29,000
నేను ఏమీ లేదు.

969
00:54:29,000 --> 00:54:32,000
నేను, కేవలం ఆసన అని, అక్కడ ఒక 0 లేదా ఒక -1 లేదా సూచిస్తుంది ఏదో ఉంచండి కాలేదు

970
00:54:32,000 --> 00:54:34,000
ఈ ఒక సక్రమం విలువ కాదు, కానీ అది లేదు ఎందుకంటే

971
00:54:34,000 --> 00:54:37,000
నేను ఎంత కాలం శ్రేణి యొక్క వెలుపల రికార్డు చేయగలరు

972
00:54:37,000 --> 00:54:41,000
కాబట్టి నాకు తెలుసు మాత్రమే ఈ శ్రేణి లో మొదటి రెండు అంశాలను చూడండి.

973
00:54:41,000 --> 00:54:47,000
ఇప్పుడు, నేను వెళ్ళి ఈ శ్రేణి సంఖ్య 8 జోడిస్తే, ఎలా చిత్రం తర్వాత మార్చదు?

974
00:54:47,000 --> 00:54:50,000
ఈ 8 అవుతుంది, మరియు ఈ 3 అవుతుంది.

975
00:54:50,000 --> 00:54:52,000
నేను ఇక్కడ కొన్ని మూలల్లో కటింగ్ నేను.

976
00:54:52,000 --> 00:54:56,000
ఇప్పుడు మేము 5, 7, 8, కలిగి తిరిగి 3 యొక్క ఒక పరిమాణం ఉన్నారు.

977
00:54:56,000 --> 00:54:58,000
ఇది అమలు చేయడానికి చాలా సులభం

978
00:54:58,000 --> 00:55:06,000
కానీ మేము ఈ నిర్ణయానికి చింతిస్తున్నాము దానికి వెళుతున్నారా?

979
00:55:06,000 --> 00:55:09,000
వచ్చిన వాటికి చాలా తప్పు మొదలు చెయ్యాలి? అవును.

980
00:55:09,000 --> 00:55:11,000
[వినబడని విద్యార్థి ప్రతిస్పందన]

981
00:55:11,000 --> 00:55:13,000
మీరు తిరిగి వెళ్ళి, మీకు సైన్ పెట్టిన తొలి మూలకం పొందడానికి ఉంటుంది

982
00:55:13,000 --> 00:55:18,000
>> ఒక స్టాక్ హుడ్ కింద వ్యూహం అయినప్పటికీ ఇది ఇక్కడ అవుతుంది

983
00:55:18,000 --> 00:55:21,000
మేము గురించి మాట్లాడటం మొదలుపెట్టాడు చేసిన ఈ డేటా నిర్మాణాలు కూడా సాధారణంగా పిలుస్తారు

984
00:55:21,000 --> 00:55:25,000
వియుక్త డేటా నిర్మాణాలు వస్తే వారు అమలు చేస్తున్నాము

985
00:55:25,000 --> 00:55:27,000
పూర్తిగా పాయింట్ పాటు ఉంటుంది.

986
00:55:27,000 --> 00:55:31,000
ఒక స్టాక్ వంటి ఒక డేటా నిర్మాణం మద్దతు కోరుకుంటున్నాము

987
00:55:31,000 --> 00:55:35,000
స్టాక్ లో ఒక ట్రే నెడుతుంది ఇది పుష్ వంటి కార్యకలాపాలను,

988
00:55:35,000 --> 00:55:39,000
మరియు స్టాక్ నుండి ఒక మూలకం తొలగిస్తుంది, అంతే ఇది పాప్,.

989
00:55:39,000 --> 00:55:43,000
మీరు ఇప్పటికే అమలు చేసిన ఇతరుల కోడ్ డౌన్లోడ్ ఉంటే

990
00:55:43,000 --> 00:55:46,000
ఈ విషయం ఒక స్టాక్ అని, ఆ వ్యక్తి రాసిన ఉండేది

991
00:55:46,000 --> 00:55:49,000
మీరు మాత్రమే రెండు విధులు, పుష్ మరియు దీని ముఖ్య ఉద్దేశం జీవితంలోని పాప్,

992
00:55:49,000 --> 00:55:51,000
సరిగ్గా ఆ విధంగా చేయడానికి ఉంటుంది.

993
00:55:51,000 --> 00:55:54,000
మీరు లేదా అతను లేదా ఆమె ఆ కార్యక్రమాన్ని అమలు చేసే

994
00:55:54,000 --> 00:55:58,000
అమలు ఎలా నిర్ణయిస్తారు పూర్తిగా ఒక ఉండేది

995
00:55:58,000 --> 00:56:00,000
హుడ్ కింద నెట్టడం మరియు పాపింగ్ యొక్క అర్థాలను

996
00:56:00,000 --> 00:56:03,000
లేదా నెట్టడం మరియు పాపింగ్ యొక్క కార్యాచరణ.

997
00:56:03,000 --> 00:56:07,000
నేను ఇక్కడ కొంత shortsighted నిర్ణయం తీసుకున్న

998
00:56:07,000 --> 00:56:10,000
ఈ సులభమైన డేటా నిర్మాణం ఎందుకు నా స్టాక్ అమలు ద్వారా?

999
00:56:10,000 --> 00:56:12,000
ఈ డేటాను నిర్మాణం బ్రేక్ చేస్తుంది?

1000
00:56:12,000 --> 00:56:18,000
ఏ సమయంలో నేను యూజర్ పుష్ కాల్స్ ఉన్నప్పుడు ఉదాహరణకు, ఒక లోపం తిరిగి ఉన్నాయి?

1001
00:56:18,000 --> 00:56:20,000
[స్టూడెంట్] ఖాళీ లేదు లేదు ఉంటే.

1002
00:56:20,000 --> 00:56:23,000
సరిగ్గా, ఖాళీ లేదు, నేను సామర్థ్యాన్ని మించిపోయాము ఉంటే, ఒకవేళ ఉంది

1003
00:56:23,000 --> 00:56:27,000
ఇది ప్రపంచ స్థిరాంకం రకమైన అని సూచిస్తుంది ఎందుకంటే ఇది అన్ని CAPS ఉంది.

1004
00:56:27,000 --> 00:56:30,000
వెల్, అప్పుడు నేను క్షమించాలి, నేను మరొక విలువ పుష్ కాదు ", చెప్పే వెళుతున్న

1005
00:56:30,000 --> 00:56:32,000
స్టాక్ లో, "చాలా మాథుర్ లాగే.

1006
00:56:32,000 --> 00:56:36,000
>> కొన్ని సమయంలో, వారు ఆ చిన్న క్యాబినెట్ ఎగువ భాగం హిట్ చూడాలని.

1007
00:56:36,000 --> 00:56:39,000
స్టాక్ ఖాళీ లేదు లేదా సామర్థ్యం లోపం రకమైన ఉంది, ఆ సమయంలో, ఉన్నాయి.

1008
00:56:39,000 --> 00:56:42,000
వారు ట్రే ఎక్కడైనా, ఎక్కడైనా మూలకం ఉంచాలి

1009
00:56:42,000 --> 00:56:44,000
లేదా ఎక్కడా అన్ని వద్ద.

1010
00:56:44,000 --> 00:56:47,000
ఇప్పుడు, ఒక క్యూ తో, మేము ఇది భిన్నంగా కొద్దిగా అమలు కాలేదు.

1011
00:56:47,000 --> 00:56:50,000
ఒక క్యూ హుడ్ కింద, అది అమలు చేసే ఒక చిన్న భిన్నంగా ఉంటుంది

1012
00:56:50,000 --> 00:56:54,000
వ్యూహం, కాని ఎందుకు, ఈ సందర్భంలో, నేను ప్రతిపాదించడం am

1013
00:56:54,000 --> 00:56:59,000
కూడా జాబితాలో తల ప్రాతినిధ్యం తల మూలకం కలిగి,

1014
00:56:59,000 --> 00:57:06,000
పరిమాణం పాటు జాబితా ముందు, ఆపిల్ స్టోర్ లో లైన్ లో మొదటి వ్యక్తి,?

1015
00:57:06,000 --> 00:57:14,000
నేను ఇక్కడ డేటా అదనపు భాగం చేయాలి?

1016
00:57:14,000 --> 00:57:16,000
ఏది సంఖ్యలు తిరిగి థింక్

1017
00:57:16,000 --> 00:57:18,000
నేను డ్రా ఉంటే అది ఈ క్రింది.

1018
00:57:18,000 --> 00:57:21,000
, ఈ ఇప్పుడు బదులుగా స్టాక్ యొక్క క్యూ ఒకవేళ

1019
00:57:21,000 --> 00:57:24,000
అనే-కేవలం ఆపిల్ స్టోర్-క్యూ వంటి తేడా ఫెయిర్ ఉంది.

1020
00:57:24,000 --> 00:57:27,000
జాబితా ప్రారంభంలో లైన్ లో మొదటి వ్యక్తి, ఈ సందర్భంలో సంఖ్య 5,

1021
00:57:27,000 --> 00:57:30,000
అతను లేదా ఆమె మొదటి స్టోర్ ప్రవేశిస్తుంది అవతరిస్తుంది.

1022
00:57:30,000 --> 00:57:32,000
యొక్క అలా లెట్.

1023
00:57:32,000 --> 00:57:35,000
ఈ ఆపిల్ స్టోర్ ఇప్పుడు సమయంలో ఈ సమయంలో నా క్యూ యొక్క స్థితి, మరియు ఆ అనుకుంటే

1024
00:57:35,000 --> 00:57:39,000
తెరుచుకుంటుంది మరియు మొదటి వ్యక్తి, సంఖ్య 5, స్టోర్ లో నడపబడుతుంది.

1025
00:57:39,000 --> 00:57:43,000
నేను మొదటి వ్యక్తి DE-క్యూలో ఇప్పుడు చిత్రాన్ని మార్చగలను

1026
00:57:43,000 --> 00:57:47,000
లైన్ ముందు వద్ద?

1027
00:57:47,000 --> 00:57:50,000
ఆ ఏమిటి? >> [స్టూడెంట్] క్యూ మార్చండి.

1028
00:57:50,000 --> 00:57:52,000
తల మార్చండి, కాబట్టి 5 అదృశ్యమవుతుంది.

1029
00:57:52,000 --> 00:57:56,000
వాస్తవంలో, అందువల్ల దీనిని వంటి అయితే-ఎలా సరిగ్గా?

1030
00:57:56,000 --> 00:58:00,000
ఈ వ్యక్తి అదృశ్యం అయితే వాస్తవంగా, ఇది.

1031
00:58:00,000 --> 00:58:03,000
సంఖ్య 7 ఒక వాస్తవ స్టోర్ లో ఏమి చేస్తుంది?

1032
00:58:03,000 --> 00:58:05,000
వారు ముందుకు ఒక పెద్ద అడుగు పడుతుంది.

1033
00:58:05,000 --> 00:58:08,000
>> అది శ్రేణుల విషయానికి వస్తే కాని మేము అభినందిస్తున్నాము వచ్చారు

1034
00:58:08,000 --> 00:58:10,000
మరియు విషయాలను కదిలే?

1035
00:58:10,000 --> 00:58:12,000
కుడివైపు, మీ సమయం వృధా రకంగా?

1036
00:58:12,000 --> 00:58:16,000
మొదటి వ్యక్తి కలిగి వంటి ఎందుకు మీరు ఆసన ఉండాలి లేదు

1037
00:58:16,000 --> 00:58:21,000
మెమరీ భాగం యొక్క భౌతికంగా ప్రారంభంలో లైన్ ప్రారంభంలో?

1038
00:58:21,000 --> 00:58:23,000
ఆ పూర్తిగా అనవసరమైన పని. ఎందుకు?

1039
00:58:23,000 --> 00:58:26,000
నేను బదులుగా ఏమి గుర్తు? >> [వినబడని విద్యార్థి ప్రతిస్పందన]

1040
00:58:26,000 --> 00:58:30,000
సరిగ్గా, నేను ఈ అదనపు డేటా సభ్యుడు తలను గుర్తు

1041
00:58:30,000 --> 00:58:34,000
ఇప్పుడు జాబితా యొక్క తల ఒక క్షణం క్రితం ఇది, ఇకపై 0 అని.

1042
00:58:34,000 --> 00:58:39,000
ఇప్పుడు ఇది నిజానికి నంబర్ 1. ఈ విధంగా, నేను కొంచెం ఆప్టిమైజేషన్ పొందండి.

1043
00:58:39,000 --> 00:58:44,000
నేను ఆపిల్ స్టోర్ లో లైన్ ప్రారంభంలో లైన్ నుండి ఎవరైనా DE-క్యూలో చేసిన వలన

1044
00:58:44,000 --> 00:58:47,000
ప్రతి ఒక్కరూ ఒక సరళ ఆపరేషన్ ఇది రీకాల్ మారిపోయే ఉంది కాదు.

1045
00:58:47,000 --> 00:58:50,000
నేను స్థిరంగా సమయం మాత్రమే ఖర్చు చేయవచ్చు

1046
00:58:50,000 --> 00:58:53,000
మరియు తర్వాత చాలా వేగంగా స్పందన సాధించడానికి.

1047
00:58:53,000 --> 00:58:56,000
కానీ నేను చెల్లించి నేను ధర అదనపు ప్రదర్శన పొందేందుకు ఏమిటి

1048
00:58:56,000 --> 00:58:58,000
మరియు ప్రతి ఒక్కరూ బదిలీ చేయడంలో?

1049
00:58:58,000 --> 00:59:01,000
అవును. >> [వినబడని విద్యార్థి ప్రతిస్పందన]

1050
00:59:01,000 --> 00:59:04,000
ఎక్కువ మంది జోడించవచ్చు, అలాగే, ఆ ​​సమస్య ఉన్న ఆర్తోగోనల్ ఉంది

1051
00:59:04,000 --> 00:59:07,000
మేము మంది బదిలీ లేదు వాస్తవాన్ని.

1052
00:59:07,000 --> 00:59:11,000
ఇది మేము ప్రతి ఒక్కరూ తీసుకెళ్లడం లేదా కాదు లేదో, అందుచే వ్యూహం యొక్క

1053
00:59:11,000 --> 00:59:13,000
ఓహ్, నేను సరే, మీరు అర్థం చూడటానికి.

1054
00:59:13,000 --> 00:59:16,000
అసలైన, నేను మీరు దాదాపు అయితే ఆ లో ఏమి చెబుతున్నారో తో అంగీకరిస్తున్నారు

1055
00:59:16,000 --> 00:59:19,000
మేము ఇప్పుడు ఇకపై ఈ శ్రేణి యొక్క ప్రారంభ ఉపయోగించడానికి వెళ్ళి ఎప్పుడూ చేస్తున్నారు

1056
00:59:19,000 --> 00:59:22,000
నేను 5 తీసివేస్తే ఎందుకంటే, అప్పుడు నేను 7 తొలగించండి.

1057
00:59:22,000 --> 00:59:24,000
కానీ నేను మాత్రమే కుడి ప్రజలు ఉంచండి.

1058
00:59:24,000 --> 00:59:28,000
>> నేను స్పేస్ వృధా ఉంటాను ఇది అనిపిస్తుంది, మరియు చివరికి నా క్యూ అసలు ఏమీ లోకి విచ్చిన్నము అవుతుంది

1059
00:59:28,000 --> 00:59:31,000
కాబట్టి, మనం కేవలం ప్రజలు చుట్టబెట్టిన కలిగి

1060
00:59:31,000 --> 00:59:35,000
మరియు మేము, వృత్తాకార నిర్మాణం యొక్క కొన్ని రకమైన నిజంగా ఈ శ్రేణి యొక్క భావిస్తున్నాను కాలేదు

1061
00:59:35,000 --> 00:59:38,000
కానీ మేము చుట్టబెట్టిన ఆ విధమైన చేయడానికి సి లో ఏం ఆపరేటర్లు ఉపయోగించాలి?

1062
00:59:38,000 --> 00:59:40,000
[వినబడని విద్యార్థి ప్రతిస్పందన] >> మాడ్యులో ఆపరేటర్లు.

1063
00:59:40,000 --> 00:59:43,000
ఇది మీరు చుట్టబెట్టిన ఎలా చేయాలి ద్వారా ఆలోచించాడు కాస్త కోపం తెప్పించేది ఉంటుంది

1064
00:59:43,000 --> 00:59:46,000
కానీ, అది చేయగల, మరియు మేము లైన్ ముందు ఉపయోగించినచోట వద్ద ప్రజలు చూస్తూ ప్రారంభం కాలేదు

1065
00:59:46,000 --> 00:59:52,000
కానీ మేము లైన్ వాస్తవ తల వాస్తవానికి ఈ తల వేరియబుల్ తో గుర్తుంచుకోవాలి.

1066
00:59:52,000 --> 00:59:57,000
ఏ మాత్రం, మా లక్ష్యం చివరికి, బదులుగా, ఉంటే

1067
00:59:57,000 --> 01:00:00,000
, మేము అనిత వేదికపై ఇక్కడ వచ్చింది, సంఖ్యలు చూసేందుకు ఉంది

1068
01:00:00,000 --> 01:00:02,000
కానీ మేము నిజంగా ఈ ప్రపంచాల ఉత్తమ అనుకుంటున్నారా?

1069
01:00:02,000 --> 01:00:05,000
మేము శ్రేణి అనుమతిస్తుంది కంటే ఆడంబరం కావలసిన

1070
01:00:05,000 --> 01:00:09,000
మేము డైనమిక్ డేటా నిర్మాణం పెరగడం సామర్థ్యం కావలసిన ఎందుకంటే.

1071
01:00:09,000 --> 01:00:12,000
కానీ మనం ఎత్తి చూపారు ఏదో ఆశ్రయించాల్సిన అవసరం చేయకూడదని

1072
01:00:12,000 --> 01:00:15,000
మొదటి ఉపన్యాసం లో, ఒక మధ్యస్థ అల్గోరిథం కాదు

1073
01:00:15,000 --> 01:00:17,000
సరళ శోధన యొక్క.

1074
01:00:17,000 --> 01:00:21,000
మీరు, నిజానికి, సాధించలేకపోవడం అవుతుంది

1075
01:00:21,000 --> 01:00:24,000
లేదా కనీసం స్థిరంగా సమయం దగ్గరగా, అనగా అనిత వంటి ఎవరైనా,

1076
01:00:24,000 --> 01:00:27,000
ఆమె డేటా నిర్మాణం ఆకృతీకరించబడుతుంది ఉంటే అనుబంధ జాబితా కాదని,

1077
01:00:27,000 --> 01:00:30,000
ఒక స్టాక్ కాదని, ఒక క్యూ కాదని, పొందగలిగిన నిజానికి,

1078
01:00:30,000 --> 01:00:33,000
ఆమె విషయాలు చూసేందుకు అనుమతించే డేటా నిర్మాణం ఆలోచన

1079
01:00:33,000 --> 01:00:37,000
కూడా పదాలు, కేవలం సంఖ్యలు, ఏ లో మేము నిరంతరం సమయం పిలుస్తాను.

1080
01:00:37,000 --> 01:00:40,000
>> నిజానికి, ముందుకు చూస్తూ, ఈ తరగతి లో psets ఒకటి దాదాపు ఎల్లప్పుడూ ఉంటుంది

1081
01:00:40,000 --> 01:00:43,000
ఒక స్పెల్ అభివృద్దిని, అనగా

1082
01:00:43,000 --> 01:00:46,000
మేము మళ్ళీ కొన్ని 150,000 ఆంగ్ల పదాలను మీరు ఇవ్వాలని మరియు గోల్ చేయడం

1083
01:00:46,000 --> 01:00:51,000
మెమోరీలో ఆ లోడ్ మరియు వేగంగా రూపం యొక్క ప్రశ్నలు సమాధానం

1084
01:00:51,000 --> 01:00:54,000
ఈ పదం సరిగ్గా ఉన్నట్లు?

1085
01:00:54,000 --> 01:00:58,000
మీరు ఆ సమాధానం అన్ని 150,000 పదాలు ద్వారా iterate వచ్చింది ఉంటే అది నిజంగా కుడుచు చేస్తుంది.

1086
01:00:58,000 --> 01:01:02,000
కానీ, నిజానికి, మేము చాలా వేగవంతంగా దీన్ని చెయ్యవచ్చు ఆ చూస్తారు.

1087
01:01:02,000 --> 01:01:06,000
మరియు అది ఒక హాష్ పట్టిక అని అమలు ఏదో కలిగి వెళుతున్న

1088
01:01:06,000 --> 01:01:09,000
మరియు మొదటి చూపులో ఒక హాష్ పట్టిక అని ఈ విషయం అన్నారు అయినప్పటికీ

1089
01:01:09,000 --> 01:01:12,000
ఈ సూపర్ వేగంగా ప్రతిస్పందన సమయం మాకు సాధించడానికి వీలు,

1090
01:01:12,000 --> 01:01:18,000
అది ఒక సమస్య నిజానికి ఉంది అవుతుంది.

1091
01:01:18,000 --> 01:01:23,000
ఇది మళ్లీ అనే ఈ విషయం అమలు వచ్చినప్పుడు, నేను దాన్ని మళ్ళీ చేస్తున్నదాన్ని.

1092
01:01:23,000 --> 01:01:25,000
నేను ఇక్కడ కేవలం ఒక ఉన్నాను.

1093
01:01:25,000 --> 01:01:28,000
అది వచ్చినప్పుడు ఈ విషయం అమలు సమయం, హాష్ పట్టిక అని

1094
01:01:28,000 --> 01:01:30,000
మేము ఒక నిర్ణయం తీసుకోవడానికి చూడాలని.

1095
01:01:30,000 --> 01:01:32,000
ఈ విషయం నిజంగా ఎంత పెద్దది ఉండాలి?

1096
01:01:32,000 --> 01:01:36,000
మరియు మేము ఈ హాష్ పట్టిక లోకి ఇన్సర్ట్ సంఖ్యలు ప్రారంభించినప్పుడు,

1097
01:01:36,000 --> 01:01:38,000
ఎలా మేము విధంగా వాటిని నిల్వ చేయడానికి వెళ్తున్నారు

1098
01:01:38,000 --> 01:01:42,000
మేము వాటిని మారిన మేము త్వరగా తిరిగి వారిని అవుట్ చేసే?

1099
01:01:42,000 --> 01:01:45,000
కానీ మేము దీర్ఘ ముందు చూస్తారు ఆ యొక్క ఈ ప్రశ్న

1100
01:01:45,000 --> 01:01:48,000
ప్రతి ఒక్కరూ పుట్టినరోజు తరగతి లో ఉన్నప్పుడు చాలా సంబంధించి ఉంటుంది.

1101
01:01:48,000 --> 01:01:51,000
ఇది ఈ గదిలో, మేము కొన్ని వందల మంది పొందారు అవుతుంది

1102
01:01:51,000 --> 01:01:56,000
మాకు రెండు ఒకే పుట్టినరోజు బహుశా చాలా ఎక్కువగా కలిగి అసమానత కాబట్టి.

1103
01:01:56,000 --> 01:01:58,000
కేవలం 40 మాకు ఈ గదిలో ఉన్నాయి ఏం?

1104
01:01:58,000 --> 01:02:02,000
అదే పుట్టినరోజు ఇద్దరు వ్యక్తుల అసమానత ఏమిటి?

1105
01:02:02,000 --> 01:02:04,000
[స్టూడెంట్స్] 50% పైగా.

1106
01:02:04,000 --> 01:02:06,000
అవును, 50% పైగా. నిజానికి, నేను కూడా ఒక చార్ట్ తీసుకువచ్చింది.

1107
01:02:06,000 --> 01:02:08,000
ఇది అవుట్ అండ్ మారుతుంది ఇది నిజంగా ఒక రహస్య ఉంది ప్రివ్యూ-

1108
01:02:08,000 --> 01:02:12,000
ఈ గదిలో మాకు మాత్రమే 58, మాకు యొక్క 2 యొక్క సంభావ్యత ఉంది ఉంటే

1109
01:02:12,000 --> 01:02:16,000
అదే పుట్టినరోజు కలిగి, దాదాపు 100% అత్యంత ఎక్కువ

1110
01:02:16,000 --> 01:02:20,000
మరియు ఆ బుధవారం మాకు హాని యొక్క మొత్తం బంచ్ కారణం చెప్పారు.

1111
01:02:20,000 --> 01:02:24,000
>> అన్నారు తో యొక్క ఇక్కడ వాయిదావెయ్యి తెలియజేయండి. మేము బుధవారం మీరు చూస్తారు.

1112
01:02:24,000 --> 01:02:28,000
[చప్పట్లు]

1113
01:02:28,000 --> 01:02:30,000
[CS50.TV]