1
00:00:00,000 --> 00:00:05,204

2
00:00:05,204 --> 00:00:07,370
डौग लॉयड: तुम हो तो अगर
ढेर पर वीडियो देखा

3
00:00:07,370 --> 00:00:09,870
यह शायद महसूस करने के लिए जा रहा है
डेजा वू का एक छोटा सा की तरह।

4
00:00:09,870 --> 00:00:13,850
यह एक बहुत ही इसी तरह की अवधारणा जा रहा है
अभी इस पर एक मामूली मोड़ के साथ।

5
00:00:13,850 --> 00:00:15,530
हम कतारों के बारे में अभी बात करने के लिए जा रहे हैं।

6
00:00:15,530 --> 00:00:19,350
तो एक ढेर के समान एक कतार,
डेटा संरचना का एक और प्रकार है

7
00:00:19,350 --> 00:00:22,412
हम बनाए रखने के लिए उपयोग कर सकते हैं
एक संगठित तरीके से डेटा।

8
00:00:22,412 --> 00:00:24,120
एक ढेर के लिए इसी प्रकार,
इसे लागू किया जा सकता है,

9
00:00:24,120 --> 00:00:27,000
एक सरणी या एक लिंक सूची के रूप में।

10
00:00:27,000 --> 00:00:30,320
एक ढेर के विपरीत, नियम
हम यह निर्धारित करने के लिए उपयोग

11
00:00:30,320 --> 00:00:34,210
चीजों को जोड़ा और से हटा ले जब
एक कतार में एक छोटा सा अलग हैं।

12
00:00:34,210 --> 00:00:36,590
>> एक ढेर के विपरीत, जो
एक LIFO संरचना है,

13
00:00:36,590 --> 00:00:45,610
में पहली बार बाहर पिछले एक कतार एक फीफो है
पहली बार में संरचना, फीफो, पहली बार बाहर।

14
00:00:45,610 --> 00:00:49,320
अब आप शायद, कतारों
कतारों के लिए एक सादृश्य है।

15
00:00:49,320 --> 00:00:52,820
क्या आपने कभी सोचा पर लाइन में किया गया है
एक मनोरंजन पार्क या एक बैंक में,

16
00:00:52,820 --> 00:00:56,430
एक निष्पक्षता की तरह नहीं है,
संरचना को लागू करने।

17
00:00:56,430 --> 00:00:59,160
लाइन में पहले व्यक्ति पर
बैंक पहले व्यक्ति है

18
00:00:59,160 --> 00:01:00,760
कौन टेलर से बात करने के लिए हो जाता है।

19
00:01:00,760 --> 00:01:03,522
>> यह एक दौड़ की तरह होगा
एक ही रास्ता है, तो नीचे करने के लिए

20
00:01:03,522 --> 00:01:06,730
आप पर टेलर से बात करने के लिए मिला
बैंक लाइन में अंतिम व्यक्ति हो गया था।

21
00:01:06,730 --> 00:01:09,146
हर कोई हमेशा चाहेगा
लाइन में अंतिम व्यक्ति हो सकता है,

22
00:01:09,146 --> 00:01:12,580
और पहले व्यक्ति जो वहाँ गया था
कौन है, थोड़ी देर के लिए इंतजार कर रहा है

23
00:01:12,580 --> 00:01:14,715
घंटे के लिए हो सकता है,
और घंटे, और घंटे

24
00:01:14,715 --> 00:01:17,590
वे वास्तव में करने के लिए एक मौका है इससे पहले
बैंक में किसी भी पैसा वापस ले लें।

25
00:01:17,590 --> 00:01:22,510
और तो कतारों की तरह कर रहे हैं
निष्पक्षता संरचना को लागू करने।

26
00:01:22,510 --> 00:01:25,780
लेकिन यह जरूरी है कि इसका मतलब यह नहीं
ढेर सिर्फ एक बुरी बात कर रहे हैं कि

27
00:01:25,780 --> 00:01:28,160
कतारों ऐसा करने का एक और तरीका है कि।

28
00:01:28,160 --> 00:01:32,420
तो फिर एक कतार पहले में पहला है
बाहर, में जो पिछले एक ढेर, बनाम

29
00:01:32,420 --> 00:01:34,440
पहले बाहर।

30
00:01:34,440 --> 00:01:36,190
एक ढेर के लिए इसी प्रकार,
हम दो आपरेशन किया है

31
00:01:36,190 --> 00:01:38,470
हम कतारों पर प्रदर्शन कर सकते हैं।

32
00:01:38,470 --> 00:01:43,910
नाम जोड़ने के लिए है, जो एन्क्यू हैं
कतार के अंत करने के लिए एक नए तत्व,

33
00:01:43,910 --> 00:01:47,330
जो है और विपंक्ति,
सबसे पुराना दूर करने के लिए

34
00:01:47,330 --> 00:01:49,670
लाइन के सामने से तत्व।

35
00:01:49,670 --> 00:01:53,600
इसलिए हम तत्वों को जोड़ने के लिए जा रहे हैं
कतार के अंत पर,

36
00:01:53,600 --> 00:01:57,220
और हम तत्वों को दूर करने के लिए जा रहे हैं
लाइन के सामने से।

37
00:01:57,220 --> 00:02:00,790
फिर, ढेर के साथ, हम जोड़ रहे थे
ढेर के शीर्ष करने के लिए तत्वों

