1
00:00:00,000 --> 00:00:02,832
>> [संगीत बजाना]

2
00:00:02,832 --> 00:00:05,670

3
00:00:05,670 --> 00:00:08,560
>> डौग लॉयड: ठीक है, पर ऐसा
पाठ्यक्रम में इस बिंदु पर,

4
00:00:08,560 --> 00:00:15,300
हम सी के मूल के एक बहुत कुछ शामिल है
हम, चर, सरणियों के बारे में बहुत कुछ पता

5
00:00:15,300 --> 00:00:17,610
संकेत दिए गए, यह सब अच्छी चीजें।

6
00:00:17,610 --> 00:00:21,610
उन सभी तरह के निर्माण कर रहे हैं
में, बुनियादी बातों के रूप में देखने के लिए

7
00:00:21,610 --> 00:00:23,880
लेकिन हम सही, अधिक कर सकते हैं?

8
00:00:23,880 --> 00:00:27,930
हम चीजों को जोड़ सकते हैं
एक साथ रोचक तरीके से।

9
00:00:27,930 --> 00:00:31,010
>> और तो चलो शुरू करते हैं, चलो करते हैं
सी हमें देता है क्या से बाहर शाखा करने के लिए,

10
00:00:31,010 --> 00:00:35,270
और हमारे अपने डेटा बनाने के लिए शुरू
इन इमारत का उपयोग संरचनाओं

11
00:00:35,270 --> 00:00:40,590
एक साथ ब्लॉकों कुछ करने के लिए
उपयोगी है, वास्तव में मूल्यवान।

12
00:00:40,590 --> 00:00:43,420
हम यह कर सकते एक ही रास्ता है
संग्रह के बारे में बात करने के लिए।

13
00:00:43,420 --> 00:00:48,360
इसलिए अब तक हम डेटा की एक तरह लिया है
संग्रहों का प्रतिनिधित्व करने के लिए संरचना

14
00:00:48,360 --> 00:00:51,030
के मूल्यों, समान मूल्यों पसंद है।

15
00:00:51,030 --> 00:00:52,350
यही कारण है कि एक सरणी होगा।

16
00:00:52,350 --> 00:00:57,020
हम पूर्णांकों का संग्रह है, या
इतने पर अक्षर और का संग्रह।

17
00:00:57,020 --> 00:01:00,890
>> संरचनाएं भी एक डेटा की तरह कर रहे हैं
जानकारी इकट्ठा करने के लिए संरचना,

18
00:01:00,890 --> 00:01:03,220
लेकिन यह मूल्यों की तरह इकट्ठा करने के लिए नहीं है।

19
00:01:03,220 --> 00:01:08,090
यह आमतौर पर विभिन्न प्रकार के डेटा घोला जा सकता है
एक साथ एक बॉक्स के अंदर।

20
00:01:08,090 --> 00:01:10,750
लेकिन यह अपने आप में नहीं है
एक साथ श्रृंखला के लिए इस्तेमाल किया

21
00:01:10,750 --> 00:01:16,920
या एक साथ इसी तरह कनेक्ट
एक सरणी की तरह आइटम,।

22
00:01:16,920 --> 00:01:20,960
सारणियों के लिए महान हैं
तत्व को देखने, लेकिन याद

23
00:01:20,960 --> 00:01:24,262
यह बहुत मुश्किल है कि
एक सरणी में सम्मिलित करने के लिए,

24
00:01:24,262 --> 00:01:26,470
हम पर डालने रहे हैं जब तक
उस सरणी के बहुत अंत।

25
00:01:26,470 --> 00:01:29,730
>> और सबसे अच्छा उदाहरण मेरे पास है
उस के लिए प्रविष्टि तरह है।

26
00:01:29,730 --> 00:01:31,650
आप हमारे वीडियो को याद करते हैं
प्रविष्टि प्रकार पर,

27
00:01:31,650 --> 00:01:34,110
इसकी बड़ी मात्रा मौजूद थी
व्यय होने में शामिल

28
00:01:34,110 --> 00:01:37,970
तत्व उठा, और उन्हें शिफ्ट करने के लिए
कुछ फिट करने के लिए जिस तरह से बाहर

29
00:01:37,970 --> 00:01:41,290
अपने सरणी के बीच में।

30
00:01:41,290 --> 00:01:44,690
सारणियों भी दूसरे से पीड़ित
समस्या यह है कि जो दृढ़ता है।

31
00:01:44,690 --> 00:01:47,150
हम एक सरणी की घोषणा करते हैं,
हम इसे एक शॉट मिलता है।

32
00:01:47,150 --> 00:01:49,790
हम मैं चाहता हूँ, कहने के लिए मिल
यह कई तत्वों।

33
00:01:49,790 --> 00:01:51,940
100 हो सकता है, यह हो सकता है
1,000 हो सकता है, यह हो सकता है

34
00:01:51,940 --> 00:01:55,930
X उपयोगकर्ता है कि एक संख्या है, जहां एक्स होना
एक प्रॉम्प्ट पर या आदेश पर हमें दिया

35
00:01:55,930 --> 00:01:56,630
लाइन।

36
00:01:56,630 --> 00:01:59,905
>> लेकिन हम केवल इसे एक शॉट मिलता है, हम
मैं वास्तव में, तो ओह कहने के लिए नहीं मिलता

37
00:01:59,905 --> 00:02:04,360
101 की जरूरत है, या मैं एक्स प्लस 20 की जरूरत है।

38
00:02:04,360 --> 00:02:07,910
बहुत देर हो गई है, हम पहले से ही घोषित कर दिया है
सरणी, और हम 101 या प्राप्त करना चाहते हैं एक्स

39
00:02:07,910 --> 00:02:12,050
प्लस 20, हम घोषणा की है
एक पूरी तरह से अलग सरणी,

40
00:02:12,050 --> 00:02:15,540
सरणी के सभी तत्वों को कॉपी
से अधिक है, और फिर हम पर्याप्त है।

41
00:02:15,540 --> 00:02:19,880
और हम फिर से गलत कर रहे हैं तो क्या, क्या
हम वास्तव में 102, या एक्स प्लस 40 की जरूरत है,

42
00:02:19,880 --> 00:02:21,970
हम फिर से ऐसा करने के लिए है।

43
00:02:21,970 --> 00:02:26,250
इसलिए वे बहुत कड़ा हो
हमारे डेटा का आकार बदलने के लिए,

44
00:02:26,250 --> 00:02:29,360
लेकिन हम एक साथ कुछ गठबंधन
हम पहले से ही है कि मूल के

45
00:02:29,360 --> 00:02:33,230
संकेत और संरचना के बारे में सीखा है,
विशेष रूप से गतिशील स्मृति का उपयोग

46
00:02:33,230 --> 00:02:36,180
malloc साथ आवंटन, हम
एक साथ इन टुकड़ों को डाल सकते हैं

47
00:02:36,180 --> 00:02:40,960
एक नए डेटा structure-- एक बनाने के लिए
अकेले हम say-- सकता सूची से जुड़े

48
00:02:40,960 --> 00:02:45,400
कि हमें विकसित करने के लिए अनुमति देता है और
मूल्यों का एक संग्रह हटना

49
00:02:45,400 --> 00:02:48,800
और हम किसी भी बर्बाद अंतरिक्ष की जरूरत नहीं होगी।

50
00:02:48,800 --> 00:02:53,320
>> तो फिर, हम इस विचार को कहते हैं,
इस धारणा, एक लिंक सूची।

51
00:02:53,320 --> 00:02:56,320
विशेष रूप से, इस वीडियो में हम कर रहे हैं
अकेले लिंक सूची के बारे में बात कर रही है,

52
00:02:56,320 --> 00:02:59,185
और फिर एक और वीडियो हम बात करेंगे
के बारे में दोगुना लिंक सूचियों, जो

53
00:02:59,185 --> 00:03:01,560
यहाँ एक विषय पर सिर्फ एक भिन्नता है।

54
00:03:01,560 --> 00:03:05,200
लेकिन एक अकेले लिंक सूची
नोड्स के शामिल है,

55
00:03:05,200 --> 00:03:08,559
नोड्स सिर्फ एक सार term-- किया जा रहा है
यह मैं बोल रहा हूँ बस कुछ है

56
00:03:08,559 --> 00:03:10,350
इस बात का एक प्रकार है
संरचना, मूल रूप से, मैं कर रहा हूँ?

57
00:03:10,350 --> 00:03:16,190
बस इसे एक node-- और इस फोन करने वाला
नोड दो सदस्यों, या दो क्षेत्रों है।

