1
00:00:00,000 --> 00:00:02,730
[Powered by Google Translate] [धारा 6: कम आरामदायक]

2
00:00:02,730 --> 00:00:05,040
[नैट Hardison] [हार्वर्ड विश्वविद्यालय]

3
00:00:05,040 --> 00:00:07,320
[यह CS50 है.] [CS50.TV]

4
00:00:07,320 --> 00:00:11,840
सही सभी. धारा 6 के लिए आपका स्वागत है.

5
00:00:11,840 --> 00:00:14,690
इस हफ्ते, हम अनुभाग में डेटा संरचना के बारे में बात कर रही हो जा रहे हैं,

6
00:00:14,690 --> 00:00:19,780
इसका मुख्य कारण इस सप्ताह के समस्या spellr पर सेट

7
00:00:19,780 --> 00:00:24,410
अलग डेटा संरचना अन्वेषण की एक पूरी गुच्छा करता है.

8
00:00:24,410 --> 00:00:26,520
वहाँ विभिन्न तरीकों से आप समस्या सेट के साथ जा सकते हैं की एक गुच्छा रहे हैं,

9
00:00:26,520 --> 00:00:31,570
और अधिक डेटा संरचनाओं आप के बारे में पता है, अधिक ठंडी चीजें आप कर सकते हैं.

10
00:00:31,570 --> 00:00:34,990
>> तो चलो शुरू हो. पहले हम ढेर के बारे में बात करने जा रहे हैं,

11
00:00:34,990 --> 00:00:37,530
ढेर और कतार डेटा संरचना है कि हम के बारे में बात करने जा रहे हैं.

12
00:00:37,530 --> 00:00:40,560
ढेर और कतार वास्तव में सहायक होते हैं जब हम रेखांकन के बारे में बात कर शुरू,

13
00:00:40,560 --> 00:00:44,390
जो हम अब इतना सही की करने के लिए नहीं जा रहे हैं.

14
00:00:44,390 --> 00:00:52,820
लेकिन वे वास्तव में एक बड़ा सीएस के मौलिक डेटा संरचनाओं की समझ के लिए अच्छा कर रहे हैं.

15
00:00:52,820 --> 00:00:54,880
समस्या सेट विनिर्देश में वर्णन,

16
00:00:54,880 --> 00:00:59,260
अगर आप इसे हटा सदृश करने के लिए के रूप में, पोट के बारे में वार्ता

17
00:00:59,260 --> 00:01:05,239
भोजन ट्रे के ढेर है कि आप डाइनिंग हॉल में कैफेटेरिया में

18
00:01:05,239 --> 00:01:09,680
जहां जब भोजन स्टाफ आता है और खाने की ट्रे डालता है के बाद वे उन्हें साफ कर दिया है,

19
00:01:09,680 --> 00:01:12,000
वे उन्हें एक दूसरे के शीर्ष पर हो चुकी है.

20
00:01:12,000 --> 00:01:15,050
और फिर जब बच्चों को भोजन प्राप्त करने में आते हैं,

21
00:01:15,050 --> 00:01:19,490
वे ट्रे पुल से दूर, एक शीर्ष 1, तो यह नीचे एक है, तो है कि नीचे एक.

22
00:01:19,490 --> 00:01:25,190
तो, प्रभाव में, 1 ट्रे कि भोजन स्टाफ नीचे डाल पिछले एक है कि दूर ले जाया जाता है.

23
00:01:25,190 --> 00:01:32,330
पिछले एक है कि खाने के कर्मचारियों पर डाल दिया 1 एक है कि रात के खाने के लिए ले जाया जाता है.

24
00:01:32,330 --> 00:01:38,100
समस्या सेट की कल्पना में है, जो आप डाउनलोड कर सकते हैं अगर आप पहले से ही नहीं है,

25
00:01:38,100 --> 00:01:46,730
हम एक ढेर डेटा संरचना का उपयोग करते हुए इस तरह के struct मॉडलिंग के बारे में बात करते हैं.

26
00:01:46,730 --> 00:01:51,070
>> तो क्या हम यहाँ मिल गया है, यह क्या व्याख्यान में प्रस्तुत किया गया था के लिए इसी तरह की है,

27
00:01:51,070 --> 00:01:58,120
व्याख्यान में छोड़कर हम ints के रूप में चार * विरोध के साथ प्रस्तुत किया.

28
00:01:58,120 --> 00:02:06,250
यह एक ढेर है कि स्टोर क्या होने जा रहा है?

29
00:02:06,250 --> 00:02:09,009
डेनियल? क्या हम इस ढेर में भंडारण कर रहे हैं?

30
00:02:09,009 --> 00:02:15,260
[डैनियल] स्ट्रिंग्स? >> हम इस ढेर में तार भंडारण कर रहे हैं वास्तव में,.

31
00:02:15,260 --> 00:02:20,950
आप सभी की जरूरत है क्रम में एक ढेर बनाने के एक सरणी है

32
00:02:20,950 --> 00:02:23,920
एक विशेष क्षमता का है, जो इस मामले में,

33
00:02:23,920 --> 00:02:28,020
क्षमता सभी टोपियां में हो सकता है क्योंकि यह एक निरंतर की जा रही है.

34
00:02:28,020 --> 00:02:36,340
और फिर सरणी के अलावा, हम सब ट्रैक करने की आवश्यकता है सरणी के मौजूदा आकार है.

35
00:02:36,340 --> 00:02:38,980
एक बात यहाँ ध्यान दें कि शांत की तरह है

36
00:02:38,980 --> 00:02:47,060
यह है कि हम एक और आंकड़ा संरचना, सरणी के शीर्ष पर खड़ी डेटा संरचना का निर्माण कर रहे हैं.

37
00:02:47,060 --> 00:02:50,110
वहाँ ढेर को लागू करने के लिए अलग अलग तरीके हैं.

38
00:02:50,110 --> 00:02:54,250
हम इसे काफी अभी तक नहीं, लेकिन उम्मीद है कि लिंक्ड सूची समस्याओं को करने के बाद क्या करेंगे,

39
00:02:54,250 --> 00:03:00,520
आप देखेंगे कि कैसे आप आसानी से एक लिंक सूची के शीर्ष पर एक ढेर के रूप में अच्छी तरह से लागू कर सकते हैं.

40
00:03:00,520 --> 00:03:02,640
लेकिन अब के लिए, हम arrays के लिए रहना होगा.

41
00:03:02,640 --> 00:03:06,350
तो फिर, हम सभी की जरूरत है एक सरणी है और हम सिर्फ सरणी के आकार को ट्रैक करने के लिए की जरूरत है.

42
00:03:06,350 --> 00:03:09,850
[सैम] क्षमा करें, ऐसा क्यों है कि आप ने कहा कि ढेर तार के शीर्ष पर है?

43
00:03:09,850 --> 00:03:13,440
मेरे लिए यह लगता है जैसे तार ढेर के भीतर हैं.

44
00:03:13,440 --> 00:03:16,790
[Hardison] हाँ. हम पैदा कर रहे हैं, हम हमारे सरणी डेटा संरचना ले जा रहे हैं -

45
00:03:16,790 --> 00:03:22,130
कि एक बड़ा सवाल है. तो सवाल यह है कि जो लोग इस ऑनलाइन देख रहे हैं के लिए है,

46
00:03:22,130 --> 00:03:24,140
हम क्यों कह रहे हैं कि ढेर तार के शीर्ष पर है,

47
00:03:24,140 --> 00:03:27,990
क्योंकि यह यहाँ की तरह तार ढेर के अंदर लग रहा है?

48
00:03:27,990 --> 00:03:31,050
जो पूरी तरह से मामला है.

49
00:03:31,050 --> 00:03:34,660
मैं बात कर रहा था क्या था कि हम एक सरणी डेटा संरचना मिल गया है.

50
00:03:34,660 --> 00:03:39,290
हम चार * की एक सरणी, तारों के इस सरणी मिल गया है,

51
00:03:39,290 --> 00:03:45,300
और हम उस को जोड़ने के क्रम में स्टैक्ड डेटा संरचना बनाने के लिए जा रहे हैं.

52
00:03:45,300 --> 00:03:48,620
>> तो एक ढेर थोड़ा एक सरणी से अधिक जटिल है.

53
00:03:48,620 --> 00:03:51,890
एक ढेर बनाने के लिए हम एक सरणी का उपयोग कर सकते हैं.

54
00:03:51,890 --> 00:03:55,810
इतना है कि जहां हम कहते हैं कि ढेर एक सरणी के शीर्ष पर बनाया गया है.

55
00:03:55,810 --> 00:04:02,510
इसी तरह, जैसे कि मैंने पहले कहा, हम एक लिंक सूची के शीर्ष पर एक ढेर का निर्माण कर सकते हैं.

56
00:04:02,510 --> 00:04:04,960
हमारे तत्वों को पकड़ने के लिए एक सरणी का उपयोग करने के बजाय,

57
00:04:04,960 --> 00:04:10,070
हम एक लिंक सूची का उपयोग करने के लिए हमारे तत्वों को पकड़ सकता है और है कि चारों ओर ढेर का निर्माण.

58
00:04:10,070 --> 00:04:12,420
चलो उदाहरण के एक जोड़े के माध्यम से चलते हैं, कुछ कोड को देख,

59
00:04:12,420 --> 00:04:14,960
देखने के लिए क्या वास्तव में यहाँ क्या हो रहा है.

60
00:04:14,960 --> 00:04:23,400
बाएँ पर, मैं नीचे फेंक दिया है कि ढेर struct किस तरह स्मृति में देखना होगा

61
00:04:23,400 --> 00:04:28,330
अगर क्षमता से चार में परिभाषित किया गया है.

62
00:04:28,330 --> 00:04:33,490
हम हमारे चार तत्व चार * सरणी मिल गया है.

63
00:04:33,490 --> 00:04:38,110
हम तार [0], तार [1], तार [2] तार, [3], मिल गया है

64
00:04:38,110 --> 00:04:43,800
और फिर हमारे आकार पूर्णांक के लिए है कि पिछले अंतरिक्ष.

65
00:04:43,800 --> 00:04:46,270
क्या इसका मतलब है? ठीक है.

66
00:04:46,270 --> 00:04:48,790
यह क्या होता है अगर मैं सही पर क्या करते हैं,

67
00:04:48,790 --> 00:04:55,790
जो मेरे कोड होगा, सिर्फ एक संरचना है, कहा जाता है एक खड़ी struct की घोषणा की है.

68
00:04:55,790 --> 00:05:01,270
यह है कि हम क्या हो. यह नीचे स्मृति में इस पदचिह्न देता है.

69
00:05:01,270 --> 00:05:05,590
पहले यहाँ सवाल यह है कि इस ढेर struct की सामग्री क्या कर रहे हैं?

70
00:05:05,590 --> 00:05:09,250
अभी वे कुछ भी नहीं कर रहे हैं, लेकिन वे पूरी तरह से कुछ भी नहीं कर रहे हैं.

71
00:05:09,250 --> 00:05:13,300
वे कचरे के इस तरह कर रहे हैं. हम कोई विचार नहीं है जो उन में है.

72
00:05:13,300 --> 00:05:17,000
जब हम ढेर एस की घोषणा करने के लिए, हम सिर्फ इतना है कि फेंक रहे हैं स्मृति के शीर्ष पर नीचे.

73
00:05:17,000 --> 00:05:19,840
यह int i घोषित करने और आरंभ करने के दौरान यह नहीं की तरह की तरह है.

74
00:05:19,840 --> 00:05:21,730
तुम नहीं जानता कि क्या वहाँ में है. आप पढ़ सकते हैं क्या वहाँ में है,

75
00:05:21,730 --> 00:05:27,690
लेकिन यह सुपर मददगार नहीं हो सकता है.

76
00:05:27,690 --> 00:05:32,680
एक बात आप हमेशा के लिए याद रखना चाहते हैं इनिशियलाइज़ जो कुछ भी प्रारंभीकृत किया जाना चाहिए.

77
00:05:32,680 --> 00:05:35,820
इस मामले में, हम के आकार को प्रारंभ करने के लिए शून्य हो जा रहे हैं,

78
00:05:35,820 --> 00:05:39,960
क्योंकि कि बाहर बारी के लिए हमारे लिए बहुत महत्वपूर्ण हो जा रहा है.

79
00:05:39,960 --> 00:05:43,450
हम आगे जाना है और संकेत के सभी, सभी चार * s शुरू नहीं कर पाया है,

80
00:05:43,450 --> 00:05:49,670
कुछ समझ मूल्य, शायद अशक्त हो.

81
00:05:49,670 --> 00:05:58,270
लेकिन यह पूरी तरह से जरूरी है कि हम ऐसा कर नहीं है.

82
00:05:58,270 --> 00:06:04,200
>> अब, दो ढेर पर मुख्य संचालन कर रहे हैं?

83
00:06:04,200 --> 00:06:07,610
किसी से व्याख्यान याद आप ढेर के साथ क्या करना है? हाँ?

84
00:06:07,610 --> 00:06:09,700
[स्टेला] धक्का और popping? वास्तव में. >>

85
00:06:09,700 --> 00:06:13,810
धक्का और popping ढेर पर दो मुख्य संचालन कर रहे हैं.

86
00:06:13,810 --> 00:06:17,060
धक्का और क्या करता है? >> यह शीर्ष पर कुछ कहते हैं

87
00:06:17,060 --> 00:06:19,300
ढेर की, और फिर popping यह दूर ले जाता है.

88
00:06:19,300 --> 00:06:23,150
[Hardison] बिल्कुल सही. तो ढेर के शीर्ष पर कुछ धक्का धक्का.

89
00:06:23,150 --> 00:06:27,700
यह भोजन एक खाने की ट्रे काउंटर पर नीचे डाल कर्मचारियों की तरह है.

90
00:06:27,700 --> 00:06:33,630
और popping एक खाने की ट्रे ढेर से दूर ले जा रहा है.

91
00:06:33,630 --> 00:06:36,460
चलो क्या होता है उदाहरण के एक जोड़े के माध्यम से चलना

92
00:06:36,460 --> 00:06:39,720
जब हम ढेर में बातें धक्का.

93
00:06:39,720 --> 00:06:45,110
यदि हम हमारे ढेर पर 'हैलो' स्ट्रिंग धक्का थे

94
00:06:45,110 --> 00:06:49,760
यह है कि क्या हमारे आरेख की तरह अब देखना होगा.

95
00:06:49,760 --> 00:06:53,410
देखें क्या होता है?

96
00:06:53,410 --> 00:06:56,530
हम हमारे तार सरणी के पहले तत्व में धकेल दिया

97
00:06:56,530 --> 00:07:01,420
और हम हमारे आकार गिनती बढ़ी 1 हो.

98
00:07:01,420 --> 00:07:05,340
तो अगर हम दो स्लाइडों के बीच अंतर को देखो, यहाँ 0 था, यहाँ धक्का से पहले है.

99
00:07:05,340 --> 00:07:08,690
यहाँ धक्का के बाद है.

100
00:07:08,690 --> 00:07:13,460
धक्का से पहले, धक्का के बाद.

101
00:07:13,460 --> 00:07:16,860
और अब हम हमारे ढेर में एक तत्व है.

102
00:07:16,860 --> 00:07:20,970
यह स्ट्रिंग "नमस्ते" है, और यह बात है.

103
00:07:20,970 --> 00:07:24,440
सरणी में बाकी सब कुछ, हमारे तार सरणी में, अभी भी कचरा.

104
00:07:24,440 --> 00:07:27,070
हम इसे प्रारंभ नहीं किया है.

105
00:07:27,070 --> 00:07:29,410
हम कहते हैं कि हम हमारे ढेर पर एक स्ट्रिंग धक्का.

106
00:07:29,410 --> 00:07:32,210
हम इस समय पर "दुनिया" धक्का करने के लिए जा रहे हैं.

107
00:07:32,210 --> 00:07:35,160
तो आप देख सकते हैं कि "दुनिया" यहाँ "हैलो" के शीर्ष पर चला जाता है,

108
00:07:35,160 --> 00:07:40,040
और आकार गिनती 2 करने के लिए चला जाता है.

109
00:07:40,040 --> 00:07:44,520
अब हम "CS50" धक्का कर सकते हैं, और कहा कि शीर्ष पर फिर से जाना होगा.

110
00:07:44,520 --> 00:07:51,110
अगर हम वापस जाओ, आप देख सकते हैं कि कैसे हम ढेर के शीर्ष पर बातें जोर दे रहे हैं.

111
00:07:51,110 --> 00:07:53,320
और अब हम पॉप करने के लिए मिलता है.

112
00:07:53,320 --> 00:07:58,910
जब हम ढेर के बंद कुछ popped, क्या हुआ?

113
00:07:58,910 --> 00:08:01,540
कोई भी अंतर देख रहे हो? यह बहुत सूक्ष्म है.

114
00:08:01,540 --> 00:08:05,810
[छात्र] आकार. >> हाँ, आकार बदल दिया है.

