1
00:00:00,000 --> 00:00:04,074

2
00:00:04,074 --> 00:00:05,990
डौग लॉयड: ठीक है,
आप कर रहे हैं इस बात से इतनी

3
00:00:05,990 --> 00:00:09,020
शायद बहुत परिचित
सरणियों और लिंक सूचियों के साथ

4
00:00:09,020 --> 00:00:10,950
दो प्राथमिक जो है
डाटा संरचनाओं हम है

5
00:00:10,950 --> 00:00:16,810
के सेट रखने के लिए के बारे में बात की थी
इसी तरह के डेटा प्रकार के डेटा का आयोजन किया।

6
00:00:16,810 --> 00:00:19,080
>> अब हम बात करने जा रहे हैं
बदलाव की एक जोड़ी के बारे में

7
00:00:19,080 --> 00:00:20,330
सरणियों और लिंक सूचियों पर।

8
00:00:20,330 --> 00:00:22,362
इस वीडियो में हम जा रहे हैं
ढेर के बारे में बात करने के लिए।

9
00:00:22,362 --> 00:00:25,320
विशेष रूप से हम बात करने जा रहे हैं
के बारे में डेटा संरचना एक ढेर बुलाया।

10
00:00:25,320 --> 00:00:28,510
पिछले चर्चाओं से याद
संकेत और स्मृति के बारे में,

11
00:00:28,510 --> 00:00:32,060
ढेर भी है कि
स्मृति का एक खंड के लिए नाम

12
00:00:32,060 --> 00:00:34,980
स्थिर रुप से घोषित जहां
memory-- स्मृति कि आप

13
00:00:34,980 --> 00:00:38,730
आप का नाम है कि चर, नाम, एट
वगैरह और समारोह तख्ते जो भी हम

14
00:00:38,730 --> 00:00:41,000
कॉल स्टैक फ्रेम मौजूद हैं।

15
00:00:41,000 --> 00:00:45,421
तो यह एक ढेर डेटा संरचना है
स्मृति की नहीं एक ढेर खंड।

16
00:00:45,421 --> 00:00:45,920
ठीक।

17
00:00:45,920 --> 00:00:46,890
>> लेकिन एक ढेर में क्या है?

18
00:00:46,890 --> 00:00:49,220
तो यह सिर्फ एक बहुत सुंदर है
संरचना के विशेष प्रकार

19
00:00:49,220 --> 00:00:51,190
कि एक संगठित तरीके से डेटा को बनाए रखता है।

20
00:00:51,190 --> 00:00:53,760
और दो बहुत ही वहाँ
आम तरीकों को लागू करने के लिए

21
00:00:53,760 --> 00:00:57,380
दो डाटा संरचनाओं का उपयोग ढेर
हम पहले से ही परिचित हैं कि,

22
00:00:57,380 --> 00:01:00,340
सरणियों और लिंक सूचियों।

23
00:01:00,340 --> 00:01:04,430
क्या एक ढेर खास है बनाता है
हम जानकारी डाल दिया है जिसमें रास्ता

24
00:01:04,430 --> 00:01:08,200
ढेर, और जिस तरह से हम में
ढेर से जानकारी निकालें।

25
00:01:08,200 --> 00:01:11,600
ढेर के साथ विशेष रूप से
नियम केवल सबसे अधिक है

26
00:01:11,600 --> 00:01:15,830
हाल ही में जोड़ा तत्व हटाया जा सकता है।

27
00:01:15,830 --> 00:01:17,660
>> यह एक ढेर के रूप में अगर तो इसके बारे में सोचते हैं।

28
00:01:17,660 --> 00:01:21,170
हम सूचना जमा कर रहे हैं
खुद के ऊपर,

29
00:01:21,170 --> 00:01:24,271
शीर्ष पर है और केवल एक चीज
ढेर के हटाया जा सकता है।

30
00:01:24,271 --> 00:01:27,020
हम नीचे बात नहीं निकाल सकते
बाकी सब होता है, क्योंकि

31
00:01:27,020 --> 00:01:28,020
पतन और अधिक गिरावट।

32
00:01:28,020 --> 00:01:32,580
इसलिए हम वास्तव में एक ढेर निर्माण कर रहे हैं कि
हम तो टुकड़ा टुकड़ा करके हटा दिया है।

33
00:01:32,580 --> 00:01:36,590
इस वजह से हम सामान्यतः का उल्लेख
एक LIFO संरचना के रूप में एक ढेर करने के लिए,

34
00:01:36,590 --> 00:01:38,940
अंतिम अंदर प्रथम बाहर।

35
00:01:38,940 --> 00:01:42,290
LIFO, पहले में बाहर पिछले।

36
00:01:42,290 --> 00:01:45,635
>> इसलिए क्योंकि इस प्रतिबंध पर की
जानकारी के लिए जोड़ा जा सकता है कि कैसे

37
00:01:45,635 --> 00:01:49,080
और एक ढेर से हटा दिया है, वहाँ वास्तव में
केवल दो बातें हम एक ढेर के साथ कर सकते हैं।

38
00:01:49,080 --> 00:01:52,010
हम है, जो धक्का कर सकते हैं
हम जोड़ने के लिए उपयोग अवधि

39
00:01:52,010 --> 00:01:55,130
के शीर्ष करने के लिए एक नए तत्व
ढेर, या अगर ढेर मौजूद नहीं है

