1
00:00:07,260 --> 00:00:10,050
[Powered by Google Translate] प्रोग्रामिंग में, हम अक्सर मूल्यों की सूची का प्रतिनिधित्व करने की जरूरत है,

2
00:00:10,050 --> 00:00:12,840
इस तरह के एक खंड में छात्रों के नाम के रूप में

3
00:00:12,840 --> 00:00:15,100
या नवीनतम प्रश्नोत्तरी पर अपने स्कोर.

4
00:00:15,100 --> 00:00:17,430
>> सी भाषा में घोषणा की, arrays इस्तेमाल किया जा सकता है

5
00:00:17,430 --> 00:00:19,160
सूची की दुकान.

6
00:00:19,160 --> 00:00:21,200
यह आसान है एक सूची के तत्वों की गणना

7
00:00:21,200 --> 00:00:23,390
एक सरणी में संग्रहीत किया जाता है, और अगर आप का उपयोग करने की आवश्यकता है

8
00:00:23,390 --> 00:00:25,050
या ith सूची तत्व को संशोधित

9
00:00:25,050 --> 00:00:27,570
कुछ मनमाने ढंग से सूचकांक के लिए मैं,

10
00:00:27,570 --> 00:00:29,910
कि लगातार समय में किया जा सकता है,

11
00:00:29,910 --> 00:00:31,660
arrays लेकिन नुकसान भी है.

12
00:00:31,660 --> 00:00:33,850
>> जब हम उन्हें घोषित, हम कहने के लिए की आवश्यकता हो

13
00:00:33,850 --> 00:00:35,900
ऊपर सामने कितना बड़ा वे कर रहे हैं,

14
00:00:35,900 --> 00:00:38,160
कि है, वे कितने तत्वों स्टोर कर सकते हैं

15
00:00:38,160 --> 00:00:40,780
और कितना बड़ा इन तत्वों रहे हैं, जो अपने प्रकार से निर्धारित होता है.

16
00:00:40,780 --> 00:00:45,450
उदाहरण के लिए, int आगमन (10)

17
00:00:45,450 --> 00:00:48,220
10 वस्तुओं की दुकान कर सकते हैं

18
00:00:48,220 --> 00:00:50,200
कि एक int के आकार के होते हैं.

19
00:00:50,200 --> 00:00:52,590
>> हम घोषणा के बाद एक सरणी के आकार को बदल नहीं सकते.

20
00:00:52,590 --> 00:00:55,290
हम एक नई सरणी बनाने के लिए है अगर हम और अधिक तत्वों को संग्रहीत करना चाहते हैं.

21
00:00:55,290 --> 00:00:57,410
कारण इस सीमा मौजूद है कि हमारे

22
00:00:57,410 --> 00:00:59,040
कार्यक्रम पूरे सरणी भंडार

23
00:00:59,040 --> 00:01:02,310
स्मृति का एक सन्निहित हिस्सा के रूप में.

24
00:01:02,310 --> 00:01:04,500
कहते हैं इस बफर जहां हम हमारे सरणी में संग्रहीत है.

25
00:01:04,500 --> 00:01:06,910
वहाँ अन्य चर हो सकता है

26
00:01:06,910 --> 00:01:08,310
सही सरणी के लिए बगल में स्थित

27
00:01:08,310 --> 00:01:10,060
स्मृति में है, तो हम नहीं कर सकते

28
00:01:10,060 --> 00:01:12,060
बस सरणी बड़ा बनाने के लिए.

29
00:01:12,060 --> 00:01:15,700
>> कभी कभी हम सरणी तेजी से डेटा का उपयोग गति व्यापार करना चाहते हैं

30
00:01:15,700 --> 00:01:17,650
एक छोटे से अधिक लचीलेपन के लिए.

31
00:01:17,650 --> 00:01:20,380
लिंक सूची, एक और बुनियादी डेटा संरचना दर्ज करें

32
00:01:20,380 --> 00:01:22,360
आप के रूप से परिचित नहीं हो सकता है.

33
00:01:22,360 --> 00:01:24,200
एक उच्च स्तर पर,

34
00:01:24,200 --> 00:01:26,840
एक लिंक सूची नोड्स के एक दृश्य में स्टोर डाटा

35
00:01:26,840 --> 00:01:29,280
कि लिंक के साथ एक दूसरे से जुड़े हुए हैं,