58
00:03:16,190 --> 00:03:20,300
यह आमतौर पर एक डेटा है,
पूर्णांक, एक चरित्र नाव,

59
00:03:20,300 --> 00:03:23,790
या कुछ अन्य डेटा प्रकार हो सकता है
आप एक प्रकार डेफ के साथ परिभाषित किया है।

60
00:03:23,790 --> 00:03:29,290
और यह करने के लिए एक सूचक होता है
एक ही प्रकार के अन्य नोड।

61
00:03:29,290 --> 00:03:34,710
>> इसलिए हम के अंदर दो बातें हैं
इस नोड, डेटा और एक सूचक

62
00:03:34,710 --> 00:03:36,380
अन्य नोड के लिए।

63
00:03:36,380 --> 00:03:39,370
और अगर आप कल्पना करने के लिए शुरू करते हैं
यही नहीं, आप इसके बारे में सोच सकते हैं

64
00:03:39,370 --> 00:03:42,280
नोड्स की एक श्रृंखला की तरह है कि
एक साथ जुड़े हुए हैं।

65
00:03:42,280 --> 00:03:45,070
हम पहला नोड है, यह
डेटा, और एक सूचक होता है

66
00:03:45,070 --> 00:03:49,110
शामिल है जो दूसरे नोड के लिए
डेटा, और तीसरे नोड के लिए एक सूचक।

67
00:03:49,110 --> 00:03:52,940
और इतना है कि हम इसे एक फोन क्यों है
लिंक सूची, वे एक साथ जुड़े रहे हैं।

68
00:03:52,940 --> 00:03:56,070
>> इस खास क्या करता है
नोड संरचना की तरह लग रही है?

69
00:03:56,070 --> 00:04:01,120
ठीक है, तुम पर हमारे वीडियो से याद करते हैं
प्रकार डेफ के साथ कस्टम प्रकार परिभाषित करने,

70
00:04:01,120 --> 00:04:05,400
हम एक structure-- परिभाषित कर सकते हैं और
इस तरह एक संरचना को परिभाषित लिखें।

71
00:04:05,400 --> 00:04:11,240
संरचना sllist tyepdef, और फिर मैं कर रहा हूँ
मनमाने ढंग से यहाँ शब्द मूल्य का उपयोग

72
00:04:11,240 --> 00:04:13,891
वास्तव में किसी भी डेटा प्रकार का संकेत।

73
00:04:13,891 --> 00:04:16,890
तुम्हें पता है, एक पूर्णांक या नाव पर पारित कर सकता है
आप जो चाहे कर सकता था।

74
00:04:16,890 --> 00:04:19,389
यह सिर्फ तक ही सीमित नहीं है
पूर्णांकों, या ऐसा कुछ।

75
00:04:19,389 --> 00:04:22,790
तो मूल्य सिर्फ एक मनमाना है
फिर डेटा प्रकार, और एक सूचक

76
00:04:22,790 --> 00:04:26,310
एक ही प्रकार के अन्य नोड के लिए।

77
00:04:26,310 --> 00:04:29,690
>> अब, एक छोटे से पकड़ है
यहां एक संरचना को परिभाषित करने के साथ

78
00:04:29,690 --> 00:04:33,030
जब यह एक आत्म referential संरचना है।

79
00:04:33,030 --> 00:04:35,340
मैं एक अस्थायी के लिए है
मेरी संरचना के लिए नाम है।

80
00:04:35,340 --> 00:04:37,640
दिन के अंत में
यह स्पष्ट रूप से फोन करना चाहते हैं

81
00:04:37,640 --> 00:04:43,030
SLL नोड, कि अंततः नया है
मेरी तरह परिभाषा के भाग का नाम,

82
00:04:43,030 --> 00:04:47,450
लेकिन मैं SLL नोड का उपयोग नहीं कर सकते
इस के बीच में।

83
00:04:47,450 --> 00:04:51,430
कारण किया जा रहा है, मैं नहीं है
एक प्रकार कहा जाता SLL नोड बनाया

84
00:04:51,430 --> 00:04:55,200
मैं यहाँ इस अंतिम बिंदु मारा जब तक।

85
00:04:55,200 --> 00:04:59,720
उस बिंदु तक, मैं करने के लिए है
एक और तरीका यह डेटा प्रकार का उल्लेख करने के लिए।

86
00:04:59,720 --> 00:05:02,440
>> और यह एक आत्म है
निर्देशात्मक डेटा प्रकार।

87
00:05:02,440 --> 00:05:06,314
यह एक के एक डेटा प्रकार है
एक डेटा वाली संरचना,

88
00:05:06,314 --> 00:05:08,480
और एक अन्य के लिए एक सूचक
एक ही प्रकार की संरचना।

89
00:05:08,480 --> 00:05:11,750
इसलिए मैं उल्लेख करने के लिए सक्षम होने की जरूरत
इस डेटा प्रकार कम से कम अस्थायी रूप से,

90
00:05:11,750 --> 00:05:14,910
इसलिए यह एक अस्थायी दे रही है
संरचना sllist के नाम

91
00:05:14,910 --> 00:05:18,540
मुझे तो लगता है मैं एक चाहते कहने के लिए अनुमति देता है
एक और संरचना sllist करने के लिए सूचक,

92
00:05:18,540 --> 00:05:24,690
एक संरचना sllist स्टार, और उसके बाद
मैं परिभाषा पूरा करने के बाद,

93
00:05:24,690 --> 00:05:27,220
मैं अब इस प्रकार के एक SLL नोड कॉल कर सकते हैं।

94
00:05:27,220 --> 00:05:30,520
>> आप देख वहाँ इतना है कि क्यों
यहां एक अस्थायी नाम,

95
00:05:30,520 --> 00:05:31,879
लेकिन यहाँ एक स्थायी नाम।

96
00:05:31,879 --> 00:05:33,920
कभी-कभी आप देख सकते हैं
संरचना की परिभाषा

97
00:05:33,920 --> 00:05:36,570
उदाहरण के लिए, कि नहीं कर रहे हैं
आत्म referential, कि

98
00:05:36,570 --> 00:05:39,390
यहां एक विनिर्देशक नाम नहीं है।

99
00:05:39,390 --> 00:05:43,040
यह सिर्फ typedef struct कहेंगे
घुंघराले ब्रेस खोलने के लिए और फिर इसे परिभाषित करते हैं।

100
00:05:43,040 --> 00:05:45,620
आप कर रहे हैं लेकिन अगर संरचना आत्म है
निर्देशात्मक, यह एक है, के रूप में

101
00:05:45,620 --> 00:05:49,010
आप एक निर्दिष्ट करने की आवश्यकता
अस्थायी प्रकार का नाम।

102
00:05:49,010 --> 00:05:51,310
लेकिन अंततः, अब
हम इस किया है कि,

103
00:05:51,310 --> 00:05:53,620
हम सिर्फ उल्लेख कर सकते हैं
इन नोड्स, इन इकाइयों,

104
00:05:53,620 --> 00:05:57,900
प्रयोजनों के लिए SLL नोड्स के रूप में
इस वीडियो के बाकी की।

105
00:05:57,900 --> 00:06:00,900
>> ठीक है, तो हम कैसे पता
एक लिंक सूची नोड बनाने।

106
00:06:00,900 --> 00:06:03,240
हम परिभाषित करने के लिए पता
एक लिंक सूची नोड।

107
00:06:03,240 --> 00:06:06,670
अब, हम शुरू करने के लिए जा रहे हैं
जानकारी इकट्ठा करने के लिए उन्हें का उपयोग कर,

108
00:06:06,670 --> 00:06:10,360
आपरेशनों की एक जोड़ी है हम
समझने के लिए और के साथ काम करने की जरूरत है।

109
00:06:10,360 --> 00:06:12,860
हम बनाने के लिए पता करने की जरूरत है
पतली हवा से बाहर एक लिंक सूची।

110
00:06:12,860 --> 00:06:14,901
कोई सूची पहले से ही नहीं है,
हम एक शुरू करने के लिए चाहते हैं।

111
00:06:14,901 --> 00:06:16,960
तो हम सक्षम होने की जरूरत
एक लिंक सूची बनाने के लिए,

112
00:06:16,960 --> 00:06:19,130
हम शायद खोज करने की जरूरत
लिंक सूची के माध्यम से

113
00:06:19,130 --> 00:06:21,830
हम देख रहे हैं एक तत्व खोजने के लिए।

114
00:06:21,830 --> 00:06:24,430
हम सम्मिलित करने में सक्षम होने की जरूरत है
सूची में नई चीजों की,