40
00:01:55,130 --> 00:01:58,550
और हम इसे सिरे से बना रहे हैं
पहली जगह में ढेर बनाने

41
00:01:58,550 --> 00:02:00,110
धक्का होगा।

42
00:02:00,110 --> 00:02:04,990
और उसके बाद पॉप, कि सीएस की तरह है
अवधि हम सबसे हाल ही हटाने का उपयोग

43
00:02:04,990 --> 00:02:08,330
ढेर के ऊपर से तत्व जोड़े।

44
00:02:08,330 --> 00:02:11,130
>> इसलिए हम पर दोनों को देखने के लिए जा रहे हैं
कार्यान्वयन, दोनों सरणी आधारित

45
00:02:11,130 --> 00:02:13,120
और लिंक सूची के आधार पर।

46
00:02:13,120 --> 00:02:14,870
और हम करने जा रहे हैं
आधारित सरणी के साथ शुरू करते हैं।

47
00:02:14,870 --> 00:02:19,990
तो यहाँ के मूल विचार है क्या
सरणी आधारित ढेर डेटा संरचना

48
00:02:19,990 --> 00:02:21,140
की तरह लग रही होगी।

49
00:02:21,140 --> 00:02:23,740
हम यहाँ एक टाइप परिभाषा है।

50
00:02:23,740 --> 00:02:27,790
अंदर की है कि हम दो सदस्य हैं
संरचना का या खेतों।

51
00:02:27,790 --> 00:02:29,880
हम एक सरणी है।

52
00:02:29,880 --> 00:02:32,400
और फिर मैं उपयोग कर रहा हूँ
मनमाने ढंग से डेटा प्रकार मूल्य।

53
00:02:32,400 --> 00:02:35,180
>> तो यह किसी भी डेटा प्रकार हो सकता है,
पूर्णांक चार या कुछ अन्य डेटा

54
00:02:35,180 --> 00:02:37,080
आपने पहले बनाया टाइप करें।

55
00:02:37,080 --> 00:02:39,861
इसलिए हम आकार क्षमता की एक सरणी है।

56
00:02:39,861 --> 00:02:44,010
क्षमता एक पाउंड, निरंतर परिभाषित किया जा रहा
शायद कहीं और हमारे फाइल में।

57
00:02:44,010 --> 00:02:47,550
इसलिए इस विशेष के साथ पहले से ही नोटिस
हम bounding रहे हैं कार्यान्वयन

58
00:02:47,550 --> 00:02:49,800
खुद के रूप में आम तौर पर था
सरणियों के साथ मामला है,

59
00:02:49,800 --> 00:02:53,170
हम गतिशील आकार नहीं कर सकते हैं, जो
जहां एक निश्चित संख्या है

60
00:02:53,170 --> 00:02:55,450
तत्वों अधिकतम की है कि
हम अपने ढेर में डाल सकते हैं।

61
00:02:55,450 --> 00:02:57,930
इस मामले में यह क्षमता तत्व है।

62
00:02:57,930 --> 00:03:00,310
>> हम यह भी का ट्रैक रखने
ढेर के शीर्ष।

63
00:03:00,310 --> 00:03:04,350
सबसे क्या तत्व है
हाल ही में ढेर करने के लिए कहा?

64
00:03:04,350 --> 00:03:07,470
और इसलिए हम उस पर नज़र रखने के
एक चर बुलाया शीर्ष में।

65
00:03:07,470 --> 00:03:11,692
और यह सब एक साथ लिपटे हो जाता है
एक ढेर नामक एक नए डेटा प्रकार में।

66
00:03:11,692 --> 00:03:13,400
और हम पैदा कर रहे हैं एक बार
इस नए डेटा प्रकार

67
00:03:13,400 --> 00:03:15,410
हम यह कैसा व्यवहार कर सकते हैं
किसी भी अन्य डेटा प्रकार।

68
00:03:15,410 --> 00:03:20,970
हम बस की तरह, ढेर एस घोषणा कर सकते हैं
हम int एक्स, या चार Y कर सकता है।

69
00:03:20,970 --> 00:03:22,990
और हम ढेर जब कहते हैं
एस, अच्छी तरह से क्या होता है

70
00:03:22,990 --> 00:03:26,420
हम का एक सेट हो जाता है
स्मृति हमारे लिए अलग निर्धारित करें।

71
00:03:26,420 --> 00:03:28,770
>> इस मामले क्षमता में
मैं जाहिरा तौर पर फैसला कर लिया है

72
00:03:28,770 --> 00:03:33,470
मैं एक मिल गया है, क्योंकि 10
प्रकार के ढेर के एकल चर

73
00:03:33,470 --> 00:03:35,320
जो दो क्षेत्रों को याद करते है।

74
00:03:35,320 --> 00:03:38,330
इस मामले में एक सरणी, जा रहा है
पूर्णांक सरणी होने के लिए

75
00:03:38,330 --> 00:03:40,440
के रूप में मेरे उदाहरण के अधिकांश में मामला है।

76
00:03:40,440 --> 00:03:43,996
और एक अन्य पूर्णांक चर
शीर्ष भंडारण की क्षमता,

77
00:03:43,996 --> 00:03:45,870
सबसे हाल ही में जोड़ा
ढेर करने के लिए तत्व।

78
00:03:45,870 --> 00:03:50,290
का तो एक ही हो चुकी है कि हम क्या
सिर्फ इस तरह लग रहा है परिभाषित किया।

