1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [6 सप्ताह]

2
00:00:02,000 --> 00:00:04,000
[डेविड जे Malan] [हार्वर्ड विश्वविद्यालय]

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 या सीए कार्यालय समय के दौरान आता है.

11
00:00:32,000 --> 00:00:34,000
तो यह मुश्किल है हमें पढ़ने के लिए.

12
00:00:34,000 --> 00:00:38,000
खैर, इस कोड वाक्य रचना सही है, और यह संकलन होगा, और यह वास्तव में चला जाएगा.

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
और मैं इस फ़ाइल conditions2.c पर इस नए आदेश, style50, चलाने दर्ज करें,,

17
00:00:55,000 --> 00:00:57,000
सूचना है कि यह मुझे सूचित किया है कि यह शैली किया गया है.

18
00:00:57,000 --> 00:01:00,000
जीएडिट में देखा है कि फ़ाइल डिस्क पर बदल दिया गया है,

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
एक कमांड लाइन कार्यक्रम के लिए, तो ग निर्दिष्ट

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 - ग 2012/pset4/resize कहते हैं,

46
00:02:42,000 --> 00:02:46,000
और फिर मैं आगे बढ़ो और फ़ाइलों के नामों का उल्लेख है,

47
00:02:46,000 --> 00:02:49,000
resize.c, और फिर हिट दर्ज compresses, यह,

48
00:02:49,000 --> 00:02:53,000
यह अपलोड, यह जाँच करता है, और मैं सिर्फ परीक्षण की एक पूरी गुच्छा विफल.

49
00:02:53,000 --> 00:02:59,000
ऊपर छोड़ दिया पर लाल रंग में एक का कहना है कि 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
और इसलिए Smiley चेहरा खड़ी है, क्योंकि वह न तो खुश है और न ही दुख की बात है,

57
00:03:21,000 --> 00:03:25,000
लेकिन हम लाल रंग में है कि इस मुद्दे से पहले उन अन्य चेक चलेंगे निवारण है.

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
सब हरे रंग की है, जिसका मतलब है कि मैं वास्तव में अच्छी तरह से 4 pset पर कर रहा हूँ अब तक.

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
तब हम इसे दुबारा आकार भी करता है जब, आकार कारक है, 1 एक 1x1 पिक्सेल बीएमपी का परीक्षण किया.

68
00:03:58,000 --> 00:04:01,000
अब, अगर आप कोई विचार नहीं पता क्या है, आप एक बार आप 4 pset में गोता जाएगा,

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 पिक्सेल बीएमपी के लिए एक 1x1 पिक्सेल resizes

72
00:04:14,000 --> 00:04:19,000
जब 2 है, तो इसी तरह, मेरा तदनुसार रूपों.

73
00:04:19,000 --> 00:04:22,000
>> संक्षेप में, यह करने के लिए, एक का मतलब है, पार उंगलियों ले

74
00:04:22,000 --> 00:04:25,000
में आप पहले सही समीकरण के के बाहर अपने pset प्रस्तुत.

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
और तब जाकर, "आह," की तरह मुझे लगता है कि बाहर लगा है चाहिए.

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
सिर्फ इसलिए कि तुम एक हरे रंग Smiley चेहरे की पूर्ण स्क्रीन मिल

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
उदाहरण के लिए, whodunit, 4 pset के पहलुओं में से एक है,

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
तुम नोटिस हूँ वहाँ नीचे इस सफेद यूआरएल है.

98
00:05:28,000 --> 00:05:30,000
अभी के लिए, यह सिर्फ नैदानिक ​​उत्पादन है.

99
00:05:30,000 --> 00:05:33,000
यदि आपको लगता है कि यूआरएल पर जाएँ, आप पागल, गुप्त संदेश की एक पूरी गुच्छा मिलेगा

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
तो क्यों यह समझ पड़ता है करने के लिए चार * एस के रूप में तार का प्रतिनिधित्व करने के लिए?

112
00:06:14,000 --> 00:06:20,000
एक चार * क्या एक स्ट्रिंग की इस अवधारणा के संदर्भ में प्रतिनिधित्व करता है?

