1
00:00:00,000 --> 00:00:00,500

2
00:00:00,500 --> 00:00:01,900
[संगीत बजाना]

3
00:00:01,900 --> 00:00:05,710

4
00:00:05,710 --> 00:00:09,150
>> डौग लॉयड: अब तक आप
सरणियों बारे में बहुत कुछ पता है,

5
00:00:09,150 --> 00:00:11,610
और आप लिंक सूचियों के बारे में बहुत कुछ पता है।

6
00:00:11,610 --> 00:00:13,650
और हम चर्चा है
पेशेवरों और विपक्ष, हम है

7
00:00:13,650 --> 00:00:16,620
सूचियों जुड़ा हुआ है कि चर्चा की
बड़े और छोटे प्राप्त कर सकते हैं,

8
00:00:16,620 --> 00:00:18,630
लेकिन वे और अधिक आकार ले।

9
00:00:18,630 --> 00:00:22,359
सारणियों और अधिक सरल करने के लिए कर रहे हैं
उपयोग करते हैं, लेकिन वे के रूप में ज्यादा में प्रतिबंधात्मक रहे

10
00:00:22,359 --> 00:00:24,900
हम का आकार निर्धारित करने के लिए है
बहुत शुरुआत में सरणी

11
00:00:24,900 --> 00:00:26,910
और फिर हम इसके साथ अटक कर रहे हैं।

12
00:00:26,910 --> 00:00:30,470
>> लेकिन यह है कि हम बहुत ज्यादा है, है
हमारे विषयों के सभी थक

13
00:00:30,470 --> 00:00:33,040
लिंक सूचियों और सरणियों के बारे में।

14
00:00:33,040 --> 00:00:34,950
या हम है?

15
00:00:34,950 --> 00:00:37,720
शायद हम कुछ कर सकते हैं
यहां तक ​​कि अधिक रचनात्मक।

16
00:00:37,720 --> 00:00:40,950
और उधार देता है कि तरह
एक हैश तालिका का विचार है।

17
00:00:40,950 --> 00:00:46,680
>> तो एक हैश तालिका में हम कोशिश करने के लिए जा रहे हैं
एक लिंक सूची के साथ एक सरणी गठबंधन।

18
00:00:46,680 --> 00:00:49,520
हम लाभ लेने के लिए जा रहे हैं
सरणी की, रैंडम एक्सेस की तरह,

19
00:00:49,520 --> 00:00:53,510
सिर्फ सरणी के लिए जाने के लिए सक्षम किया जा रहा है
तत्व 4 या सरणी तत्व 8

20
00:00:53,510 --> 00:00:55,560
भर में पुनरावृति करने के लिए बिना।

21
00:00:55,560 --> 00:00:57,260
यह ठीक है, बहुत तेज है?

22
00:00:57,260 --> 00:01:00,714
>> लेकिन हम यह भी हमारे डेटा है चाहता हूँ
संरचना बढ़ने और हटना करने में सक्षम हो।

23
00:01:00,714 --> 00:01:02,630
हम नहीं करते हैं, की जरूरत नहीं
प्रतिबंधित किया जा करना चाहते हैं।

24
00:01:02,630 --> 00:01:04,588
और हम सक्षम होना चाहता हूँ
जोड़ सकते हैं और चीजों को दूर करने के लिए

25
00:01:04,588 --> 00:01:08,430
बहुत आसानी से, जो आपको याद है,
एक सरणी के साथ बहुत जटिल है।

26
00:01:08,430 --> 00:01:11,650
और हम इस कॉल कर सकते हैं
नई बात यह है कि एक हैश तालिका।

27
00:01:11,650 --> 00:01:15,190
>> और अगर, सही ढंग से लागू
हम की तरह ले रहे हैं

28
00:01:15,190 --> 00:01:18,150
दोनों डेटा के फायदे
आप पहले से ही देखा है संरचनाओं,

29
00:01:18,150 --> 00:01:19,880
सरणियों और लिंक सूचियों।

30
00:01:19,880 --> 00:01:23,070
प्रविष्टि करने के लिए शुरू कर सकते हैं
1 का थीटा की ओर जाते हैं।

31
00:01:23,070 --> 00:01:26,207
थीटा हम वास्तव में चर्चा नहीं की है,
लेकिन थीटा सिर्फ औसत मामला है,

32
00:01:26,207 --> 00:01:27,540
क्या वास्तव में होने जा रहा है।

33
00:01:27,540 --> 00:01:29,680
तुम हमेशा के लिए नहीं जा रहे हैं
सबसे बुरी स्थिति है,

34
00:01:29,680 --> 00:01:32,555
और तुम हमेशा के लिए नहीं जा रहे हैं
सबसे अच्छी स्थिति है, तो क्या है

35
00:01:32,555 --> 00:01:33,900
औसत परिदृश्य?

36
00:01:33,900 --> 00:01:36,500
>> खैर औसत प्रविष्टि
एक हैश तालिका में

37
00:01:36,500 --> 00:01:39,370
करीब लगातार समय को पाने के लिए शुरू कर सकते हैं।

38
00:01:39,370 --> 00:01:41,570
और विलोपन प्राप्त कर सकते हैं
लगातार समय के लिए बंद कर दें।

39
00:01:41,570 --> 00:01:44,440
और देखने का मिल सकता है
लगातार समय के लिए बंद कर दें।

40
00:01:44,440 --> 00:01:48,600
That's-- हम एक डेटा नहीं है
संरचना है कि अभी तक ऐसा कर सकते हैं,

41
00:01:48,600 --> 00:01:51,180
और इसलिए यह पहले से ही लग रहा है
एक बहुत बड़ी बात यह है की तरह।

42
00:01:51,180 --> 00:01:57,010
हम वास्तव में कम किया गया है,
अपने दम पर प्रत्येक के नुकसान।

43
00:01:57,010 --> 00:01:59,160
>> इस प्रदर्शन को प्राप्त करने के लिए
, हालांकि हम उन्नयन

44
00:01:59,160 --> 00:02:03,580
हम कैसे जुड़ पुनर्विचार करने की जरूरत है
संरचना में डेटा।

45
00:02:03,580 --> 00:02:07,380
विशेष रूप से हम चाहते हैं
डेटा ही हमें बताने के लिए

46
00:02:07,380 --> 00:02:09,725
जहां यह संरचना में जाना चाहिए।

47
00:02:09,725 --> 00:02:12,850
और हम तो उस में देखने के लिए अगर जरूरत है तो
संरचना है, हम यह पता करने की जरूरत है,

48
00:02:12,850 --> 00:02:16,610
हम डेटा को देखने के लिए चाहते हैं
फिर से और प्रभावी ढंग से करने में सक्षम हो,

49
00:02:16,610 --> 00:02:18,910
डेटा का उपयोग कर, बेतरतीब ढंग से इसे उपयोग।