79
00:03:50,290 --> 00:03:53,190
यह युक्त एक बॉक्स है
10 की एक सरणी क्या

80
00:03:53,190 --> 00:03:57,280
इस मामले में पूर्णांकों हो जाएगा और
हरे रंग में वहाँ एक और पूर्णांक चर

81
00:03:57,280 --> 00:04:00,010
ढेर के शीर्ष से संकेत मिलता है।

82
00:04:00,010 --> 00:04:02,600
>> के शीर्ष सेट करने के लिए
ढेर हम सिर्फ s.top कहते हैं।

83
00:04:02,600 --> 00:04:04,890
यही कारण है कि हम एक का उपयोग कैसे करना है
एक संरचना रिकॉल के क्षेत्र।

84
00:04:04,890 --> 00:04:10,460
s.top प्रभावी ढंग से 0 के बराबर होती है
हमारे ढेर करने के लिए इस करता है।

85
00:04:10,460 --> 00:04:12,960
तो फिर हम दो आपरेशन किया है
हम अब प्रदर्शन कर सकते हैं।

86
00:04:12,960 --> 00:04:14,270
हम धक्का कर सकते हैं और हम पॉप कर सकते हैं।

87
00:04:14,270 --> 00:04:15,635
की धक्का के साथ शुरू करते हैं।

88
00:04:15,635 --> 00:04:18,260
फिर, एक नया जोड़ने का है धकेलने
ढेर के शीर्ष करने के लिए तत्व।

89
00:04:18,260 --> 00:04:21,460
>> तो क्या हम में क्या करने की जरूरत है
इस सरणी आधारित कार्यान्वयन?

90
00:04:21,460 --> 00:04:23,210
खैर सामान्य में
धक्का समारोह जा रहा है

91
00:04:23,210 --> 00:04:26,160
एक को स्वीकार करने की जरूरत है
ढेर करने के लिए सूचक।

92
00:04:26,160 --> 00:04:28,610
अब एक दूसरा ले और इसके बारे में सोचते हैं।

93
00:04:28,610 --> 00:04:32,840
हम क्यों स्वीकार करने के लिए चाहते हो जाएगा
ढेर करने के लिए एक सूचक?

94
00:04:32,840 --> 00:04:36,830
पर पिछले वीडियो से याद
चर गुंजाइश है और संकेत,

95
00:04:36,830 --> 00:04:42,350
हम सिर्फ भेजा तो क्या होगा
ढेर, एक पैरामीटर के रूप में नहीं बल्कि क्या है?

96
00:04:42,350 --> 00:04:45,770
वहाँ वास्तव में क्या पारित किया जाएगा?

97
00:04:45,770 --> 00:04:49,430
हम एक प्रतिलिपि बना रहे हैं याद रखें
हम एक समारोह के लिए इसे पारित जब

98
00:04:49,430 --> 00:04:51,160
जब तक हम संकेत का उपयोग करें।

99
00:04:51,160 --> 00:04:55,380
और इसलिए इस समारोह जरूरतों को धक्का
ढेर करने के लिए एक सूचक को स्वीकार करने के लिए

100
00:04:55,380 --> 00:04:59,160
हम वास्तव में बदल रहे हैं इतना है कि
ढेर हम बदलना चाहते हैं।

101
00:04:59,160 --> 00:05:03,060
>> दूसरी बात यह धक्का शायद करना चाहता है
स्वीकार प्रकार मूल्य के एक डेटा तत्व है।

102
00:05:03,060 --> 00:05:06,970
इस मामले में, फिर, एक पूर्णांक कि
हम ढेर के शीर्ष में जोड़ने के लिए जा रहे हैं।

103
00:05:06,970 --> 00:05:08,680
इसलिए हम अपने दो मापदंडों मिल गया है।

104
00:05:08,680 --> 00:05:11,310
हम क्या करने जा रहे हैं
अब धक्का के अंदर करते हैं?

105
00:05:11,310 --> 00:05:14,860
खैर, बस, हम सिर्फ जोड़ने के लिए जा रहे हैं
ढेर के शीर्ष करने के लिए उस तत्व

106
00:05:14,860 --> 00:05:22,860
और उसके बाद से जहां शीर्ष बदल
ढेर कि शीर्ष मूल्य डॉट है, है।

107
00:05:22,860 --> 00:05:25,639
तो यह क्या एक समारोह है
धक्का के लिए घोषणा

108
00:05:25,639 --> 00:05:27,680
एक में की तरह लग सकता है
सरणी आधारित कार्यान्वयन।

109
00:05:27,680 --> 00:05:30,967
>> फिर यह एक कठोर नियम नहीं है
आप इस बदल सकते हैं और हो सकता है कि

110
00:05:30,967 --> 00:05:32,050
यह अलग अलग तरीकों में भिन्नता है।

111
00:05:32,050 --> 00:05:33,840
शायद यह विश्व स्तर पर घोषित किया जाता है।

112
00:05:33,840 --> 00:05:36,180
और इसलिए तुम भी जरूरत नहीं है
यह एक पैरामीटर के रूप में है पारित करने के लिए।

113
00:05:36,180 --> 00:05:39,125
यह फिर से सिर्फ एक है
धक्का के लिए सामान्य स्थिति।

114
00:05:39,125 --> 00:05:41,000
और अलग देखते हैं
तरीके से इसे लागू करने के लिए।