113
00:06:20,000 --> 00:06:23,000
हाँ >> [छात्र] 1 चरित्र.

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
हाँ, बिल्कुल, यह सिर्फ पाश के लिए एक के साथ दोहराता है, जबकि पाश,

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
यह एक उपयोगकर्ता से एक int हो जाता है. यह कैसे काम करता है?

144
00:07:51,000 --> 00:07:53,000
ठीक है, वहाँ 16 लाइन में,

145
00:07:53,000 --> 00:07:56,000
सूचना है कि हम एक int 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
[डेविड एम.] ठीक है, कौन जानता है, कुछ कचरा मान संभावित है, तो 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 सिर्फ एक्स में गुजर रहा हूँ?

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
उपयोगकर्ता से एक int मैं कार्यों को पारित कर सकते हैं

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
>> लेकिन इसके बजाय, कर रही है और एक्स, मैं सचमुच में क्या गुजर रहा हूँ?

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
[छात्र] पढ़ा एक्स.

172
00:09:23,000 --> 00:09:27,000
वहाँ कुछ पढ़ने जा रहा है, लेकिन केवल एक्स के लिए संबंध के साथ.

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
याद है कि * हमारे भिन्नता ऑपरेटर, जो अनिवार्य रूप से मतलब है कि वहाँ जाना है.

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
* एक्स या वास्तव में उस पते पर जाने के लिए और कुछ मूल्य वहाँ डाल बराबर कर रही है.

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 कि एक्स में एक 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
>> ठीक है, करीब है. मुझे कि एक छोटा सा tweak.

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
क्योंकि हम स्पष्ट रूप से यह प्रारंभ नहीं किया है, इसलिए हम कुछ भी नहीं मान लेना चाहिए.

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
[छात्र] यह एक अशक्त संकेतक भिन्नता करने की कोशिश कर रहा है.

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
यदि एक विरोधी किसी भी तरह अपने कार्यक्रम में एक बहुत बड़ा शब्द injects

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
यह एक छोटा सा बेहतर है.

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
आप संकेत जा रहा है के रूप में अब लगभग arrays के बारे में सोच सकते हैं,

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 सन्निहित chars क्योंकि है कि क्या एक सरणी है

269
00:14:53,000 --> 00:14:55,000
और अब कुछ हफ्तों के लिए किया गया है.

270
00:14:55,000 --> 00:14:59,000
>> यहाँ, मैं scanf कह रहा हूँ यहाँ स्मृति का एक हिस्सा है.

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
ठीक है, द्वारा खड़े.

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
संक्षिप्त जवाब है arrays एक छोटे से विशेष कर रहे हैं.

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
यह एक सफेद झूठ का एक सा है क्योंकि arrays और संकेत

340
00:19:13,000 --> 00:19:17,000
वास्तव में कर रहे हैं, थोड़ा अलग है, लेकिन वे अक्सर लेकिन हमेशा नहीं interchangeably इस्तेमाल किया जा सकता है.

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
आप arrays के साथ एम्परसेंड करने के लिए नहीं है, क्योंकि वे पहले से ही कर रहे हैं

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
जहां arrays काफी वास्तव में पते नहीं हैं.

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
लेकिन arrays कुछ upsides और downsides है.

357
00:20:04,000 --> 00:20:06,000
Arrays अच्छा क्यों कर रहे हैं?

358
00:20:06,000 --> 00:20:11,000
एक बात है कि आप की तरह हद तक आप arrays arrays के बारे में की तरह क्या है?

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, पता नहीं कितने chars की उम्मीद है,

369
00:20:44,000 --> 00:20:48,000
तथ्य यह है कि हम क्रमिक मेमोरी का हिस्सा आवंटित कर सकते हैं अच्छा है.

370
00:20:48,000 --> 00:20:51,000
Arrays भी एक समस्या हम एक दो सप्ताह पहले अब देखा हल

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
और एक अन्य आईडी कहा जाता है क्योंकि उस कहानी में मैं तो कुछ और ही शुरू करना चाहता था चर

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
और संरचना, संरचना खोजशब्द, encapsulate करने के लिए अनुमति देता है

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
बजाय एक स्ट्रिंग के लिए मनमाने ढंग से, एक एक आईडी के लिए एक होने, और इतना आगे.