50
00:02:18,910 --> 00:02:20,700
बस को देखकर
डेटा हम होनी चाहिए

51
00:02:20,700 --> 00:02:25,890
वास्तव में हम कर रहे हैं, जहां की एक विचार
हैश तालिका में इसे खोजने के लिए जा रहा है।

52
00:02:25,890 --> 00:02:28,770
>> हैश का अब नकारात्मक पहलू
तालिका में वे वास्तव में कर रहे हैं कि है

53
00:02:28,770 --> 00:02:31,770
आदेश या डेटा छँटाई पर बहुत बुरा।

54
00:02:31,770 --> 00:02:34,970
और वास्तव में, अगर आप शुरू
आदेश या ऐसा करने के लिए उन्हें का उपयोग करने के लिए

55
00:02:34,970 --> 00:02:37,990
डेटा आप सभी को खोना
फायदे पहले आप

56
00:02:37,990 --> 00:02:40,710
प्रविष्टि और विलोपन के मामले में किया था।

57
00:02:40,710 --> 00:02:44,060
समय के करीब हो जाता है
n के थीटा, और हम मूल रूप से है

58
00:02:44,060 --> 00:02:45,530
एक लिंक सूची में वहीं।

59
00:02:45,530 --> 00:02:48,850
और इसलिए हम केवल हैश उपयोग करना चाहते हैं
टेबल के बारे में हम परवाह नहीं है

60
00:02:48,850 --> 00:02:51,490
डेटा हल है या नहीं।

61
00:02:51,490 --> 00:02:54,290
संदर्भ के लिए जो में
आप CS50 में उन्हें इस्तेमाल करेंगे

62
00:02:54,290 --> 00:02:58,900
आप शायद परवाह नहीं है
डेटा हल है कि।

63
00:02:58,900 --> 00:03:03,170
>> तो एक हैश तालिका एक संयोजन है
दो अलग-अलग टुकड़ों में से

64
00:03:03,170 --> 00:03:04,980
जिसके साथ हम परिचित हैं।

65
00:03:04,980 --> 00:03:07,930
पहले एक समारोह है, जो
हम आम तौर पर एक हैश समारोह कहते हैं।

66
00:03:07,930 --> 00:03:11,760
और कहा कि हैश समारोह के लिए जा रहा है
कुछ गैर-ऋणात्मक पूर्णांक जो वापसी

67
00:03:11,760 --> 00:03:14,870
हम आम तौर पर ठीक है, एक हैशकोड कहते हैं?

68
00:03:14,870 --> 00:03:20,230
दूसरा टुकड़ा है जो एक सरणी है
प्रकार हम के भंडारण के डेटा के लिए सक्षम

69
00:03:20,230 --> 00:03:22,190
डेटा संरचना में जगह चाहते हैं।

70
00:03:22,190 --> 00:03:24,310
हम पर पकड़ लेंगे
अब के लिए सूची तत्व से जुड़े

71
00:03:24,310 --> 00:03:27,810
और सिर्फ एक के मूल के साथ शुरू
इसके चारों ओर अपने सिर को पाने के लिए मेज हैश,

72
00:03:27,810 --> 00:03:30,210
और फिर हम शायद उड़ा देंगे
अपने मन में एक छोटा सा जब हम

73
00:03:30,210 --> 00:03:32,920
एक साथ सरणियों और लिंक सूचियों गठबंधन।

74
00:03:32,920 --> 00:03:35,590
>> मूल विचार है, हालांकि
हम कुछ डेटा ले रहा है।

75
00:03:35,590 --> 00:03:37,860
हम जानते हैं कि डेटा के माध्यम से चलाने
हैश समारोह।

76
00:03:37,860 --> 00:03:41,980
और इसलिए डेटा संसाधित किया जाता है
और यह ठीक है, एक नंबर बाहर spits?

77
00:03:41,980 --> 00:03:44,890
और फिर उस नंबर के साथ
हम सिर्फ डाटा स्टोर

78
00:03:44,890 --> 00:03:48,930
हम में संग्रहीत करना चाहते हैं
उस स्थान पर सरणी।

79
00:03:48,930 --> 00:03:53,990
तो उदाहरण के लिए हम शायद है
तार के इस हैश तालिका।

80
00:03:53,990 --> 00:03:57,350
यह ऐसा है, तो उस में 10 तत्वों मिल गया है
हम इसे में 10 तार फिट कर सकते हैं।

81
00:03:57,350 --> 00:03:59,320
>> हम जॉन हैश करने के लिए कहना चाहते हैं।

82
00:03:59,320 --> 00:04:02,979
जॉन तो डेटा के रूप में हम सम्मिलित करना चाहते हैं
कहीं न कहीं इस हैश तालिका में।

83
00:04:02,979 --> 00:04:03,770
हम कहाँ रखा है?

84
00:04:03,770 --> 00:04:05,728
खैर, आम तौर पर के साथ एक
सरणी अब तक हम शायद

85
00:04:05,728 --> 00:04:07,610
सरणी स्थान 0 में इसे रखा जाएगा।

86
00:04:07,610 --> 00:04:09,960
लेकिन अब हम इस नए हैश समारोह है।

87
00:04:09,960 --> 00:04:13,180
>> और चलो हम जॉन चलाने का कहना है कि चलो
इस हैश समारोह के माध्यम से

88
00:04:13,180 --> 00:04:15,417
और यह 4 बाहर spits है।

89
00:04:15,417 --> 00:04:17,500
हम कर रहे हैं, जहां अच्छा है कि है
जॉन डाल करना चाहते करने के लिए जा रहा है।

90
00:04:17,500 --> 00:04:22,050
हम सरणी स्थान में जॉन डाल करना चाहते हैं
4, हम again-- जॉन हैश क्योंकि अगर

91
00:04:22,050 --> 00:04:23,810
के बाद हम हम कहते हैं
खोज और देखना चाहते हैं

92
00:04:23,810 --> 00:04:26,960
जॉन इस हैश में मौजूद है
हम सब करने की ज़रूरत table--

93
00:04:26,960 --> 00:04:30,310
एक ही हैश के माध्यम से चलाया जाता है
समारोह, 4 नंबर बाहर निकलना

94
00:04:30,310 --> 00:04:33,929
और जॉन खोजने के लिए सक्षम होना
तुरंत हमारे डेटा संरचना में।

95
00:04:33,929 --> 00:04:34,720
वो काफ़ी अच्छा है।

96
00:04:34,720 --> 00:04:36,928
>> हम अब यह कर हम कहते हैं
फिर, हम पॉल हैश करने के लिए चाहते हैं।

97
00:04:36,928 --> 00:04:39,446
हम पॉल को जोड़ना चाहते हैं
इस हैश तालिका में।

98
00:04:39,446 --> 00:04:42,070
चलो इस बार हम चलाने का कहना है कि
हैश समारोह के माध्यम से पॉल,