115
00:06:24,430 --> 00:06:25,930
हम हमारी सूची में विकसित करने के लिए सक्षम होना चाहता हूँ।

116
00:06:25,930 --> 00:06:28,638
और इसी तरह, हम सक्षम होना चाहता हूँ
हमारी सूची से चीजों को नष्ट करने,

117
00:06:28,638 --> 00:06:30,250
हम हमारी सूची हटना करने में सक्षम होना चाहता हूँ।

118
00:06:30,250 --> 00:06:32,160
और अंत में हमारे
कार्यक्रम, विशेष रूप से

119
00:06:32,160 --> 00:06:34,550
आप हम कर रहे हैं कि याद करते हैं
गतिशील स्मृति आवंटन

120
00:06:34,550 --> 00:06:38,337
आम तौर पर इन सूचियों का निर्माण करने के लिए,
हम चाहते हैं कि स्मृति के सभी मुक्त करना चाहते हैं

121
00:06:38,337 --> 00:06:39,670
हम उसके साथ काम कर रहे हैं जब।

122
00:06:39,670 --> 00:06:44,627
और इसलिए हम एक नष्ट करने में सक्षम होने की जरूरत है
एक में पूरे लिंक सूची झपट्टा असफल।

123
00:06:44,627 --> 00:06:46,460
तो चलो के माध्यम से चलते हैं
इन कार्यों में से कुछ

124
00:06:46,460 --> 00:06:51,192
और हम उन्हें कल्पना कैसे हो सकता है,
विशेष रूप से स्यूडोकोड कोड में बात कर रही है।

125
00:06:51,192 --> 00:06:53,150
तो हम एक बनाना चाहते हैं
सूची से जुड़ा हुआ है, तो शायद हम

126
00:06:53,150 --> 00:06:56,480
एक समारोह को परिभाषित करना चाहते हैं
इस प्रोटोटाइप के साथ।

127
00:06:56,480 --> 00:07:01,690
SLL नोड स्टार, बनाते हैं, और मैं गुजर रहा हूँ
एक तर्क में, कुछ मनमाने ढंग से डेटा

128
00:07:01,690 --> 00:07:05,530
कुछ मनमाने ढंग से डेटा प्रकार की, फिर से लिखें।

129
00:07:05,530 --> 00:07:10,482
लेकिन मैं इस समारोह चाहिए returning-- रहा हूँ
एक अकेले करने के लिए, मेरे लिए एक सूचक लौटने

130
00:07:10,482 --> 00:07:11,190
लिंक सूची नोड।

131
00:07:11,190 --> 00:07:14,050
फिर, हम बनाने की कोशिश कर रहे हैं
पतली हवा से बाहर एक लिंक सूची,

132
00:07:14,050 --> 00:07:17,900
इसलिए मुझे लगता है के लिए एक संकेत की जरूरत है
मैं कर रहा हूँ कि जब सूची।

133
00:07:17,900 --> 00:07:19,420
>> यहाँ तो शामिल कदम क्या कर रहे हैं?

134
00:07:19,420 --> 00:07:20,960
खैर, जब मैं पहली बार बात कर रहा हूँ
क्या करने जा गतिशील है

135
00:07:20,960 --> 00:07:22,550
एक नए नोड के लिए जगह आवंटित।

136
00:07:22,550 --> 00:07:26,689
फिर, हम पतली से बाहर बना रहे हैं
हवा, इसलिए हम इसके लिए malloc अंतरिक्ष की जरूरत है।

137
00:07:26,689 --> 00:07:28,480
और जाहिर है, तुरंत
हम malloc के बाद,

138
00:07:28,480 --> 00:07:31,692
हम हमेशा यकीन है कि बनाने के लिए जाँच हमारी
pointer-- हम वापस अशक्त नहीं मिला।

139
00:07:31,692 --> 00:07:33,650
हम कोशिश करते हैं क्योंकि अगर और
एक शून्य सूचक सम्मान में,

140
00:07:33,650 --> 00:07:36,190
हम एक पीड़ित करने के लिए जा रहे हैं
SEGFAULT और हम नहीं चाहते कि।

141
00:07:36,190 --> 00:07:39,510
>> तो फिर हम इस क्षेत्र में भरना चाहते हैं,
हम मूल्य क्षेत्र को प्रारंभ करना चाहते हैं

142
00:07:39,510 --> 00:07:41,690
और अगले क्षेत्र को प्रारंभ।

143
00:07:41,690 --> 00:07:45,450
और फिर हम अंततः के रूप है-- चाहते हैं
हम चाहते हैं indicates-- समारोह प्रोटोटाइप

144
00:07:45,450 --> 00:07:49,940
एक SLL नोड के लिए एक सूचक लौटने के लिए।

145
00:07:49,940 --> 00:07:51,710
तो क्या इस नेत्रहीन तरह लग रही है?

146
00:07:51,710 --> 00:07:55,230
खैर, सबसे पहले हम गतिशील करने के लिए जा रहे हैं
एक नए SLL नोड के लिए जगह आवंटित,

147
00:07:55,230 --> 00:07:58,320
इसलिए हम यह है कि malloc--
एक दृश्य प्रतिनिधित्व

148
00:07:58,320 --> 00:08:00,020
नोड के हम अभी बनाया।

149
00:08:00,020 --> 00:08:02,757
और हम सुनिश्चित करने के लिए जाँच
यह इस मामले में null-- नहीं है

150
00:08:02,757 --> 00:08:04,840
तस्वीर नहीं होता
यह शून्य था, तो ऊपर दिखाया गया है,

151
00:08:04,840 --> 00:08:07,298
हम स्मृति से बाहर चला जाएगा
इसलिए हम वहाँ जाने के लिए अच्छे हैं।

152
00:08:07,298 --> 00:08:10,200
तो अब हम सी कदम पर कर रहे हैं,
नोड्स मूल्य क्षेत्र को प्रारंभ।

153
00:08:10,200 --> 00:08:12,280
खैर, इस समारोह पर आधारित
, मैं यहाँ का उपयोग कर रहा हूँ फोन

154
00:08:12,280 --> 00:08:16,700
मैं 6 में पारित करने के लिए चाहता हूँ की तरह लग रहा है,
इसलिए मैं मान क्षेत्र में 6 हूँ।

155
00:08:16,700 --> 00:08:18,865
अब, अगले क्षेत्र को प्रारंभ।

156
00:08:18,865 --> 00:08:21,640
खैर, क्या मैं वहां क्या करने जा रहा हूँ,
कुछ भी नहीं है, ठीक बगल में है,

157
00:08:21,640 --> 00:08:23,600
इस सूची में केवल एक ही चीज़ है।

158
00:08:23,600 --> 00:08:27,206
तो सूची में अगले बात क्या है?

159
00:08:27,206 --> 00:08:29,660
>> यह ठीक है, कुछ भी करने के लिए बात नहीं करना चाहिए।

160
00:08:29,660 --> 00:08:33,600
कुछ नहीं तो क्या है, और वहाँ नहीं है
हम इस बात का पता है अवधारणा nothing-- है

161
00:08:33,600 --> 00:08:35,638
कुछ भी नहीं करने के संकेत?

162
00:08:35,638 --> 00:08:37,929
यह हो सकता है कि हम चाहते हैं होना चाहिए
वहाँ एक शून्य सूचक डाल करने के लिए,

163
00:08:37,929 --> 00:08:40,178
और मैं अशक्त प्रतिनिधित्व करेंगे
, के रूप में सिर्फ एक लाल बॉक्स सूचक

164
00:08:40,178 --> 00:08:41,559
हम किसी भी आगे नहीं जा सकते।

165
00:08:41,559 --> 00:08:44,430
हम बाद में एक छोटे से देखेंगे,
हम अंततः चेन होगा

166
00:08:44,430 --> 00:08:46,330
तीरों के जोड़ने
एक साथ इन नोड्स,

167
00:08:46,330 --> 00:08:48,480
लेकिन आप जब मारा
लाल बॉक्स, कि, अशक्त है

168
00:08:48,480 --> 00:08:51,150
हम किसी भी आगे नहीं जा सकते
उस सूची के अंत में है।

169
00:08:51,150 --> 00:08:53,960
>> और अंत में, हम सिर्फ करना चाहते हैं
इस नोड के लिए एक सूचक लौट आते हैं।

170
00:08:53,960 --> 00:08:56,160
इसलिए हम नए फोन करता हूँ,
और नए वापस आ जाएगी

171
00:08:56,160 --> 00:08:59,370
तो यह किया जा सकता है
जो कुछ भी समारोह इसे बनाया।