395
00:22:07,000 --> 00:22:10,000
Arrays अच्छा कर रहे हैं क्योंकि वे हमें हमारे कोड की सफाई शुरू करने के लिए अनुमति देते हैं.

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, लेकिन एक सरणी होने के अधिक generically, सिर्फ स्मृति का एक हिस्सा है.

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
[छात्र] क्योंकि यह reused हो जाता है.

417
00:23:13,000 --> 00:23:15,000
यह reused हो जाता है.

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
और क्यों, जब मैं एक int या एक चार की जरूरत नहीं है,

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
फेसबुक प्रकार की समस्याओं की लाइनों और Google प्रकार की समस्याओं के साथ

476
00:26:23,000 --> 00:26:26,000
जहाँ आप विशाल डाटा सेट है, और यह अब यह कटौती

477
00:26:26,000 --> 00:26:29,000
contiguously के लिए सब कुछ की दुकान और रैखिक खोज की तरह कुछ का उपयोग करें

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
वास्तव में, एक पवित्र Grails हम बाद में इस सप्ताह या अगले के बारे में बात करेंगे

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
यह करने के लिए एक एकल सूचक होने जा रहा है क्योंकि एक पकड़ लिया

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
पहले समय और अंतरिक्ष और लचीलेपन के बीच tradeoff

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
लेकिन हे, मैं राम का 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
और किस स्थान से आया से वापस जाओ.

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
और वास्तव में, आप इन rectangles से प्रत्येक के लिए एक और सूचक जोड़ना होगा

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-dimensional संरचना मिलता है.

535
00:29:23,000 --> 00:29:26,000
आप एक दो आयामी लिंक सूची लागू कर सकता है

536
00:29:26,000 --> 00:29:29,000
अगर आप ऐड - के रूप में आप इन बातों में से प्रत्येक के लिए प्रस्तावित 3 सूचक,

537
00:29:29,000 --> 00:29:34,000
और यदि आप एक और सूची के बारे में लगता है कि आप 3 डी शैली आ रहा

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
अच्छा, तो यह एक असली दंगेबाज है.

542
00:29:50,000 --> 00:29:54,000
>> इन एल्गोरिदम है कि हम पर, ओह तरह, द्विआधारी खोज 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
की तुलना में घर और नाम और आईडी.

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
लेकिन इस दूसरी पंक्ति, संरचना नोड अगले * क्या है?

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
>> अब, इस सी. जिज्ञासा की तरह है

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 आईडी, स्ट्रिंग नाम, स्ट्रिंग घर था,

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
फिर, सी संकलक एक छोटे से गूंगा है.

590
00:32:28,000 --> 00:32:30,000
यह केवल ऊपर से नीचे पढ़ने के लिए जा रहा है,

591
00:32:30,000 --> 00:32:33,000
यदि ऐसा है तो यह 2 लाइन यहाँ तक पहुँचता है

592
00:32:33,000 --> 00:32:37,000
जहां अगले घोषित किया है और यह देखता है, ओह, यहाँ एक अगले चर बुलाया है.

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
कि वहाँ एक से पकड़ लिया है.

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
जब आप एक था उनमें से सिर्फ यह एक int पढ़ने की कोशिश कर रहा है.

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 होना चाहता है? सब ठीक है, पर आते हैं, 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
अनीता मदद हमें सॉर्ट के एक 1 में काफी सरल सवाल को हल करने के लिए जा रहा है,

633
00:34:41,000 --> 00:34:44,000
जो आप कैसे पता है या नहीं, एक मूल्य सूची में है?

634
00:34:44,000 --> 00:34:48,000
अब सूचना है कि 1, लुकास द्वारा यहाँ का प्रतिनिधित्व

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
लेकिन सूचक चित्रित, नहीं है, इसलिए तुम लोगों को कुछ हद तक awkwardly सकता है अगर

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
और अगर आप एक छोटा सा इस तरह कुचलना तो मैं अपने रास्ते में नहीं कर रहा हूँ.

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
खैर, हम आपको लुकास नहीं बुलाना चाहिए. हम आपको पहले बुलाना चाहिए.

661
00:36:22,000 --> 00:36:25,000
यहाँ वास्तविकता के अनुरूप वास्तव में ऐसा क्यों होता है?