115
00:08:05,810 --> 00:08:09,040
>> और क्या आप बदलाव की उम्मीद होता है?

116
00:08:09,040 --> 00:08:14,280
[छात्र] भी तार,. >> ठीक है. भी तार.

117
00:08:14,280 --> 00:08:17,110
यह पता चला है कि जब आप इसे इस तरह से कर रहे हैं,

118
00:08:17,110 --> 00:08:21,960
क्योंकि हम तत्वों हमारे ढेर में नहीं की नकल कर रहे हैं,

119
00:08:21,960 --> 00:08:24,670
हम वास्तव में कुछ भी नहीं है, हम सिर्फ आकार का उपयोग कर सकते हैं

120
00:08:24,670 --> 00:08:28,630
चीजों की संख्या के हमारे सरणी में ट्रैक रखने

121
00:08:28,630 --> 00:08:33,780
इतना है कि जब हम फिर से पॉप, फिर हम सिर्फ 1 आकार के लिए हमारे नीचे घटती.

122
00:08:33,780 --> 00:08:39,440
वहाँ नहीं करने के लिए वास्तव में जाओ और कुछ को अधिलेखित करने की आवश्यकता है.

123
00:08:39,440 --> 00:08:41,710
कायरता की तरह.

124
00:08:41,710 --> 00:08:46,520
यह पता चला है कि हम आम तौर पर सिर्फ बातें अकेले छोड़ क्योंकि यह कम काम के लिए हमें करने के लिए.

125
00:08:46,520 --> 00:08:50,060
अगर हम वापस जाओ और कुछ को अधिलेखित नहीं है, तो यह क्यों करते हो?

126
00:08:50,060 --> 00:08:54,150
तो जब हम ढेर की दो बार बंद पॉप, सब करता है कि आकार समय की एक जोड़ी घटती.

127
00:08:54,150 --> 00:08:59,120
और फिर, यह केवल क्योंकि हम बातें हमारे ढेर में नहीं की नकल कर रहे हैं.

128
00:08:59,120 --> 00:09:01,320
हाँ? आगे बढ़ो.

129
00:09:01,320 --> 00:09:04,460
[छात्र, unintelligible] >> और फिर क्या होता है जब आप कुछ फिर से धक्का?

130
00:09:04,460 --> 00:09:08,570
जब आप कुछ फिर से धक्का, जहां यह जाना है?

131
00:09:08,570 --> 00:09:12,390
यह, तुलसी जाना कहाँ है? [1] तार में? >> >> ठीक है.

132
00:09:12,390 --> 00:09:14,530
[3] तार में क्यों नहीं जाती है?

133
00:09:14,530 --> 00:09:19,410
[तुलसी] क्योंकि यह भूल गया है कि तार में कुछ भी थी [1] और [2]?

134
00:09:19,410 --> 00:09:24,040
[Hardison] बिल्कुल सही. हमारे ढेर, अनिवार्य रूप से, "भूल" कि यह कुछ भी करने के लिए जोत रहा था

135
00:09:24,040 --> 00:09:29,480
तार में [1] या तार [2], इसलिए जब हम "धक्का" woot

136
00:09:29,480 --> 00:09:36,670
यह सिर्फ तत्व में [1] तार पर डालता है.

137
00:09:36,670 --> 00:09:41,590
यह कैसे काम करता है पर किसी भी सवाल का एक बुनियादी स्तर पर कर रहे हैं?

138
00:09:41,590 --> 00:09:45,160
[सैम] तो यह किसी भी तरह से एक गतिशील राशि के मामले में नहीं है,

139
00:09:45,160 --> 00:09:47,620
या ढेर के आकार के मामले में?

140
00:09:47,620 --> 00:09:56,750
[Hardison] बिल्कुल सही. यह है - बात यह थी कि यह एक गतिशील growning ढेर नहीं था.

141
00:09:56,750 --> 00:10:02,850
यह एक ढेर है कि सबसे अधिक है, चार चार * सबसे चार चीजों को पकड़ कर सकते हैं.

142
00:10:02,850 --> 00:10:07,580
अगर हम कोशिश करते हैं और एक पांचवीं बात धक्का थे, तुम्हें क्या लगता है चाहिए होता है?

143
00:10:07,580 --> 00:10:11,870
[छात्रों, unintelligible]

144
00:10:11,870 --> 00:10:14,600
[Hardison] बिल्कुल सही. वहाँ चीज़ें है कि हो सकता है की एक संख्या हैं.

145
00:10:14,600 --> 00:10:19,330
यह संभवतः फॉल्ट सकता है पर निर्भर करता है कि हम क्या कर रहे थे -

146
00:10:19,330 --> 00:10:22,530
वास्तव में हम कैसे पीछे के अंत से लागू करने गए थे.

147
00:10:22,530 --> 00:10:31,740
यह परिवर्तन कर सकता है. यह है कि बफर अतिप्रवाह कि हम वर्ग के बारे में बात हो सकता है.

148
00:10:31,740 --> 00:10:35,240
सबसे महत्वपूर्ण बात यह है कि लिखा हो सकता है क्या होगा

149
00:10:35,240 --> 00:10:42,370
अगर हम हमारे ढेर पर एक अतिरिक्त बात धक्का करने की कोशिश की है?

150
00:10:42,370 --> 00:10:44,550
तो तुम एक बफर अतिप्रवाह का उल्लेख किया.

151
00:10:44,550 --> 00:10:47,870
क्या बात है कि पर लिखा मिल जाएगा या पर stomped हो सकता है

152
00:10:47,870 --> 00:10:52,320
अगर हम एक अतिरिक्त बात को पुश करने की कोशिश कर गलती overflowed?

153
00:10:52,320 --> 00:10:54,730
[डैनियल, unintelligible] >> संभव है.

154
00:10:54,730 --> 00:10:58,440
लेकिन शुरू में, क्या हो सकता है? क्या होगा अगर हम एक चौथी बात धक्का करने की कोशिश की?

155
00:10:58,440 --> 00:11:06,220
यह इस स्मृति चित्र मिल गया है कि हम कम से कम आकार में परिवर्तन कर सकता है.

156
00:11:06,220 --> 00:11:10,880
>> समस्या सेट विनिर्देश में, जो कि हम क्या करने के लिए लागू किया जा रहे हैं आज,

157
00:11:10,880 --> 00:11:16,030
क्या हम करना चाहते हैं बस वापसी झूठी है.

158
00:11:16,030 --> 00:11:20,030
हमारे धक्का विधि किसी बुलियन मान वापस जा रहा है,

159
00:11:20,030 --> 00:11:22,920
और कि बूलियन मान सच हो सकता है अगर धक्का सफल

160
00:11:22,920 --> 00:11:29,730
और अगर गलत है, हम और अधिक कुछ भी धक्का नहीं कर सकते हैं क्योंकि ढेर भरा है.

161
00:11:29,730 --> 00:11:33,620
चलो कि कोड का एक छोटा सा के माध्यम से अभी चलना.

162
00:11:33,620 --> 00:11:36,400
यहाँ हमारे धक्का समारोह है.

163
00:11:36,400 --> 00:11:40,380
हमारे एक ढेर के लिए धक्का समारोह स्ट्रिंग में लेने के लिए ढेर पर डाल दिया जा रहा है.

164
00:11:40,380 --> 00:11:45,820
यह सही वापस जा रहा है यदि स्ट्रिंग सफलतापूर्वक धक्का दिया था

165
00:11:45,820 --> 00:11:51,820
पर ढेर और गलत अन्यथा.

166
00:11:51,820 --> 00:11:59,740
क्या पर कोई सुझाव एक अच्छा पहला यहाँ बात हो सकती है?

167
00:11:59,740 --> 00:12:20,630
[सैम] अगर आकार क्षमता के बराबर होती है तो वापसी झूठी?

168
00:12:20,630 --> 00:12:23,320
[Hardison] बिंगो. अच्छा काम है.

169
00:12:23,320 --> 00:12:26,310
अगर आकार क्षमता है, हम झूठी वापसी के लिए जा रहे हैं.

170
00:12:26,310 --> 00:12:29,270
हम हमारे ढेर में अधिक कुछ भी नहीं डाल सकता.

171
00:12:29,270 --> 00:12:36,900
अन्यथा, हम ढेर के शीर्ष पर कुछ डाल करना चाहते हैं.

172
00:12:36,900 --> 00:12:41,670
"ढेर के शीर्ष," शुरू में क्या है?

173
00:12:41,670 --> 00:12:43,650
[डैनियल] साइज 0? >> 0 आकार.

174
00:12:43,650 --> 00:12:49,990
ढेर के शीर्ष के बाद वहाँ ढेर में एक बात है क्या है? Missy, तुम जानते हो?

175
00:12:49,990 --> 00:12:52,720
[Missy]. >> साइज ठीक है. आप आकार करने के लिए जोड़ने के रखने के लिए,

176
00:12:52,720 --> 00:13:01,690
और हर बार जब आप सरणी में सूचकांक आकार में नए तत्व में डाल रहे हैं.

177
00:13:01,690 --> 00:13:05,470
हम इसे एक जहाज के उस तरह के साथ क्या कर सकते हैं, कि अगर समझ में आता है.

178
00:13:05,470 --> 00:13:11,910
इसलिए हम अपने तार सरणी मिल गया है, हम इसे आकार सूचकांक में प्रवेश करने जा रहे हैं,

179
00:13:11,910 --> 00:13:14,780
और हम सिर्फ वहाँ में हमारे चार * की दुकान करने के लिए जा रहे हैं.

180
00:13:14,780 --> 00:13:19,340
सूचना कैसे कोई स्ट्रिंग नकल यहाँ पर जा रहा है,

181
00:13:19,340 --> 00:13:29,680
स्मृति का कोई गतिशील आवंटन?

182
00:13:29,680 --> 00:13:34,440
तो और Missy लाया अब हम क्या करना है,

183
00:13:34,440 --> 00:13:40,570
क्योंकि हम स्ट्रिंग सरणी में उपयुक्त जगह में संग्रहित किया है,

184
00:13:40,570 --> 00:13:49,230
और उसने कहा है कि हम एक आकार वेतन वृद्धि के लिए इतना है कि हम अगले धक्का के लिए तैयार कर रहे हैं.

185
00:13:49,230 --> 00:13:53,950
तो हम s.size के साथ कर सकते हैं कि + +.

186
00:13:53,950 --> 00:13:59,330
इस बिंदु पर, हम हमारे सरणी में धकेल दिया है. आखिरी बात हमें क्या करना है क्या है?

187
00:13:59,330 --> 00:14:10,110
[छात्र] सच लौटें. >> सच लौटें.

188
00:14:10,110 --> 00:14:14,690
तो यह बहुत आसान है, एक बहुत आसान कोड. बहुत ज्यादा नहीं है.

189
00:14:14,690 --> 00:14:17,070
एक बार जब आप कैसे काम करता है ढेर के चारों ओर अपने सिर को लपेटा है,

190
00:14:17,070 --> 00:14:21,910
इस सुंदर को लागू करने के लिए सरल है.

191
00:14:21,910 --> 00:14:26,390
>> अब, इस के अगले भाग के ढेर के एक स्ट्रिंग बंद popping है.

192
00:14:26,390 --> 00:14:29,410
मैं तुम लोगों को कुछ समय के लिए यह एक छोटा सा पर काम देने के लिए जा रहा हूँ.

193
00:14:29,410 --> 00:14:34,320
यह लगभग अनिवार्य रूप से धक्का में क्या हम यहाँ किया है के विपरीत है.

194
00:14:34,320 --> 00:14:38,510
मैंने किया है कि वास्तव में क्या है - उफ़.

195
00:14:38,510 --> 00:14:48,160
मैं यहाँ पर, और उपकरण में एक उपकरण को हटा दिया गया है,

196
00:14:48,160 --> 00:14:53,600
मैं खींच लिया है समस्या 5 विनिर्देश सेट.

197
00:14:53,600 --> 00:15:02,560
यदि हम यहाँ में ज़ूम, हम देख सकते मैं cdn.cs50.net/2012/fall/psets/pset5.pdf पर हूँ.

198
00:15:02,560 --> 00:15:08,590
क्या आप लोग इस कोड है कि यहाँ स्थित है, section6.zip डाउनलोड?

199
00:15:08,590 --> 00:15:15,030
सही सभी. अगर तुम नहीं किया है कि, कि अभी क्या करना है, बहुत जल्दी.

200
00:15:15,030 --> 00:15:22,130
मैं इसे अपने टर्मिनल विंडो में करूँगा.

201
00:15:22,130 --> 00:15:25,090
मैं वास्तव में यह यहाँ था. हाँ.

202
00:15:25,090 --> 00:15:34,730
हाँ, सैम? >> मैं आप आकार की है s.string कोष्ठक क्यों कहा str = के बारे में एक सवाल है?

203
00:15:34,730 --> 00:15:42,910
Str क्या है? है कि इससे पहले कहीं परिभाषित किया गया है, या - ओह, चार * str में?

204
00:15:42,910 --> 00:15:47,160
[Hardison] हाँ, बिल्कुल. यही तर्क था. >> ओह, ठीक है. माफ़ कीजिए.

205
00:15:47,160 --> 00:15:49,470
[Hardison] हम अंदर धक्का स्ट्रिंग निर्दिष्ट कर रहे हैं

206
00:15:49,470 --> 00:15:55,220
अन्य प्रश्न है कि आया है कि हम वास्तव में यहाँ के बारे में बात नहीं हो सकता है

207
00:15:55,220 --> 00:15:58,810
हम ले के लिए दी गई है कि हम इस चर कहा जाता था

208
00:15:58,810 --> 00:16:02,710
कि गुंजाइश है और हमारे लिए सुलभ था.

209
00:16:02,710 --> 00:16:06,960
हमने ले लिया है के लिए दी गई है कि इस ढेर struct था.

210
00:16:06,960 --> 00:16:08,930
तो इस धक्का कोड में पीछे मुड़कर देखें,

211
00:16:08,930 --> 00:16:13,450
आप देख सकते हैं कि हम इस स्ट्रिंग में पारित कर दिया गया साथ सामान कर रहे हैं

212
00:16:13,450 --> 00:16:19,210
लेकिन फिर अचानक, हम s.size पहुँच रहे हैं, जैसे, कहाँ से आए हो?

213
00:16:19,210 --> 00:16:23,020
कोड कि हम अनुभाग संग्रह में लग जा रहे हैं में

214
00:16:23,020 --> 00:16:27,100
और फिर सामान है कि आप अपनी समस्या में कर रही हो जाएगा सेट,

215
00:16:27,100 --> 00:16:32,440
हम बनाया है हमारे ढेर एक वैश्विक चर struct

216
00:16:32,440 --> 00:16:36,380
इतना है कि हम हमारे सभी विभिन्न कार्यों में इसे करने के लिए उपयोग कर सकते हैं

217
00:16:36,380 --> 00:16:40,630
स्वयं इसे पास के आसपास है और यह संदर्भ द्वारा पारित करने के लिए बिना,

218
00:16:40,630 --> 00:16:44,870
यह करने के लिए सामान की है कि सभी तरह करते हैं.

219
00:16:44,870 --> 00:16:52,280
हम सिर्फ एक छोटा सा धोखा दे रहे हैं, अगर तुम जाएगा, को अच्छे चीजों को बनाने के लिए.

220
00:16:52,280 --> 00:16:57,430
और है कि कुछ हम यहाँ कर रहे हैं क्योंकि यह मनोरंजन के लिए है, यह आसान है.

221
00:16:57,430 --> 00:17:02,800
अक्सर, आप लोगों को यह नहीं देख अगर वे एक बड़ा डेटा संरचना है

222
00:17:02,800 --> 00:17:07,750
है कि उनके कार्यक्रम के भीतर पर संचालित किया जा रहा है.

223
00:17:07,750 --> 00:17:09,560
>> उपकरण को वापस जाने के लिए.

224
00:17:09,560 --> 00:17:15,240
क्या सबको सफलतापूर्वक section6.zip मिलता है?

225
00:17:15,240 --> 00:17:20,440
हर कोई इसे खोलना खोलना section6.zip का उपयोग?

226
00:17:20,440 --> 00:17:27,200
यदि आप अनुभाग 6 निर्देशिका में जाना -

227
00:17:27,200 --> 00:17:29,220
आह, सभी जगह

228
00:17:29,220 --> 00:17:32,840
और आप सूची में यहाँ क्या है, आप देखते हैं कि आप तीन अलग अलग ग. फ़ाइलें मिली है.

229
00:17:32,840 --> 00:17:38,350
आप एक पंक्ति, एक sll, जो अकेले लिंक सूची है और एक ढेर मिल गया है.

230
00:17:38,350 --> 00:17:44,600
यदि आप stack.c खोलते हैं,

231
00:17:44,600 --> 00:17:47,330
आप देख सकते हैं कि हम यह हमारे लिए परिभाषित struct मिल गया है,