99
00:04:42,070 --> 00:04:44,600
उत्पन्न होता है कि हैशकोड 6 है।

100
00:04:44,600 --> 00:04:47,340
खैर अब हम पॉल डाल सकते हैं
सरणी स्थान 6 में।

101
00:04:47,340 --> 00:04:50,040
और हम हैं कि क्या देखने की जरूरत है, तो
पॉल इस हैश तालिका में है,

102
00:04:50,040 --> 00:04:53,900
हम सब करने की ज़रूरत पॉल चलाया जाता है
हैश समारोह के माध्यम से फिर से

103
00:04:53,900 --> 00:04:55,830
और हम फिर से बाहर 6 पाने के लिए जा रहे हैं।

104
00:04:55,830 --> 00:04:57,590
>> और फिर हम बस देखो
सरणी स्थान 6 पर।

105
00:04:57,590 --> 00:04:58,910
पॉल है?

106
00:04:58,910 --> 00:05:00,160
यदि हां, तो वह हैश तालिका में है।

107
00:05:00,160 --> 00:05:01,875
पॉल नहीं है?

108
00:05:01,875 --> 00:05:03,000
उन्होंने कहा कि हैश तालिका में नहीं है।

109
00:05:03,000 --> 00:05:05,720
यह बहुत स्पष्ट है।

110
00:05:05,720 --> 00:05:07,770
>> अब कैसे आप एक हैश समारोह परिभाषित करते हैं?

111
00:05:07,770 --> 00:05:11,460
खैर के लिए वास्तव में कोई सीमा नहीं है
संभव हैश कार्यों की संख्या।

112
00:05:11,460 --> 00:05:14,350
वास्तव में से एक नंबर, वहाँ वास्तव में
इंटरनेट पर वास्तव में अच्छे लोगों को।

113
00:05:14,350 --> 00:05:17,560
की एक संख्या है, वास्तव में नहीं है
इंटरनेट पर बहुत बुरा वाले।

114
00:05:17,560 --> 00:05:21,080
यह भी बहुत आसान है
एक बुरा एक लिखने के लिए।

115
00:05:21,080 --> 00:05:23,760
>> तो क्या एक अच्छा बनाता है ऊपर
हैश समारोह, है ना?

116
00:05:23,760 --> 00:05:27,280
वैसे एक अच्छा हैश कार्य करना चाहिए
केवल डेटा hashed किया जा रहा उपयोग करते हैं,

117
00:05:27,280 --> 00:05:29,420
और डेटा के सभी hashed जा रहा है।

118
00:05:29,420 --> 00:05:32,500
इसलिए हम anything-- का उपयोग नहीं करना चाहते हैं
हम कुछ भी शामिल नहीं है

119
00:05:32,500 --> 00:05:35,560
डेटा के अलावा अन्य।

120
00:05:35,560 --> 00:05:37,080
और हम सभी डेटा के उपयोग करना चाहते हैं।

121
00:05:37,080 --> 00:05:39,830
हम सिर्फ एक टुकड़े का उपयोग नहीं करना चाहते हैं
इसके बारे में, हम इसके बारे में सभी का उपयोग करना चाहते हैं।

122
00:05:39,830 --> 00:05:41,710
एक हैश कार्य करना चाहिए
यह भी निश्चयात्मक हो।

123
00:05:41,710 --> 00:05:42,550
इसका क्या मतलब है?

124
00:05:42,550 --> 00:05:46,200
खैर इसका मतलब यह है कि हर बार हम
डेटा की सटीक एक ही टुकड़े से पारित

125
00:05:46,200 --> 00:05:50,040
हैश समारोह में हम हमेशा
एक ही हैशकोड बाहर निकलते हैं।

126
00:05:50,040 --> 00:05:52,870
मैं में जॉन गुजरती हैं
हैश समारोह मैं 4 बाहर निकलते हैं।

127
00:05:52,870 --> 00:05:56,110
मुझे लगता है कि ऐसा करने में सक्षम होना चाहिए 10,000
बार और मैं हमेशा 4 मिल जाएगा।

128
00:05:56,110 --> 00:06:00,810
तो कोई यादृच्छिक संख्या को प्रभावी ढंग से
हमारे हैश में शामिल किया जा सकता tables--

129
00:06:00,810 --> 00:06:02,750
हमारे हैश कार्यों में।

130
00:06:02,750 --> 00:06:05,750
>> एक हैश समारोह भी चाहिए
समान रूप से डेटा वितरित।

131
00:06:05,750 --> 00:06:09,700
हर बार जब आप के माध्यम से डेटा चलाते हैं
हैश समारोह में आप, हैशकोड 0 मिल

132
00:06:09,700 --> 00:06:11,200
कि ठीक है, शायद इतना बड़ा नहीं है?

133
00:06:11,200 --> 00:06:14,600
आपको शायद यह बड़ा करना चाहते हैं
हैश कोड की एक सीमा होती है।

134
00:06:14,600 --> 00:06:17,190
इसके अलावा बातें फैल सकता है
तालिका भर में बाहर।

135
00:06:17,190 --> 00:06:23,210
और यह भी कि यह वास्तव में अगर बहुत अच्छा होगा
जॉन और जोनाथन की तरह समान डेटा,

136
00:06:23,210 --> 00:06:26,320
शायद वजन करने के लिए बाहर फैल रहे थे
हैश तालिका में विभिन्न स्थानों।

137
00:06:26,320 --> 00:06:28,750
यह एक अच्छा लाभ होगा।

138
00:06:28,750 --> 00:06:31,250
>> यहाँ एक हैश समारोह का एक उदाहरण है।

139
00:06:31,250 --> 00:06:33,150
जैसा कि मैंने पहले इस एक को लिखा था।

140
00:06:33,150 --> 00:06:35,047
यह एक विशेष रूप से नहीं है
अच्छा हैश समारोह

141
00:06:35,047 --> 00:06:37,380
वास्तव में ऐसा नहीं है कि कारणों के लिए
अब सही में जा रहा सहन।

142
00:06:37,380 --> 00:06:41,040
लेकिन तुम यहाँ क्या हो रहा है देखते हैं?

143
00:06:41,040 --> 00:06:44,420
हम एक चर घोषित कर रहे हैं ऐसा लगता है जैसे
योग और 0 के बराबर इसे स्थापित करने का आह्वान किया।

144
00:06:44,420 --> 00:06:50,010
और फिर जाहिरा तौर पर मैं कुछ कर रहा हूँ
इतने लंबे समय strstr [जम्मू] बराबर नहीं है के रूप में

145
00:06:50,010 --> 00:06:52,490
0 Backslash करने के लिए।

146
00:06:52,490 --> 00:06:54,870
मैं वहाँ क्या कर रहा हूँ?

147
00:06:54,870 --> 00:06:57,440
>> यह मूल रूप से सिर्फ एक है
[लागू करने का तरीका है? Strl?]