115
00:05:41,000 --> 00:05:42,810
लेकिन इस मामले में हमारे
धक्का ले जा रहा है

116
00:05:42,810 --> 00:05:48,540
दो तर्क, एक ढेर के लिए एक सूचक और
प्रकार मान, पूर्णांक के एक डेटा तत्व

117
00:05:48,540 --> 00:05:49,840
इस मामले में।

118
00:05:49,840 --> 00:05:52,100
>> तो हम, एस घोषित
s.top 0 के बराबर होती कहा।

119
00:05:52,100 --> 00:05:55,969
अब देखते हैं कि धक्का
ढेर पर 28 नंबर।

120
00:05:55,969 --> 00:05:57,010
अच्छा है कि क्या मतलब है?

121
00:05:57,010 --> 00:05:59,600
खैर वर्तमान में
ढेर के शीर्ष 0 है।

122
00:05:59,600 --> 00:06:01,350
और तो क्या मूल रूप से है
क्या होने जा रहा है

123
00:06:01,350 --> 00:06:05,820
हम नंबर छड़ी करने के लिए जा रहे हैं
सरणी स्थान 0 में 28।

124
00:06:05,820 --> 00:06:09,540
बहुत सीधा है, है ना, कि
शीर्ष था और अब हम जाने के लिए अच्छा कर रहे हैं।

125
00:06:09,540 --> 00:06:12,910
और फिर हम क्या बदलने की जरूरत है
ढेर के ऊपर होगा।

126
00:06:12,910 --> 00:06:15,130
अगली बार तो यह है कि
हम में एक तत्व को धक्का,

127
00:06:15,130 --> 00:06:18,017
हम में यह स्टोर करने के लिए जा रहे हैं
सरणी स्थान, शायद नहीं 0।

128
00:06:18,017 --> 00:06:20,100
हम ऊपर लिख नहीं करना चाहते हैं
हम सिर्फ वहाँ क्या रखा।

129
00:06:20,100 --> 00:06:23,510
और इसलिए हम सिर्फ शीर्ष 1 के लिए कदम होगा।

130
00:06:23,510 --> 00:06:24,890
यही कारण है कि शायद समझ में आता है।

131
00:06:24,890 --> 00:06:28,940
>> अब हम एक और तत्व डाल करना चाहते हैं
ढेर पर, हम 33 पुश करने के लिए कहना चाहते हैं

132
00:06:28,940 --> 00:06:33,190
खैर अब हम सिर्फ 33 लेने के लिए जा रहे हैं
और सरणी स्थान नंबर पर डाल

133
00:06:33,190 --> 00:06:37,580
1, और उसके बाद के शीर्ष परिवर्तन हमारे
सरणी स्थान नंबर दो होने की हो चुकी है।

134
00:06:37,580 --> 00:06:40,650
तो अगली बार अगर हम करना चाहते हैं
ढेर पर एक तत्व को धक्का,

135
00:06:40,650 --> 00:06:43,087
यह सरणी स्थान 2 में डाल दिया जाएगा।

136
00:06:43,087 --> 00:06:44,420
और है कि एक बार और करते हैं।

137
00:06:44,420 --> 00:06:45,753
हम ढेर के बंद 19 धक्का होगा।

138
00:06:45,753 --> 00:06:48,940
हम सरणी स्थान 2 में 19 डाल देता हूँ
और हमारे ढेर के शीर्ष बदल

139
00:06:48,940 --> 00:06:51,220
सरणी स्थान 3 होने की
तो अगली बार जब हम यदि

140
00:06:51,220 --> 00:06:54,780
हम जाने के लिए अच्छा कर रहे हैं एक धक्का बनाने की जरूरत है।

141
00:06:54,780 --> 00:06:56,980
>> ठीक है, तो वह संक्षेप में धक्का है।

142
00:06:56,980 --> 00:06:57,830
क्या popping के बारे में?

143
00:06:57,830 --> 00:07:00,240
तो पॉपिंग की तरह है
आगे बढ़ाने के लिए समकक्ष।

144
00:07:00,240 --> 00:07:02,720
यह हम ढेर से डेटा को हटाने का तरीका बताया।

145
00:07:02,720 --> 00:07:04,610
और सामान्य पॉप जरूरतों में
निम्न करने के लिए।

146
00:07:04,610 --> 00:07:07,600
यह करने के लिए एक सूचक को स्वीकार करने की जरूरत है
सामान्य मामले में फिर से हो चुकी है।

147
00:07:07,600 --> 00:07:10,480
कुछ अन्य मामले में आप कर सकते हैं
विश्व स्तर पर हो चुकी है की घोषणा की है,

148
00:07:10,480 --> 00:07:13,910
जो मामले में आप इसे पारित करने की जरूरत नहीं
क्योंकि यह पहले से ही यह करने के लिए उपयोग किया है

149
00:07:13,910 --> 00:07:15,541
एक वैश्विक चर के रूप में।

150
00:07:15,541 --> 00:07:17,040
लेकिन बाकी तो हम क्या करने की जरूरत है?

151
00:07:17,040 --> 00:07:21,000
खैर, हम incrementing थे
धक्का में ढेर के ऊपर,

152
00:07:21,000 --> 00:07:24,050
तो हम शायद चाहते करने के लिए जा रहे हैं
ढेर के शीर्ष घटती को