38
00:02:00,790 --> 00:02:03,380
और तत्वों को हटाने
ढेर के ऊपर से।

39
00:02:03,380 --> 00:02:07,570
एन्क्यू साथ तो, इसे जोड़ने है
सामने से हटाने के अंत।

40
00:02:07,570 --> 00:02:10,639
वहाँ के सबसे पुराने बात तो
हमेशा अगले बात है

41
00:02:10,639 --> 00:02:13,620
हम कोशिश करते हैं, तो बाहर आने के लिए
और कुछ विपंक्ति।

42
00:02:13,620 --> 00:02:18,330
>> तो फिर, कतारों के साथ, हम कर सकते हैं
सरणी आधारित कार्यान्वयन

43
00:02:18,330 --> 00:02:20,110
और लिंक्ड-सूची कार्यान्वयन आधारित है।

44
00:02:20,110 --> 00:02:24,620
हम साथ फिर से शुरू करेंगे
सरणी आधारित कार्यान्वयन।

45
00:02:24,620 --> 00:02:27,070
संरचना परिभाषा
बहुत समान दिखता है।

46
00:02:27,070 --> 00:02:30,720
हम एक और सरणी है
वहाँ डेटा प्रकार मूल्य की,

47
00:02:30,720 --> 00:02:32,690
इसलिए यह मनमाने ढंग से डेटा प्रकार पकड़ कर सकते हैं।

48
00:02:32,690 --> 00:02:35,570
हम फिर से उपयोग करने के लिए जा रहे हैं
इस उदाहरण में पूर्णांकों।

49
00:02:35,570 --> 00:02:39,830
>> और बस के साथ की तरह हमारे
सरणी आधारित ढेर कार्यान्वयन,

50
00:02:39,830 --> 00:02:42,340
हम एक का उपयोग कर रहे हैं, क्योंकि
सरणी, हम जरूरी

51
00:02:42,340 --> 00:02:46,850
कि सीमा है कि सी तरह
हम जो है, हम पर लागू करता है

52
00:02:46,850 --> 00:02:51,670
में किसी भी गतिशीलता की जरूरत नहीं है हमारी
बढ़ने और सरणी हटना करने की क्षमता।

53
00:02:51,670 --> 00:02:55,710
हम शुरुआत में फैसला करना है
चीजों की अधिकतम संख्या क्या है

54
00:02:55,710 --> 00:02:59,300
हम इस में डाल सकते हैं
कतार, और इस मामले में,

55
00:02:59,300 --> 00:03:02,070
क्षमता कुछ पाउंड होगा
हमारे कोड में लगातार परिभाषित किया।

56
00:03:02,070 --> 00:03:05,430
और इस के प्रयोजनों के लिए
वीडियो, क्षमता 10 होने जा रहा है।

57
00:03:05,430 --> 00:03:07,690
>> हम का ट्रैक रखने की जरूरत है
कतार के सामने

58
00:03:07,690 --> 00:03:11,160
इसलिए हम जो तत्व पता
हम विपंक्ति करना चाहते हैं,

59
00:03:11,160 --> 00:03:15,070
और हम भी का ट्रैक रखने की जरूरत है
कुछ तत्वों की संख्या else--

60
00:03:15,070 --> 00:03:16,690
हम अपने कतार में है।

61
00:03:16,690 --> 00:03:19,360
हम ट्रैक नहीं रख रहे हैं नोटिस
कतार के अंत की, बस

62
00:03:19,360 --> 00:03:21,150
कतार के आकार।

63
00:03:21,150 --> 00:03:24,310
और उस के लिए कारण उम्मीद है कि होगा
एक पल में एक सा साफ हो गया है।

64
00:03:24,310 --> 00:03:26,143
हम पूरा कर लें
इस प्रकार की परिभाषा

65
00:03:26,143 --> 00:03:29,080
हम एक नए डेटा प्रकार है
कतार में कहा जाता है, जो हम अब कर सकते हैं

66
00:03:29,080 --> 00:03:30,630
कि डेटा प्रकार के चर घोषणा।

67
00:03:30,630 --> 00:03:35,350
और कुछ हद तक भ्रामक, मैं तय कर लिया
, पत्र इस कतार क्यू फोन करने के लिए

68
00:03:35,350 --> 00:03:38,090
बजाय डेटा प्रकार क्यू क्यू।

69
00:03:38,090 --> 00:03:39,600
>> तो यहाँ हमारे कतार है।

70
00:03:39,600 --> 00:03:40,700
यह एक संरचना है।

71
00:03:40,700 --> 00:03:45,730
यह तीन सदस्यों या तीन में शामिल
खेतों, आकार क्षमता की एक सरणी।

72
00:03:45,730 --> 00:03:47,340
इस मामले में, क्षमता 10 है।

73
00:03:47,340 --> 00:03:49,580
और इस सरणी है
पूर्णांकों आयोजित करने जा रहा।

74
00:03:49,580 --> 00:03:55,240
हरे रंग में हमारी लाइन के सामने है,
अगले तत्व हटा दिया, और लाल रंग में किया जाना है

75
00:03:55,240 --> 00:03:58,610
कतार के आकार का हो जाएगा,
कितने तत्वों वर्तमान में कर रहे हैं

76
00:03:58,610 --> 00:04:01,190
कतार में मौजूदा।