36
00:01:29,280 --> 00:01:31,760
इसलिए नाम 'लिंक सूची है.'

37
00:01:31,760 --> 00:01:33,840
जैसा कि हम देखेंगे, डिजाइन में इस अंतर

38
00:01:33,840 --> 00:01:35,500
अलग फायदे और नुकसान के लिए ले जाता है

39
00:01:35,500 --> 00:01:37,000
एक सरणी से.

40
00:01:37,000 --> 00:01:39,840
>> यहाँ पूर्णांकों की एक बहुत ही सरल लिंक सूची के लिए कुछ सी कोड है.

41
00:01:39,840 --> 00:01:42,190
आप देख सकते हैं कि हम प्रत्येक नोड का प्रतिनिधित्व किया है

42
00:01:42,190 --> 00:01:45,520
जिसमें 2 बातें एक struct के रूप में सूची में,

43
00:01:45,520 --> 00:01:47,280
स्टोर करने के लिए पूर्णांक 'वैल' कहा जाता है

44
00:01:47,280 --> 00:01:50,460
और सूची में अगले नोड के लिए एक कड़ी

45
00:01:50,460 --> 00:01:52,990
जो हम एक बुलाया सूचक के रूप में प्रतिनिधित्व करते हैं 'अगले.'

46
00:01:54,120 --> 00:01:56,780
इस तरह, हम पूरी सूची को ट्रैक कर सकते हैं

47
00:01:56,780 --> 00:01:58,790
सिर्फ 1 नोड के लिए एक ही सूचक के साथ,

48
00:01:58,790 --> 00:02:01,270
और फिर हम अगले संकेत का पालन कर सकते हैं

49
00:02:01,270 --> 00:02:03,130
2 नोड के लिए,

50
00:02:03,130 --> 00:02:05,280
3 नोड के लिए,

51
00:02:05,280 --> 00:02:07,000
4 नोड के लिए,

52
00:02:07,000 --> 00:02:09,889
और इतने पर, जब तक हम सूची के अंत करने के लिए मिलता है.

53
00:02:10,520 --> 00:02:12,210
>> आप 1 लाभ यह है देखने में सक्षम हो सकता है

54
00:02:12,210 --> 00:02:14,490
स्थैतिक सरणी संरचना पर एक लिंक सूची के साथ,

55
00:02:14,490 --> 00:02:16,450
हम स्मृति का एक बड़ा हिस्सा पूरी तरह जरूरत नहीं है.

56
00:02:17,400 --> 00:02:20,530
सूची के 1 नोड स्मृति में इस स्थान पर रह सकता है,

57
00:02:20,530 --> 00:02:23,160
और 2 नोड यहाँ पर सभी तरह का हो सकता है.

58
00:02:23,160 --> 00:02:25,780
हम सभी नोड्स के लिए कोई फर्क नहीं पड़ता कि वे कहाँ स्मृति में कर सकते हैं,

59
00:02:25,780 --> 00:02:28,890
क्योंकि 1 नोड में शुरू, प्रत्येक नोड अगले सूचक

60
00:02:28,890 --> 00:02:31,700
वास्तव में हमें बताता जहां अगले जाना.

61
00:02:31,700 --> 00:02:33,670
>> इसके अतिरिक्त, हम करने के लिए सामने कहने की ज़रूरत नहीं

62
00:02:33,670 --> 00:02:36,740
कितना बड़ा एक लिंक सूची हम स्थिर arrays के साथ करते हो जाएगा,

63
00:02:36,740 --> 00:02:39,060
के बाद से हम एक सूची नोड्स जोड़ने रख सकते हैं

64
00:02:39,060 --> 00:02:42,600
के रूप में लंबे समय के रूप में वहाँ अंतरिक्ष नए नोड्स के लिए स्मृति में कहीं है.

65
00:02:42,600 --> 00:02:45,370
इसलिए, लिंक सूचियों गतिशील का आकार बदलने के लिए आसान कर रहे हैं.

66
00:02:45,370 --> 00:02:47,950
कहते हैं, बाद में इस कार्यक्रम में हम अधिक नोड्स जोड़ने की जरूरत

67
00:02:47,950 --> 00:02:49,350
हमारी सूची में.

68
00:02:49,350 --> 00:02:51,480
हमारी सूची में मक्खी पर एक नया नोड सम्मिलित करने के लिए,