153
00:07:24,050 --> 00:07:25,009
पॉप में, है ना?

154
00:07:25,009 --> 00:07:26,800
और फिर बेशक
हम भी चाहते करने के लिए जा रहे हैं

155
00:07:26,800 --> 00:07:29,240
हम दूर कि मूल्य लौटने के लिए।

156
00:07:29,240 --> 00:07:32,125
हम तत्वों को जोड़ने रहे हैं, हम चाहते हैं
पर बाद में तत्वों को बाहर निकलने के लिए,

157
00:07:32,125 --> 00:07:34,000
शायद वास्तव में हम
उन्हें तो हम संग्रहीत करना चाहते हैं

158
00:07:34,000 --> 00:07:36,490
बस से उन्हें नष्ट नहीं है
ढेर और फिर उनके साथ कुछ भी नहीं है।

159
00:07:36,490 --> 00:07:38,500
आम तौर पर हम कर रहे हैं
धक्का और यहां popping

160
00:07:38,500 --> 00:07:41,250
हम इस संग्रहीत करना चाहते हैं
एक सार्थक तरीके में जानकारी

161
00:07:41,250 --> 00:07:43,250
और इसलिए यह नहीं कर सकता
भावना सिर्फ यह त्यागने के लिए।

162
00:07:43,250 --> 00:07:46,380
इसलिए इस कार्य करना चाहिए
शायद हमारे पास एक मूल्य वापसी।

163
00:07:46,380 --> 00:07:51,040
>> तो यह पॉप के लिए क्या एक घोषणा है
ऊपर छोड़ दिया पर वहाँ की तरह लग सकता है।

164
00:07:51,040 --> 00:07:53,870
इस समारोह में रिटर्न
प्रकार मूल्य के डेटा।

165
00:07:53,870 --> 00:07:56,320
फिर हम प्रयोग किया गया है
पूर्णांकों भर।

166
00:07:56,320 --> 00:08:01,916
और यह एक ढेर के रूप में करने के लिए एक सूचक को स्वीकार करता है
इसका एकमात्र तर्क या एकमात्र पैरामीटर।

167
00:08:01,916 --> 00:08:03,040
तो क्या पॉप करने जा रहा है?

168
00:08:03,040 --> 00:08:07,990
हम अब तक कहना चाहते हैं
एस के बंद एक तत्व पॉप।

169
00:08:07,990 --> 00:08:14,000
तो मैं ढेर पिछले रहे हैं ने कहा कि याद
पहली बार बाहर, LIFO डेटा संरचनाओं में।

170
00:08:14,000 --> 00:08:17,855
कौन सा तत्व जा रहा है
ढेर से हटा दिया जा सकता है?

171
00:08:17,855 --> 00:08:21,780

172
00:08:21,780 --> 00:08:24,150
आप 19 लगता था?

173
00:08:24,150 --> 00:08:25,290
तुम सही होगा क्योंकि।

174
00:08:25,290 --> 00:08:28,836
19 हम करने के लिए जोड़ा पिछले तत्व था
हम पर तत्वों जोर दे रहे थे जब ढेर,

175
00:08:28,836 --> 00:08:31,210
और इसलिए यह पहली बार होने जा रहा है
हटा दिया जाता है कि तत्व।

176
00:08:31,210 --> 00:08:34,780
यह हम 28 ने कहा कि अगर के रूप में है, और
फिर हम यह की चोटी पर 33 डाल

177
00:08:34,780 --> 00:08:36,659
और हम उस के शीर्ष पर 19 डाल दिया।

178
00:08:36,659 --> 00:08:40,650
हम से दूर ले जा सकते हैं केवल तत्व 19 है।

179
00:08:40,650 --> 00:08:45,019
>> अब यहाँ चित्र में मैंने क्या किया है
तरह की सरणी से 19 हटाया जाता है।

180
00:08:45,019 --> 00:08:46,810
यही कारण है कि वास्तव में नहीं है
हम क्या करने जा रहे हैं।

181
00:08:46,810 --> 00:08:48,934
हम बस की तरह करने के लिए जा रहे हैं
की यह वहाँ नहीं है नाटक।

182
00:08:48,934 --> 00:08:51,441
यह अभी भी वहाँ है
कि स्मृति स्थान,

183
00:08:51,441 --> 00:08:54,190
लेकिन हम सिर्फ इसे नजरअंदाज करने के लिए जा रहे हैं
हमारे ढेर के शीर्ष बदलकर

184
00:08:54,190 --> 00:08:56,080
3-2 से किया जा रहा।

185
00:08:56,080 --> 00:08:58,720
अगर हम थे तो अब धक्का
ढेर पर एक और तत्व,

186
00:08:58,720 --> 00:09:00,720
इस पर 19 लिखना होगा।

187
00:09:00,720 --> 00:09:03,990
>> लेकिन हमें यह नहीं मुसीबत के माध्यम से चलते हैं
ढेर से 19 को हटाने की।

188
00:09:03,990 --> 00:09:05,830
हम सिर्फ यह नहीं है वहाँ नाटक कर सकते हैं।

189
00:09:05,830 --> 00:09:11,107
ढेर के प्रयोजनों के लिए अगर यह चला गया है
हम 2 की बजाय 3 होने की शीर्ष बदल जाते हैं।

190
00:09:11,107 --> 00:09:12,690
ठीक है, कि यह बहुत ज्यादा था इसलिए।