172
00:08:59,370 --> 00:09:03,100
इसलिए हम वहाँ जाते हैं, हम एक अकेले बना लिया है
पतली हवा से बाहर लिंक सूची नोड,

173
00:09:03,100 --> 00:09:05,920
और अब हम साथ काम कर सकते हैं एक सूची है।

174
00:09:05,920 --> 00:09:08,260
>> अब, हम पहले से ही हम हम कहते हैं
एक बड़ी श्रृंखला है,

175
00:09:08,260 --> 00:09:09,800
और हम उस में कुछ खोजने के लिए चाहते हैं।

176
00:09:09,800 --> 00:09:12,716
और हम जा रहा है कि एक समारोह चाहते हैं
सही है या गलत लौटने के आधार पर करने के लिए

177
00:09:12,716 --> 00:09:15,840
एक मूल्य है कि सूची में मौजूद है पर।

178
00:09:15,840 --> 00:09:18,160
एक समारोह प्रोटोटाइप, या
उस समारोह के लिए घोषणा,

179
00:09:18,160 --> 00:09:23,320
है- मिल बूल की तरह लग रही है, और हो सकता है
फिर हम दो तर्क में पारित करने के लिए चाहते हैं।

180
00:09:23,320 --> 00:09:26,996
>> सबसे पहले, के लिए एक संकेत है
लिंक सूची के पहले तत्व।

181
00:09:26,996 --> 00:09:29,620
यह आपको हूँ वास्तव में कुछ है
हमेशा की ट्रैक रखना चाहते हैं,

182
00:09:29,620 --> 00:09:33,110
और वास्तव में कुछ हो सकता है कि
आप भी एक वैश्विक चर में डाल दिया है।

183
00:09:33,110 --> 00:09:35,360
आप एक सूची बना लेते हैं,
हमेशा हमेशा के लिए आप,

184
00:09:35,360 --> 00:09:38,990
बहुत का ट्रैक रखने के लिए चाहते हैं
सूची में सबसे पहला तत्व।

185
00:09:38,990 --> 00:09:43,690
आप अन्य सभी का उल्लेख कर सकते हैं इस तरह
सिर्फ श्रृंखला का पालन करके तत्वों,

186
00:09:43,690 --> 00:09:47,300
संकेत रखने के बिना
हर एक तत्व को बरकरार।

187
00:09:47,300 --> 00:09:50,920
आप केवल पहले का ट्रैक रखने की जरूरत है
एक वे सब एक साथ जंजीर कर रहे हैं।

188
00:09:50,920 --> 00:09:52,460
>> और फिर दूसरी बात
हम फिर से गुजर रहे हैं

189
00:09:52,460 --> 00:09:54,376
मनमाने ढंग से some-- है
जो कुछ डेटा प्रकार हम कर रहे हैं

190
00:09:54,376 --> 00:09:59,640
वहाँ के लिए देख के अंदर है
उम्मीद है कि सूची में नोड्स में से एक।

191
00:09:59,640 --> 00:10:00,980
तो कदम क्या हैं?

192
00:10:00,980 --> 00:10:04,250
खैर, हम ऐसा पहली बात है
हम एक आड़ा सूचक बनाने

193
00:10:04,250 --> 00:10:06,015
सूचियों के सिर की ओर इशारा करते।

194
00:10:06,015 --> 00:10:08,890
खैर, यही वजह है कि हम पहले से ही हम क्या करें
सूचियों के सिर पर एक सूचक है,

195
00:10:08,890 --> 00:10:10,974
यही कारण है कि हम बस के आसपास है कि एक कदम नहीं है?

196
00:10:10,974 --> 00:10:13,140
खैर, मैं सिर्फ इतना कहा की तरह,
यह हमारे लिए वास्तव में महत्वपूर्ण है

197
00:10:13,140 --> 00:10:17,580
हमेशा का ट्रैक रखने के लिए
सूची में बहुत पहले तत्व।

198
00:10:17,580 --> 00:10:21,270
और इसलिए यह वास्तव में बेहतर है
इस बात का एक डुप्लिकेट बनाने के लिए,

199
00:10:21,270 --> 00:10:25,350
और इसलिए हम कभी नहीं चारों ओर ले जाने के लिए उपयोग
गलती से दूर ले जाते हैं, या हमेशा की तरह हम

200
00:10:25,350 --> 00:10:30,430
है कि कुछ बिंदु पर एक सूचक है
सही सूची के पहले तत्व पर।

201
00:10:30,430 --> 00:10:33,290
तो यह एक बनाने के लिए बेहतर है
हम स्थानांतरित करने के लिए उपयोग किए जाने वाले दूसरे एक।

202
00:10:33,290 --> 00:10:35,877
>> तो हम बस कि क्या तुलना
उस नोड पर मूल्य क्षेत्र

203
00:10:35,877 --> 00:10:38,960
अगर यह हम देख रहे हैं, और क्या है
नहीं, हम सिर्फ अगले नोड के लिए कदम।

204
00:10:38,960 --> 00:10:41,040
और हम कर रखना है
और अधिक से अधिक और अधिक से अधिक,

205
00:10:41,040 --> 00:10:44,811
हम या तो लगता है जब तक
तत्व है, या हम मारा

206
00:10:44,811 --> 00:10:47,310
null-- हम अंत में पहुँच गए हैं
और सूची की यह वहाँ नहीं है।

207
00:10:47,310 --> 00:10:50,540
यह उम्मीद है कि एक घंटी की अंगूठी चाहिए
आप बस के रूप में रैखिक खोज,

208
00:10:50,540 --> 00:10:54,430
हम बस में नकल कर रहे हैं
एक अकेले लिंक सूची संरचना

209
00:10:54,430 --> 00:10:56,280
इसके बजाय यह करने के लिए एक सरणी का उपयोग करने का।

210
00:10:56,280 --> 00:10:58,210
>> तो यहाँ का एक उदाहरण है
एक अकेले लिंक सूची।

211
00:10:58,210 --> 00:11:00,043
यह एक के होते हैं
पाँच नोड्स, और हम

212
00:11:00,043 --> 00:11:04,330
के सिर के लिए एक सूचक
सूची कहा जाता है जो सूची।

213
00:11:04,330 --> 00:11:07,385
हम क्या करना चाहते पहली बात यह है
फिर, कि चंक्रमण सूचक पैदा करते हैं।

214
00:11:07,385 --> 00:11:09,760
तो क्या अब हम दो संकेत है
एक ही बात करने के लिए उस बिंदु।

215
00:11:09,760 --> 00:11:15,025
>> अब भी यहां नोटिस मैं नहीं था
सफर के लिए किसी भी स्थान malloc के लिए है।

216
00:11:15,025 --> 00:11:18,970
मैं Trav malloc के बराबर होती है यह नहीं कहा
कुछ है, उस नोड पहले से ही मौजूद है,

217
00:11:18,970 --> 00:11:21,160
स्मृति में है कि अंतरिक्ष में पहले से ही मौजूद है।

218
00:11:21,160 --> 00:11:24,290
इसलिए मैं वास्तव में क्या कर रहा हूँ सब है
यह करने के लिए एक और सूचक बनाने।

219
00:11:24,290 --> 00:11:28,210
मैं एक अतिरिक्त mallocing नहीं कर रहा हूँ
अंतरिक्ष, बस अब दो संकेत है

220
00:11:28,210 --> 00:11:31,370
एक ही बात की ओर इशारा करते।

221
00:11:31,370 --> 00:11:33,710
>> तो 2 के लिए मैं देख रहा हूँ क्या है?

222
00:11:33,710 --> 00:11:37,220
नहीं, ठीक है, तो बजाय मैं कर रहा हूँ
अगले एक को स्थानांतरित करने के लिए जा रहा है।

223
00:11:37,220 --> 00:11:41,740
तो बुनियादी तौर पर मैं कहना चाहूँगा
Trav अगले सफर के बराबर होती है।

224
00:11:41,740 --> 00:11:43,630
मैं नहीं, क्या देख रहा हूँ 3 है।

225
00:11:43,630 --> 00:11:45,780
तो मैं जाने के लिए जारी
के माध्यम से, अंततः जब तक

226
00:11:45,780 --> 00:11:48,690
मैं देख रहा हूँ जो है, जो 6 के लिए मिलता है
समारोह कॉल के आधार पर करने के लिए

227
00:11:48,690 --> 00:11:51,600
मैं शीर्ष पर है
वहाँ है, और इसलिए मैं कर रहा हूँ।

228
00:11:51,600 --> 00:11:54,150
>> अब, तत्व मैं क्या कर रहा हूँ
के लिए लग रही है, सूची में नहीं है