232
00:17:47,330 --> 00:17:51,330
सटीक struct है कि हम सिर्फ स्लाइड में के बारे में बात की थी.

233
00:17:51,330 --> 00:17:56,340
हम ढेर के लिए हमारे वैश्विक चर मिल गया है,

234
00:17:56,340 --> 00:18:00,110
हम हमारे धक्का समारोह मिल गया है,

235
00:18:00,110 --> 00:18:04,230
और फिर हम अपने पॉप समारोह मिल गया है.

236
00:18:04,230 --> 00:18:08,320
मैं कोड डाल करने के लिए वापस धक्का स्लाइड पर यहाँ हूँ,

237
00:18:08,320 --> 00:18:10,660
लेकिन मैं आप लोगों को करने के लिए करना चाहते हैं जो अपनी क्षमता का सबसे अच्छा करने के लिए है,

238
00:18:10,660 --> 00:18:13,790
जाओ और पॉप समारोह को लागू करने.

239
00:18:13,790 --> 00:18:18,480
एक बार जब आप इसे लागू किया है, तो आप ढेर बनाने के साथ इस संकलन कर सकते हैं,

240
00:18:18,480 --> 00:18:22,540
और फिर परिणामी ढेर निष्पादन योग्य चलाने,

241
00:18:22,540 --> 00:18:28,390
और कहा कि इस परीक्षण कोड का सब यहाँ नीचे है कि मुख्य चलेंगे.

242
00:18:28,390 --> 00:18:31,060
और मुख्य वास्तव में धक्का और पॉप कॉल बनाने का ख्याल रखता है

243
00:18:31,060 --> 00:18:33,220
और यकीन है कि सब कुछ सही माध्यम से चला जाता है.

244
00:18:33,220 --> 00:18:36,820
यह भी आकार धुआँरा सही यहाँ initializes

245
00:18:36,820 --> 00:18:39,780
ताकि आप कि आरंभ करने के दौरान के बारे में चिंता करने की ज़रूरत नहीं है.

246
00:18:39,780 --> 00:18:42,310
आप मान सकते हैं कि यह ठीक से किया गया initialized है

247
00:18:42,310 --> 00:18:48,000
जब तक कि आप यह पॉप समारोह में उपयोग.

248
00:18:48,000 --> 00:18:53,530
क्या इसका यह मतलब है?

249
00:18:53,530 --> 00:19:00,100
तो यहाँ हम चले. वहाँ धक्का कोड है.

250
00:19:00,100 --> 00:19:13,210
मैं तुम्हें 5 लोग या 10 मिनट दे देंगे.

251
00:19:13,210 --> 00:19:15,690
और अगर आप अंतरिम में किसी भी सवाल है जब आप कोडिंग कर रहे हैं,

252
00:19:15,690 --> 00:19:17,710
कृपया उन्हें पूछना ज़ोर से.

253
00:19:17,710 --> 00:19:23,080
तो अगर आप एक चिपके बिंदु को मिलता है, बस पूछो.

254
00:19:23,080 --> 00:19:26,030
मुझे पता है, बाकी सब लोग जानते हैं.

255
00:19:26,030 --> 00:19:28,160
अपने पड़ोसी के साथ भी काम करते हैं.

256
00:19:28,160 --> 00:19:30,360
[डैनियल] हम सिर्फ पॉप रहे हैं अभी लागू करने? >> पॉप.

257
00:19:30,360 --> 00:19:34,200
हालांकि आप धक्का के कार्यान्वयन की नकल यदि आप चाहें तो कर सकते हैं

258
00:19:34,200 --> 00:19:37,780
इतना है कि परीक्षण के काम करेंगे.

259
00:19:37,780 --> 00:19:41,940
क्योंकि यह मुश्किल है में हो रही बातों का परीक्षण

260
00:19:41,940 --> 00:19:49,030
या, यह मुश्किल है popping चीजों का परीक्षण एक ढेर से बाहर अगर वहाँ ढेर में के साथ शुरू करने के लिए कुछ भी नहीं है.

261
00:19:49,030 --> 00:19:55,250
>> लौटने होना चाहिए पॉप क्या है? ढेर के ऊपर से तत्व.

262
00:19:55,250 --> 00:20:01,260
यह ढेर के शीर्ष के तत्व प्राप्त करने के लिए माना जाता है

263
00:20:01,260 --> 00:20:05,780
और फिर ढेर के आकार घटती,

264
00:20:05,780 --> 00:20:07,810
और अब आप शीर्ष पर तत्व खो दिया है.

265
00:20:07,810 --> 00:20:11,420
और फिर आप शीर्ष पर तत्व वापस.

266
00:20:11,420 --> 00:20:20,080
[छात्र, unintelligible]

267
00:20:20,080 --> 00:20:28,810
[Hardison] तो क्या होता है अगर आपको लगता है कि? [छात्र, unintelligible]

268
00:20:28,810 --> 00:20:34,000
क्या समाप्त होता है हो रहा है तो आप शायद या तो पहुँच रहे हैं

269
00:20:34,000 --> 00:20:37,350
एक तत्व है कि अभी तक प्रारंभ नहीं किया गया है, ताकि अपनी गणना

270
00:20:37,350 --> 00:20:39,990
जहां पिछले तत्व है बंद है.

271
00:20:39,990 --> 00:20:46,260
तो यहाँ है, अगर तुम नोटिस, धक्का हम s.size तत्व पर तार पहुँच रहे हैं

272
00:20:46,260 --> 00:20:48,560
क्योंकि यह एक नया सूचकांक है.

273
00:20:48,560 --> 00:20:51,460
यह ढेर के नए शीर्ष है.

274
00:20:51,460 --> 00:21:01,100
पॉप में जबकि, s.size अगले अंतरिक्ष होने जा रहा है,

275
00:21:01,100 --> 00:21:05,210
अंतरिक्ष कि आपके ढेर में सभी तत्वों के शीर्ष पर है.

276
00:21:05,210 --> 00:21:10,050
तो तत्व सर्वोच्च s.size पर नहीं है,

277
00:21:10,050 --> 00:21:14,930
बल्कि, यह नीचे है.

278
00:21:14,930 --> 00:21:19,640
>> अन्य बात करने के लिए आप जब पॉप में,

279
00:21:19,640 --> 00:21:22,030
आप आकार घटती है.

280
00:21:22,030 --> 00:21:28,750
यदि आप हमारे छोटे चित्र वापस सही यहाँ याद है,

281
00:21:28,750 --> 00:21:30,980
वास्तव में, एक ही बात है कि हम हो देखा जब हम पॉप बुलाया

282
00:21:30,980 --> 00:21:36,150
था कि इस आकार के पहले 2 से गिरा दिया, तो 1 के लिए,.

283
00:21:36,150 --> 00:21:42,620
फिर जब हम पर एक नए तत्व को धक्का दे दिया, यह उचित स्थान पर जाना होगा.

284
00:21:42,620 --> 00:21:49,610
[तुलसी] यदि s.size 2 है, तो यह 2 तत्व को नहीं जाना होगा,

285
00:21:49,610 --> 00:21:54,400
और फिर आप उस तत्व पॉप बंद करना चाहते हैं?

286
00:21:54,400 --> 00:21:59,510
तो अगर हम करने के लिए चला गया - >> तो हम इस पर फिर से देखो.

287
00:21:59,510 --> 00:22:07,730
यदि यह इस बिंदु पर हमारे ढेर

288
00:22:07,730 --> 00:22:12,130
और हम पॉप कहते हैं,

289
00:22:12,130 --> 00:22:16,150
जिस पर सर्वोच्च तत्व सूचकांक है?

290
00:22:16,150 --> 00:22:19,300
[2] में तुलसी, लेकिन यह 3 पॉप जा रहा है. >> ठीक है.

291
00:22:19,300 --> 00:22:24,220
तो यह है कि जहां हमारे आकार 3 है, लेकिन हम 2 सूचकांक में तत्व पॉप चाहते हैं.

292
00:22:24,220 --> 00:22:29,900
यह एक है कि आप शून्य arrays के अनुक्रमण के साथ है कि बंद के एक विशिष्ट प्रकार है.

293
00:22:29,900 --> 00:22:36,430
तो आप 3 तत्व पॉप करना चाहते हैं, लेकिन 3 तत्व सूचकांक 3 में नहीं है.

294
00:22:36,430 --> 00:22:39,430
और कारण है कि हम नहीं है कि शून्य से 1 जब हम जोर दे रहे हैं

295
00:22:39,430 --> 00:22:44,120
क्योंकि अभी, तुम नोटिस कि सर्वोच्च तत्व,

296
00:22:44,120 --> 00:22:47,600
, अगर हम इस बिंदु पर ढेर पर कुछ और धक्का थे

297
00:22:47,600 --> 00:22:50,360
हम यह 3 सूचकांक में धक्का चाहते हैं.

298
00:22:50,360 --> 00:23:03,550
और यह सिर्फ इतना होता है कि आकार और सूचकांक अप लाइन जब आप जोर दे रहे हैं.

299
00:23:03,550 --> 00:23:06,960
>> एक काम ढेर कार्यान्वयन कौन मिल गया है?

300
00:23:06,960 --> 00:23:09,690
आप एक काम ढेर मिला है. क्या आप पॉप अभी तक काम कर रहा है?

301
00:23:09,690 --> 00:23:11,890
[डैनियल] हाँ. एसा मुझे मालूम होता हैं

302
00:23:11,890 --> 00:23:14,610
>> कार्यक्रम चल रहा है और seg दोषयुक्त नहीं, यह बाहर मुद्रण है?

303
00:23:14,610 --> 00:23:17,520
क्या यह "सफलता" प्रिंट जब आप इसे चलाते?

304
00:23:17,520 --> 00:23:22,630
हाँ. धुआँरा बनाओ, इसे चलाते हैं, अगर यह बाहर प्रिंट "सफलता" और बूम नहीं,

305
00:23:22,630 --> 00:23:26,000
तो सब अच्छा है.

306
00:23:26,000 --> 00:23:34,070
सही सभी. चलो उपकरण को बहुत जल्दी जाना,

307
00:23:34,070 --> 00:23:46,100
और हम इस माध्यम से चलना होगा.

308
00:23:46,100 --> 00:23:51,110
यदि हम क्या हो रहा है पॉप के साथ यहाँ पर देखो,

309
00:23:51,110 --> 00:23:55,220
डैनियल, पहली बात है कि तुमने क्या था?

310
00:23:55,220 --> 00:23:58,850
[डैनियल] यदि s.size 0 से अधिक है.

311
00:23:58,850 --> 00:24:03,120
[Hardison] ठीक है. और तुमने ऐसा क्यों किया?

312
00:24:03,120 --> 00:24:05,610
[डैनियल] यकीन है कि वहाँ ढेर अंदर कुछ था.

313
00:24:05,610 --> 00:24:10,950
[Hardison] सही है. आप करने के लिए सुनिश्चित करें कि s.size 0 से अधिक है परीक्षण करना चाहते हैं;

314
00:24:10,950 --> 00:24:13,280
अन्यथा, आप क्या चाहते हो?

315
00:24:13,280 --> 00:24:16,630
[डैनियल] रिटर्न अशक्त? >> रिटर्न अशक्त, बिल्कुल.

316
00:24:16,630 --> 00:24:20,740
तो अगर s.size 0 से अधिक है. तो हम क्या करने जा रहे हैं?

317
00:24:20,740 --> 00:24:25,890
हम क्या अगर ढेर खाली नहीं है क्या करते हो?

318
00:24:25,890 --> 00:24:31,210
[स्टेला] आप आकार घटती? >> आप आकार घटती है, ठीक है.

319
00:24:31,210 --> 00:24:34,440
तो आपको लगता है कि कैसे क्या किया? >> S.size -.

320
00:24:34,440 --> 00:24:37,030
[Hardison] ग्रेट. और फिर तुमने क्या किया?

321
00:24:37,030 --> 00:24:44,140
[स्टेला] और फिर मैं वापस s.string कहा [s.size]

322
00:24:44,140 --> 00:24:48,560
[Hardison] ग्रेट.

323
00:24:48,560 --> 00:24:51,940
अन्यथा आप अशक्त लौटने के लिए. हाँ, सैम?

324
00:24:51,940 --> 00:24:55,510
[सैम] यह क्यों की आवश्यकता नहीं करता है s.size 1 +?

325
00:24:55,510 --> 00:24:58,430
[Hardison] 1 प्लस? >> हाँ. >> समझे.

326
00:24:58,430 --> 00:25:00,980
[सैम] मैंने सोचा था कि क्योंकि आप 1 बाहर ले जा रहे हैं,

327
00:25:00,980 --> 00:25:04,290
तो आप एक के लिए कहा है कि वे नहीं लौट जा रहे हैं.

328
00:25:04,290 --> 00:25:09,400
[Hardison] और यह सिर्फ हम क्या बारे में 0 सूचकांक के इस पूरे मुद्दे के साथ बात कर रहे थे.

329
00:25:09,400 --> 00:25:11,380
तो अगर हम यहाँ पर वापस ज़ूम.

330
00:25:11,380 --> 00:25:15,650
अगर हम इस आदमी को सही लग रही है, आप देख सकते हैं कि जब हम पॉप,

331
00:25:15,650 --> 00:25:19,340
हम 2 सूचकांक में तत्व popping रहे हैं.

332
00:25:19,340 --> 00:25:25,200
>> इसलिए हम अपने आकार 1 कमी है, तो हमारे आकार हमारे सूचकांक से मेल खाता है.

333
00:25:25,200 --> 00:25:39,650
अगर हम आकार 1 घटती नहीं है, तो हम आकार -1 और तब घटती है.

334
00:25:39,650 --> 00:25:45,270
बढ़िया है. सब अच्छा है?

335
00:25:45,270 --> 00:25:47,530
इस पर कोई सवाल?

336
00:25:47,530 --> 00:25:54,050
वहाँ अलग तरीके की एक संख्या के रूप में अच्छी तरह से यह लिखने के हैं.

337
00:25:54,050 --> 00:26:03,290
वास्तव में, हम कुछ भी कर सकते हैं - हम एक एक लाइनर कर सकते हैं.

338
00:26:03,290 --> 00:26:05,770
हम एक एक लाइन वापसी कर सकते हैं.

339
00:26:05,770 --> 00:26:12,980
तो हम वास्तव में इससे पहले कि हम कर रही है कि वापस घटती कर सकते हैं.

340
00:26:12,980 --> 00:26:18,320
S.size पहले तो डाल.

341
00:26:18,320 --> 00:26:22,060
वह लाइन वास्तव में घने बनाता है.

342
00:26:22,060 --> 00:26:30,940
कहाँ के बीच अंतर - आकार और s.size -

343
00:26:30,940 --> 00:26:40,130
है कि यह पोस्टफिक्स - वे यह पोस्टफिक्स फोन वजह से आता है के बाद s.size -

344
00:26:40,130 --> 00:26:47,430
मतलब है कि s.size सूचकांक ढूँढने के प्रयोजनों के लिए मूल्यांकन किया जाता है

345
00:26:47,430 --> 00:26:50,410
के रूप में यह वर्तमान में है जब इस लाइन को मार डाला है,

346
00:26:50,410 --> 00:26:54,290
और तो यह होता है के बाद रेखा को मार डाला जाता है.

347
00:26:54,290 --> 00:27:00,340
है बाद सूचकांक s.size में तत्व पहुँचा है.

348
00:27:00,340 --> 00:27:07,260
और है कि हम क्या चाहते हैं नहीं है, क्योंकि हम घटती 1 ऐसा करना चाहते हैं.

349
00:27:07,260 --> 00:27:10,990
Othewise, हम करने के लिए सरणी तक पहुँचने के होने जा रहे हैं, प्रभावी ढंग से, सीमा के बाहर है.

350
00:27:10,990 --> 00:27:16,850
हम एक है कि हम वास्तव में उपयोग करना चाहते ऊपर तत्व तक पहुँचने हो जा रहे हैं.

351
00:27:16,850 --> 00:27:23,840
हाँ, सैम? >> यह तेजी से या कम रैम का उपयोग करने के लिए एक लाइन या नहीं में है?

352
00:27:23,840 --> 00:27:29,620
[Hardison] ईमानदारी से, यह वास्तव में निर्भर करता है.

353
00:27:29,620 --> 00:27:34,220
[सैम, unintelligible] >> हाँ, यह निर्भर करता है. आप संकलक चाल हो सकती है

354
00:27:34,220 --> 00:27:41,580
संकलक पाने के लिए है कि पहचान के लिए, आम तौर पर, मैं कल्पना.

355
00:27:41,580 --> 00:27:44,840
>> तो हम इस संकलक अनुकूलन सामान के बारे में एक छोटा सा उल्लेख किया है

356
00:27:44,840 --> 00:27:47,400
कि आप संकलन कर सकते हैं,

357
00:27:47,400 --> 00:27:50,580
और कहा कि बात की तरह है कि एक संकलक पता लगाने में सक्षम हो सकता है,