148
00:06:57,440 --> 00:06:59,773
आप है और जब पता लगाने
स्ट्रिंग के अंत पर पहुंच गया।

149
00:06:59,773 --> 00:07:02,480
इसलिए मैं वास्तव में करने के लिए नहीं है
स्ट्रिंग की लंबाई की गणना,

150
00:07:02,480 --> 00:07:05,640
मैं मारा जब मैं बस का उपयोग कर रहा हूँ
बैकस्लैश 0 चरित्र मुझे पता है

151
00:07:05,640 --> 00:07:07,185
मैं स्ट्रिंग के अंत में पहुँच गए हैं।

152
00:07:07,185 --> 00:07:09,560
और फिर मैं रखने के लिए जा रहा हूँ
कि तार के माध्यम से पुनरावृति,

153
00:07:09,560 --> 00:07:15,310
strstr [जम्मू] जोड़ने में तो राशि है, और करने के लिए
दिन के अंत योग आधुनिक वापस जा रहा

154
00:07:15,310 --> 00:07:16,200
HASH_MAX।

155
00:07:16,200 --> 00:07:18,700
>> असल में यह सब हैश
समारोह को जोड़ कर रही है

156
00:07:18,700 --> 00:07:23,450
के ASCII मूल्यों के सभी
मेरे स्ट्रिंग, और फिर यह है

157
00:07:23,450 --> 00:07:26,390
कुछ हैशकोड लौटने
HASH_MAX द्वारा modded।

158
00:07:26,390 --> 00:07:29,790
यह शायद आकार है
मेरी सरणी की, है ना?

159
00:07:29,790 --> 00:07:33,160
मैं हैश हो रही हो नहीं करना चाहते हैं
कोड अपने सरणी आकार 10 का है,

160
00:07:33,160 --> 00:07:35,712
मैं हो रही हो नहीं करना चाहते हैं
बाहर हैश कोड 11, 12,

161
00:07:35,712 --> 00:07:38,690
13, मैं चीजों में नहीं डाल सकते हैं
सरणी के उन स्थानों,

162
00:07:38,690 --> 00:07:39,790
कि गैरकानूनी होगा।

163
00:07:39,790 --> 00:07:42,130
मैं एक विभाजन गलती पीड़ित था।

164
00:07:42,130 --> 00:07:45,230
>> अब यहाँ एक और जल्दी अलग है।

165
00:07:45,230 --> 00:07:48,470
आम तौर पर आप शायद करने के लिए नहीं जा रहे हैं
अपने खुद के हैश कार्यों लिखना चाहते हैं।

166
00:07:48,470 --> 00:07:50,997
यह वास्तव में एक सा है
एक कला है, एक विज्ञान नहीं।

167
00:07:50,997 --> 00:07:52,580
और उन में चला जाता है कि एक बहुत कुछ है।

168
00:07:52,580 --> 00:07:55,288
जैसा मैंने कहा इंटरनेट, भरा हुआ है,
वास्तव में अच्छा हैश कार्यों की,

169
00:07:55,288 --> 00:07:58,470
और आप के लिए इंटरनेट का उपयोग करना चाहिए
यह सच है, क्योंकि हैश कार्यों मिल

170
00:07:58,470 --> 00:08:03,230
बस की तरह एक अनावश्यक
समय की बर्बादी के लिए अपने स्वयं के बनाने के लिए।

171
00:08:03,230 --> 00:08:05,490
>> आप साधारण लोगों को लिख सकते हैं
परीक्षण प्रयोजनों के लिए।

172
00:08:05,490 --> 00:08:08,323
लेकिन अगर आप वास्तव में करने जा रहे हैं जब
डेटा hashing और यह भंडारण शुरू

173
00:08:08,323 --> 00:08:10,780
आप कर रहे हैं एक हैश तालिका में
शायद चाहते करने जा

174
00:08:10,780 --> 00:08:14,580
उत्पन्न किया गया था कि कुछ समारोह का उपयोग करने के लिए
आप के लिए, कि इंटरनेट पर मौजूद है।

175
00:08:14,580 --> 00:08:17,240
आप बस सुनिश्चित करते हैं
अपने सूत्रों का हवाला देते।

176
00:08:17,240 --> 00:08:21,740
वहाँ कोई कारण नहीं है
यहाँ कुछ भी plagiarize।

177
00:08:21,740 --> 00:08:25,370
>> कंप्यूटर विज्ञान समुदाय है
निश्चित रूप से मूल्यों बढ़ रही है, और वास्तव में

178
00:08:25,370 --> 00:08:28,796
खुला स्रोत है, और यह वास्तव में महत्वपूर्ण है
अपने सूत्रों का हवाला देते हैं ताकि लोग

179
00:08:28,796 --> 00:08:30,670
के लिए रोपण प्राप्त कर सकते हैं
वे कर रहे हैं कि काम

180
00:08:30,670 --> 00:08:32,312
समुदाय के लाभ के लिए कर रही है।

181
00:08:32,312 --> 00:08:34,020
तो हमेशा sure-- होना
और न सिर्फ हैश के लिए

182
00:08:34,020 --> 00:08:37,270
काम करता है, लेकिन आम तौर पर जब आप
एक बाहरी स्रोत से कोड का उपयोग,

183
00:08:37,270 --> 00:08:38,299
हमेशा अपने स्रोत का हवाला देते हैं।

184
00:08:38,299 --> 00:08:43,500
किया है जो व्यक्ति को ऋण देने
काम के कुछ है ताकि आप की जरूरत नहीं है।

185
00:08:43,500 --> 00:08:46,720
>> ठीक है तो चलो इस पर फिर से आना चलो
एक पल के लिए हैश तालिका।

186
00:08:46,720 --> 00:08:48,780
हम छोड़ दिया, जहां यह है
हम डाला के बाद बंद

187
00:08:48,780 --> 00:08:53,300
इस हैश तालिका में जॉन और पॉल।

188
00:08:53,300 --> 00:08:55,180
आप यहाँ एक समस्या देखते हैं?

189
00:08:55,180 --> 00:08:58,410
आप दो देख सकते हैं।

190
00:08:58,410 --> 00:09:02,240
लेकिन विशेष रूप से, आप करते हैं
इस संभावित समस्या देखते हैं?

191
00:09:02,240 --> 00:09:06,770
>> क्या मैं रिंगो हैश, और अगर यह
बाद के प्रसंस्करण पता चला है कि

192
00:09:06,770 --> 00:09:14,000
हैश समारोह के माध्यम से उस डेटा
रिंगो भी हैशकोड 6 उत्पन्न।

193
00:09:14,000 --> 00:09:16,810
मैं पहले से ही पर डेटा मिल गया है
hashcode-- सरणी स्थान 6।

194
00:09:16,810 --> 00:09:22,000
तो यह शायद एक सा होने जा रहा है
अब मेरे लिए एक समस्या की, है ना?

195
00:09:22,000 --> 00:09:23,060
>> हम एक टकराव कहते हैं।