229
00:11:54,150 --> 00:11:55,510
यह अभी भी काम करने के लिए जा रहा है?

230
00:11:55,510 --> 00:11:57,120
खैर, इस सूची में है कि नोटिस
यहाँ, आसानी से अलग है

231
00:11:57,120 --> 00:11:59,410
और यह है कि एक और बात है
लिंक सूचियों के साथ महत्वपूर्ण है,

232
00:11:59,410 --> 00:12:01,780
आप को बनाए रखने की जरूरत नहीं है
उन्हें किसी विशेष क्रम में।

233
00:12:01,780 --> 00:12:05,390
अगर आप चाहते हैं, कर सकते हैं लेकिन
आप पहले से ही देखा हो सकता है

234
00:12:05,390 --> 00:12:09,310
हम का ट्रैक रखने नहीं कर रहे हैं कि
हम क्या नंबर तत्व पर हैं।

235
00:12:09,310 --> 00:12:13,150
>> और कहा कि एक व्यापार की तरह है कि हम
सरणियों छंद लिंक सूची के साथ है,

236
00:12:13,150 --> 00:12:15,300
यह हम नहीं है
अब रैंडम एक्सेस।

237
00:12:15,300 --> 00:12:18,150
हम सिर्फ मैं चाहता हूँ, यह नहीं कह सकते
0 तत्व करने के लिए जाने के लिए,

238
00:12:18,150 --> 00:12:21,410
या अपने सरणी के 6 तत्व,
जो मैं एक सरणी में कर सकते हैं।

239
00:12:21,410 --> 00:12:25,080
मैं मैं करने के लिए जाना चाहता हूँ नहीं कह सकता
0 तत्व, या 6 तत्व,

240
00:12:25,080 --> 00:12:30,360
या मेरे लिंक सूची की 25 वीं तत्व,
कोई उनके साथ जुड़े सूचकांक है।

241
00:12:30,360 --> 00:12:33,660
और तो यह वास्तव में कोई फर्क नहीं पड़ता
हम क्रम में हमारे सूची की रक्षा करते हैं।

242
00:12:33,660 --> 00:12:36,080
क्या आप चाहते हैं
निश्चित रूप से यह कर सकते हैं, लेकिन वहाँ

243
00:12:36,080 --> 00:12:38,567
वे की जरूरत है तो कोई वजह
किसी भी क्रम में संरक्षित किया।

244
00:12:38,567 --> 00:12:40,400
तो फिर, चलो कोशिश करते हैं और
इस सूची में 6 पाते हैं।

245
00:12:40,400 --> 00:12:43,200
खैर, हम पर शुरू
शुरुआत में, हम, 6 नहीं मिल रहा है

246
00:12:43,200 --> 00:12:47,690
और फिर हम नहीं मिल जारी
6, हम अंत में यहाँ करने के लिए मिलता है जब तक।

247
00:12:47,690 --> 00:12:52,790
नोड के लिए तो अभी Trav अंक
8 से युक्त है, और छह वहाँ में नहीं है।

248
00:12:52,790 --> 00:12:55,250
>> तो अगले कदम होगा
अगले सूचक पर जाने के लिए,

249
00:12:55,250 --> 00:12:57,440
इसलिए Trav अगले सफर के बराबर होती है कहना।

250
00:12:57,440 --> 00:13:00,750
खैर, सफर बगल में है, ने संकेत दिया
वहाँ लाल बॉक्स, रिक्त है।

251
00:13:00,750 --> 00:13:03,020
तो कहीं और वहाँ
तो इस बिंदु पर जाना है, और

252
00:13:03,020 --> 00:13:06,120
हम पहुँच गए हैं कि निष्कर्ष निकाल सकते हैं
लिंक सूची के अंत में,

253
00:13:06,120 --> 00:13:07,190
और 6 वहाँ में नहीं है।

254
00:13:07,190 --> 00:13:10,980
और इसे लौटा दिया जाएगा
इस मामले में झूठा।

255
00:13:10,980 --> 00:13:14,540
>> ठीक है, कैसे हम एक नए डालने हो
लिंक सूची में नोड?

256
00:13:14,540 --> 00:13:17,310
इसलिए हम बनाने के लिए सक्षम किया गया है
कहीं से भी बाहर एक लिंक सूची,

257
00:13:17,310 --> 00:13:19,370
लेकिन हम शायद करना चाहते हैं
एक श्रृंखला का निर्माण और नहीं

258
00:13:19,370 --> 00:13:22,620
अलग सूचियों का एक गुच्छा बना।

259
00:13:22,620 --> 00:13:25,700
हम एक सूची है चाहता हूँ कि
, उस में नोड्स का एक गुच्छा है

260
00:13:25,700 --> 00:13:28,040
एक नोड के साथ सूची की एक गुच्छा नहीं है।

261
00:13:28,040 --> 00:13:31,260
तो हम बस बनाने का उपयोग कर नहीं रख सकते
समारोह अब हम पहले परिभाषित हम

262
00:13:31,260 --> 00:13:33,860
एक में सम्मिलित करना चाहते हैं
पहले से ही मौजूद है कि सूची।

263
00:13:33,860 --> 00:13:36,499
>> इस मामले तो, हम जा रहे हैं
दो तर्क में पारित करने के लिए,

264
00:13:36,499 --> 00:13:39,290
उस के सिर करने के लिए सूचक
हम में जोड़ना चाहते हैं कि सूची में जुड़े।

265
00:13:39,290 --> 00:13:40,910
यह इसलिए है क्यों फिर, वह है,
महत्वपूर्ण हमेशा हम उस

266
00:13:40,910 --> 00:13:43,400
क्योंकि, इसे का ट्रैक रखने
यह वास्तव में एक ही तरीका है कि हम है

267
00:13:43,400 --> 00:13:46,690
पूरी सूची है उल्लेख करने के लिए है
सिर्फ पहला तत्व के लिए एक संकेत है।

268
00:13:46,690 --> 00:13:49,360
तो हम एक में पास करना चाहते हैं
कि पहले तत्व के लिए सूचक,

269
00:13:49,360 --> 00:13:52,226
और जो कुछ भी मूल्य हम
सूची में जोड़ना चाहते हैं।

270
00:13:52,226 --> 00:13:54,600
और अंत में इस समारोह
एक सूचक वापस करने के लिए जा रहा है

271
00:13:54,600 --> 00:13:57,980
एक लिंक सूची के नए प्रमुख के लिए।

272
00:13:57,980 --> 00:13:59,700
>> यहाँ शामिल कदम क्या हैं?

273
00:13:59,700 --> 00:14:02,249
ठीक है, बस बनाने के साथ की तरह,
हम गतिशील आवंटित की जरूरत

274
00:14:02,249 --> 00:14:05,540
एक नए नोड के लिए जगह है, और बनाने की जांच
यकीन है कि हम स्मृति से बाहर नहीं चला है, फिर से,

275
00:14:05,540 --> 00:14:07,150
हम malloc का उपयोग कर रहे हैं, क्योंकि।

276
00:14:07,150 --> 00:14:09,080
तो फिर हम आबाद करना चाहते हैं
और, नोड सम्मिलित

277
00:14:09,080 --> 00:14:12,730
इतनी संख्या में डाल दिया, जो कुछ भी
वैल नोड में है।

278
00:14:12,730 --> 00:14:17,310
हम कम से नोड सम्मिलित करना चाहते हैं
लिंक सूची की शुरुआत।

279
00:14:17,310 --> 00:14:19,619
>> एक कारण है कि मैं
ऐसा करना चाहते हैं, और यह

280
00:14:19,619 --> 00:14:21,910
एक दूसरे लेने लायक हो सकता है
यहाँ वीडियो को थामने के लिए,

281
00:14:21,910 --> 00:14:25,860
और मैं क्यों करना चाहते हैं के बारे में सोचते
एक लिंक्ड की शुरुआत में डालने

282
00:14:25,860 --> 00:14:26,589
सूची।

283
00:14:26,589 --> 00:14:28,630
फिर, जैसा कि मैंने पहले उल्लेख किया
यह सच नहीं है कि

284
00:14:28,630 --> 00:14:33,020
हम किसी में इसे संरक्षित करता है, तो कोई फर्क
आदेश है, इसलिए हो सकता है कि एक संकेत है।

285
00:14:33,020 --> 00:14:36,040
और तुम हम तो क्या होगा देखा
चाहता था है-- या सिर्फ एक दूसरे से

286
00:14:36,040 --> 00:14:37,360
पहले जब हम जा रहे थे
खोज के माध्यम से आप