191
00:09:12,690 --> 00:09:15,080
यही कारण है कि हम सब करने की ज़रूरत है
एक तत्व बंद पॉप करने के लिए।

192
00:09:15,080 --> 00:09:16,090
चलो इसे फिर से करते हैं।

193
00:09:16,090 --> 00:09:18,610
तो मैं करने के लिए यहाँ लाल रंग में यह प्रकाश डाला है
हम एक और फोन कर रहे हैं संकेत मिलता है।

194
00:09:18,610 --> 00:09:19,720
हम एक ही बात करने के लिए जा रहे हैं।

195
00:09:19,720 --> 00:09:20,803
>> तो क्या होने जा रहा है?

196
00:09:20,803 --> 00:09:23,670
खैर, हम स्टोर करने के लिए जा रहे हैं
एक्स में 33 और हम जा रहे हैं

197
00:09:23,670 --> 00:09:26,217
1 करने के लिए ढेर के शीर्ष बदलने के लिए।

198
00:09:26,217 --> 00:09:29,050
हम एक पुश करने के लिए अब थे तो यह है कि
हम कर रहे हैं जो ढेर में तत्व

199
00:09:29,050 --> 00:09:31,610
अभी क्या जा रहा है,
क्या होने जा रहा है

200
00:09:31,610 --> 00:09:36,367
हम अधिलेखित जा रहे है
सरणी स्थान नंबर 1।

201
00:09:36,367 --> 00:09:38,950
एक तरह से छोड़ दिया गया था कि 33 तो यह है कि
उस के पीछे हम सिर्फ नाटक

202
00:09:38,950 --> 00:09:44,390
वहाँ नहीं है, हम बस जा रहे हैं
यह पीटना और वहाँ के बजाय 40 डाल दिया।

203
00:09:44,390 --> 00:09:46,290
और फिर बेशक,
हम एक धक्का दिया के बाद से,

204
00:09:46,290 --> 00:09:48,780
हम वेतन वृद्धि के लिए जा रहे हैं
1-2 ढेर के शीर्ष

205
00:09:48,780 --> 00:09:50,950
इसलिए हम अब जोड़ते हैं कि
एक और तत्व यह हूँ

206
00:09:50,950 --> 00:09:54,700
सरणी स्थान नंबर दो में चलते हैं।

207
00:09:54,700 --> 00:09:57,590
>> अब लिंक सूचियों एक और कर रहे हैं
ढेर को लागू करने का तरीका है।

208
00:09:57,590 --> 00:10:01,210
और पर इस परिभाषा यदि
स्क्रीन, यहाँ आप परिचित लग रहा है

209
00:10:01,210 --> 00:10:04,260
यह लगभग लग रहा है, क्योंकि यह है
बिल्कुल वैसा ही है, वास्तव में,

210
00:10:04,260 --> 00:10:07,790
यह बहुत ज्यादा ठीक है
एक अकेले लिंक सूची के रूप में ही,

211
00:10:07,790 --> 00:10:11,990
आप की हमारी चर्चा से याद करते हैं
अकेले एक अन्य वीडियो में सूचियों से जुड़े।

212
00:10:11,990 --> 00:10:15,510
यहां केवल प्रतिबंध
, प्रोग्रामर के रूप में हमारे लिए है

213
00:10:15,510 --> 00:10:17,900
हम करने के लिए अनुमति नहीं कर रहे
डालने या बेतरतीब ढंग से हटाना

214
00:10:17,900 --> 00:10:20,620
अकेले लिंक सूची से
हम पहले से कर सकता है।

215
00:10:20,620 --> 00:10:25,820
हम केवल अब डालने और से हटा सकते हैं
सामने या जुड़े के शीर्ष

216
00:10:25,820 --> 00:10:26,320
सूची।

217
00:10:26,320 --> 00:10:28,028
यही कारण है कि सच में ही है
फर्क है।

218
00:10:28,028 --> 00:10:29,700
यह तो एक अकेले लिंक सूची है।

219
00:10:29,700 --> 00:10:32,060
यह केवल प्रतिबंध है
खुद पर की जगह

220
00:10:32,060 --> 00:10:35,770
प्रोग्रामर के रूप में है कि
एक ढेर में बदल जाता है।

221
00:10:35,770 --> 00:10:39,280
>> यहां नियम हमेशा एक बनाए रखने के लिए है
एक लिंक सूची के सिर करने के लिए सूचक।

222
00:10:39,280 --> 00:10:41,520
यह निश्चित रूप से एक आम तौर पर है
पहली महत्वपूर्ण नियम।

223
00:10:41,520 --> 00:10:44,260
अकेले आप सूची वैसे भी जुड़ा हुआ है के लिए
केवल सिर के लिए एक संकेत की जरूरत है

224
00:10:44,260 --> 00:10:46,160
कि के क्रम में
श्रृंखला का उल्लेख करने में सक्षम हो

225
00:10:46,160 --> 00:10:48,596
हर दूसरे तत्व को
लिंक सूची में।

226
00:10:48,596 --> 00:10:50,470
लेकिन यह विशेष रूप से है
एक ढेर के साथ महत्वपूर्ण है।

227
00:10:50,470 --> 00:10:52,386
और तो आम तौर पर आप कर रहे हैं
वास्तव में चाहते करने जा

228
00:10:52,386 --> 00:10:54,090
इस सूचक एक वैश्विक चर हो।