196
00:09:23,060 --> 00:09:26,460
और टकराव जब दो होता है
डेटा के टुकड़े ही हैश के माध्यम से चलाने

197
00:09:26,460 --> 00:09:29,200
समारोह में एक ही हैशकोड निकलेगा।

198
00:09:29,200 --> 00:09:32,850
मुमकिन है कि हम अभी भी दोनों प्राप्त करना चाहते हैं
हैश तालिका में डेटा के टुकड़े,

199
00:09:32,850 --> 00:09:36,330
अन्यथा हम रिंगो चल नहीं किया जाएगा
मनमाने ढंग से हैश समारोह के माध्यम से।

200
00:09:36,330 --> 00:09:40,870
हम संभवतः प्राप्त करना चाहते हैं
उस सरणी में रिंगो।

201
00:09:40,870 --> 00:09:46,070
>> हम हालांकि यह कैसे करते हो, यदि वह
और पॉल दोनों उपज हैशकोड 6?

202
00:09:46,070 --> 00:09:49,520
हम पॉल के ऊपर लिख नहीं करना चाहते हैं,
हम पॉल भी वहाँ रहना चाहता हूँ।

203
00:09:49,520 --> 00:09:52,790
तो हम पाने के लिए एक रास्ता खोजने की जरूरत
हैश तालिका में तत्वों कि

204
00:09:52,790 --> 00:09:56,550
अभी भी हमारे त्वरित बरकरार रखता है
प्रविष्टि और त्वरित देखो ऊपर।

205
00:09:56,550 --> 00:10:01,350
और इसके साथ सौदा करने के लिए एक तरह से करने के लिए है
जांच कर रही रैखिक बुलाया कुछ करो।

206
00:10:01,350 --> 00:10:04,170
>> हम एक है, तो इस विधि का प्रयोग
टक्कर, ठीक है, हम क्या करें?

207
00:10:04,170 --> 00:10:08,580
खैर, हम सरणी स्थान में उसे नहीं डाल सकते हैं
6, या जो कुछ भी हैशकोड उत्पन्न किया गया था,

208
00:10:08,580 --> 00:10:10,820
के हैशकोड प्लस 1 में उसे डाल दिया।

209
00:10:10,820 --> 00:10:13,670
और कहा कि पूरा चलो अगर
हैशकोड प्लस 2 में डाल दिया।

210
00:10:13,670 --> 00:10:17,420
इस होने का लाभ है कि वह अगर
नहीं वास्तव में हम वह है जहां आपको लगता है,

211
00:10:17,420 --> 00:10:20,850
और हम खोज शुरू कर दिया है,
शायद हम बहुत दूर जाने की जरूरत नहीं है।

212
00:10:20,850 --> 00:10:23,900
शायद हम खोज करने की जरूरत नहीं है
हैश तालिका के सभी n तत्वों।

213
00:10:23,900 --> 00:10:25,790
शायद हम खोज करने के लिए
उनमें से एक जोड़ी।

214
00:10:25,790 --> 00:10:30,680
>> और इसलिए हम अभी भी ओर प्रवृत्त कर रहे हैं
औसत के मामले एक के करीब बनाम जा रहा है कि

215
00:10:30,680 --> 00:10:34,280
एन के करीब है, तो हो सकता है कि काम करेंगे।

216
00:10:34,280 --> 00:10:38,010
तो चलो यह कैसे देखते हैं
वास्तविकता में बाहर काम हो सकता है।

217
00:10:38,010 --> 00:10:41,460
और हो सकता है कि हम पता लगा सकते हैं, तो चलो देखते हैं
यहां हो सकता है कि समस्या।

218
00:10:41,460 --> 00:10:42,540
>> हम बार्ट हैश कहते हैं।

219
00:10:42,540 --> 00:10:45,581
तो अब हम एक नया सेट चलाने के लिए जा रहे हैं
हैश समारोह के माध्यम से तार की,

220
00:10:45,581 --> 00:10:48,460
और हम हैश के माध्यम से बार्ट चलाने
समारोह में, हम हैशकोड 6 मिलता है।

221
00:10:48,460 --> 00:10:52,100
हम एक बार देख ले, हम 6 देखना
खाली है, इसलिए हम वहाँ बार्ट डाल सकते हैं।

222
00:10:52,100 --> 00:10:55,410
>> अब हम लिसा और हैश
यह भी हैशकोड 6 उत्पन्न करता है।

223
00:10:55,410 --> 00:10:58,330
खैर अब हम इस का उपयोग कर रहे हैं कि
रेखीय, हम 6 बजे शुरू विधि की जांच कर रही

224
00:10:58,330 --> 00:10:59,330
हम 6 भरा है कि देखते हैं।

225
00:10:59,330 --> 00:11:00,990
हम 6 में लिसा नहीं डाल सकते हैं।

226
00:11:00,990 --> 00:11:02,090
तो हम कहाँ जाते हो?

227
00:11:02,090 --> 00:11:03,280
7 के लिए चलते हैं।

228
00:11:03,280 --> 00:11:04,610
7 खाली है, इसलिए काम करता है।

229
00:11:04,610 --> 00:11:06,510
तो चलो देखते लिसा डाल दिया।

230
00:11:06,510 --> 00:11:10,200
>> अब हम होमर हैश और हम 7 मिलता है।

231
00:11:10,200 --> 00:11:13,380
ठीक है अच्छी तरह हम जानते हैं कि 7 की पूरी कि
अब, इसलिए हम वहाँ होमर नहीं डाल सकते हैं।

232
00:11:13,380 --> 00:11:14,850
तो चलो 8 के लिए चलते हैं।

233
00:11:14,850 --> 00:11:15,664
8 उपलब्ध है?

234
00:11:15,664 --> 00:11:18,330
हाँ, और 7 से 8 के करीब है, यदि ऐसा है तो
हम हम कर रहे हैं खोज शुरू करने के लिए है

235
00:11:18,330 --> 00:11:20,020
बहुत दूर जाने की जरूरत नहीं जा रहा।

236
00:11:20,020 --> 00:11:22,860
और तो 8 पर होमर डाल दिया।

237
00:11:22,860 --> 00:11:25,151
>> अब हम हैश मैगी और
3 देता है, भगवान का शुक्र है

238
00:11:25,151 --> 00:11:26,650
हम सिर्फ वहाँ मैगी डाल करने में सक्षम हो।

239
00:11:26,650 --> 00:11:29,070
हम कोई भी कार्य करने की जरूरत नहीं है
एक तरह से उस के लिए जांच कर रही है।

240
00:11:29,070 --> 00:11:32,000
अब हम मार्ज हैश, और
मार्ज भी 6 रिटर्न।

241
00:11:32,000 --> 00:11:39,560
>> खैर 6, 8 भरा है, 7 भरा है, पूर्ण है
9, सब ठीक 9 खाली है, भगवान का शुक्र है।