287
00:14:37,360 --> 00:14:39,235
क्या हो सकता है देख सकता है
हम कोशिश कर रहे थे तो क्या

288
00:14:39,235 --> 00:14:41,330
सूची के अंत में डालने के लिए।

289
00:14:41,330 --> 00:14:44,750
हम एक नहीं है, क्योंकि
सूची के अंत करने के लिए सूचक।

290
00:14:44,750 --> 00:14:47,490
>> तो कारण है कि मैं चाहता हूँ होगा कि
शुरुआत में डालने के लिए,

291
00:14:47,490 --> 00:14:49,380
मैं तुरंत इसे कर सकते हैं क्योंकि है।

292
00:14:49,380 --> 00:14:52,730
मैं शुरुआत में एक सूचक है, और
हम एक दूसरे में एक दृश्य में यह देखेंगे।

293
00:14:52,730 --> 00:14:55,605
लेकिन मैं अंत में सम्मिलित करना चाहते हैं, तो
मैं शुरुआत में शुरू करना है

294
00:14:55,605 --> 00:14:58,760
करने के लिए सभी तरह से पार
अंत में, और फिर उस पर हमले।

295
00:14:58,760 --> 00:15:01,420
तो यह है कि इसका मतलब यह होगा
सूची के अंत में डालने

296
00:15:01,420 --> 00:15:04,140
n के एक ओ बन जाएगा
आपरेशन, वापस जा रहा

297
00:15:04,140 --> 00:15:06,720
के बारे में हमारी चर्चा करने के लिए
अभिकलनात्मक जटिलता।

298
00:15:06,720 --> 00:15:10,140
यह n आपरेशन, जहां की एक ओ हो गया था
सूची बड़ा है, और बड़ा हो गया, के रूप में

299
00:15:10,140 --> 00:15:13,310
और बड़ा है, यह और अधिक हो जाएगा और
कुछ हमले के लिए अधिक मुश्किल

300
00:15:13,310 --> 00:15:14,661
अंत में पर।

301
00:15:14,661 --> 00:15:17,410
लेकिन यह हमेशा के लिए वास्तव में आसान है
शुरुआत में पर कुछ हमले,

302
00:15:17,410 --> 00:15:19,060
आप शुरुआत में हमेशा से रहे हैं।

303
00:15:19,060 --> 00:15:21,620
>> और हम फिर से इस का एक दृश्य देखेंगे।

304
00:15:21,620 --> 00:15:24,100
और फिर हम एक बार, कर रहे हैं एक बार
हम नए नोड डाला है,

305
00:15:24,100 --> 00:15:26,880
हम करने के लिए हमारे सूचक वापसी करना चाहते हैं
एक लिंक सूची के नए प्रमुख, जो

306
00:15:26,880 --> 00:15:29,213
हम पर डालने रहे हैं के बाद
शुरुआत, वास्तव में किया जाएगा

307
00:15:29,213 --> 00:15:31,060
हम अभी बनाया नोड के लिए एक सूचक।

308
00:15:31,060 --> 00:15:33,280
है, चलो इस कल्पना करते हैं
क्योंकि मैं इसे मदद करेंगे।

309
00:15:33,280 --> 00:15:36,661
>> यहाँ तो हमारी सूची है, इसके बारे में होते हैं
चार तत्वों, एक नोड, 15 से युक्त

310
00:15:36,661 --> 00:15:38,410
जो एक नोड के लिए अंक
9 युक्त जो

311
00:15:38,410 --> 00:15:41,370
13 से युक्त एक नोड के लिए अंक,
जो युक्त एक नोड के लिए अंक

312
00:15:41,370 --> 00:15:44,840
अशक्त है जो 10,
अपनी अगली सूचक के रूप में सूचक

313
00:15:44,840 --> 00:15:47,010
इसलिए उस सूची के अंत में है।

314
00:15:47,010 --> 00:15:50,200
तो हम एक सम्मिलित करना चाहते हैं
मूल्य के साथ 12 नए नोड

315
00:15:50,200 --> 00:15:52,720
इस की शुरुआत में
सूची, हम क्या करें?

316
00:15:52,720 --> 00:15:58,770
खैर, सबसे पहले हम के लिए अंतरिक्ष malloc
नोड, और फिर हम वहाँ में 12 डाल दिया।

317
00:15:58,770 --> 00:16:02,211
>> तो अब हम पहुँच गए एक
निर्णय बिंदु, है ना?

318
00:16:02,211 --> 00:16:03,960
हम की एक जोड़ी है
संकेत है कि हम कर सकते थे

319
00:16:03,960 --> 00:16:06,770
हम पहले जो एक बढ़ना चाहिए, ले जाने के लिए?

320
00:16:06,770 --> 00:16:09,250
हम 12 बिंदु के लिए करना चाहिए
list-- के नए प्रमुख

321
00:16:09,250 --> 00:16:13,020
या मुझे माफ करना, हम 12 बनाना चाहिए
सूची के पुराने सिर को इंगित?

322
00:16:13,020 --> 00:16:15,319
या फिर हम कहना चाहिए कि
सूची में अब 12 से शुरू होता है।

323
00:16:15,319 --> 00:16:17,110
एक अंतर है
वहाँ, और हम देख लेंगे

324
00:16:17,110 --> 00:16:19,870
साथ दोनों एक दूसरे में क्या होता है।

325
00:16:19,870 --> 00:16:23,350
>> लेकिन यह एक करने के लिए सुराग
साइडबार के लिए बड़ा विषय,

326
00:16:23,350 --> 00:16:26,280
जिनमें से एक यह है कि
लिंक सूचियों के साथ trickiest बातें

327
00:16:26,280 --> 00:16:30,980
संकेत व्यवस्था करने के लिए किया जाता है
सही क्रम में।

328
00:16:30,980 --> 00:16:34,520
आप आदेश की बातें बाहर ले जाते हैं,
अगर आप गलती से समाप्त कर सकते हैं

329
00:16:34,520 --> 00:16:36,050
सूची के बाकी orphaning।

330
00:16:36,050 --> 00:16:37,300
और यहाँ इस बात का एक उदाहरण है।

331
00:16:37,300 --> 00:16:40,540
तो चलो इस विचार के साथ चलते हैं of--
खैर, हम सिर्फ 12 बना लिया है।

332
00:16:40,540 --> 00:16:43,180
हम 12 होने जा रहा है पता है
सूची के नए प्रमुख,

333
00:16:43,180 --> 00:16:47,660
और तो क्यों हम सिर्फ कदम नहीं है
सूची सूचक वहाँ बात करने के लिए।

334
00:16:47,660 --> 00:16:49,070
>> ठीक है, तो यह अच्छी बात है।

335
00:16:49,070 --> 00:16:51,560
तो अब जहां 12 अगले अंक करता है?

336
00:16:51,560 --> 00:16:54,580
मैं नेत्रहीन हम देख सकते हैं, मतलब
यह 15 के लिए बात करेंगे कि,

337
00:16:54,580 --> 00:16:57,250
मनुष्य के रूप में यह हमारे लिए वास्तव में स्पष्ट है।

338
00:16:57,250 --> 00:17:00,300
कैसे कंप्यूटर पता है?

339
00:17:00,300 --> 00:17:02,720
हम कुछ भी नहीं है
अब 15 की ओर इशारा करते, है ना?

340
00:17:02,720 --> 00:17:05,869
>> हम 15 का उल्लेख करने के लिए किसी भी क्षमता खो दिया है।

341
00:17:05,869 --> 00:17:11,460
हम नए तीर अगले बराबरी नहीं कह सकता
वहाँ कुछ भी नहीं है।

342
00:17:11,460 --> 00:17:13,510
वास्तव में, हम अनाथ कर दिया है
सूची के बाकी

343
00:17:13,510 --> 00:17:16,465
ऐसा करके, हम है
गलती से चेन टूटी हुई है।

344
00:17:16,465 --> 00:17:18,089
और हम निश्चित रूप से ऐसा करने के लिए नहीं करना चाहती।

345
00:17:18,089 --> 00:17:20,000
>> तो चलो वापस जाने के लिए और फिर से इस कोशिश करते हैं।

346
00:17:20,000 --> 00:17:24,060
हो सकता है कि सही बात करना
12 की अगली सूचक स्थापित करने के लिए है

347
00:17:24,060 --> 00:17:28,290
पहली सूची के पुराने सिर करने के लिए,
फिर हम सूची पर स्थानांतरित कर सकते हैं।

348
00:17:28,290 --> 00:17:30,420
और वास्तव में, यह है कि
सही क्रम हम उस