69
00:02:51,480 --> 00:02:53,740
हम सभी को करना है कि नोड के लिए स्मृति आवंटित है,

70
00:02:53,740 --> 00:02:55,630
डेटा मूल्य में खटखटाने से,

71
00:02:55,630 --> 00:02:59,070
और फिर यह जगह है जहाँ हम उपयुक्त संकेत का समायोजन करके चाहते.

72
00:02:59,070 --> 00:03:02,310
>> उदाहरण के लिए, अगर हम करने के लिए बीच में एक नोड जगह चाहता था

73
00:03:02,310 --> 00:03:04,020
सूची के 2 और 3 नोड्स,

74
00:03:04,020 --> 00:03:06,800
 हम 2 या 3 नोड्स सब पर स्थानांतरित करने के लिए नहीं होता.

75
00:03:06,800 --> 00:03:09,190
हम कहते हैं कि हम इस लाल नोड डालने रहे हैं.

76
00:03:09,190 --> 00:03:12,890
सब हम करना चाहते हैं नए नोड अगले सूचक सेट कर दिया जाता है

77
00:03:12,890 --> 00:03:14,870
3 नोड को इंगित करने के लिए

78
00:03:14,870 --> 00:03:18,580
और फिर अगले 2 नोड सूचक rewire

79
00:03:18,580 --> 00:03:20,980
हमारे नए नोड को इंगित.

80
00:03:22,340 --> 00:03:24,370
तो, हम मक्खी पर हमारी सूची का आकार बदल सकते हैं

81
00:03:24,370 --> 00:03:26,090
के बाद से हमारे कंप्यूटर अनुक्रमण पर भरोसा नहीं करता,

82
00:03:26,090 --> 00:03:28,990
बल्कि संकेत का उपयोग करने के लिए उन्हें स्टोर जोड़ने पर.

83
00:03:29,120 --> 00:03:31,600
>> हालांकि, एक नुकसान से जुड़े सूची

84
00:03:31,600 --> 00:03:33,370
है कि, एक स्थिर सरणी के विपरीत,

85
00:03:33,370 --> 00:03:36,690
कंप्यूटर सिर्फ सूची के बीच करने के लिए कूद नहीं कर सकता.

86
00:03:38,040 --> 00:03:40,780
चूंकि कंप्यूटर लिंक की गई सूची में प्रत्येक नोड पर जाएँ

87
00:03:40,780 --> 00:03:42,330
अगले एक करने के लिए मिलता है,

88
00:03:42,330 --> 00:03:44,770
यह अब लेने के लिए एक विशेष नोड को खोजने के लिए जा रहा है

89
00:03:44,770 --> 00:03:46,400
यह एक सरणी में से.

90
00:03:46,400 --> 00:03:48,660
पार पूरी सूची समय लेता है आनुपातिक

91
00:03:48,660 --> 00:03:50,580
सूची की लंबाई

92
00:03:50,580 --> 00:03:54,630
या O (n) उपगामी संकेतन में.

93
00:03:54,630 --> 00:03:56,510
औसत पर, किसी भी नोड तक पहुँचने

94
00:03:56,510 --> 00:03:58,800
भी समय लगता है पता करने के लिए आनुपातिक है.

95
00:03:58,800 --> 00:04:00,700
>> अब, हम वास्तव में कुछ कोड लिखने

96
00:04:00,700 --> 00:04:02,000
कि लिंक सूचियों के साथ काम करता है.

97
00:04:02,000 --> 00:04:04,220
हम कहते हैं कि हम पूर्णांकों की एक लिंक सूची चाहते हैं.

98
00:04:04,220 --> 00:04:06,140
हम हमारी सूची में फिर से एक नोड का प्रतिनिधित्व कर सकते हैं

99
00:04:06,140 --> 00:04:08,340
2 क्षेत्रों के साथ एक struct के रूप में,

100
00:04:08,340 --> 00:04:10,750
एक पूर्णांक 'वैल' नामक मूल्य

101
00:04:10,750 --> 00:04:13,490
और सूची के अगले नोड के लिए एक अगली सूचक.

102
00:04:13,490 --> 00:04:15,660
खैर, काफी सरल लगता है.

103
00:04:15,660 --> 00:04:17,220
>> हम कहते हैं कि हम करने के लिए एक समारोह लिखने के लिए चाहते हैं

104
00:04:17,220 --> 00:04:19,329
जो बहती है और सूची से बाहर प्रिंट