242
00:11:39,560 --> 00:11:41,600
मैं 9 पर मार्ज डाल सकते हैं।

243
00:11:41,600 --> 00:11:45,280
पहले से ही हम हम शुरू कर रहे हैं कि देख सकते हैं
हम कर रहे हैं, जहां अब इस समस्या के लिए

244
00:11:45,280 --> 00:11:48,780
तरह बातें फैलाने के लिए शुरू कर
के दूर दूर उनके हैश कोड से।

245
00:11:48,780 --> 00:11:52,960
और 1 के कि थीटा, कि औसत
लगातार समय होने के मामले,

246
00:11:52,960 --> 00:11:56,560
एक छोटे more-- पाने के लिए शुरू कर रहा है
एक छोटे से अधिक करते हैं करने के लिए शुरू

247
00:11:56,560 --> 00:11:58,050
n के थीटा की ओर।

248
00:11:58,050 --> 00:12:01,270
हम जानते हैं कि कम करने के लिए शुरू कर रहे हैं
हैश तालिकाओं का लाभ।

249
00:12:01,270 --> 00:12:03,902
>> हम सिर्फ देखा है कि यह समस्या
क्लस्टरिंग कहा जाता है।

250
00:12:03,902 --> 00:12:06,360
और सच के बारे में बुरा क्या है
क्लस्टरिंग कि आप एक बार अब है

251
00:12:06,360 --> 00:12:09,606
पक्ष हैं कि दो तत्वों से है
यह इसे और भी अधिक होने की संभावना बनाता पक्ष,

252
00:12:09,606 --> 00:12:11,480
आप डबल है
मौका है, आप जा रहे हैं कि

253
00:12:11,480 --> 00:12:13,516
एक और टक्कर के लिए है
कि क्लस्टर के साथ,

254
00:12:13,516 --> 00:12:14,890
और क्लस्टर एक के द्वारा विकसित होगा।

255
00:12:14,890 --> 00:12:19,640
और अगर आप बढ़ रही है और बढ़ रहा रखेंगे
एक टक्कर होने की संभावना।

256
00:12:19,640 --> 00:12:24,470
और अंत में यह बस के रूप में बुरा है
के रूप में सभी डेटा छँटाई नहीं।

257
00:12:24,470 --> 00:12:27,590
>> दूसरी समस्या यह है कि हम है
अभी भी, और अब तक इस बात के लिए,

258
00:12:27,590 --> 00:12:30,336
हम बस की तरह किया गया है
एक हैश तालिका में क्या है, समझ

259
00:12:30,336 --> 00:12:31,960
हम अभी भी केवल 10 तार के लिए कमरा है।

260
00:12:31,960 --> 00:12:37,030
हम हैश करने के लिए जारी रखना चाहते हैं
स्प्रिंगफील्ड के नागरिकों,

261
00:12:37,030 --> 00:12:38,790
हम केवल वहाँ में उनमें से 10 प्राप्त कर सकते हैं।

262
00:12:38,790 --> 00:12:42,619
और हम कोशिश करते हैं और एक 11 वीं या 12 वीं जोड़ने अगर
हम उन्हें डाल करने के लिए एक जगह की जरूरत नहीं है।

263
00:12:42,619 --> 00:12:45,660
हम बस में चारों ओर कताई किया जा सकता है
हलकों, एक खाली जगह खोजने की कोशिश

264
00:12:45,660 --> 00:12:49,000
और हम शायद अटक जाते हैं
एक अनंत लूप में।

265
00:12:49,000 --> 00:12:51,810
>> तो विचार को उधार देता है की इस तरह
कुछ की श्रंखला का आह्वान किया।

266
00:12:51,810 --> 00:12:55,790
और यह हम लाने के लिए जा रहे हैं, जहां है
वापस तस्वीर में लिंक सूचियों।

267
00:12:55,790 --> 00:13:01,300
क्या होगा अगर बजाय सिर्फ संचय के लिए
सरणी में डेटा ही,

268
00:13:01,300 --> 00:13:04,471
सरणी के प्रत्येक तत्व सकता है
कई टुकड़े डेटा की पकड़?

269
00:13:04,471 --> 00:13:05,970
अच्छा है कि ठीक है, मतलब नहीं है?

270
00:13:05,970 --> 00:13:09,280
हम जानते हैं कि एक सरणी ही पता कर सकते हैं
एक सरणी के प्रत्येक तत्व hold--

271
00:13:09,280 --> 00:13:12,930
केवल एक टुकड़ा पकड़ कर सकते हैं
कि डेटा प्रकार के डेटा की।

272
00:13:12,930 --> 00:13:16,750
>> लेकिन क्या है कि अगर डेटा प्रकार
एक लिंक सूची है, सही?

273
00:13:16,750 --> 00:13:19,830
तो क्या हुआ अगर हर
सरणी का तत्व था

274
00:13:19,830 --> 00:13:22,790
एक लिंक सूची के सिर के लिए एक संकेत?

275
00:13:22,790 --> 00:13:24,680
और फिर हम निर्माण कर सकता है
उन लिंक सूचियों

276
00:13:24,680 --> 00:13:27,120
और, मनमाने ढंग से उन्हें विकसित
लिंक सूचियों अनुमति है, क्योंकि

277
00:13:27,120 --> 00:13:32,090
हमें आगे बढ़ने और एक बहुत अधिक हटना करने के लिए
एक सरणी करता है लचीले ढंग से।

278
00:13:32,090 --> 00:13:34,210
तो क्या अब हम का उपयोग करते हैं,
हम सही, इस का लाभ उठाने?

279
00:13:34,210 --> 00:13:37,760
हम इन जंजीरों विकसित करने के लिए शुरू
इन सरणी स्थानों से बाहर।

280
00:13:37,760 --> 00:13:40,740
>> अब हम एक अनंत फिट कर सकते हैं
डेटा की राशि, या अनंत नहीं,

281
00:13:40,740 --> 00:13:44,170
की एक मनमाना राशि
डेटा, हमारे हैश तालिका में

282
00:13:44,170 --> 00:13:47,760
कभी में चल रहे बिना
टक्कर की समस्या।

283
00:13:47,760 --> 00:13:50,740
हम भी समाप्त कर दिया है
ऐसा करके क्लस्टरिंग।

284
00:13:50,740 --> 00:13:54,380
और अच्छी तरह से हम सम्मिलित करते हैं कि पता
एक लिंक सूची में, यदि आपको याद है

285
00:13:54,380 --> 00:13:57,779
अकेले, लिंक सूचियों पर हमारे वीडियो से
लिंक सूचियों और दोगुना लिंक सूचियों,

286
00:13:57,779 --> 00:13:59,070
यह एक निरंतर समय ऑपरेशन है।

287
00:13:59,070 --> 00:14:00,710
हम बस सामने से जोड़ रहे हैं।