349
00:17:30,420 --> 00:17:32,836
हम कर रहे हैं जब पालन करने की आवश्यकता
अकेले लिंक सूची के साथ काम कर रहे हैं।

350
00:17:32,836 --> 00:17:36,460
हम हमेशा कनेक्ट करना चाहते हैं
सूची में नए तत्व,

351
00:17:36,460 --> 00:17:41,010
हम उस तरह लेने से पहले
बदलने की दिशा में महत्वपूर्ण कदम

352
00:17:41,010 --> 00:17:43,360
जहां लिंक सूची के सिर है।

353
00:17:43,360 --> 00:17:46,740
फिर, कि इस तरह के एक बुनियादी बात है,
हम इसे का ट्रैक खोना नहीं चाहते हैं।

354
00:17:46,740 --> 00:17:49,310
>> तो हम उस बनाना चाहते
सब कुछ एक साथ जंजीर है

355
00:17:49,310 --> 00:17:52,040
हम चाहते हैं कि सूचक ले जाने से पहले।

356
00:17:52,040 --> 00:17:55,300
और हां यह सही आदेश होगा,
जो सूची के लिए 12 से कनेक्ट करने के लिए है,

357
00:17:55,300 --> 00:17:57,630
तब सूची एक 12 शुरू होता है कि कहते हैं।

358
00:17:57,630 --> 00:18:00,860
हम सूची 12 में शुरू होता है कहा कि अगर और
तो, इस सूची के लिए 12 से कनेक्ट करने की कोशिश की

359
00:18:00,860 --> 00:18:02,193
हम पहले से ही क्या होता है देखा है।

360
00:18:02,193 --> 00:18:04,920
हम गलती से सूची खो देते हैं।

361
00:18:04,920 --> 00:18:06,740
>> ठीक है, तो एक और बात के बारे में बात करने के लिए।

362
00:18:06,740 --> 00:18:09,750
क्या हम से छुटकारा पाने के लिए चाहते हैं
एक पूरे पर एक बार सूची से जुड़ा हुआ?

363
00:18:09,750 --> 00:18:11,750
फिर, हम mallocing रहे
यह सब जगह है, और इसलिए हम

364
00:18:11,750 --> 00:18:13,351
हम कर रहे हैं जब यह मुक्त करने की जरूरत है।

365
00:18:13,351 --> 00:18:15,350
तो अब हम को हटाना चाहते हैं
पूरे लिंक सूची।

366
00:18:15,350 --> 00:18:16,850
खैर, हम क्या करना चाहते हैं?

367
00:18:16,850 --> 00:18:20,460
>> हम शून्य सूचक पहुँच गए हैं, तो हम
अन्यथा, बस नष्ट, बंद करना चाहते हैं

368
00:18:20,460 --> 00:18:23,420
तब सूची के बाकी है और मुझे मुक्त।

369
00:18:23,420 --> 00:18:28,890
सूची के बाकी को हटाएँ,
और फिर वर्तमान नोड मुक्त।

370
00:18:28,890 --> 00:18:32,850
जैसे कि ध्वनि करता है,
क्या तकनीक हम बात की है

371
00:18:32,850 --> 00:18:35,440
के बारे में पहले से है जैसे कि ध्वनि करता है?

372
00:18:35,440 --> 00:18:39,560
तो, बाकी सब मिटायें
वापस आते हैं और मुझे हटा दें।

373
00:18:39,560 --> 00:18:42,380
>> यही कारण है कि प्रत्यावर्तन है, हम कर दिया है
थोड़ा छोटा समस्या,

374
00:18:42,380 --> 00:18:46,910
हम हर किसी को नष्ट कह रहे हैं
वरना, तो आप मुझे हटा सकते हैं।

375
00:18:46,910 --> 00:18:50,940
और आगे सड़क के नीचे, उस नोड
बाकी सब को नष्ट, कहेगा।

376
00:18:50,940 --> 00:18:53,940
लेकिन अंत में हम के लिए मिल जाएगा
सूची रिक्त है बिंदु है, जहां

377
00:18:53,940 --> 00:18:55,310
और कहा कि अपने बेस मामला है।

378
00:18:55,310 --> 00:18:57,010
>> तो चलो इस पर एक नजर डालते हैं,
और यह काम कैसे हो सकता है।

379
00:18:57,010 --> 00:18:59,759
यहाँ तो हमारी सूची है, यह वैसा ही है
, हम बस के बारे में बात कर रहे थे की सूची

380
00:18:59,759 --> 00:19:00,980
और कदम है।

381
00:19:00,980 --> 00:19:04,200
पाठ का एक बहुत यहाँ है, लेकिन
उम्मीद है कि दृश्य में मदद मिलेगी।

382
00:19:04,200 --> 00:19:08,557
>> इसलिए हम have-- और मैं भी खींच लिया
हमारे ढेर फ्रेम उदाहरण अप

383
00:19:08,557 --> 00:19:10,890
कॉल के ढेर पर हमारे वीडियो से,
और उम्मीद है कि इस सब के

384
00:19:10,890 --> 00:19:13,260
एक साथ क्या हो रहा है आपको दिखाई देगा।

385
00:19:13,260 --> 00:19:14,510
तो यहाँ हमारे स्यूडोकोड कोड है।

386
00:19:14,510 --> 00:19:17,830
हम एक अशक्त तक पहुँच जाते हैं
सूचक, अन्यथा, बंद करो

387
00:19:17,830 --> 00:19:21,320
सूची के बाकी को नष्ट,
तो वर्तमान नोड मुक्त।

388
00:19:21,320 --> 00:19:25,700
इसलिए अभी, list--
हम कर रहे हैं कि सूचक

389
00:19:25,700 --> 00:19:28,410
में गुजर से 12 अंक नष्ट करने के लिए।

390
00:19:28,410 --> 00:19:33,340
12 एक शून्य सूचक नहीं है, इसलिए हम कर रहे हैं
सूची के बाकी को नष्ट करने के लिए जा रहा है।

391
00:19:33,340 --> 00:19:35,450
>> क्या हटा रहा है
हम में से बाकी शामिल?

392
00:19:35,450 --> 00:19:37,950
खैर, यह एक बनाने का मतलब
कह रही है, को नष्ट करने के लिए कॉल

393
00:19:37,950 --> 00:19:42,060
15 कि की शुरुआत है
हम नष्ट करना चाहते हैं सूची के बाकी।

394
00:19:42,060 --> 00:19:47,480
और तो कॉल को नष्ट करने के लिए
12 पकड़ पर किस तरह का है।

395
00:19:47,480 --> 00:19:52,690
इसके लिए इंतज़ार कर, वहां जमे हुए है
अपना काम खत्म करने के लिए, 15 को नष्ट करने के लिए कहते हैं।

396
00:19:52,690 --> 00:19:56,280
>> खैर, 15 एक शून्य सूचक नहीं है, और
इसलिए यह कहने जा रहा है, सब ठीक है,

397
00:19:56,280 --> 00:19:58,450
खैर, सूची के बाकी को हटा दें।

398
00:19:58,450 --> 00:20:00,760
सूची के बाकी शुरू होता है
9 में, और इसलिए हम सिर्फ हूँ

399
00:20:00,760 --> 00:20:04,514
आप सभी को हटा रुको जब तक कि
सामान, फिर वापस आ गया और मुझे हटा दें।

400
00:20:04,514 --> 00:20:06,680
खैर 9 अच्छी तरह से कहने जा रहा है,
मैं एक शून्य सूचक नहीं हूँ

401
00:20:06,680 --> 00:20:09,020
इसलिए यहां से बाकी सूची को हटा दें।

402
00:20:09,020 --> 00:20:11,805
और इसलिए कोशिश करते हैं और 13 को नष्ट कर।

403
00:20:11,805 --> 00:20:15,550
13, मैं शून्य सूचक नहीं हूँ, कहते हैं
एक ही बात है, यह हिरन गुजरता है।

404
00:20:15,550 --> 00:20:17,930
10, 10 शून्य सूचक नहीं है
एक शून्य सूचक होता है,

405
00:20:17,930 --> 00:20:20,200
लेकिन 10 नहीं अपने आप में एक है
अशक्त सही अब सूचक,

406
00:20:20,200 --> 00:20:22,470
और इसलिए यह भी हिरन गुजरता है।

407
00:20:22,470 --> 00:20:25,560
>> और अब, वहाँ यह अंक सूची
वास्तव में some-- से बात करेंगे

408
00:20:25,560 --> 00:20:28,710
मैं छवि में और अधिक स्थान था,
यह कुछ बेतरतीब अंतरिक्ष से बात करेंगे