105
00:04:19,329 --> 00:04:22,150
मूल्य सूची के अंतिम नोड में संग्रहीत.

106
00:04:22,150 --> 00:04:24,850
खैर, इसका मतलब है कि हम सूची में सभी नोड्स पार की आवश्यकता होगी

107
00:04:24,850 --> 00:04:27,310
पिछले एक मिल जाए, लेकिन जब से हम नहीं जोड़ रहे हैं

108
00:04:27,310 --> 00:04:29,250
या कुछ भी को हटाने, हम बदलने के लिए नहीं करना चाहती

109
00:04:29,250 --> 00:04:32,210
सूची में अगले संकेत की आंतरिक संरचना.

110
00:04:32,210 --> 00:04:34,790
>> तो, हम एक सूचक चंक्रमण के लिए विशेष रूप से की आवश्यकता होगी

111
00:04:34,790 --> 00:04:36,940
जिसे हम 'क्रॉलर.' फोन करता हूँ

112
00:04:36,940 --> 00:04:38,870
यह सूची के सभी तत्वों के माध्यम से क्रॉल जाएगा

113
00:04:38,870 --> 00:04:41,190
अगले संकेत की श्रृंखला के बाद.

114
00:04:41,190 --> 00:04:43,750
हम सभी संग्रहीत है 1 नोड के लिए एक सूचक है,

115
00:04:43,750 --> 00:04:45,730
या सूची के 'सर'.

116
00:04:45,730 --> 00:04:47,370
1 नोड के लिए प्रमुख अंक.

117
00:04:47,370 --> 00:04:49,120
यह सूचक नोड प्रकार का है.

118
00:04:49,120 --> 00:04:51,280
>> सूची में वास्तविक 1 नोड प्राप्त करने के लिए,

119
00:04:51,280 --> 00:04:53,250
हम भिन्नता यह सूचक है,

120
00:04:53,250 --> 00:04:55,100
लेकिन इससे पहले कि हम यह भिन्नता कर सकते हैं, हम करने के लिए जांच की जरूरत है

121
00:04:55,100 --> 00:04:57,180
अगर सूचक अशक्त 1 है.

122
00:04:57,180 --> 00:04:59,190
यदि यह रिक्त है, सूची खाली है,

123
00:04:59,190 --> 00:05:01,320
और हम एक संदेश है कि, क्योंकि सूची खाली है प्रिंट चाहिए,

124
00:05:01,320 --> 00:05:03,250
वहाँ कोई अंतिम नोड है.

125
00:05:03,250 --> 00:05:05,190
लेकिन, हम कहते हैं कि सूची खाली नहीं है.

126
00:05:05,190 --> 00:05:08,340
यदि ऐसा नहीं है, तो हम पूरी सूची के माध्यम से क्रॉल चाहिए

127
00:05:08,340 --> 00:05:10,440
जब तक हम सूची में अंतिम नोड मिल,

128
00:05:10,440 --> 00:05:13,030
और हम कैसे बता सकते हैं अगर हम सूची में अंतिम नोड में देख रहे हैं?

129
00:05:13,670 --> 00:05:16,660
>> खैर, अगर एक नोड अगले सूचक अशक्त है,

130
00:05:16,660 --> 00:05:18,320
हम जानते हैं कि हम अंत में कर रहे हैं

131
00:05:18,320 --> 00:05:22,390
के बाद से पिछले अगले सूचक सूची में कोई अगले नोड के लिए बिंदु होगा.

132
00:05:22,390 --> 00:05:26,590
यह अच्छा अभ्यास है हमेशा पिछले नोड अगले अशक्त initialized सूचक रखने

133
00:05:26,590 --> 00:05:30,800
एक मानकीकृत संपत्ति है जो हमें सचेतक जब हम सूची के अंत तक पहुँच है.

134
00:05:30,800 --> 00:05:33,510
>> तो, अगर क्रॉलर → अगले रिक्त है,

135
00:05:34,120 --> 00:05:38,270
याद है कि तीर वाक्यविन्यास dereferencing के लिए एक शॉर्टकट है

136
00:05:38,270 --> 00:05:40,010
एक struct के लिए एक सूचक है, तब तक पहुँचने

137
00:05:40,010 --> 00:05:42,510
अपनी अगली अजीब के बराबर क्षेत्र:

138
00:05:42,510 --> 00:05:48,750
(क्रॉलर *) अगले.