77
00:04:01,190 --> 00:04:05,300
हम q.front बराबरी का कहना है कि यदि ऐसा है तो
0, और q.size आकार के बराबर होती है 0--

78
00:04:05,300 --> 00:04:07,120
हम उन क्षेत्रों में 0s डाल रहे हैं।

79
00:04:07,120 --> 00:04:11,070
और इस बिंदु पर, हम बहुत ज्यादा कर रहे हैं
हमारे कतार के साथ काम शुरू करने के लिए तैयार है।

80
00:04:11,070 --> 00:04:14,140
>> तो पहला ऑपरेशन हम कर सकते हैं
प्रदर्शन कुछ enqueue करने के लिए है,

81
00:04:14,140 --> 00:04:16,860
करने के लिए एक नया तत्व जोड़ने के लिए
कतार के अंत।

82
00:04:16,860 --> 00:04:19,089
खैर, हम करने के लिए क्या जरूरत है
सामान्य मामले में क्या?

83
00:04:19,089 --> 00:04:23,690
वैसे इस समारोह की जरूरत है enqueue
हमारे कतार के लिए एक सूचक को स्वीकार करने के लिए।

84
00:04:23,690 --> 00:04:26,370
फिर, हम घोषणा की थी कि अगर
विश्व स्तर पर हमारी कतार,

85
00:04:26,370 --> 00:04:29,490
हम ऐसा करने की जरूरत नहीं होगी
जरूरी है, लेकिन सामान्य तौर पर, हम

86
00:04:29,490 --> 00:04:32,330
संकेत स्वीकार करने की जरूरत
डेटा संरचनाओं के लिए

87
00:04:32,330 --> 00:04:35,040
इस तरह, अन्यथा, क्योंकि
हम हम कर रहे हैं value-- के पास से गुजर रहे हैं

88
00:04:35,040 --> 00:04:38,140
कतार की प्रतियों में से गुजर रहा है,
और इसलिए हम वास्तव में नहीं बदल रहे हैं

89
00:04:38,140 --> 00:04:41,050
हम बदलने का इरादा है कि कतार।

90
00:04:41,050 --> 00:04:44,860
>> यह करने की जरूरत है दूसरी बात यह स्वीकार है
उचित प्रकार के एक डेटा तत्व।

91
00:04:44,860 --> 00:04:46,818
फिर, इस मामले में, यह है
पूर्णांकों होने जा रहा,

92
00:04:46,818 --> 00:04:49,330
लेकिन आप मनमाने ढंग से कर सकता है
मूल्य के रूप में डेटा प्रकार की घोषणा

93
00:04:49,330 --> 00:04:51,160
और अधिक आम तौर पर इस का उपयोग करें।

94
00:04:51,160 --> 00:04:56,030
यही कारण है कि हम enqueue करना चाहते तत्व है
हम कतार के अंत में जोड़ना चाहते हैं।

95
00:04:56,030 --> 00:04:58,573
तो फिर हम वास्तव में करना चाहते हैं
कतार में है कि डेटा जगह है।

96
00:04:58,573 --> 00:05:01,490
इस मामले में, में रखकर
हमारे सरणी का सही स्थान,

97
00:05:01,490 --> 00:05:05,040
और फिर हम आकार बदलना चाहते हैं
कतार के, कितने तत्व हम

98
00:05:05,040 --> 00:05:07,050
वर्तमान में है।

99
00:05:07,050 --> 00:05:07,990
>> तो चलो शुरू हो जाओ।

100
00:05:07,990 --> 00:05:10,890
यहाँ, फिर से, सामान्य कि
प्रपत्र समारोह घोषणा

101
00:05:10,890 --> 00:05:13,980
एन्क्यू की तरह लग सकता है के लिए।

102
00:05:13,980 --> 00:05:14,910
और अब हम चले।

103
00:05:14,910 --> 00:05:18,335
के नंबर enqueue चलो
कतार में 28।

104
00:05:18,335 --> 00:05:19,460
तो हम क्या करने जा रहे हैं?

105
00:05:19,460 --> 00:05:23,390
खैर, हमारे लाइन के सामने है
0, और हमारे कतार के आकार पर

106
00:05:23,390 --> 00:05:29,680
0 पर है, और इसलिए हम शायद डाल करना चाहते हैं
सरणी तत्व संख्या में 28 नंबर

107
00:05:29,680 --> 00:05:31,124
0, है ना?

108
00:05:31,124 --> 00:05:32,540
तो क्या अब हम वहाँ में है कि रखा है।

109
00:05:32,540 --> 00:05:34,820
तो अब क्या हमें बदलने की जरूरत है?

110
00:05:34,820 --> 00:05:37,090
हम बदल नहीं करना चाहते हैं
कतार के सामने,

111
00:05:37,090 --> 00:05:40,850
हम क्या तत्व जानना चाहते हैं क्योंकि
हम बाद में विपंक्ति करने की आवश्यकता हो सकती है।

112
00:05:40,850 --> 00:05:44,020
तो कारण है कि हम सामने देखते हैं
क्या है की एक संकेत की तरह है

113
00:05:44,020 --> 00:05:46,439
सरणी में सबसे पुरानी बात है।

114
00:05:46,439 --> 00:05:49,730
खैर array-- में सबसे पुराना बात में
तथ्य यह है, सरणी में केवल एक चीज सही