662
00:36:25,000 --> 00:36:27,000
एक, 1 पहले से ही मौजूद है.

663
00:36:27,000 --> 00:36:30,000
पहले संभाव्यतः आवंटित किया गया है कहीं ऊपर यहाँ.

664
00:36:30,000 --> 00:36:35,000
नोड 1, और यह एक सूची गया है किसी भी तरह आवंटित.

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
और अब बाद कहानी यह सब फेसबुक पर जाहिरा तौर पर जाने में इस बिंदु पर

668
00:36:44,000 --> 00:36:49,000
कहानी में इस बिंदु पर, अनीता 1 के बराबर हो गया है 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
अब भी अनीता 32 बिट के अंदर - 1, 2, 3.

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
तो Ramon. >> Ramon, रेमन 22 पकड़ रहा है.

678
00:37:18,000 --> 00:37:20,000
अब आप एक चेक किया है.

679
00:37:20,000 --> 00:37:24,000
क्या Ramon 22 ==, और अगर ऐसा है, उदाहरण के लिए, हम सच लौट सकते हैं.

680
00:37:24,000 --> 00:37:26,000
मुझे, जबकि इन लोगों को यहाँ कुछ awkwardly खड़े

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
और तब पता क्षेत्र कहा जाता मिलता है.

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
जो आम तौर पर अगले व्यक्ति को Ramon तरह होगा बिंदु,

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
यदि हम वास्तव में अनुकरण तुम लोगों को इस कर सकते हैं, जबकि अभी भी एक ही लोगों को इशारा,

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
दूसरे शब्दों में, हम Ramon, जो 22 नंबर धारण करने के लिए जाना है,

732
00:40:45,000 --> 00:40:51,000
और फिर अगले है के रूप में हालांकि अनीता उसके बाएं हाथ सूचक नकल किया जाएगा.

733
00:40:51,000 --> 00:40:54,000
लेकिन वह Ramon की तुलना में आगे नहीं जाना है क्योंकि हम 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
यह वास्तव में एक छोटे से जानबूझकर ओह, आप वास्तव में मैं क्या लिखा नहीं देखा था.

737
00:41:04,000 --> 00:41:08,000
यह अधिक सम्मोहक हो अगर तुम सकता है. देखा!

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
1, हम पता करने के लिए जाना है कि अनीता पर इशारा कर रहा है

741
00:41:18,000 --> 00:41:23,000
और जहां वह न केवल पता है, जो हम सिर्फ तुलना खातिर के लिए जाँच मिल जाएगा,

742
00:41:23,000 --> 00:41:25,000
इस मामले में, लेकिन आप भी अगले मिल जाएगा

743
00:41:25,000 --> 00:41:28,000
Ramon के बाएं हाथ की सूची में अगले नोड की ओर इशारा करते.

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
अनीता अब अशक्त है, और मुझे पता है तुम बस यहाँ खड़े कर रहे हैं, अधर में लटकी awkwardly

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
अनीता कहानी में उस बिंदु पर रिक्त है तो, जबकि पाश terminates,

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
या + + एक मैं चर क्योंकि अब हम नहीं लगता है कि कर सकते हैं

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
हम सिर्फ नोड * saad किया है.

807
00:45:07,000 --> 00:45:11,000
हम malloc (sizeof (नोड)).

808
00:45:11,000 --> 00:45:16,000
हम तो एक ही सटीक सिंटैक्स के रूप में हम पहले 20 के लिए किया था,

809
00:45:16,000 --> 00:45:20,000
और मैं अगले = रिक्त करने के लिए, और अब उसने अनिता पर निर्भर है

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
किसका बाएं हाथ 1 शायद अद्यतन किया जाना चाहिए? हाँ.

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
मार्शल, अगर हम अपने हाथ 1 नीचे स्थानांतरित करने के लिए अशक्त,

824
00:46:22,000 --> 00:46:25,000
अब हम सचमुच इस सूची में चार लोगों के अनाथ

825
00:46:25,000 --> 00:46:29,000
क्योंकि वह Ramon और बाईं करने के लिए हर किसी पर ही बात की ओर इशारा करते हुए था,