358
00:27:50,580 --> 00:27:54,710
तरह ओह, हे, हो सकता है मैं एक ऑपरेशन में यह सब कर सकते हैं,

359
00:27:54,710 --> 00:27:59,420
के रूप में राम से आकार चर में लोड करने के लिए विरोध किया है,

360
00:27:59,420 --> 00:28:03,770
यह decrementing, इसे वापस भंडारण के बाहर, और फिर इसे वापस में फिर से लोड हो रहा है

361
00:28:03,770 --> 00:28:08,000
इस आपरेशन के बाकी प्रक्रिया.

362
00:28:08,000 --> 00:28:10,710
लेकिन आम तौर पर, नहीं, इस तरह की बात नहीं है

363
00:28:10,710 --> 00:28:20,770
कि काफी तेजी से अपने कार्यक्रम बनाने जा रहा है.

364
00:28:20,770 --> 00:28:26,000
ढेर पर कोई और सवाल?

365
00:28:26,000 --> 00:28:31,360
>> तो धक्का और popping. अगर आप लोग बाहर हैकर संस्करण की कोशिश करना चाहते हैं,

366
00:28:31,360 --> 00:28:33,660
हम हैकर संस्करण में किया है क्या वास्तव में चला गया है

367
00:28:33,660 --> 00:28:37,670
बनाया है और इस स्टैक गतिशील हो जाना.

368
00:28:37,670 --> 00:28:43,190
चुनौती है वहाँ मुख्य रूप से धक्का समारोह में यहाँ है,

369
00:28:43,190 --> 00:28:48,820
पता लगाने की कैसे बनाने के लिए है कि सरणी बढ़ने

370
00:28:48,820 --> 00:28:52,450
के रूप में आप पर ढेर करने के लिए अधिक से अधिक तत्वों को धक्का रखने.

371
00:28:52,450 --> 00:28:56,000
यह वास्तव में बहुत ज्यादा अतिरिक्त कोड नहीं है.

372
00:28:56,000 --> 00:29:00,080
आप वहाँ में malloc कॉल ठीक से याद है, बस एक फोन

373
00:29:00,080 --> 00:29:03,310
और फिर बाहर आंकड़ा जब आप realloc कॉल करने के लिए जा रहे हैं.

374
00:29:03,310 --> 00:29:06,090
यह एक मजेदार चुनौती है अगर आप रुचि रखते हैं.

375
00:29:06,090 --> 00:29:11,550
>> लेकिन कुछ समय के लिए है, पर स्थानांतरित करने, और हम पंक्तिज के बारे में बात करते हैं.

376
00:29:11,550 --> 00:29:15,680
यहाँ के माध्यम से स्क्रॉल.

377
00:29:15,680 --> 00:29:19,340
कतार ढेर के एक करीबी भाई है.

378
00:29:19,340 --> 00:29:25,380
तो ढेर में, चीजें हैं जो पिछले में डाल रहे थे

379
00:29:25,380 --> 00:29:28,810
पहले तो पुनः प्राप्त किया जा बातें कर रहे थे.

380
00:29:28,810 --> 00:29:33,600
हम इस में पिछले, बाहर पहली, या LIFO, आदेश मिल गया है.

381
00:29:33,600 --> 00:29:38,390
जबकि कतार में है, के रूप में आप जब आप लाइन में खड़े कर रहे हैं से उम्मीद थी,

382
00:29:38,390 --> 00:29:41,980
1 व्यक्ति लाइन में, 1 बात करने के लिए कतार में लाने के,

383
00:29:41,980 --> 00:29:47,630
पहली बात यह है कि कतार से लिया जाता है.

384
00:29:47,630 --> 00:29:51,490
कतार भी अक्सर इस्तेमाल किया जाता है जब हम रेखांकन के साथ काम कर रहे हैं,

385
00:29:51,490 --> 00:29:55,560
जैसे हम के बारे में संक्षेप में बात के ढेर के साथ

386
00:29:55,560 --> 00:30:00,260
और कतार भी अन्य चीजों की एक गुच्छा के लिए काम कर रहे हैं.

387
00:30:00,260 --> 00:30:06,180
एक बात है कि अक्सर आता है को बनाए रखने की कोशिश कर रहा है, उदाहरण के लिए,

388
00:30:06,180 --> 00:30:12,310
तत्वों का एक क्रमबद्ध सूची.

389
00:30:12,310 --> 00:30:17,650
और तुम एक सरणी के साथ कर सकते हैं. आप एक सरणी में एक चीजों की क्रमबद्ध सूची बनाए रख सकते हैं,

390
00:30:17,650 --> 00:30:20,650
लेकिन जहां मुश्किल हो जाता है कि है तो आप हमेशा के लिए खोजने के लिए है

391
00:30:20,650 --> 00:30:26,160
अगली बात डालने के लिए उपयुक्त जगह है.

392
00:30:26,160 --> 00:30:28,250
तो अगर आप 10 के माध्यम से संख्या की एक सरणी, 1,

393
00:30:28,250 --> 00:30:31,630
और तब आप 100 के माध्यम से सभी नंबर 1 का विस्तार करना चाहते हैं,

394
00:30:31,630 --> 00:30:33,670
और आप इन नंबरों यादृच्छिक क्रम में हो रही है और सब कुछ रखने की कोशिश कर रहा

395
00:30:33,670 --> 00:30:40,650
क्रमबद्ध रूप में आप के माध्यम से जाना है, तो आप अंत में स्थानांतरण की एक बहुत कुछ कर रहा है.

396
00:30:40,650 --> 00:30:43,910
कतारों और अंतर्निहित डेटा संरचनाओं के कुछ प्रकार के कुछ प्रकार के साथ,

397
00:30:43,910 --> 00:30:46,670
आप वास्तव में यह काफी आसान रख सकते हैं.

398
00:30:46,670 --> 00:30:50,640
आप कुछ जोड़ सकते हैं और फिर पूरी बात हर बार फेरबदल नहीं है.

399
00:30:50,640 --> 00:30:56,770
और न ही आप आंतरिक तत्व के आसपास के स्थानांतरण के एक बहुत कुछ करना है.

400
00:30:56,770 --> 00:31:02,990
जब हम एक कतार में लग रही है, तो आपको लगता है कि देख - भी queue.c में अनुभाग कोड में -

401
00:31:02,990 --> 00:31:10,950
struct है कि हम तुम्हें दे दिया है वास्तव में struct है कि हम आप के लिए दिया एक ढेर के लिए इसी तरह की है.

402
00:31:10,950 --> 00:31:13,770
>> इसका एक अपवाद है कि और एक अपवाद

403
00:31:13,770 --> 00:31:21,700
यह है कि हम इस अतिरिक्त सिर बुलाया पूर्णांक है,

404
00:31:21,700 --> 00:31:28,120
और यहाँ सिर कतार के सिर का ट्रैक रखने के लिए है,

405
00:31:28,120 --> 00:31:32,160
या कतार में पहला तत्व है.

406
00:31:32,160 --> 00:31:37,470
एक ढेर के साथ, हम तत्व का ट्रैक रखने के लिए है कि हम पुनः प्राप्त करने के बारे में थे करने में सक्षम थे,

407
00:31:37,470 --> 00:31:40,800
या ढेर के शीर्ष, सिर्फ आकार का उपयोग,

408
00:31:40,800 --> 00:31:44,220
जबकि एक कतार के साथ, हम विपरीत छोर के साथ सौदा कर रहे हैं.

409
00:31:44,220 --> 00:31:49,000
हम अंत में बातें हमले करने की कोशिश कर रहे हैं, लेकिन तो सामने से चीजों वापसी.

410
00:31:49,000 --> 00:31:54,640
बहुत प्रभावी ढंग से सिर के साथ, हम लाइन की शुरुआत के सूचकांक है,

411
00:31:54,640 --> 00:31:58,920
और आकार हमें कतार के अंत के सूचकांक देता है

412
00:31:58,920 --> 00:32:03,730
इतना है कि हम सिर से चीजों को पुनः प्राप्त करने और पूंछ को चीजों को जोड़ने के कर सकते हैं.

413
00:32:03,730 --> 00:32:06,890
जबकि ढेर के साथ, हम केवल कभी ढेर के शीर्ष के साथ काम कर रहे थे.

414
00:32:06,890 --> 00:32:08,900
हम ढेर के नीचे का उपयोग कभी नहीं था.

415
00:32:08,900 --> 00:32:12,220
हम केवल शीर्ष पर चीजों को जोड़ा और बातें शीर्ष से दूर ले गया

416
00:32:12,220 --> 00:32:17,470
तो हम हमारे struct के अंदर है कि अतिरिक्त क्षेत्र जरूरत नहीं थी.

417
00:32:17,470 --> 00:32:20,590
यह नहीं है कि आम तौर पर समझ बनाने के?

418
00:32:20,590 --> 00:32:27,670
सही सभी. हाँ, Charlotte? [Charlotte, unintelligible]

419
00:32:27,670 --> 00:32:32,660
[Hardison] यह एक बड़ा सवाल है, और कहा कि एक कि व्याख्यान में आया था.

420
00:32:32,660 --> 00:32:36,290
शायद कुछ उदाहरण के माध्यम से चलने समझाना होगा क्यों

421
00:32:36,290 --> 00:32:41,400
हम तार कतार के सिर के रूप में [0] का उपयोग नहीं करना चाहती.

422
00:32:41,400 --> 00:32:46,770
>> तो कल्पना कि हम हमारे कतार है, हम यह कतार कॉल करने के लिए जा रहे हैं.

423
00:32:46,770 --> 00:32:49,210
शुरुआत में, जब हम सिर्फ यह instantiated है,

424
00:32:49,210 --> 00:32:53,330
जब हम सिर्फ यह घोषित किया है, हम कुछ भी प्रारंभ नहीं किया है.

425
00:32:53,330 --> 00:32:56,790
यह सब कचरा है. तो निश्चित रूप से हम यकीन है कि हम इनिशियलाइज़ बनाना चाहते हैं

426
00:32:56,790 --> 00:33:00,950
दोनों आकार और सिर क्षेत्रों 0, उचित कुछ हो.

427
00:33:00,950 --> 00:33:05,770
हम भी आगे जा सकते हैं और हमारे कतार में तत्वों अशक्त.

428
00:33:05,770 --> 00:33:09,930
और इस चित्र फिट कर, सूचना है कि अब हमारे कतार केवल तीन तत्वों को पकड़ कर सकते हैं;

429
00:33:09,930 --> 00:33:13,150
जबकि हमारे ढेर चार पकड़ सकता है, हमारे कतार केवल तीन पकड़ सकते हैं.

430
00:33:13,150 --> 00:33:18,680
और कहा कि सिर्फ आरेख फिट कर.

431
00:33:18,680 --> 00:33:26,150
पहली बात यह है कि यहाँ क्या होता है हम स्ट्रिंग enqueue "हाय".

432
00:33:26,150 --> 00:33:30,380
और जैसे हम ढेर के साथ किया था, बहुत अलग यहाँ कुछ भी नहीं है,

433
00:33:30,380 --> 00:33:39,230
हम तार पर [0] और 1 से हमारे आकार वेतन वृद्धि पर स्ट्रिंग फेंक देते हैं.

434
00:33:39,230 --> 00:33:42,720
हम enqueue "अलविदा", उस पर डाल दिया जाता है.

435
00:33:42,720 --> 00:33:45,870
तो यह सबसे अधिक भाग के लिए एक ढेर की तरह लग रहा है.

436
00:33:45,870 --> 00:33:53,230
हम यहाँ से शुरू कर दिया है, नए तत्व, नए तत्व, आकार ऊपर जा रहा रखता है.

437
00:33:53,230 --> 00:33:56,330
इस बिंदु पर क्या होता है जब हम कुछ विपंक्ति करना चाहते हैं?

438
00:33:56,330 --> 00:34:01,280
जब हम विपंक्ति चाहते हैं, जो तत्व कि हम विपंक्ति करना चाहते है?

439
00:34:01,280 --> 00:34:04,110
[तुलसी] स्ट्रिंग्स [0]. शून्य. >> बिल्कुल सही, तुलसी,.

440
00:34:04,110 --> 00:34:10,960
हम पहली स्ट्रिंग, इस एक, "नमस्ते" से छुटकारा प्राप्त करना चाहते हैं.

441
00:34:10,960 --> 00:34:13,170
तो दूसरी बात है कि बदल क्या था?

442
00:34:13,170 --> 00:34:17,010
सूचना जब हम stack के कुछ बंद popped, हम सिर्फ आकार बदल गया है,

443
00:34:17,010 --> 00:34:22,080
लेकिन यहाँ, हम चीजों को बदलने कि एक जोड़े को मिल गया है.

444
00:34:22,080 --> 00:34:27,440
न केवल आकार बदलने के लिए, लेकिन सिर में परिवर्तन करता है.

445
00:34:27,440 --> 00:34:31,020
यह Charlotte पहले बात करने के लिए वापस जा रहा है:

446
00:34:31,020 --> 00:34:38,699
हम क्यों इस सिर के रूप में अच्छी तरह से है?

447
00:34:38,699 --> 00:34:42,110
क्या अब यह समझ में आता है, Charlotte? >> तरह.

448
00:34:42,110 --> 00:34:47,500
[Hardison] की तरह? तो क्या हुआ जब हम dequeued?

449
00:34:47,500 --> 00:34:54,340
सिर क्या किया है कि अब दिलचस्प है?

450
00:34:54,340 --> 00:34:56,449
[Charlotte] ओह, क्योंकि यह बदल - ठीक है. अच्छा.

451
00:34:56,449 --> 00:35:02,090
क्योंकि सिर - जहां सिर स्थान के संदर्भ में परिवर्तन करने के लिए इशारा कर रहा है.

452
00:35:02,090 --> 00:35:07,200
यह अब हमेशा शून्य सूचकांक एक है. >> हाँ, बिल्कुल.

453
00:35:07,200 --> 00:35:17,660
क्या हुआ अगर उच्च तत्व dequeueing

454
00:35:17,660 --> 00:35:20,590
किया गया था और हम इस सिर क्षेत्र नहीं था

455
00:35:20,590 --> 00:35:26,880
क्योंकि हम हमेशा 0 सूचकांक हमारे कतार के सिर पर इस स्ट्रिंग बुला थे,

456
00:35:26,880 --> 00:35:30,170
तो हम नीचे कतार के बाकी बदलाव करना चाहते हैं.

457
00:35:30,170 --> 00:35:36,010
हम से "अलविदा" तार से [1] तार [0] को शिफ्ट करना चाहते हैं.

458
00:35:36,010 --> 00:35:38,760
और तार [2] नीचे करने के लिए तार [1].

459
00:35:38,760 --> 00:35:43,050
और हम तत्वों की पूरी सूची के लिए यह करना होगा,

460
00:35:43,050 --> 00:35:45,110
तत्वों के पूरे सरणी.

461
00:35:45,110 --> 00:35:50,490
और जब हम एक सरणी के साथ कर रहे हैं, जो वास्तव में महंगा हो जाता है.

462
00:35:50,490 --> 00:35:53,340
तो यहाँ, यह एक बड़ा सौदा नहीं है. हम सिर्फ हमारे सरणी में तीन तत्व है.

463
00:35:53,340 --> 00:35:57,230
लेकिन अगर हम एक हजार तत्वों या एक लाख तत्वों की एक कतार थी,

464
00:35:57,230 --> 00:36:00,060
और फिर अचानक, हम विपंक्ति का एक गुच्छा बनाने शुरू एक पाश में कहता है,

465
00:36:00,060 --> 00:36:03,930
बातें सच धीमा करने के लिए के रूप में यह सब कुछ बदलाव लगातार नीचे जा रहे हैं.

466
00:36:03,930 --> 00:36:07,320
तुम्हें पता है, 1 से पाली, 1 से 1 पाली, पाली, 1 से बदलाव.

467
00:36:07,320 --> 00:36:13,650
इसके बजाय, हम इस सिर का उपयोग करें, हम इसे एक "सूचक" कहते हैं भले ही यह वास्तव में एक सूचक नहीं है

468
00:36:13,650 --> 00:36:16,430
सख्त अर्थ में, यह एक सूचक प्रकार नहीं है.

469
00:36:16,430 --> 00:36:19,410
यह एक int * या एक चार * या ऐसा कुछ नहीं है.

470
00:36:19,410 --> 00:36:28,930
लेकिन यह ओर इशारा करते हुए या हमारे कतार के सिर का संकेत है. हाँ?

471
00:36:28,930 --> 00:36:38,800
>> [छात्र] विपंक्ति बस बंद पॉप जो भी सिर पर है कैसे पता है?

472
00:36:38,800 --> 00:36:43,620
[Hardison] विपंक्ति कैसे पता है कि कैसे पॉप करने के लिए जो कुछ भी सिर पर है? >> ठीक है, हाँ.