115
00:05:49,730 --> 00:05:53,540
now-- है, जो 28 है
सरणी स्थान 0 पर।

116
00:05:53,540 --> 00:05:56,160
इसलिए हम नहीं करना चाहते हैं
कि, हरी संख्या में परिवर्तन

117
00:05:56,160 --> 00:05:57,910
वजह यह है कि सबसे पुराने तत्व है।

118
00:05:57,910 --> 00:06:00,510
बल्कि, हम आकार बदलना चाहते हैं।

119
00:06:00,510 --> 00:06:04,110
तो इस मामले में, हम करेंगे
1 करने के लिए आकार में वृद्धि।

120
00:06:04,110 --> 00:06:08,430
>> जहां के विचार के बारे में अब एक सामान्य प्रकार
अगले तत्व एक कतार में जाना जा रहा है

121
00:06:08,430 --> 00:06:12,310
उन दो संख्याओं को जोड़ने के लिए है
एक साथ, आगे और आकार,

122
00:06:12,310 --> 00:06:16,390
और कहा कि जहां अगले तुम्हें बताता हूँ
कतार में तत्व जाना जा रहा है।

123
00:06:16,390 --> 00:06:18,130
तो अब दूसरे नंबर enqueue करते हैं।

124
00:06:18,130 --> 00:06:20,250
33 enqueue करते हैं।

125
00:06:20,250 --> 00:06:24,480
तो 33 में जाना जा रहा है
सरणी स्थान 0 प्लस 1।

126
00:06:24,480 --> 00:06:26,840
इस मामले में तो, यह जा रहा है
सरणी स्थान 1 में जाने के लिए,

127
00:06:26,840 --> 00:06:29,500
और अब हमारे कतार के आकार 2 है।

128
00:06:29,500 --> 00:06:31,840
>> फिर, हम नहीं बदल रहे हैं
हमारी लाइन के सामने,

129
00:06:31,840 --> 00:06:34,730
28 अब भी है क्योंकि
सबसे पुराने तत्व है, और हम

130
00:06:34,730 --> 00:06:38,220
हम अंत में मिलता है जब चाहते है--
तत्वों को हटाने, dequeuing को

131
00:06:38,220 --> 00:06:43,300
इस कतार से, हम जानना चाहते हैं
जहां सबसे पुराने तत्व है।

132
00:06:43,300 --> 00:06:48,620
और इसलिए हम हमेशा बनाए रखने की जरूरत
वह यह है कि जहां से कुछ के सूचक।

133
00:06:48,620 --> 00:06:50,410
तो यह है कि 0 के लिए वहाँ क्या है।

134
00:06:50,410 --> 00:06:52,910
यही कारण है कि सामने के लिए वहाँ क्या है।

135
00:06:52,910 --> 00:06:55,022
>> एन्क्यू में की एक और तत्व, 19 दें।

136
00:06:55,022 --> 00:06:56,980
मैं आप अनुमान लगा सकते हैं यकीन
जहां 19 जाना जा रहा है।

137
00:06:56,980 --> 00:06:59,860
इस बारे में जाना जा रहा है
सरणी स्थान नंबर 2।

138
00:06:59,860 --> 00:07:01,570
यही कारण है कि 0 से अधिक 2 है।

139
00:07:01,570 --> 00:07:03,199
और अब हमारे कतार के आकार 3 है।

140
00:07:03,199 --> 00:07:04,240
हम इसे में 3 तत्व है।

141
00:07:04,240 --> 00:07:08,490
तो हम करने के लिए थे, और हम नहीं जा रहे हैं
अब ठीक करने के लिए, एक और तत्व enqueue

142
00:07:08,490 --> 00:07:11,370
यह सरणी स्थान में जाना होगा
नंबर 3, और हमारे कतार के आकार

143
00:07:11,370 --> 00:07:13,160
4 होगा।

144
00:07:13,160 --> 00:07:15,279
तो क्या अब हम कई तत्वों कतारबद्ध गए हैं।

145
00:07:15,279 --> 00:07:16,570
अब हम उन्हें दूर करने के लिए शुरू करते हैं।

146
00:07:16,570 --> 00:07:19,450
की कतार से उन्हें विपंक्ति करते हैं।

147
00:07:19,450 --> 00:07:23,340
>> तरह है, जो पॉप के समान
ढेर के लिए इस के अनुरूप की,

148
00:07:23,340 --> 00:07:26,180
विपंक्ति एक को स्वीकार करने की जरूरत है
फिर queue-- करने के लिए सूचक,

149
00:07:26,180 --> 00:07:28,140
जब तक यह विश्व स्तर पर घोषित की है।

150
00:07:28,140 --> 00:07:31,610
अब हम स्थान बदलना चाहते हैं
कतार के सामने की।

151
00:07:31,610 --> 00:07:35,050
यह एक तरह से आता है जहां यह है
खेलने में, कि सामने चर,

152
00:07:35,050 --> 00:07:37,310
हम हटाने क्योंकि एक बार
एक तत्व है, हम चाहते हैं

153
00:07:37,310 --> 00:07:40,720
अगले सबसे पुराने तत्व को स्थानांतरित करने के लिए।

154
00:07:40,720 --> 00:07:44,180
>> तो फिर हम में कमी करना चाहते हैं
कतार के आकार,