409
00:20:28,710 --> 00:20:29,960
हम यह क्या है पता नहीं है।

410
00:20:29,960 --> 00:20:34,680
हालांकि यह शून्य सूचक है, सूची
सचमुच अब यह नल मान है सेट किया जाता है।

411
00:20:34,680 --> 00:20:36,820
यह सही है कि लाल बॉक्स के अंदर इशारा कर रहा है।

412
00:20:36,820 --> 00:20:39,960
हम तो, एक शून्य सूचक पहुंच गया
हम रोक सकते हैं, और हम कर रहे हैं।

413
00:20:39,960 --> 00:20:46,230
>> और इतना है कि बैंगनी रंग के फ्रेम पर now-- है
सक्रिय फ्रेम है कि stack-- के ऊपर,

414
00:20:46,230 --> 00:20:47,017
लेकिन यह हो चुका है।

415
00:20:47,017 --> 00:20:48,600
हम एक शून्य सूचक पर पहुंच गया है, बंद करो।

416
00:20:48,600 --> 00:20:51,290
हम कुछ नहीं करते हम
एक शून्य सूचक मुक्त नहीं कर सकते हैं,

417
00:20:51,290 --> 00:20:55,070
हम किसी भी malloc नहीं किया
अंतरिक्ष, और इसलिए हम कर रहे हैं।

418
00:20:55,070 --> 00:20:57,590
उस समारोह फ्रेम तो
नष्ट कर दिया है, और हम है

419
00:20:57,590 --> 00:21:00,930
हम छोड़ दिया, जहां resume-- हम उठाओ
उच्चतम अगले एक, साथ बंद जो

420
00:21:00,930 --> 00:21:02,807
यहां यह गहरे नीले रंग की फ्रेम है।

421
00:21:02,807 --> 00:21:04,390
तो हम कहाँ दूर छोड़ दिया सही उठाओ।

422
00:21:04,390 --> 00:21:06,598
हम में से बाकी के हटाए गए
सूची में पहले से ही है, तो अब हम कर रहे हैं

423
00:21:06,598 --> 00:21:08,000
वर्तमान नोड्स मुक्त करने के लिए जा रहा है।

424
00:21:08,000 --> 00:21:12,920
तो अब हम अब इस नोड मुक्त कर सकते हैं, और
हम समारोह के अंत में पहुँच गए हैं।

425
00:21:12,920 --> 00:21:16,810
और इतना है कि समारोह फ्रेम, नष्ट हो जाता है
और हम हल्के नीले रंग की एक में उठा।

426
00:21:16,810 --> 00:21:20,650
>> तो यह है कि मैं पहले से ही done-- किया है says--
सूची के बाकी को हटाने इसलिए

427
00:21:20,650 --> 00:21:23,140
वर्तमान नोड मुक्त।

428
00:21:23,140 --> 00:21:26,520
और अब पीला फ्रेम है
वापस ढेर के शीर्ष पर।

429
00:21:26,520 --> 00:21:29,655
जैसा कि आप देख और हां, तो हम अब कर रहे हैं
सही से सूची को नष्ट करने के लिए छोड़ दिया।

430
00:21:29,655 --> 00:21:33,710

431
00:21:33,710 --> 00:21:37,280
>> क्या है, हालांकि, क्या हुआ होगा
हम चीजों को गलत तरीके से किया था?

432
00:21:37,280 --> 00:21:39,410
बस हम कोशिश की, जब की तरह
एक तत्व जोड़ने के लिए।

433
00:21:39,410 --> 00:21:41,909
हम यदि चेन, गड़बड़ तो
हम संकेत कनेक्ट नहीं किया

434
00:21:41,909 --> 00:21:44,690
सही क्रम में, अगर हम
सिर्फ पहला तत्व मुक्त कर दिया,

435
00:21:44,690 --> 00:21:47,420
हम सिर्फ मुक्त कर दिया है, तो
सूची के सिर, अब हम

436
00:21:47,420 --> 00:21:49,642
उल्लेख करने के लिए कोई रास्ता नहीं है
सूची के बाकी।

437
00:21:49,642 --> 00:21:51,350
और इसलिए हम होगा
अनाथ सब कुछ,

438
00:21:51,350 --> 00:21:53,880
हम क्या होता था
एक स्मृति रिसाव बुलाया।

439
00:21:53,880 --> 00:21:56,800
आप हमारे वीडियो से याद करते हैं
गतिशील स्मृति आवंटन पर,

440
00:21:56,800 --> 00:21:58,650
कि बहुत अच्छी बात नहीं है।

441
00:21:58,650 --> 00:22:00,810
>> तो जैसा कि मैं ने कहा,
कई संचालन कर रहे हैं

442
00:22:00,810 --> 00:22:04,010
हम काम करने के लिए उपयोग करने की आवश्यकता है कि
साथ प्रभावी ढंग से सूची से जोड़ा।

443
00:22:04,010 --> 00:22:08,430
और तुम, मैं एक लोप देखा हो सकता है
एक लिंक्ड से एक भी तत्व को हटाने

444
00:22:08,430 --> 00:22:09,064
सूची।

445
00:22:09,064 --> 00:22:10,980
मैंने किया है कि कारण
यह वास्तव में किस तरह की है है

446
00:22:10,980 --> 00:22:14,360
को नष्ट करने के बारे में सोचने के लिए मुश्किल
एक अकेले से एक ही तत्व

447
00:22:14,360 --> 00:22:15,600
लिंक्ड सूची।

448
00:22:15,600 --> 00:22:19,950
हम पर छोड़ करने में सक्षम होने की जरूरत है
सूची में कुछ जो

449
00:22:19,950 --> 00:22:22,975
हम एक point-- हम करने के लिए मिल का मतलब
इस node-- हटाना चाहते हैं

450
00:22:22,975 --> 00:22:25,350
लेकिन क्रम में हम ऐसा करने के लिए
किसी भी जानकारी को खोना नहीं है,

451
00:22:25,350 --> 00:22:30,530
हम इस को जोड़ने की जरूरत
यहाँ यहाँ पर नोड।

452
00:22:30,530 --> 00:22:33,390
>> इसलिए मुझे लगता है कि शायद गलत नहीं किया
एक दृश्य के नजरिए से।

453
00:22:33,390 --> 00:22:36,830
इसलिए हम की शुरुआत में हो हमारी
सूची में, हम के माध्यम से आगे बढ़ने से कर रहे हैं

454
00:22:36,830 --> 00:22:40,510
हम इस नोड को नष्ट करना चाहते हैं।

455
00:22:40,510 --> 00:22:43,440
, हम सिर्फ यह हटाते हैं
हम श्रृंखला टूट गए हैं।

456
00:22:43,440 --> 00:22:45,950
यहीं इस नोड
बाकी सब को दर्शाता है,

457
00:22:45,950 --> 00:22:48,260
यह यहाँ पर बाहर से श्रृंखला में शामिल है।

458
00:22:48,260 --> 00:22:51,190
>> इसलिए हम वास्तव में क्या करने की जरूरत
हम इस बात के लिए प्राप्त करने के बाद,

459
00:22:51,190 --> 00:22:56,670
हम एक कदम वापस करने की जरूरत है, और है
इस नोड के लिए इस नोड पर कनेक्ट,

460
00:22:56,670 --> 00:22:58,590
इसलिए हम तो नष्ट कर सकते हैं
बीच में एक।

461
00:22:58,590 --> 00:23:02,120
लेकिन अकेले लिंक सूचियों नहीं करते
हमें पीछे की ओर जाने के लिए एक तरीका प्रदान करते हैं।

462
00:23:02,120 --> 00:23:05,160
तो हम या तो रखने की जरूरत
दो संकेत है, और उन्हें स्थानांतरित

463
00:23:05,160 --> 00:23:09,527
बंद कदम की तरह है, पीछे से एक
अन्य हमें जाना है, या एक बात करने के लिए मिल के रूप में

464
00:23:09,527 --> 00:23:11,110
और उसके बाद के माध्यम से एक और सूचक भेजें।

465
00:23:11,110 --> 00:23:13,150
और आप इसे देख सकते हैं
एक छोटी सी गड़बड़ हो सकता है।

466
00:23:13,150 --> 00:23:15,360
सौभाग्य से, हमारे पास
एक और तरीका है कि हल करने के लिए,

467
00:23:15,360 --> 00:23:17,810
जब हम दोगुना लिंक सूचियों के बारे में बात करते हैं।

468
00:23:17,810 --> 00:23:20,720
>> मैं डौग लॉयड हूँ, इस CS50 है।

469
00:23:20,720 --> 00:23:22,298