229
00:10:54,090 --> 00:10:56,574
यह शायद करने के लिए जा रहा है
और भी आसान है कि जिस तरह से किया।

230
00:10:56,574 --> 00:10:58,240
तो धक्का और पॉप की एनालॉगों क्या कर रहे हैं?

231
00:10:58,240 --> 00:10:58,740
ठीक है।

232
00:10:58,740 --> 00:11:01,812
तो फिर आगे बढ़ाने के जोड़ने का है
ढेर करने के लिए एक नए तत्व।

233
00:11:01,812 --> 00:11:03,770
एक लिंक की गई सूची में उस
हमारे पास करने के लिए जा रहे हैं इसका मतलब

234
00:11:03,770 --> 00:11:07,770
हम कर रहे हैं कि एक नया नोड बनाने के लिए
लिंक सूची में जोड़ने के लिए जा रहा है,

235
00:11:07,770 --> 00:11:10,500
और फिर सावधान चरणों का पालन करें
हम पहले से रेखांकित किया है कि

236
00:11:10,500 --> 00:11:16,050
अकेले लिंक सूचियों में इसे जोड़ने के लिए
चेन तोड़ने के बिना श्रृंखला

237
00:11:16,050 --> 00:11:18,900
और खोने या किसी orphaning
लिंक सूची के तत्वों।

238
00:11:18,900 --> 00:11:21,820
और कहा कि मूल रूप से क्या है
पाठ की छोटी सी बूँद वहाँ सार।

239
00:11:21,820 --> 00:11:23,740
और चलो एक नजर डालते हैं
एक चित्र के रूप में इसे।

240
00:11:23,740 --> 00:11:24,823
>> तो यहाँ हमारे लिंक सूची है।

241
00:11:24,823 --> 00:11:26,620
यह समवर्ती चार तत्व शामिल हैं।

242
00:11:26,620 --> 00:11:30,420
और अधिक पूरी तरह से हमारे यहाँ है
चार तत्वों से युक्त हो चुकी है।

243
00:11:30,420 --> 00:11:36,030
और चलो अब हम कहना चाहते हैं
इस ढेर पर एक नया आइटम धक्का।

244
00:11:36,030 --> 00:11:39,792
और हम एक नया धक्का चाहते हैं
जिसका डेटा मान मद 12 है।

245
00:11:39,792 --> 00:11:41,000
वैसे तो हम क्या करने जा रहे हैं?

246
00:11:41,000 --> 00:11:43,420
अच्छी तरह से पहले हम करने जा रहे हैं
गतिशील malloc अंतरिक्ष,

247
00:11:43,420 --> 00:11:45,411
एक नए नोड के लिए जगह आवंटित।

248
00:11:45,411 --> 00:11:48,160
और निश्चित रूप से तुरंत बाद
हम हमेशा हम malloc के लिए एक फोन करना

249
00:11:48,160 --> 00:11:52,989
, अशक्त के लिए जाँच करने के लिए सुनिश्चित करें
हम वापस अशक्त मिला क्योंकि अगर

250
00:11:52,989 --> 00:11:54,280
समस्या का किसी प्रकार का था।

251
00:11:54,280 --> 00:11:57,570
हम जानते हैं कि अशक्त भिन्नता नहीं करना चाहते हैं
सूचक या आप एक SEG गलती भुगतना होगा।

252
00:11:57,570 --> 00:11:58,510
यह अच्छा नहीं है।

253
00:11:58,510 --> 00:11:59,760
इसलिए हम नोड के malloced गए हैं।

254
00:11:59,760 --> 00:12:01,260
हम यहाँ सफलता मिली है मान लेंगे।

255
00:12:01,260 --> 00:12:06,090
हम में से 12 डाल करने के लिए जा रहे हैं
उस नोड के डेटा क्षेत्र।

256
00:12:06,090 --> 00:12:11,570
अब क्या आपको याद है कि हमारे संकेत के जो
इसलिए हम श्रृंखला तोड़ नहीं है अगली चाल?

257
00:12:11,570 --> 00:12:15,100
हम यहाँ विकल्पों में से एक जोड़ी है लेकिन
सुरक्षित होने जा रहा है कि केवल एक ही

258
00:12:15,100 --> 00:12:19,330
सूचक अगले करने के लिए खबर स्थापित करने के लिए है
सूची के पुराने सिर इंगित

259
00:12:19,330 --> 00:12:21,360
या जल्दी ही हो जाएगा क्या
सूची के पुराने सिर।

260
00:12:21,360 --> 00:12:23,610
और अब के सभी कि हमारे
तत्व एक साथ जंजीर हैं,

261
00:12:23,610 --> 00:12:27,370
हम सिर्फ बात करने के लिए सूची स्थानांतरित कर सकते हैं
नई करता है कि एक ही जगह पर।

262
00:12:27,370 --> 00:12:33,550
और अब हम प्रभावी रूप से धक्का दिया है एक
ढेर के सामने पर नए तत्व।

263
00:12:33,550 --> 00:12:36,420
>> हम पॉप करने के लिए अभी करना चाहते हैं
कि पहला तत्व हटा दें।

264
00:12:36,420 --> 00:12:38,150
और तो मूल रूप से क्या
हम यहाँ क्या करना है

265
00:12:38,150 --> 00:12:40,050
अच्छी तरह से हम दूसरे तत्व खोजने के लिए है।