155
00:07:44,180 --> 00:07:47,130
और फिर हम मूल्य वापसी करना चाहते हैं
कि कतार से हटा दिया गया था।

156
00:07:47,130 --> 00:07:48,921
फिर, हम सिर्फ यह त्यागने के लिए नहीं करना चाहती।

157
00:07:48,921 --> 00:07:51,170
हम संभवतः निकालने रहे हैं
हम कर रहे हैं queue-- से

158
00:07:51,170 --> 00:07:54,170
हम इसके बारे में परवाह है क्योंकि यह dequeuing।

159
00:07:54,170 --> 00:08:01,080
इसलिए हम इस समारोह में वापसी करना चाहते हैं
प्रकार मूल्य के एक डेटा तत्व।

160
00:08:01,080 --> 00:08:04,360
फिर, इस मामले में, मूल्य पूर्णांक है।

161
00:08:04,360 --> 00:08:05,670
>> तो अब कुछ विपंक्ति करते हैं।

162
00:08:05,670 --> 00:08:09,310
की कतार से एक तत्व को दूर करते हैं।

163
00:08:09,310 --> 00:08:15,970
अगर हम कहते हैं पूर्णांक एक्स के बराबर होती है और क्यू, एम्परसेंड q--
फिर कि इस क्यू डेटा के लिए एक संकेत है

164
00:08:15,970 --> 00:08:20,177
structure-- क्या तत्व
dequeued होने जा रहा है?

165
00:08:20,177 --> 00:08:23,840

166
00:08:23,840 --> 00:08:29,480
इस मामले में, यह पहली बार है, क्योंकि
में पहली डेटा संरचना, फीफो बाहर,

167
00:08:29,480 --> 00:08:33,690
हम इस में डाल पहली बात
कतार में 28 था, और इसलिए इस मामले में,

168
00:08:33,690 --> 00:08:37,245
हम में से 28 लेने के लिए जा रहे हैं
जो है, जो कतार, नहीं, 19

169
00:08:37,245 --> 00:08:38,870
इस एक ढेर था कि अगर हम किया होता।

170
00:08:38,870 --> 00:08:42,220
हम कतार में से 28 लेने के लिए जा रहे हैं।

171
00:08:42,220 --> 00:08:44,960
>> हम साथ क्या किया था के लिए इसी प्रकार
एक ढेर, हम वास्तव में नहीं कर रहे हैं

172
00:08:44,960 --> 00:08:47,345
28 को नष्ट करने के लिए जा रहा
कतार से ही,

173
00:08:47,345 --> 00:08:49,470
हम बस की तरह करने के लिए जा रहे हैं
की यह वहाँ नहीं है नाटक।

174
00:08:49,470 --> 00:08:51,678
तो यह वहाँ रहने के लिए जा रहा है
स्मृति में है, लेकिन हम सिर्फ रहे हैं

175
00:08:51,678 --> 00:08:57,820
एक तरह से ले जाकर इसे नजरअंदाज करने के लिए जा रहा
हमारे क्यू डेटा के अन्य दो क्षेत्रों

176
00:08:57,820 --> 00:08:58,830
संरचना।

177
00:08:58,830 --> 00:09:00,230
हम सामने बदलने जा रहे हैं।

178
00:09:00,230 --> 00:09:04,290
Q.front अब करने जा रहा है
कि अब है, क्योंकि 1 हो

179
00:09:04,290 --> 00:09:07,740
हम में है सबसे पुरानी तत्व हमारे
कतार, हम पहले से ही 28 को हटा दिया है, क्योंकि

180
00:09:07,740 --> 00:09:10,460
जो पूर्व के सबसे पुराने तत्व था।

181
00:09:10,460 --> 00:09:13,540
>> और अब, हम बदलना चाहते हैं
कतार के आकार

182
00:09:13,540 --> 00:09:15,780
दो तत्वों के बजाय तीन करने के लिए।

183
00:09:15,780 --> 00:09:20,450
अब याद पहले जब मैंने कहा कि हम
कतार में तत्वों को जोड़ना चाहते हैं,

184
00:09:20,450 --> 00:09:26,000
हम एक सरणी स्थान में रख दिया
जो आगे और आकार का योग है।

185
00:09:26,000 --> 00:09:29,050
इस मामले में तो, हम अभी भी डाल रहे हैं
यह, कतार में अगले तत्व,

186
00:09:29,050 --> 00:09:33,360
सरणी स्थान 3, और में
हम एक दूसरे में देखेंगे।

187
00:09:33,360 --> 00:09:35,730
>> तो क्या अब हम dequeued किया है हमारी
कतार से पहले तत्व।

188
00:09:35,730 --> 00:09:36,480
चलो इसे फिर से करते हैं।

189
00:09:36,480 --> 00:09:38,696
चलो एक और दूर करते हैं
कतार से तत्व।

190
00:09:38,696 --> 00:09:42,400
सबसे पुराने मामले में, वर्तमान
तत्व सरणी स्थान 1 है।

191
00:09:42,400 --> 00:09:44,220
यही कारण है कि q.front हमें बताता है।

192
00:09:44,220 --> 00:09:46,980
यही कारण है कि हरे बॉक्स हमें बताता है कि
कि सबसे पुराना तत्व है।

193
00:09:46,980 --> 00:09:49,310
और हां, x 33 हो जाएगा।