139
00:05:49,820 --> 00:05:51,260
एक बार जब हम पिछले नोड पाया है,

140
00:05:51,260 --> 00:05:53,830
हम क्रॉलर → वैल प्रिंट चाहते हैं,

141
00:05:53,830 --> 00:05:55,000
वर्तमान नोड में मूल्य

142
00:05:55,000 --> 00:05:57,130
हम जानते हैं जो पिछले एक है.

143
00:05:57,130 --> 00:05:59,740
अन्यथा, अगर हम अभी तक सूची में अंतिम नोड में नहीं कर रहे हैं,

144
00:05:59,740 --> 00:06:02,340
हम सूची में अगले नोड के लिए आगे बढ़ना है

145
00:06:02,340 --> 00:06:04,750
और जांच अगर है कि पिछले एक है.

146
00:06:04,750 --> 00:06:07,010
ऐसा करने के लिए, हम सिर्फ हमारे क्रॉलर सूचक सेट

147
00:06:07,010 --> 00:06:09,840
लिए वर्तमान नोड के अगले मान बिंदु,

148
00:06:09,840 --> 00:06:11,680
कि है, सूची में अगले नोड.

149
00:06:11,680 --> 00:06:13,030
इस सेटिंग के द्वारा किया जाता है

150
00:06:13,030 --> 00:06:15,280
क्रॉलर = क्रॉलर अगला →.

151
00:06:16,050 --> 00:06:18,960
तो फिर हम उदाहरण के लिए एक पाश के साथ इस प्रक्रिया को दोहराने के लिए,

152
00:06:18,960 --> 00:06:20,960
जब तक हम पिछले नोड लगता है.

153
00:06:20,960 --> 00:06:23,150
तो, उदाहरण के लिए, अगर क्रॉलर सिर की ओर इशारा करते हुए किया गया था,

154
00:06:24,050 --> 00:06:27,710
हम क्रॉलर सेट क्रॉलर → अगले बात,

155
00:06:27,710 --> 00:06:30,960
जो 1 नोड के अगले क्षेत्र के रूप में एक ही है.

156
00:06:30,960 --> 00:06:33,620
तो, अब हमारे क्रॉलर 2 नोड को इशारा कर रहा है,

157
00:06:33,620 --> 00:06:35,480
और, फिर से, हम एक पाश के साथ यह दोहरा,

158
00:06:37,220 --> 00:06:40,610
जब तक हम पिछले नोड पाया है, कि है,

159
00:06:40,610 --> 00:06:43,640
नोड अगले सूचक अशक्त करने के लिए जहां इशारा कर रहा है.

160
00:06:43,640 --> 00:06:45,070
और वहाँ हम यह है,

161
00:06:45,070 --> 00:06:47,620
हम पिछले नोड सूची में पाया है, और अपने मूल्य मुद्रित,

162
00:06:47,620 --> 00:06:50,800
हम सिर्फ क्रॉलर → वैल का उपयोग करें.

163
00:06:50,800 --> 00:06:53,130
>> Traversing इतना बुरा नहीं है, लेकिन क्या डालने के बारे में?

164
00:06:53,130 --> 00:06:56,290
आओ हम कहते हैं कि हम 4 की स्थिति में एक पूर्णांक सम्मिलित करना चाहते हैं

165
00:06:56,290 --> 00:06:58,040
एक पूर्णांक सूची में.

166
00:06:58,040 --> 00:07:01,280
कि वर्तमान 3 और 4 नोड्स के बीच है.

167
00:07:01,280 --> 00:07:03,760
फिर, हम सूची में सिर्फ पार

168
00:07:03,760 --> 00:07:06,520
3 तत्व है, एक के बाद हम डालने रहे हैं मिलता है.

169
00:07:06,520 --> 00:07:09,300
तो, हम एक क्रॉलर संकेतक को फिर से बनाने के लिए सूची को पार करने के लिए,

170
00:07:09,300 --> 00:07:11,400
अगर हमारे सिर सूचक अशक्त है,

171
00:07:11,400 --> 00:07:14,810
और अगर ऐसा नहीं है, सिर नोड में हमारे क्रॉलर सूचक बिंदु.

172
00:07:16,880 --> 00:07:18,060
तो, हम 1 तत्व पर कर रहे हैं.