288
00:14:00,710 --> 00:14:04,400
>> और देखो ऊपर के लिए, अच्छी तरह से हम जानते हैं
कि एक लिंक सूची में ऊपर देखो

289
00:14:04,400 --> 00:14:05,785
ठीक है, एक समस्या हो सकती है?

290
00:14:05,785 --> 00:14:07,910
हम के माध्यम से खोज करने के लिए
शुरू से ही इसे समाप्त करने के लिए।

291
00:14:07,910 --> 00:14:10,460
कोई यादृच्छिक नहीं है
एक लिंक सूची में पहुँच।

292
00:14:10,460 --> 00:14:15,610
लेकिन यदि बजाय एक होने के लिंक्ड
एक देखने एन हे होगा जहां सूची,

293
00:14:15,610 --> 00:14:19,590
हम अब 10 लिंक सूचियों है,
या 1,000 लिंक सूचियों,

294
00:14:19,590 --> 00:14:24,120
अब यह 10 से विभाजित n के हे,
या एन हे 1,000 से विभाजित।

295
00:14:24,120 --> 00:14:26,940
>> और हम बात कर रहे थे, जबकि
सैद्धांतिक रूप से जटिलता के बारे में

296
00:14:26,940 --> 00:14:30,061
हम वास्तविक में, स्थिरांक उपेक्षा
इन बातों को वास्तव में कोई फर्क दुनिया,

297
00:14:30,061 --> 00:14:30,560
है ना?

298
00:14:30,560 --> 00:14:33,080
हम वास्तव में नोटिस जाएगा
ऐसा होता है कि

299
00:14:33,080 --> 00:14:36,610
तेजी से 10 बार चलाने के लिए,
या 1,000 गुना तेजी से,

300
00:14:36,610 --> 00:14:41,570
हम लंबे समय से एक का वितरण कर रहे हैं, क्योंकि
1,000 छोटे चेन पार श्रृंखला।

301
00:14:41,570 --> 00:14:45,090
और इसलिए हम हर बार खोज करने के लिए
हम कर सकते हैं उन श्रृंखलाओं में से एक के माध्यम से

302
00:14:45,090 --> 00:14:50,290
हम परवाह नहीं है 999 चेन की अनदेखी
के बारे में है, और सिर्फ इतना है कि एक खोज करते हैं।

303
00:14:50,290 --> 00:14:53,220
>> जो करने के लिए औसत पर है
1,000 बार कम हो।

304
00:14:53,220 --> 00:14:56,460
और इसलिए हम अभी भी एक तरह से कर रहे हैं
इस औसत के मामले की ओर प्रवृत्त

305
00:14:56,460 --> 00:15:01,610
की लगातार समय से किया जा रहा है, लेकिन
केवल हम लाभ कर रहे हैं, क्योंकि

306
00:15:01,610 --> 00:15:03,730
कुछ बड़ी निरंतर पहलू से विभाजित।

307
00:15:03,730 --> 00:15:05,804
यह कैसे हो सकता है चलो देखते हैं
वास्तव में, हालांकि देखो।

308
00:15:05,804 --> 00:15:08,720
तो यह है कि हम था हैश तालिका था
हम एक हैश तालिका घोषित करने से पहले कि

309
00:15:08,720 --> 00:15:10,270
10 तार भंडारण के लिए सक्षम था।

310
00:15:10,270 --> 00:15:11,728
हम अब और ऐसा करने के लिए नहीं जा रहे हैं।

311
00:15:11,728 --> 00:15:13,880
हम पहले से ही पता
कि विधि की सीमाओं।

312
00:15:13,880 --> 00:15:20,170
अब हमारी हैश तालिका होने जा रहा है
10 नोड्स, संकेत की एक सरणी

313
00:15:20,170 --> 00:15:22,120
लिंक सूचियों के प्रमुखों को।

314
00:15:22,120 --> 00:15:23,830
>> और अभी यह रिक्त है।

315
00:15:23,830 --> 00:15:26,170
उन 10 संकेत से हर एक रिक्त है।

316
00:15:26,170 --> 00:15:29,870
कुछ भी नहीं है हमारे में नहीं है
अब सही तालिका हैश।

317
00:15:29,870 --> 00:15:32,690
>> अब हम कुछ डाल करने के लिए शुरू करते हैं
इस हैश तालिका में बातें।

318
00:15:32,690 --> 00:15:35,440
और हम इस पद्धति है कि कैसे देखते हैं
हमें एक छोटा सा फायदा होने जा रहा।

319
00:15:35,440 --> 00:15:36,760
चलो अब जॉय हैश करते हैं।

320
00:15:36,760 --> 00:15:40,210
हम स्ट्रिंग जॉय के माध्यम से चलेंगे करेंगे
एक हैश समारोह और हम 6 वापसी।

321
00:15:40,210 --> 00:15:41,200
खैर अब हम क्या करते हैं?

322
00:15:41,200 --> 00:15:44,090
>> खैर अब लिंक सूचियों के साथ काम कर रहे हैं,
हम सरणियों के साथ काम नहीं कर रहे।

323
00:15:44,090 --> 00:15:45,881
और हम काम कर रहे हैं
लिंक सूचियों के साथ हम

324
00:15:45,881 --> 00:15:49,790
हम गतिशील शुरू करने की जरूरत है
अंतरिक्ष और निर्माण चेन का आवंटन।

325
00:15:49,790 --> 00:15:54,020
उस तरह की उन प्रमुख हैं how-- है
एक लिंक की गई सूची के निर्माण के तत्वों।

326
00:15:54,020 --> 00:15:57,670
तो गतिशील चलो
जॉय के लिए जगह आवंटित,

327
00:15:57,670 --> 00:16:00,390
और उसके बाद की श्रृंखला के लिए उसे जोड़ दें।

328
00:16:00,390 --> 00:16:03,170
>> तो अब हम क्या किया है देखो।

329
00:16:03,170 --> 00:16:06,440
हम जॉय हैश जब हम हैशकोड 6 मिला है।

330
00:16:06,440 --> 00:16:11,790
सरणी स्थान 6 पर अब सूचक
एक लिंक सूची के सिर पर बताते हैं,

331
00:16:11,790 --> 00:16:14,900
और अभी यह केवल
एक लिंक सूची के तत्व।

332
00:16:14,900 --> 00:16:18,350
और उस में नोड
लिंक सूची जॉय है।

333
00:16:18,350 --> 00:16:22,300
>> हम जॉय को देखने की जरूरत है तो अगर
बाद में, हम तो बस फिर जॉय हैश,

334
00:16:22,300 --> 00:16:26,300
हम अपने क्योंकि फिर 6 मिलता है
हैश समारोह निर्धारक है।

335
00:16:26,300 --> 00:16:30,400
और फिर हम सिर पर शुरू
लिंक सूची का इशारा

336
00:16:30,400 --> 00:16:33,360
सरणी स्थान के आधार पर करने के लिए
6, और हम पुनरावृति कर सकते हैं