194
00:09:49,310 --> 00:09:52,130
हम बस की तरह भूल जाओगे
33 सरणी में मौजूद है,

195
00:09:52,130 --> 00:09:55,100
और अब हम कहेंगे कि
कतार में नए सबसे पुराने तत्व

196
00:09:55,100 --> 00:09:58,900
सरणी स्थान 2, और आकार में है
तत्वों की कतार की, संख्या

197
00:09:58,900 --> 00:10:02,152
हम कतार में, 1 है।

198
00:10:02,152 --> 00:10:05,110
अब चलो कुछ enqueue है, और मैं
एक तरह से, एक दूसरे महीने में यह दूर दे दी

199
00:10:05,110 --> 00:10:10,340
लेकिन हम में से 40 डाल करना चाहते हैं
कतार, जहां 40 से जाना जा रहा है?

200
00:10:10,340 --> 00:10:12,880

201
00:10:12,880 --> 00:10:17,730
खैर हम इसे टाल दिया गया है
q.front प्लस कतार आकार में,

202
00:10:17,730 --> 00:10:20,850
और तो यह समझ में आता है
वास्तव में यहां 40 डाल दिया।

203
00:10:20,850 --> 00:10:22,840
अब कम से सूचना है कि
कुछ बिंदु, हम जा रहे हैं

204
00:10:22,840 --> 00:10:27,980
का अंत करने के लिए
क्यू के अंदर हमारे सरणी,

205
00:10:27,980 --> 00:10:32,010
लेकिन लगता है कि 28 और बाहर फीका 33--
वे तकनीकी रूप से, वास्तव में कर रहे

206
00:10:32,010 --> 00:10:33,300
खुली जगह, है ना?

207
00:10:33,300 --> 00:10:36,040
और हां, तो हम अंततः सकता है
उनका कहना है की है कि शासन

208
00:10:36,040 --> 00:10:40,390
उन दो together-- हम अंत में कर सकते हैं
क्षमता के आकार के द्वारा आधुनिक करने की जरूरत है

209
00:10:40,390 --> 00:10:41,410
इसलिए हम चारों ओर लपेट कर सकते हैं।

210
00:10:41,410 --> 00:10:43,620
>> हम तत्व करने के लिए मिलता है तो
है, हम कर रहे हैं तो 10 नंबर

211
00:10:43,620 --> 00:10:48,790
तत्व नंबर 10 में यह जगह, हम चाहते हैं
वास्तव में सरणी स्थान 0 में डाल दिया।

212
00:10:48,790 --> 00:10:50,997
और हम करने के लिए जा रहे थे
सरणी मुझे माफ location--,

213
00:10:50,997 --> 00:10:53,080
हम उन्हें एक साथ जोड़ा है, तो
और हम नंबर के लिए मिला

214
00:10:53,080 --> 00:10:56,330
हम डाल दिया जाएगा, जहां 11 होगा
यह, जो इस array-- में मौजूद नहीं है

215
00:10:56,330 --> 00:10:58,200
यह सीमा से बाहर जा रहा होगा।

216
00:10:58,200 --> 00:11:03,367
हम 10 से रक्षा मंत्रालय और डाल सकता है
यह सरणी स्थान 1 में।

217
00:11:03,367 --> 00:11:04,450
तो यह है कि कतारों काम कैसे करना है।

218
00:11:04,450 --> 00:11:08,540
वे हमेशा बाएं से जाने जा रहे हैं
सही करने के लिए और संभवतः आसपास लपेटो।

219
00:11:08,540 --> 00:11:11,280
और अगर आप वे कर रहे हैं कि पता है
पूर्ण यदि आकार, लाल बॉक्स कि,

220
00:11:11,280 --> 00:11:13,710
क्षमता के बराबर हो जाता है।

221
00:11:13,710 --> 00:11:16,720
और हम करने के लिए 40 जोड़ दिया है, ताकि बाद
कतार, अच्छी तरह से हम क्या करने की जरूरत है?

222
00:11:16,720 --> 00:11:19,890
खैर, सबसे पुराना तत्व
कतार में, अभी भी 19 है

223
00:11:19,890 --> 00:11:21,990
इसलिए हम बदल नहीं करना चाहते हैं
कतार के सामने,

224
00:11:21,990 --> 00:11:23,820
लेकिन अब हम दो हैं
कतार में तत्वों,

225
00:11:23,820 --> 00:11:28,710
और इसलिए हम बढ़ाना चाहते हैं
1-2 हमारे आकार।

226
00:11:28,710 --> 00:11:31,820
>> यही कारण है कि यह बहुत सुंदर के साथ है
सरणी आधारित कतारों के साथ काम कर रहा है,

227
00:11:31,820 --> 00:11:33,630
और ढेर के समान है,
एक रास्ता भी है

228
00:11:33,630 --> 00:11:36,450
एक लिंक सूची के रूप में एक कतार को लागू करने के लिए।

229
00:11:36,450 --> 00:11:40,150
अब इस डेटा संरचना प्रकार यदि
आप परिचित लग रहा है, यह है।

230
00:11:40,150 --> 00:11:43,780
यह एक अकेले लिंक सूची में नहीं है
यह एक दोगुना लिंक सूची है।

231
00:11:43,780 --> 00:11:46,790
और अब, एक अलग रूप में, यह है
को लागू करने के लिए वास्तव में संभव