473
00:36:43,620 --> 00:36:49,050
>> पर लग रहा है क्या है सिर्फ सिर जो क्षेत्र के लिए सेट कर दिया जाता है.

474
00:36:49,050 --> 00:36:52,710
तो इस पहले मामले में, अगर हम सही यहाँ देखो,

475
00:36:52,710 --> 00:36:55,690
हमारे सिर 0 0, सूचकांक है. >> ठीक है.

476
00:36:55,690 --> 00:37:00,500
[Hardison] तो यह सिर्फ ठीक है, अच्छी तरह से, सूचकांक में 0 तत्व, स्ट्रिंग "हाय" कहते हैं,

477
00:37:00,500 --> 00:37:03,050
हमारे कतार के सिर पर तत्व है.

478
00:37:03,050 --> 00:37:05,570
तो हम उस आदमी को विपंक्ति करने के लिए जा रहे हैं.

479
00:37:05,570 --> 00:37:09,800
और उस तत्व है कि फोन करने के लिए वापस आ जाता होगा.

480
00:37:09,800 --> 00:37:14,540
हाँ, साद? >> सिर तो मूल रूप से सेट जहाँ आप यह सूचकांक करने के लिए जा रहे हैं?

481
00:37:14,540 --> 00:37:17,750
कि यह की शुरुआत है? >> हाँ. ठीक है. >>

482
00:37:17,750 --> 00:37:22,900
[Hardison] कि हमारे सरणी के लिए नई शुरुआत बनने है.

483
00:37:22,900 --> 00:37:28,930
तो जब आप कुछ विपंक्ति, सूचकांक q.head पर तत्व का उपयोग करने के लिए सब तुम्हें क्या करना है है,

484
00:37:28,930 --> 00:37:32,240
और उस तत्व कि आप विपंक्ति चाहते हो जाएगा.

485
00:37:32,240 --> 00:37:34,930
तुम भी आकार घटती है.

486
00:37:34,930 --> 00:37:39,430
हम एक बिट में देख सकते हैं जहां चीजें इस के साथ एक छोटे से मुश्किल हो जाएगा.

487
00:37:39,430 --> 00:37:46,520
हम विपंक्ति, और अब, अगर हम फिर enqueue,

488
00:37:46,520 --> 00:37:51,300
जहाँ हम enqueue करते?

489
00:37:51,300 --> 00:37:55,000
अगले तत्व हमारे कतार में कहां जाना है?

490
00:37:55,000 --> 00:37:57,980
कहते हैं कि हम "सीएस" स्ट्रिंग enqueue चाहते.

491
00:37:57,980 --> 00:38:02,240
जो सूचकांक में जाना होगा? [छात्र] स्ट्रिंग्स [2]. दो. >>

492
00:38:02,240 --> 00:38:04,980
क्यों नहीं 2 और 0?

493
00:38:04,980 --> 00:38:13,570
[तुलसी] क्योंकि अब सिर 1 है तो, है कि सूची के शुरुआत की तरह है?

494
00:38:13,570 --> 00:38:21,220
[Hardison] सही है. और क्या सूची के अंत अर्थ?

495
00:38:21,220 --> 00:38:23,290
हम क्या हमारे कतार के अंत को निरूपित करने के लिए इस्तेमाल कर रहे थे?

496
00:38:23,290 --> 00:38:25,970
सिर हमारे कतार के सिर, हमारे कतार की शुरुआत है.

497
00:38:25,970 --> 00:38:29,530
हमारी कतार के अंत क्या है? साइज [छात्र]. >> आकार, बिल्कुल.

498
00:38:29,530 --> 00:38:36,360
इसलिए हमारे नए तत्व आकार में जाओ, और तत्व है कि हम ले बंद सिर पर उतर आते हैं.

499
00:38:36,360 --> 00:38:45,390
जब हम अगले तत्व enqueue, हम यह आकार में डाल रहे हैं.

500
00:38:45,390 --> 00:38:48,530
इससे पहले कि आप [छात्र] डाल दिया है कि हालांकि, आकार 1 था, सही?

501
00:38:48,530 --> 00:38:55,690
[Hardison] सही है. तो आकार में काफी नहीं है. +, साइज, लेकिन नहीं +1 + सिर.

502
00:38:55,690 --> 00:38:59,990
क्योंकि हम सब कुछ सिर राशि से स्थानांतरित कर दिया.

503
00:38:59,990 --> 00:39:14,270
यहाँ तो, अब हम 1 आकार की एक कतार है कि 1 सूचकांक में शुरू होता है मिल गया है.

504
00:39:14,270 --> 00:39:20,730
पूंछ के सूचकांक में 2 है. हाँ?

505
00:39:20,730 --> 00:39:25,780
>> [छात्र] क्या होता है जब आप विपंक्ति तार [0], और स्मृति में तार 'स्लॉट

506
00:39:25,780 --> 00:39:29,420
अभी खाली है, पाने के मूल रूप से, या बस भूल?

507
00:39:29,420 --> 00:39:34,700
[Hardison] हाँ. इस अर्थ में, हम सिर्फ उन्हें भूल रहे हो.

508
00:39:34,700 --> 00:39:42,640
अगर हम उन की प्रतियां के लिए भंडारण कर रहे थे -

509
00:39:42,640 --> 00:39:46,310
कई डेटा संरचनाओं अक्सर तत्वों के अपने प्रतियां स्टोर

510
00:39:46,310 --> 00:39:51,760
इतना है कि डेटा संरचना के प्रबंधन के व्यक्ति को चिंता नहीं है

511
00:39:51,760 --> 00:39:53,650
जहां उन सभी संकेत जा रहे हैं के बारे में.

512
00:39:53,650 --> 00:39:56,000
डेटा संरचना करने के लिए सब कुछ करने के लिए पर धारण, सभी प्रतियां करने के लिए पर रखती है,

513
00:39:56,000 --> 00:39:59,580
लगता है कि सब कुछ उचित बनी रहती है.

514
00:39:59,580 --> 00:40:03,140
हालांकि, इस मामले में, इन आंकड़ा संरचना सिर्फ सादगी के लिए,

515
00:40:03,140 --> 00:40:05,580
नहीं बना है कि हम उन्हें में भंडारण कर रहे हैं कुछ की प्रतियां.

516
00:40:05,580 --> 00:40:08,630
[छात्र] तो यह एक निरंतर सरणी है? हाँ. >>

517
00:40:08,630 --> 00:40:14,350
अगर हम परिभाषा क्या इस संरचना का था पर वापस देखो, यह है.

518
00:40:14,350 --> 00:40:19,110
यह सिर्फ एक मानक सरणी है आप की तरह देखा है,

519
00:40:19,110 --> 00:40:24,280
चार * ओं की एक सरणी.

520
00:40:24,280 --> 00:40:26,340
कि क्या? >> हाँ, मैं सोच रहा था

521
00:40:26,340 --> 00:40:29,130
अगर तुम अंततः स्मृति से बाहर चलने देंगे, एक निश्चित सीमा तक,

522
00:40:29,130 --> 00:40:32,330
अगर आप अपने सरणी में इन खाली स्थानों है?

523
00:40:32,330 --> 00:40:36,390
[Hardison] हाँ, यह एक अच्छी बात है.

524
00:40:36,390 --> 00:40:41,530
>> यदि हम क्या हुआ है पर अब इस बिंदु पर देखो,

525
00:40:41,530 --> 00:40:46,350
हम हमारे कतार भर दिया है, ऐसा लगता है.

526
00:40:46,350 --> 00:40:50,390
लेकिन हम वास्तव में हमारे कतार नहीं भर दिया है

527
00:40:50,390 --> 00:40:57,710
क्योंकि हम एक कतार है कि 2 आकार है, लेकिन यह 1 सूचकांक में शुरू होता है,

528
00:40:57,710 --> 00:41:02,160
कारण है कि जहां हमारे सिर सूचक है.

529
00:41:02,160 --> 00:41:08,400
जैसे आप कह रहे थे कि, तार पर तत्व [0], 0 सूचकांक में, वास्तव में वहाँ नहीं है.

530
00:41:08,400 --> 00:41:10,450
यह हमारे कतार में अब और नहीं है.

531
00:41:10,450 --> 00:41:16,460
हम बस में जाना है और इसे अधिलेखित जब हम यह dequeued जहमत नहीं उठाई.

532
00:41:16,460 --> 00:41:18,700
तो भले ही यह लग रहा है जैसे हम स्मृति से बाहर चलाने की है, हम वास्तव में नहीं है.

533
00:41:18,700 --> 00:41:23,270
जगह है कि हमें का उपयोग करने के लिए उपलब्ध है.

534
00:41:23,270 --> 00:41:29,310
उचित व्यवहार, अगर हम कोशिश करते हैं और पहले विपंक्ति कुछ थे

535
00:41:29,310 --> 00:41:34,420
"अलविदा" की तरह, कि अलविदा पॉप बंद होगा.

536
00:41:34,420 --> 00:41:38,460
अब हमारे कतार 2 सूचकांक में शुरू होता है और 1 आकार की है.

537
00:41:38,460 --> 00:41:42,240
और अब अगर हम कोशिश करते हैं और कुछ enqueue फिर, 50 कहते हैं,

538
00:41:42,240 --> 00:41:47,880
50 0 सूचकांक में इस जगह में जाना चाहिए

539
00:41:47,880 --> 00:41:51,270
क्योंकि यह अभी भी हमारे लिए उपलब्ध है. हाँ, साद?

540
00:41:51,270 --> 00:41:53,630
[साद] कि स्वचालित रूप से होता है?

541
00:41:53,630 --> 00:41:56,150
[Hardison] यह काफी स्वतः नहीं होता है. आप गणित करने के लिए है

542
00:41:56,150 --> 00:42:00,380
बनाने के लिए यह काम करते हैं, लेकिन अनिवार्य रूप से हम क्या किया है हम सिर्फ चारों ओर लपेटा है.

543
00:42:00,380 --> 00:42:04,070
[Saad] और यह ठीक है अगर यह इसे के बीच में एक छेद है?

544
00:42:04,070 --> 00:42:08,720
[Hardison] यह है कि अगर हम गणित ठीक से काम कर सकते हैं.

545
00:42:08,720 --> 00:42:15,470
>> और यह पता चला कि है कि वास्तव में माड आपरेटर के साथ करने के लिए मुश्किल नहीं है.

546
00:42:15,470 --> 00:42:20,040
तो बस जैसे हम सीज़र और क्रिप्टो सामान के साथ किया था,

547
00:42:20,040 --> 00:42:25,190
आधुनिक का उपयोग करते हुए, हम चीजों के आसपास लपेटो करने के लिए मिलता है और जा रहा रख सकते

548
00:42:25,190 --> 00:42:28,090
के आसपास है और आसपास और चारों ओर के साथ हमारे कतार

549
00:42:28,090 --> 00:42:32,180
है कि सिर सूचक के चारों ओर बढ़ रखने.

550
00:42:32,180 --> 00:42:38,840
सूचना है कि आकार हमेशा तत्वों की संख्या वास्तव में सम्मान कतार के भीतर.

551
00:42:38,840 --> 00:42:43,110
और यह सिर्फ सिर सूचक है कि माध्यम से साइकिल रहता है.

552
00:42:43,110 --> 00:42:49,660
यदि हम यहाँ क्या हुआ है पर देखो, अगर हम शुरू करने के लिए वापस जाओ,

553
00:42:49,660 --> 00:42:55,020
और तुम बस देखो क्या सिर करने के लिए होता है

554
00:42:55,020 --> 00:42:58,240
जब हम कुछ enqueue, सिर करने के लिए कुछ भी नहीं हुआ.

555
00:42:58,240 --> 00:43:00,970
जब हम कुछ और कतारबद्ध, सिर करने के लिए कुछ भी नहीं हुआ.

556
00:43:00,970 --> 00:43:04,130
ही हम कुछ dequeued, एक सिर से ऊपर चला जाता है.

557
00:43:04,130 --> 00:43:06,600
हम कुछ कतारबद्ध, सिर करने के लिए कुछ भी नहीं होता है.

558
00:43:06,600 --> 00:43:11,060
जब हम कुछ विपंक्ति, अचानक सिर incremented हो जाता है.

559
00:43:11,060 --> 00:43:14,660
जब हम कुछ enqueue, सिर करने के लिए कुछ भी नहीं होता है.

560
00:43:14,660 --> 00:43:20,240
>> इस बिंदु पर क्या होगा अगर हम कुछ फिर विपंक्ति थे?

561
00:43:20,240 --> 00:43:23,240
किसी भी विचार? सिर करने के लिए क्या होगा?

562
00:43:23,240 --> 00:43:27,190
क्या सिर करने के लिए नहीं होना चाहिए

563
00:43:27,190 --> 00:43:32,990
अगर हम कुछ विपंक्ति थे?

564
00:43:32,990 --> 00:43:35,400
सिर सही अब 2 सूचकांक में है,

565
00:43:35,400 --> 00:43:38,920
जिसका अर्थ है कि कतार के सिर तार [2].

566
00:43:38,920 --> 00:43:44,280
[छात्र] जो 0 देता है? >> यह 0 से लौट जाना चाहिए. यह पीठ के आसपास लपेटो, बिल्कुल चाहिए.

567
00:43:44,280 --> 00:43:48,440
अब तक, हर बार हम विपंक्ति बुलाया, हम सिर करने के लिए किया गया है उनका कहना है,

568
00:43:48,440 --> 00:43:50,960
सिर करने के लिए एक जोड़ने के लिए, सिर के लिए एक जोड़ने के लिए, सिर के लिए एक जोड़ने.

569
00:43:50,960 --> 00:43:58,400
जैसे ही सिर सूचक हमारे सरणी में अंतिम सूचकांक के लिए हो जाता है,

570
00:43:58,400 --> 00:44:05,650
तो हम इसे लपेटो वापस शुरू करने के लिए चारों ओर है, 0 से वापस जाओ.

571
00:44:05,650 --> 00:44:09,900
[Charlotte] एक ढेर में कतार की क्षमता निर्धारित करता है?

572
00:44:09,900 --> 00:44:13,120
[Hardison] इस मामले में, हम सिर्फ एक # परिभाषित निरंतर है का उपयोग किया गया है. ठीक है. >>

573
00:44:13,120 --> 00:44:19,590
[Hardison] वास्तविक ग फ़ाइल में, आप यह एक छोटा सा के साथ में और गंदगी जा सकते हैं

574
00:44:19,590 --> 00:44:21,710
और यह बड़ा या के रूप में थोड़ा के रूप में आप चाहते हैं के रूप में कर सकते हैं.

575
00:44:21,710 --> 00:44:25,310
[Charlotte] तो जब आप इसे एक कतार बना रहे हैं, कैसे तुम बनाने के कंप्यूटर पता है

576
00:44:25,310 --> 00:44:29,120
आप कितना बड़ा ढेर होने के लिए करना चाहते हैं?

577
00:44:29,120 --> 00:44:31,700
[Hardison] यह एक बड़ा सवाल है.

578
00:44:31,700 --> 00:44:34,800
वहाँ तरीके के एक जोड़े हैं. बस इसे परिभाषित सामने है

579
00:44:34,800 --> 00:44:42,050
और यह कहने के लिए एक पंक्ति है कि 4 तत्वों या 50 तत्वों या 10,000 है होने जा रहा है.

580
00:44:42,050 --> 00:44:45,430
अन्य तरीका हैकर संस्करण लोग क्या कर रहे हैं

581
00:44:45,430 --> 00:44:52,310
और कार्यों के लिए अपनी कतार गतिशील बढ़ने के रूप में अधिक चीजें अंदर शामिल हो

582
00:44:52,310 --> 00:44:54,740
>> [Charlotte] तो पहले विकल्प के साथ जाना है, क्या वाक्यविन्यास आप का उपयोग करते हैं

583
00:44:54,740 --> 00:44:57,830
कार्यक्रम बता कतार के आकार क्या है?

584
00:44:57,830 --> 00:45:04,780
[Hardison] आह. तो चलो इस से बाहर निकलने के लिए.

585
00:45:04,780 --> 00:45:12,650
मैं अभी भी यहाँ stack.c में हूँ, इसलिए मैं सिर्फ ऊपर करने के लिए यहाँ स्क्रॉल करने जा रहा हूँ.

586
00:45:12,650 --> 00:45:17,920
आप यह सही देख सकते हैं यहाँ? यह # 10 क्षमता को परिभाषित.

587
00:45:17,920 --> 00:45:24,600
और यह लगभग उसी वाक्यविन्यास कि हम कतार के लिए है.

588
00:45:24,600 --> 00:45:28,390
कतार में छोड़कर, हम यहाँ कि अतिरिक्त struct क्षेत्र मिल गया है.

589
00:45:28,390 --> 00:45:32,760
[Charlotte] ओह, मैंने सोचा क्षमता स्ट्रिंग के लिए क्षमता का मतलब है.

590
00:45:32,760 --> 00:45:36,770
[Hardison] आह. >> है कि यह शब्द की अधिकतम लंबाई है. >> समझे.