173
00:07:18,060 --> 00:07:21,020
हम आगे 2 अधिक तत्वों को जाने से पहले हम सम्मिलित कर सकते हैं,

174
00:07:21,020 --> 00:07:23,390
तो हम एक पाश के लिए उपयोग कर सकते हैं

175
00:07:23,390 --> 00:07:26,430
int i = 1; i <3, मैं + +

176
00:07:26,430 --> 00:07:28,590
और लूप के प्रत्येक चलना में,

177
00:07:28,590 --> 00:07:31,540
1 नोड द्वारा हमारे क्रॉलर सूचक आगे अग्रिम

178
00:07:31,540 --> 00:07:34,570
द्वारा जाँच अगर वर्तमान नोड अगले क्षेत्र रिक्त है,

179
00:07:34,570 --> 00:07:37,550
और अगर ऐसा नहीं है, अगले नोड के लिए हमारे क्रॉलर संकेतक चाल

180
00:07:37,550 --> 00:07:41,810
यह वर्तमान नोड अगले सूचक के लिए बराबर की स्थापना से.

181
00:07:41,810 --> 00:07:45,210
तो, के बाद से हमारे पाश के लिए क्या करना है कि कहते हैं

182
00:07:45,210 --> 00:07:47,550
दो बार,

183
00:07:49,610 --> 00:07:51,190
हम 3 नोड पहुँच गए हैं,

184
00:07:51,190 --> 00:07:53,110
और एक बार हमारे क्रॉलर सूचक नोड के बाद तक पहुँच गया है

185
00:07:53,110 --> 00:07:55,270
जो हम करने के लिए हमारी नई पूर्णांक सम्मिलित करना चाहते हैं,

186
00:07:55,270 --> 00:07:57,050
हम वास्तव में कैसे डालने करते हैं?

187
00:07:57,050 --> 00:07:59,440
>> खैर, हमारे नए पूर्णांक सूची में डाला जा सकता है

188
00:07:59,440 --> 00:08:01,250
अपने स्वयं के नोड struct के भाग के रूप में,

189
00:08:01,250 --> 00:08:03,140
क्योंकि यह वास्तव में नोड्स के एक दृश्य है.

190
00:08:03,140 --> 00:08:05,690
तो, चलो नोड के लिए एक नया सूचक

191
00:08:05,690 --> 00:08:08,910
'new_node,' कहा जाता है

192
00:08:08,910 --> 00:08:11,800
और इसे स्थापित करने के लिए स्मृति का कहना है कि हम अब आवंटित

193
00:08:11,800 --> 00:08:14,270
नोड खुद के लिए ढेर पर,

194
00:08:14,270 --> 00:08:16,000
और हम कितना स्मृति आवंटित की जरूरत है?

195
00:08:16,000 --> 00:08:18,250
खैर, एक नोड के आकार,

196
00:08:20,450 --> 00:08:23,410
और हम पूर्णांक है कि हम सम्मिलित करना चाहते करने के लिए अपने वैल क्षेत्र स्थापित करना चाहते हैं.

197
00:08:23,410 --> 00:08:25,590
चलो कहना है, 6.

198
00:08:25,590 --> 00:08:27,710
अब, नोड हमारे पूर्णांक मान शामिल हैं.

199
00:08:27,710 --> 00:08:30,650
यह भी अच्छा अभ्यास करने के लिए नए नोड अगले क्षेत्र इनिशियलाइज़

200
00:08:30,650 --> 00:08:33,690
को अशक्त बिंदु,

201
00:08:33,690 --> 00:08:35,080
लेकिन अब क्या?

202
00:08:35,080 --> 00:08:37,179
>> हम सूची की आंतरिक संरचना को बदलने के लिए है

203
00:08:37,179 --> 00:08:40,409
और अगले मौजूदा सूची में निहित संकेत

204
00:08:40,409 --> 00:08:42,950
3 और 4 नोड्स.

205
00:08:42,950 --> 00:08:46,560
चूंकि अगले संकेत सूची के क्रम का निर्धारण करने के लिए,

206
00:08:46,560 --> 00:08:48,650
और जब से हम हमारे नए नोड डालने रहे हैं

207
00:08:48,650 --> 00:08:50,510
सही सूची के बीच में,

208
00:08:50,510 --> 00:08:52,010
यह थोड़ा मुश्किल हो सकता है.

209
00:08:52,010 --> 00:08:54,250
इस वजह से, याद है, हमारे कंप्यूटर