232
00:11:46,790 --> 00:11:50,160
एक अकेले लिंक सूची के रूप में एक कतार है, लेकिन
मैं, दृश्य के बारे में सोचना

233
00:11:50,160 --> 00:11:53,350
यह वास्तव में देखने के लिए मदद कर सकता है
एक दोगुना लिंक सूची के रूप में इस।

234
00:11:53,350 --> 00:11:56,850
लेकिन यह निश्चित रूप से संभव है
एक अकेले लिंक सूची के रूप में यह करते हैं।

235
00:11:56,850 --> 00:12:00,110
>> तो चलो पर एक नज़र है
क्या इस तरह लग सकता है।

236
00:12:00,110 --> 00:12:02,750
हम enquue-- चाहते हैं
तो अब, फिर से हम कर रहे हैं

237
00:12:02,750 --> 00:12:05,360
एक लिंक्ड-सूची का उपयोग करने जा
यहां मॉडल के आधार पर।

238
00:12:05,360 --> 00:12:08,420
हम enqueue चाहते हैं, हम चाहते हैं
खैर, एक नया तत्व जोड़ने के लिए

239
00:12:08,420 --> 00:12:09,730
हमें क्या करना होगा?

240
00:12:09,730 --> 00:12:12,770
सब से पहले, ठीक है, क्योंकि
हम अंत करने के लिए जोड़ रहे हैं

241
00:12:12,770 --> 00:12:15,520
और से हटाने
शुरुआत में, हम शायद

242
00:12:15,520 --> 00:12:20,050
दोनों के लिए संकेत बनाए रखना चाहते हैं
सिर और लिंक सूची की पूंछ?

243
00:12:20,050 --> 00:12:22,660
पूंछ के लिए एक और कार्यकाल के किया जा रहा है
लिंक सूची के अंत में,

244
00:12:22,660 --> 00:12:24,496
लिंक सूची में पिछले तत्व।

245
00:12:24,496 --> 00:12:26,620
और ये, शायद होगा
फिर, हमारे लिए फायदेमंद हो सकता है

246
00:12:26,620 --> 00:12:28,477
वे वैश्विक चर रहे हैं।

247
00:12:28,477 --> 00:12:31,060
लेकिन अब हम एक नया जोड़ना चाहते हैं
तत्व हमें क्या करना है?

248
00:12:31,060 --> 00:12:35,262
क्या हम सिर्फ [? मलक?] या गतिशील
खुद के लिए हमारे नए नोड का आवंटन।

249
00:12:35,262 --> 00:12:38,220
हम किसी भी जोड़ने और फिर, जब सिर्फ पसंद
एक दोगुना लिंक सूची हम करने के लिए तत्व,

250
00:12:38,220 --> 00:12:40,410
सिर्फ of-- हल करना होगा
यहां उन पिछले तीन चरणों

251
00:12:40,410 --> 00:12:43,330
बस सब जाने के बारे में कर रहे हैं
सही तरीके से संकेत

252
00:12:43,330 --> 00:12:46,710
तो यह है कि तत्व में जोड़ा जाता है
चेन तोड़ने के बिना श्रृंखला

253
00:12:46,710 --> 00:12:49,580
या गलती किसी प्रकार का कर रही है
या दुर्घटना के किसी प्रकार का कर

254
00:12:49,580 --> 00:12:54,505
जिससे हम गलती से हो
हमारे कतार के कुछ तत्वों को अनाथ।

255
00:12:54,505 --> 00:12:55,880
यहाँ इस तरह लग सकता है।

256
00:12:55,880 --> 00:13:00,980
हम तत्व जोड़ना चाहते हैं
इस पंक्ति के अंत में 10।

257
00:13:00,980 --> 00:13:03,380
यहां के सबसे पुराने तत्व तो
सिर का प्रतिनिधित्व करती है।

258
00:13:03,380 --> 00:13:06,800
यही कारण है कि हम डाल पहले की बात है
यहाँ इस काल्पनिक कतार में।

259
00:13:06,800 --> 00:13:10,430
और पूंछ, 13, सबसे अधिक है
हाल ही में तत्व जोड़े।

260
00:13:10,430 --> 00:13:17,030
और इसलिए हम में 10 enqueue करना चाहते हैं
इस कतार में, हम 13 के बाद यह करना चाहते हैं।

261
00:13:17,030 --> 00:13:19,860
और इसलिए हम गतिशील करने के लिए जा रहे हैं
एक नए नोड के लिए जगह आवंटित

262
00:13:19,860 --> 00:13:23,280
और यह सुनिश्चित करना बातिल के लिए जाँच
हम एक स्मृति विफलता नहीं है।

263
00:13:23,280 --> 00:13:27,040
तो फिर हम करने जा रहे हैं
उस नोड में 10 जगह,

264
00:13:27,040 --> 00:13:30,030
और अब हम सावधान रहने की जरूरत
हम संकेत व्यवस्थित कैसे के बारे में

265
00:13:30,030 --> 00:13:32,180
इसलिए हम श्रृंखला तोड़ नहीं है।

266
00:13:32,180 --> 00:13:38,910
>> हम 10 के पिछले क्षेत्र सेट कर सकते हैं
पुराने पूंछ वापस करने के लिए बात करने के लिए,

267
00:13:38,910 --> 00:13:41,620
और '10 के बाद से हो जाएगा
कुछ बिंदु पर नए पूंछ