266
00:12:40,050 --> 00:12:43,540
अंततः है कि नए बन जाएगा
हम पहले से एक को हटाने के बाद सिर।

267
00:12:43,540 --> 00:12:47,300
तो हम बस से शुरू करने की जरूरत
शुरुआत में, एक आगे बढ़ना है।

268
00:12:47,300 --> 00:12:50,340
हम एक पर एक पकड़ मिल गया है एक बार
जहां हम के आगे वर्तमान में

269
00:12:50,340 --> 00:12:53,850
हम सुरक्षित रूप से पहले से एक को नष्ट कर सकते हैं
और फिर हम सिर्फ सिर स्थानांतरित कर सकते हैं

270
00:12:53,850 --> 00:12:57,150
क्या था को इंगित करने के लिए
अब तो दूसरे कार्यकाल और

271
00:12:57,150 --> 00:12:59,170
उस के बाद सबसे पहले है
नोड हटा दिया गया है।

272
00:12:59,170 --> 00:13:01,160
>> तो फिर, एक नज़र लेने
इस पर एक चित्र के रूप में हम

273
00:13:01,160 --> 00:13:05,022
अब एक पॉप करने के लिए करना चाहते हैं
इस ढेर के बंद तत्व।

274
00:13:05,022 --> 00:13:05,730
तो हम क्या करें?

275
00:13:05,730 --> 00:13:08,188
वैसे तो हम पहले पैदा करने के लिए जा रहे हैं
जा रहा है कि एक नया सूचक

276
00:13:08,188 --> 00:13:10,940
प्रमुख के रूप में एक ही जगह पर बात करने के लिए।

277
00:13:10,940 --> 00:13:13,790
हम इसे एक की स्थिति को स्थानांतरित करने के लिए जा रहे हैं
आगे Trav बराबरी कह कर

278
00:13:13,790 --> 00:13:17,510
उदाहरण के लिए अगले TRAV जो
Trav सूचक एक अग्रिम होगा

279
00:13:17,510 --> 00:13:19,324
आगे की स्थिति।

280
00:13:19,324 --> 00:13:21,240
अब हमें मिल गया है कि एक
पहला तत्व पर पकड़

281
00:13:21,240 --> 00:13:24,573
सूचक कहा जाता सूची, और के माध्यम से
कहा जाता है एक सूचक के माध्यम से दूसरे तत्व

282
00:13:24,573 --> 00:13:28,692
Trav, हम सुरक्षित रूप से है कि नष्ट कर सकते हैं
ढेर से पहला तत्व

283
00:13:28,692 --> 00:13:30,650
बाकी को खोने के बिना
चेन की वजह से हम

284
00:13:30,650 --> 00:13:32,358
उल्लेख करने के लिए एक रास्ता है
दूसरा तत्व को

285
00:13:32,358 --> 00:13:34,780
के रास्ते से आगे
सूचक Trav बुलाया।

286
00:13:34,780 --> 00:13:37,100
>> तो अब हम उस नोड मुक्त कर सकते हैं।

287
00:13:37,100 --> 00:13:38,404
हम सूची मुक्त कर सकते हैं।

288
00:13:38,404 --> 00:13:41,320
और फिर हम अब सब करने की ज़रूरत है
एक ही जगह पर बात करने के लिए सूची को स्थानांतरित

289
00:13:41,320 --> 00:13:44,482
कि सफर करता है, और हम की पीठ तरह कर रहे हैं
हम 12 से धक्का दे दिया इससे पहले कि हम शुरू कर दिया है, जहां

290
00:13:44,482 --> 00:13:45,690
पहले स्थान पर, सही है।

291
00:13:45,690 --> 00:13:46,940
हम कहाँ थे यह ठीक है।

292
00:13:46,940 --> 00:13:48,840
हम इस चार तत्व ढेर था।

293
00:13:48,840 --> 00:13:49,690
हम एक पांचवें गयी।

294
00:13:49,690 --> 00:13:51,910
हम एक पांचवें धक्का दिया
तत्व पर, और फिर हम

295
00:13:51,910 --> 00:13:55,980
popped कि सबसे हाल ही में
पीछे से तत्व जोड़े।

296
00:13:55,980 --> 00:13:58,816
>> यही कारण है कि बहुत ज्यादा सच है
सभी ढेर करने के लिए नहीं है।

297
00:13:58,816 --> 00:14:00,190
आप सरणियों के रूप में उन्हें लागू कर सकते हैं।

298
00:14:00,190 --> 00:14:01,815
आप लिंक सूचियों के रूप में उन्हें लागू कर सकते हैं।

299
00:14:01,815 --> 00:14:04,810
अन्य, ज़ाहिर है, कर रहे हैं
तरीके के रूप में उन्हें अच्छी तरह से लागू करने के लिए।

300
00:14:04,810 --> 00:14:09,060
हम प्रयोग करेंगे असल कारण
ढेर को इस तरह से डेटा को बनाए रखने के लिए है

301
00:14:09,060 --> 00:14:12,090
सबसे हाल ही में कहा कि
तत्व हम कर रहे हैं पहली बात यह है

302
00:14:12,090 --> 00:14:14,980
वापस पाने के लिए चाहते हो जा।

303
00:14:14,980 --> 00:14:17,900
मैं डौग लॉयड हूँ, इस CS50 है।

304
00:14:17,900 --> 00:14:19,926