210
00:08:54,250 --> 00:08:56,250
सूची में केवल नोड्स के स्थान जानता

211
00:08:56,250 --> 00:09:00,400
अगले पिछले नोड्स में संग्रहीत संकेत की वजह से.

212
00:09:00,400 --> 00:09:03,940
तो, अगर हम कभी भी इन स्थानों में से किसी का ट्रैक खो दिया है,

213
00:09:03,940 --> 00:09:06,860
हमारी सूची में अगले संकेत की बदलती करके कहते हैं,

214
00:09:06,860 --> 00:09:09,880
उदाहरण के लिए कहते हैं, हम बदल

215
00:09:09,880 --> 00:09:12,920
3 नोड अगले क्षेत्र

216
00:09:12,920 --> 00:09:15,610
यहाँ पर कुछ नोड को इंगित.

217
00:09:15,610 --> 00:09:17,920
हम भाग्य से बाहर हो सकता है, क्योंकि हम नहीं चाहते

218
00:09:17,920 --> 00:09:20,940
जहां सूची के बाकी खोजने के लिए किसी भी विचार है,

219
00:09:20,940 --> 00:09:23,070
और जाहिर है कि वास्तव में बुरा है.

220
00:09:23,070 --> 00:09:25,080
तो, हम वास्तव में आदेश के बारे में सावधान रहना होगा

221
00:09:25,080 --> 00:09:28,360
जिसमें हम प्रविष्टि के दौरान हमारी अगली संकेत हेरफेर.

222
00:09:28,360 --> 00:09:30,540
>> तो, इस सरल, चलो का कहना है कि

223
00:09:30,540 --> 00:09:32,220
हमारे 1 4 नोड्स

224
00:09:32,220 --> 00:09:36,200
कर रहे हैं ए, बी, सी, और डी संकेत के श्रृंखला का प्रतिनिधित्व तीर के साथ कहा जाता है,

225
00:09:36,200 --> 00:09:38,070
कि नोड्स कनेक्ट.

226
00:09:38,070 --> 00:09:40,050
तो, हम हमारे नए नोड डालने की जरूरत है

227
00:09:40,050 --> 00:09:42,070
नोड्स सी और डी के बीच में

228
00:09:42,070 --> 00:09:45,060
यह यह सही क्रम में करने के लिए महत्वपूर्ण है, और मैं तुम्हें दिखाता हूँ क्यों.

229
00:09:45,060 --> 00:09:47,500
>> चलो गलत रास्ते पर यह पहली बार ऐसा देखने.

230
00:09:47,500 --> 00:09:49,490
अरे, हम जानते नए नोड सी के बाद सही आ गया है,

231
00:09:49,490 --> 00:09:51,910
तो चलो सी अगले सूचक सेट

232
00:09:51,910 --> 00:09:54,700
करने के लिए new_node बिंदु.

233
00:09:56,530 --> 00:09:59,180
सब ठीक है, ठीक लगता है, हम अभी तक अब तक खत्म कर दिया है

234
00:09:59,180 --> 00:10:01,580
विकास के लिए नए नोड अगले सूचक बिंदु बना रही है,

235
00:10:01,580 --> 00:10:03,250
लेकिन रुकिए, कैसे हम कि कर सकते हैं?

236
00:10:03,250 --> 00:10:05,170
केवल एक चीज है कि हमें बताओ जहां विकास था सकता है,

237
00:10:05,170 --> 00:10:07,630
अगले सूचक पहले सी में संग्रहीत,

238
00:10:07,630 --> 00:10:09,870
लेकिन हम सिर्फ इतना है कि सूचक rewrote

239
00:10:09,870 --> 00:10:11,170
नए नोड को इंगित करने के लिए,

240
00:10:11,170 --> 00:10:14,230
तो हम अब कोई सुराग जहां विकास स्मृति में है,

241
00:10:14,230 --> 00:10:17,020
और हम सूची के बाकी खो दिया है.

242
00:10:17,020 --> 00:10:19,000
सभी में अच्छा नहीं है.

243
00:10:19,000 --> 00:10:21,090
>> तो, हम कैसे यह सही है?

244
00:10:22,360 --> 00:10:25,090
पहला, नए नोड डी. में अगले सूचक बिंदु

245
00:10:26,170 --> 00:10:28,990
अब, दोनों नए नोड और सी अगले संकेत