591
00:45:36,770 --> 00:45:41,180
हाँ. यहाँ क्षमता है कि एक बड़ा मुद्दा है.

592
00:45:41,180 --> 00:45:44,000
और यह कुछ है कि मुश्किल है

593
00:45:44,000 --> 00:45:49,480
क्योंकि हम यहाँ घोषित किया है जो चार * s की एक सरणी है.

594
00:45:49,480 --> 00:45:52,770
संकेत की एक सरणी.

595
00:45:52,770 --> 00:45:56,690
यह वर्ण की एक सरणी है.

596
00:45:56,690 --> 00:46:01,690
शायद यह है कि आप क्या करते हैं जब आप फ़ाइल के लिए किया गया है अपने buffers की घोषणा देखा है मैं / हे,

597
00:46:01,690 --> 00:46:06,840
जब तुम तार किया गया है मैन्युअल बनाने के ढेर पर.

598
00:46:06,840 --> 00:46:09,090
हालांकि, हम यहाँ मिल गया है क्या * चार की एक सरणी है.

599
00:46:09,090 --> 00:46:13,400
तो यह संकेत की एक सरणी है.

600
00:46:13,400 --> 00:46:18,350
वास्तव में, अगर हम वापस बाहर ज़ूम और को हम देखते हैं यहाँ क्या हो रहा है

601
00:46:18,350 --> 00:46:23,140
प्रस्तुति में, आपको लगता है कि वास्तविक तत्वों, चरित्र डेटा

602
00:46:23,140 --> 00:46:26,180
सरणी के भीतर ही जमा नहीं है.

603
00:46:26,180 --> 00:46:42,690
हमारे सरणी के भीतर यहाँ संग्रहीत क्या चरित्र डेटा के संकेत दिए गए हैं.

604
00:46:42,690 --> 00:46:52,560
ठीक है. तो हमने देखा है कि कतार के आकार ढेर के साथ की तरह है,

605
00:46:52,560 --> 00:46:58,670
आकार हमेशा तत्वों की संख्या वर्तमान का सम्मान कतार में.

606
00:46:58,670 --> 00:47:02,720
2 enqueues करने के बाद, आकार 2 है.

607
00:47:02,720 --> 00:47:07,110
एक विपंक्ति करने के बाद आकार अब है 1.

608
00:47:07,110 --> 00:47:09,330
एक और enqueue करने के बाद आकार 2 के लिए वापस है.

609
00:47:09,330 --> 00:47:12,340
तो आकार निश्चित रूप से कतार में तत्वों की संख्या का सम्मान करता है,

610
00:47:12,340 --> 00:47:15,580
और फिर सिर सिर्फ साइकिल चालन रहता है.

611
00:47:15,580 --> 00:47:20,210
यह 0-1-2, 0-1-2 0-1-2 से चला जाता है.

612
00:47:20,210 --> 00:47:25,620
और हर बार हम विपंक्ति कॉल, सिर सूचक अगले सूचकांक incremented हो जाता है.

613
00:47:25,620 --> 00:47:29,930
और अगर सिर खत्म हो जाने के बारे में है, यह चारों ओर 0 से वापस loops.

614
00:47:29,930 --> 00:47:34,870
तो उस के साथ, हम विपंक्ति समारोह लिख सकते हैं.

615
00:47:34,870 --> 00:47:40,200
और हम enqueue समारोह छोड़ने के बजाय के लिए आप लोगों को लागू करने के लिए जा रहे हैं.

616
00:47:40,200 --> 00:47:45,880
>> जब हम हमारे कतार के एक तत्व बाहर विपंक्ति

617
00:47:45,880 --> 00:47:55,490
पहली बात यह है कि डैनियल किया था जब हम ढेर के लिए पॉप समारोह लेखन शुरू कर दिया था?

618
00:47:55,490 --> 00:48:00,490
मुझे कोई है जो अभी तक बात नहीं की है से सुना है.

619
00:48:00,490 --> 00:48:06,710
चलो देखते हैं, साद, तुम्हें याद है डैनियल क्या पहली बात है जब वह पॉप लिखा है के रूप में किया था?

620
00:48:06,710 --> 00:48:08,860
[साद] वहाँ है, यह था - >> वह कुछ के लिए परीक्षण किया गया.

621
00:48:08,860 --> 00:48:12,140
साद] यदि आकार 0 से अधिक है. वास्तव में. >>

622
00:48:12,140 --> 00:48:14,390
और के लिए कि परीक्षण क्या था?

623
00:48:14,390 --> 00:48:19,090
[साद] यह देखने के लिए अगर वहाँ सरणी के अंदर कुछ भी परीक्षण किया गया.

624
00:48:19,090 --> 00:48:23,210
[Hardison] हाँ. बिल्कुल सही. तो आप ढेर से बाहर कुछ भी नहीं पॉप अगर यह खाली है.

625
00:48:23,210 --> 00:48:26,510
इसी तरह, आप एक कतार से कुछ भी नहीं विपंक्ति अगर यह खाली है सकते हैं.

626
00:48:26,510 --> 00:48:30,420
पहली बात हम हमारे विपंक्ति समारोह में यहाँ क्या करना चाहिए क्या है, क्या लगता है?

627
00:48:30,420 --> 00:48:33,860
साद] यदि आकार 0 से अधिक है? >> हाँ.

628
00:48:33,860 --> 00:48:37,710
इस मामले में, मैं वास्तव में सिर्फ देखने के लिए अगर यह 0 है परीक्षण किया गया.

629
00:48:37,710 --> 00:48:42,240
यदि यह 0 है, हम अशक्त लौट सकते हैं.

630
00:48:42,240 --> 00:48:45,280
लेकिन सटीक एक ही तर्क है.

631
00:48:45,280 --> 00:48:49,110
और इस के साथ जारी रखने के.

632
00:48:49,110 --> 00:48:54,600
यदि आकार नहीं 0 है, जहां तत्व कि हम विपंक्ति करना चाहते है?

633
00:48:54,600 --> 00:48:58,550
[साद] सिर? वास्तव में. >>

634
00:48:58,550 --> 00:49:01,720
हम सिर्फ हमारे कतार में पहला तत्व खींच कर सकते हैं

635
00:49:01,720 --> 00:49:07,040
सिर पर तत्व तक पहुँचने के द्वारा.

636
00:49:07,040 --> 00:49:14,630
पागल कुछ भी नहीं है.

637
00:49:14,630 --> 00:49:19,620
उसके बाद, हमें क्या करना चाहिए? क्या होता है?

638
00:49:19,620 --> 00:49:23,740
दूसरी बात यह है कि हम विपंक्ति में के बारे में बात की थी क्या था?

639
00:49:23,740 --> 00:49:28,130
दो बातें करने के लिए होता है, क्योंकि हमारे कतार बदल गया है.

640
00:49:28,130 --> 00:49:35,640
[डैनियल] आकार को कम करें. >> हम आकार को कम करने के लिए, और सिर में वृद्धि करने के लिए है? बिल्कुल सही.

641
00:49:35,640 --> 00:49:40,600
सिर को बढ़ाने के लिए, हम बस आँख बंद करके सिर में वृद्धि नहीं कर सकते हैं, याद है.

642
00:49:40,600 --> 00:49:45,080
सिर्फ हम नहीं कर सकते हैं queue.head करना + +.

643
00:49:45,080 --> 00:49:51,630
हम भी क्षमता से इस आधुनिक शामिल है.

644
00:49:51,630 --> 00:49:54,740
और क्यों हम क्षमता द्वारा आधुनिक करते हैं, स्टैला?

645
00:49:54,740 --> 00:49:58,680
स्टेला] क्योंकि यह चारों ओर लपेटो है. वास्तव में. >>

646
00:49:58,680 --> 00:50:04,750
हम क्षमता द्वारा आधुनिक क्योंकि यह 0 से चारों ओर वापस लपेटो है.

647
00:50:04,750 --> 00:50:07,400
तो अब, इस बिंदु पर, हम कर सकते हैं डैनियल ने क्या कहा है.

648
00:50:07,400 --> 00:50:12,700
हम आकार घटती कर सकते हैं.

649
00:50:12,700 --> 00:50:29,170
और फिर हम सिर्फ तत्व है कि कतार के शीर्ष पर था लौट सकते हैं.

650
00:50:29,170 --> 00:50:34,000
यह किस तरह का ऐंठा हुआ लगता है पहली बार. आप एक सवाल हो सकता है. क्षमा करें?

651
00:50:34,000 --> 00:50:37,260
>> [सैम] 1 पंक्ति के शीर्ष पर क्यों है? कि कहां जाना है?

652
00:50:37,260 --> 00:50:42,480
[Hardison] यह नीचे से चौथी लाइन से आता है.

653
00:50:42,480 --> 00:50:46,060
के बाद हम यह सुनिश्चित करना है कि हमारे कतार खाली नहीं है परीक्षण,

654
00:50:46,060 --> 00:50:54,100
हम चार * 1 खींच, हम बाहर तत्व कि सिर सूचकांक पर बैठा है खींच

655
00:50:54,100 --> 00:50:58,680
हमारे सरणी के, हमारे तार सरणी >>, और पहली बार है कि कॉल के?

656
00:50:58,680 --> 00:51:04,500
[Hardison] और हम यह पहली बार कहते हैं. हाँ.

657
00:51:04,500 --> 00:51:09,850
बस उस पर पालन करने के लिए, तुम क्यों लगता है कि हम ऐसा करने के लिए किया था?

658
00:51:09,850 --> 00:51:18,270
[सैम] प्रत्येक 1 बस q.strings लौट रहा है [q.head?] >> हाँ.

659
00:51:18,270 --> 00:51:23,830
>> क्योंकि हम आधुनिक समारोह के साथ q.head के इस बदलते कर रहे हैं,

660
00:51:23,830 --> 00:51:27,810
और वहाँ कोई वापसी लाइन के भीतर भी है कि ऐसा करने के लिए एक रास्ता है.

661
00:51:27,810 --> 00:51:31,640
[Hardison] बिल्कुल सही. आप मौके पर ही कर रहे हैं. सैम पर पूरी तरह से जगह है.

662
00:51:31,640 --> 00:51:36,800
कारण है कि हम हमारे कतार में पहला तत्व खींचने के लिए और यह एक चर में संग्रहीत था

663
00:51:36,800 --> 00:51:43,030
क्योंकि इस लाइन जहाँ हम सिर्फ q.head था,

664
00:51:43,030 --> 00:51:47,030
वहाँ में माड आपरेटर कुछ है कि हम क्या कर सकते है नहीं है

665
00:51:47,030 --> 00:51:51,230
एक पंक्ति में यह बिना सिर पर प्रभाव ले.

666
00:51:51,230 --> 00:51:54,480
तो हम वास्तव में पहला तत्व खींच है, तो सिर को समायोजित करने के लिए,

667
00:51:54,480 --> 00:52:00,430
आकार को समायोजित करने के लिए, और फिर लौटने के तत्व है कि हम बाहर खींच लिया.

668
00:52:00,430 --> 00:52:02,680
और यह कुछ है कि हम आ देखेंगे के साथ बाद में

669
00:52:02,680 --> 00:52:04,920
जुडी हुई सूचियों, के रूप में हम उनके साथ खेलने के आसपास.

670
00:52:04,920 --> 00:52:08,410
अक्सर जब तुम मुक्त कर रहे हैं या लिंक सूचियों का निपटान

671
00:52:08,410 --> 00:52:13,500
आप अगले तत्व, एक लिंक सूची के अगले सूचक को याद करने की जरूरत है

672
00:52:13,500 --> 00:52:16,330
मौजूदा एक के निपटान से पहले.

673
00:52:16,330 --> 00:52:23,580
क्योंकि अन्यथा आप क्या सूची में छोड़ दिया है की जानकारी दूर फेंक देते हैं.

674
00:52:23,580 --> 00:52:34,160
अब, अगर आप अपने उपकरण के लिए जाना है, तो आप इस queue.c-x खुला बाहर.

675
00:52:34,160 --> 00:52:39,390
तो अगर मैं queue.c खोलते हैं, तो यहाँ मुझे ज़ूम, चलो

676
00:52:39,390 --> 00:52:44,970
आप देखेंगे कि आप एक समान दिखने वाले फ़ाइल है.

677
00:52:44,970 --> 00:52:49,200
समान दिखने फ़ाइल क्या हम stack.c साथ पहले था.

678
00:52:49,200 --> 00:52:54,690
हम बस के रूप में परिभाषित हम स्लाइड्स पर देखा कतार के लिए हमारे struct मिल गया है.

679
00:52:54,690 --> 00:52:59,870
>> हम हमारे enqueue समारोह है जो आप करने के लिए है.

680
00:52:59,870 --> 00:53:04,340
और हम विपंक्ति समारोह यहाँ है.

681
00:53:04,340 --> 00:53:06,870
फ़ाइल में विपंक्ति समारोह लागू नहीं किया गया है,

682
00:53:06,870 --> 00:53:13,230
लेकिन मैं इसे वापस डाल देंगे PowerPoint पर इतना है कि आप इसे में टाइप करें, यदि आप चाहें तो कर सकते हैं.

683
00:53:13,230 --> 00:53:16,690
तो अगले 5 मिनट या ऐसा करने के लिए, आप लोग enqueue पर काम

684
00:53:16,690 --> 00:53:22,570
जो लगभग सिर्फ विपंक्ति के विपरीत है.

685
00:53:22,570 --> 00:53:29,560
आप सिर समायोजित जब आप enqueueing रहे हैं नहीं है, लेकिन क्या आप को समायोजित करने के लिए है?

686
00:53:29,560 --> 00:53:38,920
आकार. तो जब आप enqueue, सिर अछूता रहता है, आकार में परिवर्तित हो जाता है.

687
00:53:38,920 --> 00:53:46,920
लेकिन यह एक छोटा सा ले करता है - आप उस आधुनिक के साथ खेलने के आसपास होगा

688
00:53:46,920 --> 00:53:57,560
बाहर ठीक आंकड़ा क्या सूचकांक नए तत्व में डाला जाना चाहिए.

689
00:53:57,560 --> 00:54:03,080
तो मैं तुम लोगों को एक छोटा सा दे देंगे, स्लाइड पर वापस विपंक्ति डाल दिया,

690
00:54:03,080 --> 00:54:05,200
और के रूप में आप लोगों को सवाल है, उन्हें चिल्लाओ बाहर इतना है कि हम कर सकते हैं

691
00:54:05,200 --> 00:54:09,220
एक समूह के रूप में उनके बारे में सभी बात करते हैं.

692
00:54:09,220 --> 00:54:13,960
इसके अलावा, आप नहींं आकार के साथ - जब आप के आकार को समायोजित करने के लिए, आप हमेशा ही कर सकते हैं -

693
00:54:13,960 --> 00:54:18,720
आप आकार कभी आधुनिक है? [डैनियल] नहीं >> तुम आकार आधुनिक नहीं है, सही है.

694
00:54:18,720 --> 00:54:24,260
क्योंकि आकार हमेशा, अगर तुम जाएगा - संभालने आप बातें कर रहे हैं उचित प्रबंध,

695
00:54:24,260 --> 00:54:30,840
आकार हमेशा 0 और 3 के बीच होगा.

696
00:54:30,840 --> 00:54:38,680
आप आधुनिक जब आप कर रहे हैं enqueue कहाँ है?

697
00:54:38,680 --> 00:54:41,060
केवल सिर के लिए [छात्र]. सिर के लिए केवल >> बिल्कुल.

698
00:54:41,060 --> 00:54:44,620
और आप सब पर enqueue में आधुनिक क्यों है?

699
00:54:44,620 --> 00:54:48,830
जब ऐसी स्थिति में आप आधुनिक चाहते है?

700
00:54:48,830 --> 00:54:53,630
[छात्र] यदि आप रिक्त स्थान पर सामान है, रिक्त स्थान 1 और 2 में करना चाहते हैं,

701
00:54:53,630 --> 00:54:55,950
और फिर तुम 0 में कुछ जोड़ने की जरूरत है.

702
00:54:55,950 --> 00:55:02,570
[Hardison] हाँ, बिल्कुल. तो अगर आपके सिर सूचक बहुत अंत में है,

703
00:55:02,570 --> 00:55:14,210
या अगर अपने आकार प्लस अपने सिर बड़ा है या बल्कि, कतार के आसपास लपेटो करने के लिए जा रहा है.

704
00:55:14,210 --> 00:55:17,830
>> तो इस स्थिति में है कि हम मिल गया है यहाँ स्लाइड पर अब सही,

705
00:55:17,830 --> 00:55:24,370
अगर मैं अभी कुछ enqueue चाहते हैं,

706
00:55:24,370 --> 00:55:31,110
हम 0 सूचकांक में कुछ enqueue चाहते हैं.

707
00:55:31,110 --> 00:55:35,450
तो अगर आप जहां 50 चला जाता है पर देखो, और मैं enqueue 50 कहते हैं,