826
00:46:29,000 --> 00:46:31,000
इतना है कि सूचक 1 अद्यतन बुरा था.

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
क्योंकि अब और कैसे हम सूची अपडेट करूँ?

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
बहुत बढ़िया, तो यह वास्तव में तीन कुल मामलों में से 3 है.

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 के अभी भी बड़ा हे, तो यह कोई रैखिक खोज की तुलना में बेहतर है.

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
लुकास, जो 1 सूचक था.

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
backtracks कि तब और भी मुश्किल हो सकता है जब तक आप था

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
प्रभावी ढंग से एक डेटा संरचना है कि अधिक से अधिक यह की चोटी पर स्तरित सामान है.

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
यदि आप 1 के ढेर पर रखा जा ट्रे,

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
में पिछले 1 बाहर है.

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
में, 1 बाहर पिछले वास्तव में मजबूर है?

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
जो सभी के लिए एक iPhone और लाइनों को पाने के लिए कोशिश कर रहा रात इंतजार कर रहा है

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
और फिर से कतार plucked.

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
और आप में पहली बार एक 1 एक होने के लिए बाहर करना चाहते हैं

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
और सामूहिक, यहाँ पूरी iPad एक ढेर संरचना का प्रतिनिधित्व करता है.

943
00:53:02,000 --> 00:53:07,000
अब, डिफ़ॉल्ट रूप से, आकार संभाव्यतः 0 प्रारंभ किया जा मिला है,

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 है, तो मैं प्रोग्राम पता है, सरणी में तत्वों की किसी में नहीं लग रहे हो.

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
धक्का और हुड के नीचे popping के शब्दों

996
00:56:00,000 --> 00:56:03,000
या धक्का और popping की कार्यक्षमता.

997
00:56:03,000 --> 00:56:07,000
और मैं कुछ हद तक एक अदूरदर्शा निर्णय यहाँ बना दिया है

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
जो सभी टोपियां है क्योंकि यह पता चलता है कि यह वैश्विक निरंतर के कुछ प्रकार है.

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
एक सरणी के रूप में है, लेकिन क्यों, इस मामले में, मैं प्रस्ताव कर रहा हूँ

1013
00:56:54,000 --> 00:56:59,000
करने के लिए भी एक सूची के सिर सिर का प्रतिनिधित्व तत्व है,

1014
00:56:59,000 --> 00:57:06,000
सूची के सामने, एप्पल की दुकान पर लाइन में 1 व्यक्ति आकार के अलावा?

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
खोलता है और 1 व्यक्ति, संख्या 5, दुकान में नेतृत्व किया है.

1025
00:57:39,000 --> 00:57:43,000
कैसे मैं तस्वीर अब बदलने के लिए है कि मैं पहले व्यक्ति कतार

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
>> लेकिन क्या हम सराहना करते आए हैं जब यह arrays के लिए आता है

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
आप इतना गुदा होना क्यों है के रूप में 1 व्यक्ति

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
अब यह वास्तव में एक संख्या है. इस तरह, मैं एक मामूली अनुकूलन मिलता है.

1043
00:58:39,000 --> 00:58:44,000
सिर्फ इसलिए कि मैं है पंक्ति के प्रारंभ में एप्पल स्टोर पर लाइन से किसी डे पंक्तिबद्ध

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
और अधिक लोगों को जोड़ सकते हैं, ठीक है, कि समस्या orthogonal है

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
तो हम सिर्फ लोगों wraparound हो सकता है,

1060
00:59:31,000 --> 00:59:35,000
और हम इस सरणी के परिपत्र संरचना के कुछ प्रकार के रूप में वास्तव में सोच सकता है,

1061
00:59:35,000 --> 00:59:38,000
लेकिन हम क्या सी में ऑपरेटर का उपयोग करने के लिए wraparound का है कि तरह करते हैं?

1062
00:59:38,000 --> 00:59:40,000
[अश्राव्य छात्र प्रतिक्रिया] >> modulo ऑपरेटर.

1063
00:59:40,000 --> 00:59:43,000
यह एक छोटे से परेशान हो के माध्यम से लगता है कि कैसे आप wraparound करते हो,

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
जिससे एक spellchecker का कार्यान्वयन,

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 शब्दों के माध्यम से पुनरावृति करने के लिए जवाब है कि चूसना होगा.

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]