268
00:13:41,620 --> 00:13:44,459
इन सब के समय से
चेन से जुड़े हुए हैं,

269
00:13:44,459 --> 00:13:46,250
कुछ भी नहीं आ रहा है
बाद 10 अब ठीक है।

270
00:13:46,250 --> 00:13:49,880
और तो 10 की अगली सूचक
अशक्त करने के लिए बात करेंगे,

271
00:13:49,880 --> 00:13:53,580
हम है के बाद और फिर हम ऐसा करने के बाद
, श्रृंखला के लिए 10 को पीछे की ओर से जुड़ा

272
00:13:53,580 --> 00:13:57,780
हम पुराने सिर, या, बहाना ले जा सकते हैं
मुझे, कतार के पुराने पूंछ।

273
00:13:57,780 --> 00:14:02,980
कतार के पुराने अंत,
13, और यह 10 को इंगित करते हैं।

274
00:14:02,980 --> 00:14:08,220
और अब, इस बिंदु पर, हम है
इस कतार में 10 नंबर कतारबद्ध।

275
00:14:08,220 --> 00:14:14,740
अब हम क्या करने की जरूरत सिर्फ कदम है
पूंछ करने के लिए 10 के बजाय 13 को इंगित करने के लिए।

276
00:14:14,740 --> 00:14:17,630
>> Dequeuing वास्तव में है
popping के लिए बहुत समान

277
00:14:17,630 --> 00:14:21,710
है कि एक ढेर से
एक लिंक सूची के रूप में लागू

278
00:14:21,710 --> 00:14:24,040
आप ढेर वीडियो देखा है।

279
00:14:24,040 --> 00:14:27,280
हम सब करने की जरूरत पर शुरू है
शुरुआत, दूसरा तत्व मिल जाए,

280
00:14:27,280 --> 00:14:30,480
पहला तत्व मुक्त,
और फिर सिर को स्थानांतरित

281
00:14:30,480 --> 00:14:32,930
दूसरा तत्व को इंगित करने के लिए।

282
00:14:32,930 --> 00:14:37,920
शायद बेहतर यह कल्पना करने के लिए
अभी इसके बारे में अतिरिक्त स्पष्ट किया जाना है।

283
00:14:37,920 --> 00:14:39,230
तो यहाँ हमारे कतार फिर से है।

284
00:14:39,230 --> 00:14:42,600
12 सबसे पुराने तत्व है
हमारे कतार, सिर में।

285
00:14:42,600 --> 00:14:46,210
10 नवीनतम तत्व है
हमारे कतार, हमारी पूंछ में।

286
00:14:46,210 --> 00:14:49,310
>> और इसलिए हम चाहते हैं कि जब
एक तत्व विपंक्ति करने के लिए,

287
00:14:49,310 --> 00:14:52,202
हम सबसे पुराने तत्व हटाना चाहते हैं।

288
00:14:52,202 --> 00:14:52,910
तो हम क्या करें?

289
00:14:52,910 --> 00:14:55,243
खैर, हम एक चंक्रमण सूचक सेट
कि, सिर में शुरू होता है

290
00:14:55,243 --> 00:14:57,840
और हम तो यह है कि यह कदम है यह
दूसरा तत्व के लिए अंक

291
00:14:57,840 --> 00:15:02,290
इस बात का सफर कह कर कुछ queue--
Trav अगले तीर के बराबर होती है, उदाहरण के लिए,

292
00:15:02,290 --> 00:15:07,170
को इंगित करने के लिए वहाँ Trav ले जाया जाएगा
हम 12 विपंक्ति के बाद जो, 15,,

293
00:15:07,170 --> 00:15:13,030
हम 12 निकालने के बाद या होगा,
तत्कालीन सबसे पुराने तत्व बन जाते हैं।

294
00:15:13,030 --> 00:15:16,360
>> अब हम पहले पर एक पकड़ मिल गया है
सूचक सिर के माध्यम से तत्व

295
00:15:16,360 --> 00:15:19,440
और दूसरा तत्व
सूचक Trav के माध्यम से।

296
00:15:19,440 --> 00:15:25,170
हम अब स्वतंत्र सिर कर सकते हैं, और फिर हम कर सकते हैं
कुछ भी नहीं अब और 15 से पहले आता है।

297
00:15:25,170 --> 00:15:29,990
इसलिए हम 15 के पिछले बदल सकते हैं
सूचक अशक्त करने के लिए बात करने के लिए,

298
00:15:29,990 --> 00:15:31,874
और हम सिर्फ सिर पर ले जाते हैं।

299
00:15:31,874 --> 00:15:32,540
और वहाँ हम चले।

300
00:15:32,540 --> 00:15:35,840
अब हम सफलतापूर्वक
12 dequeued, और अब हम

301
00:15:35,840 --> 00:15:39,180
4 तत्वों का एक और कतार है।

302
00:15:39,180 --> 00:15:41,700
यही कारण है कि बहुत ज्यादा सब है
, कतारों को देखते है

303
00:15:41,700 --> 00:15:45,810
दोनों सरणी आधारित और लिंक्ड-सूची के आधार पर।

304
00:15:45,810 --> 00:15:46,860
मैं डौग लॉयड हूँ।

305
00:15:46,860 --> 00:15:49,100
इस सीएस 50 है।

306
00:15:49,100 --> 00:15:50,763