708
00:55:35,450 --> 00:55:40,840
यह वहाँ नीचे चला जाता है नीचे. यह सूचकांक 0 में चला जाता है.

709
00:55:40,840 --> 00:55:44,160
यह जगह 'हाय' है कि पहले से ही dequeued था.

710
00:55:44,160 --> 00:55:46,210
[डैनियल] इस बात का ख्याल नहीं ले आप विपंक्ति में पहले से ही?

711
00:55:46,210 --> 00:55:50,550
यह enqueue में सिर के साथ क्यों करता है कुछ भी करते हैं?

712
00:55:50,550 --> 00:55:55,770
[Hardison] ओह, तो आप सिर नहीं संशोधित कर रहे हैं, माफ करना.

713
00:55:55,770 --> 00:56:02,310
लेकिन आप माड आपरेटर के उपयोग जब आप पहुँच रहे हैं

714
00:56:02,310 --> 00:56:04,250
तत्व है कि आप जब आप तक पहुँचने रहे हैं enqueue चाहते

715
00:56:04,250 --> 00:56:06,960
अपनी कतार में अगले तत्व.

716
00:56:06,960 --> 00:56:10,960
[तुलसी] मैं ऐसा नहीं था, और मैं वहाँ पर "सफलता" मिला.

717
00:56:10,960 --> 00:56:13,370
[डैनियल] ओह, मैं समझता हूँ कि तुम क्या कह रहे हैं.

718
00:56:13,370 --> 00:56:16,240
[Hardison] तो आप फ्लॉप - आप सिर्फ q.size में किया था?

719
00:56:16,240 --> 00:56:20,670
[तुलसी] हाँ. मैं सिर्फ पक्षों बदल गया है, मैं सिर के साथ कुछ भी नहीं था.

720
00:56:20,670 --> 00:56:24,300
[] Hardison आप वास्तव में सिर को पुनर्स्थापित करने के लिए कुछ भी हो सकता है नहीं है,

721
00:56:24,300 --> 00:56:31,650
लेकिन तार सरणी में आप जब सूचकांक,

722
00:56:31,650 --> 00:56:39,500
आप वास्तव में आगे जाना है और गणना के लिए जहां अगले तत्व है,

723
00:56:39,500 --> 00:56:44,230
क्योंकि ढेर withe, अपने ढेर में अगले तत्व हमेशा था

724
00:56:44,230 --> 00:56:48,740
आकार के लिए इसी सूचकांक में.

725
00:56:48,740 --> 00:56:55,850
यदि हम हमारे ढेर धक्का समारोह में वापस देखो,

726
00:56:55,850 --> 00:57:03,100
हम हमेशा सही सूचकांक आकार में हमारे नए तत्व में फेंकना सकता है.

727
00:57:03,100 --> 00:57:06,710
जबकि कतार के साथ, हम ऐसा नहीं कर सकते

728
00:57:06,710 --> 00:57:10,340
क्योंकि अगर हम इस स्थिति में हैं,

729
00:57:10,340 --> 00:57:18,130
अगर हम 50 कतारबद्ध हमारे नए स्ट्रिंग सही [1] तार पर जाना होगा

730
00:57:18,130 --> 00:57:20,540
जो हमें नहीं करना चाहती.

731
00:57:20,540 --> 00:57:41,200
हम नए स्ट्रिंग 0 सूचकांक में जाना चाहते हैं.

732
00:57:41,200 --> 00:57:44,320
>> किसी को भी - हाँ? [छात्र] मैं एक सवाल है, लेकिन यह वास्तव में संबंधित नहीं है.

733
00:57:44,320 --> 00:57:48,160
यह क्या होता है जब किसी को सिर्फ कॉल pred सूचक की तरह कुछ मतलब है?

734
00:57:48,160 --> 00:57:51,260
कि नाम क्या है के लिए कम? मुझे पता है कि यह सिर्फ एक नाम है.

735
00:57:51,260 --> 00:57:59,110
[Hardison] Pred सूचक है? चलो देखते हैं. किस संदर्भ में?

736
00:57:59,110 --> 00:58:01,790
[छात्र] यह डालने के लिए किया गया था. मैं तुम्हें पूछने के बाद अगर आप चाहते हैं

737
00:58:01,790 --> 00:58:03,920
क्योंकि यह वास्तव में संबंधित नहीं है, लेकिन मैं सिर्फ -

738
00:58:03,920 --> 00:58:07,300
[Hardison] दाऊद के व्याख्यान से डालने के कोड से?

739
00:58:07,300 --> 00:58:10,860
हम जानते हैं कि खींच कर सकते हैं और इस बारे में बात.

740
00:58:10,860 --> 00:58:15,550
हम कि अगले, एक बार हम लिंक सूचियों को पाने के बारे में बात करेंगे.

741
00:58:15,550 --> 00:58:21,440
>> तो सच में जल्दी चलो enqueue समारोह की तरह लग रहा है पर देखो.

742
00:58:21,440 --> 00:58:26,530
पहली बात यह है कि लोगों को अपने enqueue लाइन में करने की कोशिश की क्या था? इस कतार में?

743
00:58:26,530 --> 00:58:29,960
तुम क्या धकेलने के ढेर के लिए किया था के लिए भी इसी तरह.

744
00:58:29,960 --> 00:58:32,080
आप क्या किया, स्टेला?

745
00:58:32,080 --> 00:58:35,050
[स्टैला, unintelligible]

746
00:58:35,050 --> 00:58:45,700
[Hardison] बिल्कुल सही. यदि (== क्षमता q.size)

747
00:58:45,700 --> 00:58:54,720
मैं सही जगह में मेरी ब्रेसिज़ डाल की जरूरत है - वापसी झूठी.

748
00:58:54,720 --> 00:59:01,370
एक छोटा सा में ज़ूम. ठीक है.

749
00:59:01,370 --> 00:59:03,800
अब अगली बात यह है कि हम करना पड़ा है?

750
00:59:03,800 --> 00:59:11,370
बस ढेर के साथ करना चाहते हैं, और सही जगह पर डाला.

751
00:59:11,370 --> 00:59:16,010
और इसलिए सही है कि डालने के जगह क्या था?

752
00:59:16,010 --> 00:59:23,170
ढेर के साथ यह सूचकांक आकार का था, इस के साथ यह नहीं है कि काफी है.

753
00:59:23,170 --> 00:59:30,210
[डैनियल] मैं q.head या - >> q.strings? >> हाँ.

754
00:59:30,210 --> 00:59:40,470
q.strings [q.head q.size + आधुनिक क्षमता]?

755
00:59:40,470 --> 00:59:42,740
[Hardison] हम शायद इस के आसपास कोष्ठक डाल करना चाहते हैं

756
00:59:42,740 --> 00:59:48,830
ताकि हम उपयुक्त पूर्वता हो रही है और इसलिए है कि हर किसी के लिए cleart है.

757
00:59:48,830 --> 00:59:55,800
सेट और कहा कि बराबर है? Str करने के लिए? >> Str करने के लिए. >> बढ़िया है.

758
00:59:55,800 --> 01:00:00,160
और अब आखिरी बात यह है कि हमें क्या करना है क्या है?

759
01:00:00,160 --> 01:00:06,780
वैसे ही जैसे हम ढेर में किया था. >> आकार बढ़त? >> आकार बढ़त.

760
01:00:06,780 --> 01:00:13,830
बूम. और फिर, स्टार्टर कोड के बाद से बस डिफ़ॉल्ट रूप से झूठी लौटे,

761
01:00:13,830 --> 01:00:27,460
हम सच करने के लिए इस बदल सकता है अगर सभी के माध्यम से चला जाता है और सब कुछ अच्छी तरह से चला जाता है चाहता हूँ.

762
01:00:27,460 --> 01:00:33,050
सही सभी. अनुभाग के लिए जानकारी का एक बहुत कुछ है.

763
01:00:33,050 --> 01:00:39,480
हम काफी खत्म नहीं कर रहे हैं. हम अकेले लिंक सूचियों के बारे में वास्तव में जल्दी से बात करना चाहता हूँ.

764
01:00:39,480 --> 01:00:44,010
मैं इस डाल तो हम इसे वापस करने के बाद जा सकते हैं.

765
01:00:44,010 --> 01:00:50,850
लेकिन हमारे प्रस्तुति के लिए अभी कुछ और स्लाइड के लिए वापस जाना.

766
01:00:50,850 --> 01:00:53,790
तो enqueue TODO है, अब हम इसे किया है.

767
01:00:53,790 --> 01:00:57,430
>> अब चलो अकेले लिंक सूचियों पर एक नज़र रखना.

768
01:00:57,430 --> 01:01:00,040
हम व्याख्यान में ये एक छोटा सा के बारे में अधिक बात की थी.

769
01:01:00,040 --> 01:01:02,540
तुम लोगों में से कितने डेमो देखा जहां हम लोग थे

770
01:01:02,540 --> 01:01:08,220
awkwardly एक दूसरे को और होल्डिंग संख्या की ओर इशारा करते हैं? >> मैं उस में था.

771
01:01:08,220 --> 01:01:16,620
>> तुम लोगों को क्या लगता है? किया है कि, उम्मीद है कि ये एक छोटा सा demystify?

772
01:01:16,620 --> 01:01:25,990
एक सूची के साथ, यह पता चला है कि हम इस प्रकार के साथ सौदा है कि हम एक नोड फोन करने के लिए जा रहे हैं.

773
01:01:25,990 --> 01:01:32,520
जबकि कतार और ढेर के साथ हम structs कि हम ढेर में कतार फोन था था,

774
01:01:32,520 --> 01:01:34,860
हम ढेर प्रकार में इन नए कतार थी,

775
01:01:34,860 --> 01:01:39,240
यहाँ एक सूची वास्तव में सिर्फ नोड्स के एक गुच्छा के ऊपर बनाया है.

776
01:01:39,240 --> 01:01:45,920
एक ही तरीका है कि तार सिर्फ वर्ण की एक गुच्छा रहे हैं सभी एक दूसरे के बगल में खड़े हैं.

777
01:01:45,920 --> 01:01:50,650
एक लिंक की गई सूची में सिर्फ एक नोड और एक अन्य नोड और अन्य नोड और किसी अन्य नोड है.

778
01:01:50,650 --> 01:01:55,080
और नहीं बल्कि सभी नोड्स के साथ मुंहतोड़ और उन्हें contiguously से भंडारण की तुलना में

779
01:01:55,080 --> 01:01:58,090
सही स्मृति में सभी एक दूसरे के बगल में,

780
01:01:58,090 --> 01:02:04,470
यह अगले सूचक होने के हमें जहाँ भी नोड्स के स्टोर करने के लिए यादृच्छिक पर, की अनुमति देता है.

781
01:02:04,470 --> 01:02:10,500
और फिर तार की तरह उन सब को एक साथ करने के लिए एक से दूसरे बात करने के लिए.

782
01:02:10,500 --> 01:02:15,850
>> और क्या बड़ा लाभ यह है कि यह एक सरणी पर था?

783
01:02:15,850 --> 01:02:21,680
भंडारण सब कुछ खत्म contiguously सिर्फ एक दूसरे के बगल में फंस रहे हैं?

784
01:02:21,680 --> 01:02:24,190
तुम्हें याद है? हाँ? >> गतिशील स्मृति आवंटन?

785
01:02:24,190 --> 01:02:27,220
>> गतिशील स्मृति आवंटन में क्या अर्थ है?

786
01:02:27,220 --> 01:02:31,780
[छात्र] है कि आप यह बड़ा है और आप अपने पूरे सरणी कदम नहीं है बनाने रखने के लिए कर सकते हैं?

787
01:02:31,780 --> 01:02:40,940
[Hardison] बिल्कुल सही. तो एक सरणी के साथ, जब आप इसे के बीच में एक नए तत्व डाल करना चाहते हैं

788
01:02:40,940 --> 01:02:45,320
आप के लिए सब कुछ बदलाव करने के लिए जगह बनाने के है.

789
01:02:45,320 --> 01:02:47,880
और जैसे हम कतार के साथ के बारे में बात की थी,

790
01:02:47,880 --> 01:02:50,080
यही कारण है कि हम है कि सिर सूचक रखने,

791
01:02:50,080 --> 01:02:52,050
इतना है कि हम लगातार बातें नहीं जा रहे हैं.

792
01:02:52,050 --> 01:02:54,520
क्योंकि महंगा हो जाता है कि अगर आप एक बड़ा सरणी मिल गया है

793
01:02:54,520 --> 01:02:57,130
और आप लगातार इन बेतरतीब सम्मिलन कर रहे हैं.

794
01:02:57,130 --> 01:03:00,820
जबकि एक सूची के साथ, सब तुम्हें क्या करना है यह एक नया नोड पर फेंक देते हैं,

795
01:03:00,820 --> 01:03:06,330
संकेत को समायोजित करने के लिए, और आप कर रहे हैं.

796
01:03:06,330 --> 01:03:10,940
क्या इस बारे में बेकार है?

797
01:03:10,940 --> 01:03:16,830
अलावा तथ्य यह है कि यह आसान के रूप में एक सरणी के रूप में साथ काम नहीं? हाँ?

798
01:03:16,830 --> 01:03:22,980
[डैनियल] खैर, मुझे लगता है कि यह बहुत कठिन है लिंक की गई सूची में एक विशिष्ट तत्व का उपयोग?

799
01:03:22,980 --> 01:03:30,470
[Hardison] तुम सिर्फ अपने लिंक सूची के बीच में एक मनमाना तत्व नहीं कूद कर सकते हैं.

800
01:03:30,470 --> 01:03:33,800
बजाय आप इसे कैसे करना है? >> आप पूरी बात के माध्यम से कदम है.

801
01:03:33,800 --> 01:03:35,660
[Hardison] हाँ. आप एक समय में, एक एक समय में एक के माध्यम से जाना है.

802
01:03:35,660 --> 01:03:38,480
यह एक बहुत बड़ा है - यह एक दर्द है.

803
01:03:38,480 --> 01:03:41,550
अन्य क्या है - वहाँ इस के लिए एक पतन है.

804
01:03:41,550 --> 01:03:45,340
[तुलसी] आप आगे और पीछे की ओर नहीं जा सकते? आप एक दिशा में जाने के लिए है?

805
01:03:45,340 --> 01:03:48,570
[Hardison] हाँ. तो कैसे हम कभी कभी को हल करने के लिए,?

806
01:03:48,570 --> 01:03:53,370
[तुलसी] सूचियों दोगुना से जुड़े? वास्तव में. >> दोगुना से जुड़े सूचियों हैं.

807
01:03:53,370 --> 01:03:55,540
वहाँ भी कर रहे हैं - खेद?

808
01:03:55,540 --> 01:03:57,620
>> [सैम] कि pred बात यह है कि का उपयोग कर के रूप में एक ही है -

809
01:03:57,620 --> 01:04:01,090
मुझे अभी याद नहीं है कि pred बात के लिए क्या है?

810
01:04:01,090 --> 01:04:05,850
में दोगुना और अकेले के बीच नहीं है?

811
01:04:05,850 --> 01:04:10,020
वास्तव में वह क्या कर रहा था पर [Hardison] चलो देखो.

812
01:04:10,020 --> 01:04:15,760
तो यहाँ हम चले. यहाँ सूची कोड है.

813
01:04:15,760 --> 01:04:25,620
हम यहाँ predptr यहाँ है. यह है कि आप किस बारे में बात कर रहे थे?

814
01:04:25,620 --> 01:04:30,750
तो यह था - वह मुक्त एक सूची है और वह इसे करने के लिए एक सूचक की दुकान की कोशिश कर रहा है.

815
01:04:30,750 --> 01:04:35,000
यह दोगुना अकेले, लिंक सूची नहीं है.

816
01:04:35,000 --> 01:04:40,090
हम इस बारे में और अधिक सूची को मुक्त कराने के बारे में बाद में बात कर सकते हैं, के बाद से यह बात कर रही है

817
01:04:40,090 --> 01:04:42,900
और मैं कुछ अन्य सामान पहले दिखाना चाहते हैं.

818
01:04:42,900 --> 01:04:51,480
लेकिन यह सिर्फ यह ptr के मूल्य याद है

819
01:04:51,480 --> 01:04:54,170
[छात्र] ओह, यह पूर्ववर्ती सूचक है? >> हाँ.

820
01:04:54,170 --> 01:05:04,070
तो है कि हम तो पहले हम तो मुक्त predptr क्या है ptr ही वेतन वृद्धि कर सकते हैं.

821
01:05:04,070 --> 01:05:09,130
क्योंकि हम मुक्त ptr और फिर ptr = ptr अगले, है ना? फोन नहीं कर सकते

822
01:05:09,130 --> 01:05:11,260
यह बुरा होगा.

823
01:05:11,260 --> 01:05:20,940
तो देखते हैं, इस आदमी के लिए वापस.