246
00:10:28,990 --> 00:10:30,660
उसी नोड, डी की ओर इशारा करते हुए कर रहे हैं,

247
00:10:30,660 --> 00:10:32,290
लेकिन वह ठीक है.

248
00:10:32,290 --> 00:10:35,680
अब हम सी नई नोड पर अगले सूचक बात कर सकते हैं.

249
00:10:37,450 --> 00:10:39,670
तो, हम किसी भी डेटा को खोने के बिना यह किया है.

250
00:10:39,670 --> 00:10:42,280
कोड में, सी वर्तमान नोड

251
00:10:42,280 --> 00:10:45,540
कि चंक्रमण सूचक क्रॉलर इशारा कर रहा है,

252
00:10:45,540 --> 00:10:50,400
और विकास नोड वर्तमान नोड अगले क्षेत्र द्वारा की ओर इशारा द्वारा प्रतिनिधित्व किया है,

253
00:10:50,400 --> 00:10:52,600
या क्रॉलर → अगले.

254
00:10:52,600 --> 00:10:55,460
तो, हम 1 नए नोड अगले सूचक सेट

255
00:10:55,460 --> 00:10:57,370
क्रॉलर → अगले बात है,

256
00:10:57,370 --> 00:11:00,880
उसी तरह हम कहा new_node अगले सूचक चाहिए

257
00:11:00,880 --> 00:11:02,780
चित्रण में विकास के लिए इशारा करते हैं.

258
00:11:02,780 --> 00:11:04,540
तो, हम वर्तमान नोड अगले सूचक सेट कर सकते हैं

259
00:11:04,540 --> 00:11:06,330
हमारे नए नोड के लिए,

260
00:11:06,330 --> 00:11:10,980
बस के रूप में हम करने के लिए बात करने के लिए सी ड्राइंग में new_node इंतजार करना पड़ा.

261
00:11:10,980 --> 00:11:12,250
अब सब कुछ क्रम में है, और हम खोना नहीं था

262
00:11:12,250 --> 00:11:14,490
किसी भी डेटा का ट्रैक, और हम सिर्फ करने में सक्षम थे

263
00:11:14,490 --> 00:11:16,200
सूची के बीच में हमारे नए नोड छड़ी

264
00:11:16,200 --> 00:11:19,330
पूरी बात पुनर्निर्माण या यहां तक ​​कि किसी भी तत्व स्थानांतरण के बिना

265
00:11:19,330 --> 00:11:22,490
जिस तरह से हम एक निश्चित - लम्बाई सरणी के साथ होता था.

266
00:11:22,490 --> 00:11:26,020
>> तो, लिंक सूचियों एक बुनियादी है, लेकिन महत्वपूर्ण, गतिशील डेटा संरचना

267
00:11:26,020 --> 00:11:29,080
जो दोनों के फायदे और नुकसान

268
00:11:29,080 --> 00:11:31,260
arrays और अन्य डेटा संरचनाओं की तुलना में,

269
00:11:31,260 --> 00:11:33,350
और के रूप में अक्सर कंप्यूटर विज्ञान में मामला है,

270
00:11:33,350 --> 00:11:35,640
यह जानना महत्वपूर्ण है कि जब प्रत्येक उपकरण का उपयोग करने के लिए,

271
00:11:35,640 --> 00:11:37,960
ताकि आप सही काम के लिए सही उपकरण चुन सकते हैं.

272
00:11:37,960 --> 00:11:40,060
>> अधिक अभ्यास के लिए, कार्य लिखने की कोशिश

273
00:11:40,060 --> 00:11:42,080
एक लिंक सूची से नोड्स नष्ट -

274
00:11:42,080 --> 00:11:44,050
जिस क्रम में आप को पुनर्व्यवस्थित करने के बारे में सावधान रहने की याद

275
00:11:44,050 --> 00:11:47,430
अपने अगले संकेत करने के लिए सुनिश्चित करें कि आप अपनी सूची का एक हिस्सा खोना नहीं है -

276
00:11:47,430 --> 00:11:50,200
या एक समारोह के लिए एक लिंक सूची में नोड्स गिनती

277
00:11:50,200 --> 00:11:53,280
या एक मजाक, एक लिंक सूची में नोड्स के सभी के आदेश रिवर्स.

278
00:11:53,280 --> 00:11:56,090
>> मेरा नाम जैक्सन STEINKAMP है, इस CS50 है.