337
00:16:33,360 --> 00:16:35,650
जॉय खोजने की कोशिश है कि भर में।

338
00:16:35,650 --> 00:16:37,780
और हम का निर्माण करता है, तो हमारे
प्रभावी ढंग से मेज हैश,

339
00:16:37,780 --> 00:16:41,790
और हमारे हैश समारोह को प्रभावी ढंग से
अच्छी तरह से डेटा को वितरित करने के लिए,

340
00:16:41,790 --> 00:16:45,770
औसत पर उन लोगों में से प्रत्येक से जुड़े
हर सरणी स्थान पर सूचियां

341
00:16:45,770 --> 00:16:50,110
यदि का आकार 1/10 होगी हम
सिर्फ एक ही विशाल के रूप में यह था

342
00:16:50,110 --> 00:16:51,650
यह सब कुछ के साथ लिंक सूची।

343
00:16:51,650 --> 00:16:55,670
>> हम विशाल जुड़ा हुआ है कि वितरित
10 लिंक सूचियों भर सूची

344
00:16:55,670 --> 00:16:57,760
प्रत्येक सूची 1/10 आकार का हो जाएगा।

345
00:16:57,760 --> 00:17:01,432
और इस तरह 10 बार तेज
के माध्यम से खोज करने के लिए।

346
00:17:01,432 --> 00:17:02,390
तो चलो फिर से यह करते हैं।

347
00:17:02,390 --> 00:17:04,290
चलो अब रॉस हैश करते हैं।

348
00:17:04,290 --> 00:17:07,540
>> और चलो हम ऐसा जब रॉस, हम कहते हैं
हम वापस मिल हैश कोड 2 है।

349
00:17:07,540 --> 00:17:10,630
खैर अब हम गतिशील रूप से एक का आवंटन
नए नोड, हम उस नोड में रॉस डाल

350
00:17:10,630 --> 00:17:14,900
और हम सरणी स्थान अब कहते हैं
2, शून्य की ओर इशारा करते बजाय,

351
00:17:14,900 --> 00:17:18,579
एक लिंक्ड के सिर करने के लिए अंक
जिसका केवल नोड सूची रॉस है।

352
00:17:18,579 --> 00:17:22,660
और हम, हम इस एक बार और क्या कर सकते हैं
राहेल हैश और हैशकोड 4 प्राप्त कर सकते हैं।

353
00:17:22,660 --> 00:17:25,490
में राहेल डाल दिया, एक नया नोड malloc
नोड, और एक सरणी स्थान का कहना है

354
00:17:25,490 --> 00:17:27,839
4 अब सिर करने के लिए अंक
जिसका एक लिंक सूची की

355
00:17:27,839 --> 00:17:31,420
केवल तत्व राहेल होना होता है।

356
00:17:31,420 --> 00:17:33,470
>> ठीक है, लेकिन क्या होता है अगर
हम एक टकराव है?

357
00:17:33,470 --> 00:17:38,560
हम टक्करों संभाल कैसे देखते हैं
अलग श्रृंखलन विधि के प्रयोग से।

358
00:17:38,560 --> 00:17:39,800
के चांद हैश करते हैं।

359
00:17:39,800 --> 00:17:41,094
हम हैशकोड 6 मिलता है।

360
00:17:41,094 --> 00:17:44,010
हमारे पिछले उदाहरण में हम सिर्फ थे
सरणी में तार भंडारण।

361
00:17:44,010 --> 00:17:45,980
यह एक समस्या थी।

362
00:17:45,980 --> 00:17:48,444
>> हम पीटना नहीं करना चाहते हैं
जॉय, और हम पहले से ही है

363
00:17:48,444 --> 00:17:51,110
हम कुछ क्लस्टरिंग प्राप्त कर सकते हैं कि देखा
समस्याओं हम कोशिश करते हैं और अगर कदम

364
00:17:51,110 --> 00:17:52,202
के माध्यम से और जांच।

365
00:17:52,202 --> 00:17:54,660
लेकिन क्या करता है, तो हम बस की तरह
यह सही है, उसी तरह से व्यवहार करता है?

366
00:17:54,660 --> 00:17:57,440
यह सिर्फ एक तत्व जोड़ने की तरह है
एक लिंक सूची के सिर पर।

367
00:17:57,440 --> 00:18:00,220
चांद के लिए चलो बस malloc अंतरिक्ष करते हैं।

368
00:18:00,220 --> 00:18:04,764
>> हम चांद की अगली सूचक अंक कहूँगा
लिंक सूची के पुराने सिर करने के लिए,

369
00:18:04,764 --> 00:18:07,180
और फिर 6 बस के लिए अंक
लिंक सूची के नए प्रमुख के।

370
00:18:07,180 --> 00:18:10,150
और अब हम में चांद बदल दिया है, देखो।

371
00:18:10,150 --> 00:18:14,210
अब हम दो स्टोर कर सकते हैं
हैशकोड 6 के साथ तत्वों,

372
00:18:14,210 --> 00:18:17,170
और हम किसी भी समस्या नहीं है।

373
00:18:17,170 --> 00:18:20,147
>> यही कारण है कि बहुत ज्यादा सब है
श्रृंखलन के लिए नहीं है।

374
00:18:20,147 --> 00:18:21,980
और श्रृंखलन निश्चित रूप से है
है कि विधि

375
00:18:21,980 --> 00:18:27,390
अगर आप के लिए सबसे अधिक प्रभावी होने जा रहा
आप एक हैश तालिका में डेटा भंडारण कर रहे हैं।

376
00:18:27,390 --> 00:18:30,890
लेकिन के इस संयोजन
सरणियों और लिंक सूचियों

377
00:18:30,890 --> 00:18:36,080
एक साथ वास्तव में एक हैश तालिका के लिए फार्म का
नाटकीय ढंग से अपनी क्षमता में सुधार

378
00:18:36,080 --> 00:18:40,550
डेटा की बड़ी मात्रा में स्टोर, और करने के लिए
बहुत जल्दी और कुशलता से खोज

379
00:18:40,550 --> 00:18:41,630
कि डेटा के माध्यम से।

380
00:18:41,630 --> 00:18:44,150
>> एक और अभी भी है
वहाँ से बाहर आंकड़ा संरचना

381
00:18:44,150 --> 00:18:48,700
कि यह भी एक सा हो सकता है
गारंटी देने के मामले में बेहतर

382
00:18:48,700 --> 00:18:51,920
कि हमारी प्रविष्टि, हटाने, और
देखो बार भी तेजी से कर रहे हैं।

383
00:18:51,920 --> 00:18:55,630
और हम कोशिश करता है पर एक वीडियो में देखेंगे।

384
00:18:55,630 --> 00:18:58,930
मैं डौग लॉयड हूँ, इस CS50 है।

385
00:18:58,930 --> 00:19:00,214