824
01:05:20,940 --> 01:05:23,900
>> सूचियों के बारे में अन्य बुरी बात यह है कि जबकि एक सरणी के साथ

825
01:05:23,900 --> 01:05:26,520
हम सिर्फ सभी तत्वों को खुद को एक दूसरे के बगल में stacked है,

826
01:05:26,520 --> 01:05:29,050
यहाँ हम भी यह सूचक पेश किया है.

827
01:05:29,050 --> 01:05:34,060
तो वहाँ स्मृति के एक अतिरिक्त हिस्सा है कि हम का उपयोग कर रहे हैं

828
01:05:34,060 --> 01:05:37,910
हर तत्व है कि हम हमारी सूची में भंडारण कर रहे हैं के लिए.

829
01:05:37,910 --> 01:05:40,030
हम लचीलापन मिलता है, लेकिन यह एक कीमत पर आता है.

830
01:05:40,030 --> 01:05:42,230
यह इस समय और लागत के साथ आता है,

831
01:05:42,230 --> 01:05:45,270
और यह इस स्मृति लागत के साथ भी आता है.

832
01:05:45,270 --> 01:05:47,800
भावना में समय है कि हम अब सरणी में प्रत्येक तत्व के माध्यम से जाना है

833
01:05:47,800 --> 01:05:58,670
10 सूचकांक में एक, या 10 सूचकांक एक सरणी में होता है कि लगता है.

834
01:05:58,670 --> 01:06:01,230
>> सिर्फ सच में जल्दी से, जब हम बाहर इन सूचियों आरेख,

835
01:06:01,230 --> 01:06:05,980
आम तौर पर हम सूची के सिर या सूची की पहली सूचक पर पकड़

836
01:06:05,980 --> 01:06:08,010
और ध्यान दें कि यह एक सच सूचक है.

837
01:06:08,010 --> 01:06:11,100
यह सिर्फ 4 बाइट्स है. यह एक वास्तविक नोड ही नहीं है.

838
01:06:11,100 --> 01:06:17,120
तो आप देखते हैं कि यह उस में नहीं int मूल्य में कोई अगली सूचक है.

839
01:06:17,120 --> 01:06:20,790
यह सचमुच सिर्फ एक सूचक है.

840
01:06:20,790 --> 01:06:23,550
यह करने के लिए कुछ है कि एक वास्तविक नोड struct है इंगित करने के लिए जा रहा है.

841
01:06:23,550 --> 01:06:28,480
[सैम] एक नोड बुलाया सूचक है? >> यह है - नहीं. इस प्रकार नोड के कुछ करने के लिए एक सूचक है.

842
01:06:28,480 --> 01:06:32,540
यह एक नोड struct एक सूचक है. >> ओह, ठीक है.

843
01:06:32,540 --> 01:06:36,870
सही पर छोड़ दिया कोड, पर आरेख.

844
01:06:36,870 --> 01:06:42,190
हम यह अशक्त है, जो एक अच्छा तरीका शुरू करने के लिए सेट कर सकते हैं.

845
01:06:42,190 --> 01:06:49,850
जब आप इसे आरेख, आप या तो यह शून्य के रूप में लिखने के लिए या आप इसे माध्यम से एक लाइन डाल की तरह है कि.

846
01:06:49,850 --> 01:06:53,910
>> एक सूची के साथ काम करने के लिए सबसे आसान तरीकों में से एक है,

847
01:06:53,910 --> 01:06:57,430
और हम तुम दोनों प्रीपेंड पूछना है और दोनों के बीच मतभेद को देखने के परिशिष्ट के रूप में लगाना,

848
01:06:57,430 --> 01:07:01,320
लेकिन prepending निश्चित रूप से आसान है.

849
01:07:01,320 --> 01:07:05,790
जब आप prepend, यह तुम कहाँ है - जब आप प्रीपेंड (7),

850
01:07:05,790 --> 01:07:10,050
तुम जाओ और नोड struct बनाने

851
01:07:10,050 --> 01:07:13,870
और आप पहली बार यह बात है, क्योंकि अब, जब से हम इसे सम्पन्न

852
01:07:13,870 --> 01:07:17,240
यह करने के लिए सूची की शुरुआत में होने जा रहा है.

853
01:07:17,240 --> 01:07:22,540
यदि हम प्रीपेंड (3), कि एक और नोड बनाता है, लेकिन अब 3 7 से पहले आता है.

854
01:07:22,540 --> 01:07:31,130
तो हम हमारी सूची पर अनिवार्य रूप से कर रहे हैं बातें धक्का.

855
01:07:31,130 --> 01:07:34,720
अब, आप देख सकते हैं कि प्रीपेंड, कभी कभी लोगों को फोन इसे धक्का,

856
01:07:34,720 --> 01:07:39,600
क्योंकि आप अपनी सूची पर जोर दे रहे हैं एक नए तत्व.

857
01:07:39,600 --> 01:07:43,270
यह भी एक सूची के मोर्चे पर हटाना आसान नहीं है.

858
01:07:43,270 --> 01:07:45,650
तो लोगों को अक्सर है कि पॉप कहते हैं जाएगा.

859
01:07:45,650 --> 01:07:52,200
और उस रास्ते में, आप एक ढेर एक लिंक सूची का उपयोग का अनुकरण कर सकते हैं.

860
01:07:52,200 --> 01:07:57,880
वूप्स. क्षमा करें, अब हम संलग्न में हो रही है. यहाँ तो हम (7) सम्पन्न, अब हम प्रीपेंड (3).

861
01:07:57,880 --> 01:08:02,600
यदि हम इस सूची पर सब कुछ सम्पन्न, अगर हम सम्पन्न (4),

862
01:08:02,600 --> 01:08:06,540
तो हम 4 है और फिर 3 और फिर 7.

863
01:08:06,540 --> 01:08:14,220
तो फिर हम पॉप और 4 को निकालने के लिए, 3 हटायें, 7 को हटा दें.

864
01:08:14,220 --> 01:08:16,500
अक्सर इस बारे में सोचने के लिए अधिक सहज तरीका संलग्न के साथ है.

865
01:08:16,500 --> 01:08:20,310
तो मैं बाहर diagrammed है कि यह क्या साथ यहाँ परिशिष्ट के रूप में लगाना तरह लग रही होगी.

866
01:08:20,310 --> 01:08:23,380
यहाँ, संलग्न (7) कोई अलग नहीं लगती है

867
01:08:23,380 --> 01:08:25,160
क्योंकि वहाँ केवल सूची में एक तत्व है.

868
01:08:25,160 --> 01:08:28,620
और appending (3) यह अंत में डालता है.

869
01:08:28,620 --> 01:08:31,020
शायद तुम सही अब संलग्न के साथ चाल देख सकते हैं

870
01:08:31,020 --> 01:08:36,600
वह यह है कि जब से हम सिर्फ इतना पता है कि जहां सूची की शुरुआत है,

871
01:08:36,600 --> 01:08:39,450
एक सूची आप सूची के माध्यम से सभी तरह चलना है संलग्न

872
01:08:39,450 --> 01:08:46,500
अंत करने के लिए, बंद करो, तो अपने नोड और खनखनाहट नीचे सब कुछ का निर्माण.

873
01:08:46,500 --> 01:08:50,590
सब सामान तार.

874
01:08:50,590 --> 01:08:55,170
तो प्रीपेंड साथ, के रूप में हम सिर्फ इस के माध्यम से बहुत जल्दी फट,

875
01:08:55,170 --> 01:08:58,170
जब आप एक सूची से जोड़ें, यह काफी आसान है.

876
01:08:58,170 --> 01:09:02,960
>> आप अपने नए नोड बनाने के लिए, कुछ गतिशील स्मृति आवंटन शामिल है.

877
01:09:02,960 --> 01:09:09,830
तो यहाँ हम एक नोड struct बनाने malloc का उपयोग कर रहे हैं.

878
01:09:09,830 --> 01:09:14,710
Malloc तो हम क्योंकि है कि एक तरफ के लिए बाद में हमारे लिए स्मृति सेट का उपयोग कर रहे हैं

879
01:09:14,710 --> 01:09:20,350
- हम इस स्मृति एक लंबे समय के लिए जारी रहती है क्योंकि हम यह नहीं चाहता चाहते हैं.

880
01:09:20,350 --> 01:09:25,350
और हम है कि हम सिर्फ आवंटित स्मृति में अंतरिक्ष के लिए एक सूचक मिलता है.

881
01:09:25,350 --> 01:09:29,260
हम नोड के आकार का उपयोग करें, हम इस क्षेत्र की राशि नहीं है.

882
01:09:29,260 --> 01:09:31,899
हम स्वयं बाइट्स की संख्या उत्पन्न नहीं करते हैं,

883
01:09:31,899 --> 01:09:39,750
बजाय हम sizeof इतना है कि हम जानते हैं कि हम बाइट्स की उचित संख्या में हो रही है का उपयोग करें.

884
01:09:39,750 --> 01:09:43,660
हम कि हमारे malloc कॉल सफल परीक्षण करने के लिए सुनिश्चित कर लें.

885
01:09:43,660 --> 01:09:47,939
यह कुछ आप सामान्य रूप में करना चाहते हैं.

886
01:09:47,939 --> 01:09:52,590
आधुनिक मशीनों पर स्मृति से बाहर चल रहे कुछ है कि आसान नहीं है

887
01:09:52,590 --> 01:09:56,610
जब तक आप सामान की एक टन का आवंटन कर रहे हैं और एक विशाल सूची बनाने,

888
01:09:56,610 --> 01:10:02,220
लेकिन अगर आप एक iPhone या एक Android की तरह का निर्माण कर रहे हैं, कहते हैं, के लिए सामान,

889
01:10:02,220 --> 01:10:05,230
आप सीमित स्मृति संसाधन है, खासकर यदि आप तीव्र कुछ कर रहे हैं.

890
01:10:05,230 --> 01:10:08,300
तो यह अच्छी बात है कि व्यवहार में लाने के.

891
01:10:08,300 --> 01:10:10,510
>> सूचना है कि मैं कुछ अलग कार्यों का उपयोग किया है यहाँ

892
01:10:10,510 --> 01:10:12,880
कि तुम्हें देखा है कि नई की तरह कर रहे हैं.

893
01:10:12,880 --> 01:10:15,870
तो fprintf सिर्फ printf की तरह है

894
01:10:15,870 --> 01:10:21,320
अपनी पहली तर्क को छोड़कर स्ट्रीम करने के लिए जो आप मुद्रित करना चाहते है.

895
01:10:21,320 --> 01:10:23,900
इस मामले में, हम मानक त्रुटि स्ट्रिंग मुद्रित करना चाहते हैं

896
01:10:23,900 --> 01:10:29,410
है जो मानक outstream से अलग है.

897
01:10:29,410 --> 01:10:31,620
मूलभूत रूप से यह एक ही स्थान में पता चलता है.

898
01:10:31,620 --> 01:10:34,600
यह भी टर्मिनल से बाहर प्रिंट, लेकिन आप यह कर सकते हैं -

899
01:10:34,600 --> 01:10:38,790
उन आदेशों का उपयोग आप के बारे में, redirection तकनीक सीखा

900
01:10:38,790 --> 01:10:42,290
आप टॉमी वीडियो में के बारे में समस्या 4 सेट के लिए सीखा है, तो आप यह प्रत्यक्ष कर सकते हैं

901
01:10:42,290 --> 01:10:47,900
विभिन्न क्षेत्रों के लिए, तो बाहर निकलने के लिए, यहीं, अपने कार्यक्रम से बाहर निकालता है.

902
01:10:47,900 --> 01:10:50,440
यह मुख्य से लौटने की तरह अनिवार्य है,

903
01:10:50,440 --> 01:10:53,600
छोड़कर हम बाहर निकलें का उपयोग करें, क्योंकि यहां वापसी कुछ नहीं करेंगे.

904
01:10:53,600 --> 01:10:57,140
हम मुख्य में नहीं कर रहे हैं, तो कार्यक्रम की तरह हम चाहते लौटने से बाहर नहीं निकलते है.

905
01:10:57,140 --> 01:11:03,020
तो हम बाहर निकलें समारोह का उपयोग करें और यह एक त्रुटि कोड दे.

906
01:11:03,020 --> 01:11:11,890
यहाँ तो हम नए नोड मान फ़ील्ड, मैं अपने क्षेत्र की स्थापना की मैं बराबर हो सकता है, और फिर हम इसे तार.

907
01:11:11,890 --> 01:11:15,530
हम नए नोड अगले सूचक सेट करने के लिए पहली बात है,

908
01:11:15,530 --> 01:11:20,460
और फिर 1 अब नए नोड के लिए बात करेंगे.

909
01:11:20,460 --> 01:11:25,120
कोड की ये पहली लाइनों, हम वास्तव में नए नोड का निर्माण कर रहे हैं.

910
01:11:25,120 --> 01:11:27,280
इस समारोह के पिछले दो लाइनें लेकिन पहले वाले.

911
01:11:27,280 --> 01:11:30,290
आप वास्तव में एक समारोह में बाहर खींच सकते हैं, एक सहायक समारोह में.

912
01:11:30,290 --> 01:11:32,560
यह अक्सर है कि मुझे क्या करना है, मैं इसे एक समारोह में बाहर खींच,

913
01:11:32,560 --> 01:11:36,040
मैं यह निर्माण नोड की तरह कुछ कहते हैं,

914
01:11:36,040 --> 01:11:40,410
और कहा कि प्रीपेंड समारोह बहुत छोटा रहता है, यह सिर्फ 3 लाइनों है तो.

915
01:11:40,410 --> 01:11:48,710
मैं मेरी नोड समारोह का निर्माण करने के लिए एक फोन बनाने के लिए, और फिर मैं तार को सब कुछ.

916
01:11:48,710 --> 01:11:51,970
>> अंतिम बात मैं तुम्हें दिखाने के लिए करना चाहते हैं,

917
01:11:51,970 --> 01:11:54,030
और मैं हूँ आप अपने दम पर संलग्न और कहा कि सभी करते हैं,

918
01:11:54,030 --> 01:11:57,500
कैसे एक सूची पुनरावृति को.

919
01:11:57,500 --> 01:12:00,780
वहाँ एक सूची पुनरावृति अलग तरीके का एक गुच्छा रहे हैं.

920
01:12:00,780 --> 01:12:03,140
इस मामले में, हम एक सूची की लंबाई को खोजने के लिए जा रहे हैं.

921
01:12:03,140 --> 01:12:06,570
तो हम = 0 लंबाई के साथ शुरू करते हैं.

922
01:12:06,570 --> 01:12:11,580
यह बहुत एक स्ट्रिंग के लिए strlen लेखन के लिए इसी तरह की है.

923
01:12:11,580 --> 01:12:17,780
यह है कि क्या मैं तुम्हें दिखाने के लिए, यह सही यहाँ पाश के लिए चाहते हैं.

924
01:12:17,780 --> 01:12:23,530
यह थोड़े कायरता लग रहा है, यह सामान्य नहीं है int i = 0, मैं जो कुछ भी <, मैं + +.

925
01:12:23,530 --> 01:12:34,920
इसके बजाय यह हमारे चर n आरंभ करने के लिए सूची की शुरुआत हो.

926
01:12:34,920 --> 01:12:40,620
और फिर, जबकि हमारे iterator चर रिक्त नहीं है, हम रख रहा है.

927
01:12:40,620 --> 01:12:46,340
इस वजह से, सम्मेलन द्वारा हमारी सूची के अंत रिक्त हो जाएगा.

928
01:12:46,340 --> 01:12:48,770
और फिर, + + करने के बजाय वेतन वृद्धि करने के लिए,

929
01:12:48,770 --> 01:12:57,010
जुड़े + की सूची बराबर + n n => अगले है.

930
01:12:57,010 --> 01:13:00,410
>> मैं आप यहाँ अंतराल में भर जाने के कारण हम समय से बाहर हो जाएगा.

931
01:13:00,410 --> 01:13:09,300
लेकिन यह ध्यान में रखना के रूप में आप अपने spellr psets पर काम.

932
01:13:09,300 --> 01:13:11,650
लिंक सूचियों, अगर आप एक हैश तालिका को लागू कर रहे हैं,

933
01:13:11,650 --> 01:13:14,010
निश्चित रूप से बहुत काम में आ जाएगा.

934
01:13:14,010 --> 01:13:21,780
और इस मुहावरा होने बातों पर पाशन के लिए एक जीवन बहुत आसान बनाने के लिए, उम्मीद है.

935
01:13:21,780 --> 01:13:25,910
कोई प्रश्न, जल्दी?

936
01:13:25,910 --> 01:13:28,920
[सैम] पूरा sll और सुप्रीम कोर्ट भेज देंगे?

937
01:13:28,920 --> 01:13:38,360
[Hardison] हाँ. मैं पूरा स्लाइड और पूरा sll ढेर और queue.cs भेज देंगे.

938
01:13:38,360 --> 01:13:41,360
[CS50.TV]