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
>> డౌ LLOYD: ఇప్పుడు ద్వారా మీరు
శ్రేణుల గురించి చాలా తెలుసు,

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
అంతటా iterate చేయకుండా.

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
అందువలన డేటా ప్రాసెస్
మరియు అది సరే, ఒక సంఖ్య ఉమ్మి వేస్తారు?

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 ఉమ్మి వేస్తారు లో.

89
00:04:15,417 --> 00:04:17,500
మేము ఉన్నాము పేరు బాగా ఆ
జాన్ ఉంచాలి కావలసిన వెళుతున్న.

90
00:04:17,500 --> 00:04:22,050
మేము శ్రేణి ప్రదేశంలో జాన్ ఉంచాలి కావలసిన
4, మేము మళ్ళీ జాన్ హాష్ ఉంటే ఎందుకంటే

91
00:04:22,050 --> 00:04:23,810
యొక్క తరువాత మేము చెప్పటానికి వీలు
అన్వేషణ మరియు చూడాలనుకుంటే

92
00:04:23,810 --> 00:04:26,960
దీనిద్వారా హాష్ ఉన్నట్లయితే
మేము చెయ్యాల్సిన అన్ని పట్టిక

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
Well ఇప్పుడు మేము పాల్ ఉంచవచ్చు
అర్రే నగర 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
Well ఒక మంచి హాష్ ఫంక్షన్ను తప్పక
మాత్రమే డేటా హ్యాష్ చేస్తున్నారు ఉపయోగించండి

117
00:05:27,280 --> 00:05:29,420
మరియు డేటా యొక్క అన్ని హ్యాష్ చేస్తున్నారు.

118
00:05:29,420 --> 00:05:32,500
కాబట్టి మేము ఏదైనా ఉపయోగించడానికి వద్దు
మేము ఏదైనా పొందుపరచడానికి లేదు

119
00:05:32,500 --> 00:05:35,560
డేటా కంటే ఇతర else.

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
ఒక nice ప్రయోజనం ఉంటుంది.

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 [j] సమానం కాదు

145
00:06:50,010 --> 00:06:52,490
0 బ్యాక్స్లాష్ కు.

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
ఆపై నేను ఉంచడానికి వెళుతున్న
ఆ స్ట్రింగ్ ద్వారా iterating,

153
00:07:09,560 --> 00:07:15,310
strstr [j] జోడించడం అప్పుడు సంకలనం, మరియు
రోజు చివరిలో మొత్తం mod తిరిగి వెళుతున్న

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
కానీ మీరు నిజంగా వెళుతున్న చేసినప్పుడు
డేటా హ్యాషింగ్ మరియు అది నిల్వ మొదలు

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
ఎల్లప్పుడూ మీ మూలం cite.

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
>> కాబట్టి మేము ఇంకా వైపు తీర్చ చేస్తున్నారు
సగటు కేసు 1 దగ్గరగా vs ఉండటం

215
00:10:30,680 --> 00:10:34,280
n కు దగ్గరగా, కాబట్టి బహుశా ఆ పని చేస్తాము.

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
Well ఇప్పుడు మేము ఈ ఉపయోగించి చేస్తున్న
సరళ మేము 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
Well ఆ కుడి, అర్ధవంతం లేదు?

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
కానీ బదులుగా ఒక కలిగి అనుసంధాన
ఒక లుక్అప్ n యొక్క O ఉండగల జాబితా

293
00:14:15,610 --> 00:14:19,590
మేము ఇప్పుడు 10 అనుసంధాన జాబితాలు ఉన్నాయి,
లేదా 1,000 అనుసంధాన జాబితాలు

294
00:14:19,590 --> 00:14:24,120
ఇప్పుడు అది 10 ద్వారా విభజించబడింది n యొక్క O,
లేదా n యొక్క O 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 గమనికలు ప్రతి ఒకటి NULL.

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
>> Well ఇప్పుడు లింక్ జాబితాలు పని,
మేము శ్రేణుల పని లేదు.

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
ఆ విధమైన ఆ ప్రధానమైనవి లేదు ఎలా వార్తలు
ఒక లింక్ జాబితా నిర్మించే అంశాలు.

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, మరియు మేము iterate చేయవచ్చు

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
Well ఇప్పుడు మేము డైనమిక్ ఒక కేటాయించాలని
కొత్త నోడ్, మేము ఆ నోడ్ లో రాస్ చాలు

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
>> మేము clobber వద్దు
జోయి, మరియు మేము ఇప్పటికే చేసిన

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