1
00:00:00,000 --> 00:00:11,856

2
00:00:11,856 --> 00:00:13,050
>> రాబ్ బౌడెన్: ఎక్కువ.

3
00:00:13,050 --> 00:00:16,210
నేను రాబ్ ఉన్నాను, మరియు లెట్స్ హాష్
ఈ పరిష్కారాన్ని.

4
00:00:16,210 --> 00:00:20,070
కాబట్టి ఇక్కడ అమలు చూడాలని
ఒక సాధారణ హాష్ పట్టిక.

5
00:00:20,070 --> 00:00:24,090
మేము చూడండి మా హాష్ Struct నోడ్
పట్టిక ఇలా అన్నారు.

6
00:00:24,090 --> 00:00:28,710
కనుక ఇది ఒక చార్ పదం కలిగి జరగబోతోంది
పరిమాణం పొడవు ప్లస్ 1 శ్రేణి.

7
00:00:28,710 --> 00:00:32,259
గరిష్ట నుండి 1 మరువకండి
నిఘంటువులో పదాన్ని 45 ఉంది

8
00:00:32,259 --> 00:00:35,110
అక్షరాలు, ఆపై మేము చూడాలని
ఒక అదనపు పాత్ర అవసరం

9
00:00:35,110 --> 00:00:37,070
బాక్ స్లాష్ 0.

10
00:00:37,070 --> 00:00:40,870
>> ఆపై ప్రతి లో మా హాష్ పట్టిక
బకెట్ నిల్వ అన్నారు ఒక

11
00:00:40,870 --> 00:00:42,320
ల లింక్ జాబితా.

12
00:00:42,320 --> 00:00:44,420
మేము ఇక్కడ పరిశీలించకుండా సరళ చేయడం లేదు.

13
00:00:44,420 --> 00:00:48,430
అందువలన క్రమంలో తదుపరి లింక్
బకెట్ లో మూలకం, మేము ఒక అవసరం

14
00:00:48,430 --> 00:00:51,110
struct నోడ్ * తదుపరి.

15
00:00:51,110 --> 00:00:53,090
కాబట్టి ఒక నోడ్ కనిపిస్తోంది ఉంది.

16
00:00:53,090 --> 00:00:56,180
ఇప్పుడు, ఇక్కడ ప్రకటన
మా హాష్ పట్టిక.

17
00:00:56,180 --> 00:01:01,910
ఇది 16.384 బకెట్లు కలిగి జరగబోతోంది కానీ
ఆ సంఖ్య నిజంగా పట్టింపు లేదు.

18
00:01:01,910 --> 00:01:05,450
చివరకు, మేము చూడాలని
ప్రపంచ వేరియబుల్ hashtable_size, ఇది

19
00:01:05,450 --> 00:01:08,640
0 గా కాకుండా ప్రారంభించు అన్నారు, మరియు అది ఉంది
ట్రాక్ అన్నారు ఎన్ని పదాలు

20
00:01:08,640 --> 00:01:10,080
మా నిఘంటువులో లో ఉన్నాయి.

21
00:01:10,080 --> 00:01:10,760
అన్ని కుడి.

22
00:01:10,760 --> 00:01:13,190
>> కాబట్టి యొక్క లోడ్ పరిశీలించి వీలు.

23
00:01:13,190 --> 00:01:16,390
కాబట్టి ఆ లోడ్ గమనించి,
ఇది ఒక bool తిరిగి.

24
00:01:16,390 --> 00:01:20,530
ఇది విజయవంతంగా ఉంటే మీరు నిజమైన తిరిగి
లేకపోతే లోడ్ మరియు తప్పుడు.

25
00:01:20,530 --> 00:01:23,990
మరియు అది ఒక కాన్స్ట్ చార్ * స్టార్ పడుతుంది
నిఘంటువు ఇది నిఘంటువు,

26
00:01:23,990 --> 00:01:25,280
మేము తెరవడానికి కావలసిన.

27
00:01:25,280 --> 00:01:27,170
కాబట్టి ఆ మొదటి విషయం
మేము చేయబోతున్నామని.

28
00:01:27,170 --> 00:01:30,420
మేము కోసం నిఘంటువులో fopen చూడాలని
చదవడం, మరియు మేము చూడాలని

29
00:01:30,420 --> 00:01:34,700
ఇది అయితే విజయం నిర్ధారించుకోండి
ఇది NULL తిరిగి, అప్పుడు మేము కాదు

30
00:01:34,700 --> 00:01:37,440
విజయవంతంగా నిఘంటువు తెరిచి
మరియు మేము తప్పుడు తిరిగి.

31
00:01:37,440 --> 00:01:41,580
>> కానీ విజయవంతంగా అని ఊహిస్తూ
ఓపెన్, అప్పుడు మేము చదవాలనుకుంటున్న

32
00:01:41,580 --> 00:01:42,400
నిఘంటువు.

33
00:01:42,400 --> 00:01:46,210
మేము కొన్ని కనుగొనేందుకు వరకు మళ్ళీ వెతికినా ఉంచడానికి
ఈ బయటకు కారణం

34
00:01:46,210 --> 00:01:47,570
మేము చూస్తారు లూప్.

35
00:01:47,570 --> 00:01:51,780
కాబట్టి మళ్ళీ వెతికినా ఉంచడానికి, మరియు ఇప్పుడు మేము చూడాలని
ఒక నోడ్ malloc కు.

36
00:01:51,780 --> 00:01:56,800
మరియు కోర్సు యొక్క, మేము చెక్ తప్పొప్పులకు అవసరం
మళ్ళీ mallocing విజయవంతం కాలేదు కనుక

37
00:01:56,800 --> 00:02:00,660
మరియు మేము ఆ మేము ఏ నోడ్ దించుతున్న మీరు
ముందు malloc జరిగింది, దగ్గరగా

38
00:02:00,660 --> 00:02:02,590
నిఘంటువు మరియు తప్పుడు తిరిగి.

39
00:02:02,590 --> 00:02:07,440
>> కానీ ఆ విస్మరించి, ఊహిస్తూ మేము
విజయం, అప్పుడు మేము fscanf ఉపయోగించడానికి

40
00:02:07,440 --> 00:02:12,400
నుండి ఒకే పదం చదవడానికి మా
మా నోడ్ నిఘంటువు.

41
00:02:12,400 --> 00:02:17,310
కాబట్టి ఆ ప్రవేశ> పదం గుర్తు చార్
పదం పరిమాణం పొడవు బఫర్ ప్లస్

42
00:02:17,310 --> 00:02:20,300
మేము చూడాలని ఒక
సైన్ పదాన్ని నిల్వ

43
00:02:20,300 --> 00:02:25,280
కాబట్టి fscanf 1 కాలం తిరిగి అన్నారు
ఇది విజయవంతంగా ఒక చదవగలిగాను వంటి

44
00:02:25,280 --> 00:02:26,750
ఫైలు నుండి పదం.

45
00:02:26,750 --> 00:02:31,030
>> లోపం గాని జరుగుతుంది లేదా మేము చేరే
ఫైలు చివర, అది లేదు

46
00:02:31,030 --> 00:02:34,950
అది కాకపోతే సందర్భంలో 1 తిరిగి
1 తిరిగి, మేము చివరకు బ్రేక్ చూడాలని

47
00:02:34,950 --> 00:02:37,280
ఈ సమయంలో లూప్ బయటకు.

48
00:02:37,280 --> 00:02:42,770
కాబట్టి మేము, మేము విజయవంతంగా ఉంటాయి
ఒక పదాన్ని చదవడానికి

49
00:02:42,770 --> 00:02:48,270
ప్రవేశ> పదం, అప్పుడు మేము హాష్ చూడాలని
మా హాష్ ఫంక్షన్ను ఉపయోగించి ఆ పదం.

50
00:02:48,270 --> 00:02:49,580
యొక్క పరిశీలించి లెట్
హాష్ ఫంక్షన్ను.

51
00:02:49,580 --> 00:02:52,430

52
00:02:52,430 --> 00:02:55,610
>> కాబట్టి మీరు నిజంగా అవసరం లేదు
ఈ అర్థం.

53
00:02:55,610 --> 00:02:59,460
మరియు వాస్తవానికి, మేము ఈ లాగి
ఇంటర్నెట్ నుండి ఫంక్షన్ హాష్.

54
00:02:59,460 --> 00:03:04,010
మీరు గుర్తించడానికి అవసరం మాత్రమే విషయం
ఈ ఒక కాన్స్ట్ చార్ * పదం పడుతుంది,

55
00:03:04,010 --> 00:03:08,960
ఇది ఇన్పుట్ వంటి స్ట్రింగ్ తీసుకుని యొక్క
అవుట్పుట్ ఒక Int సైన్ చేయని తిరిగి.

56
00:03:08,960 --> 00:03:12,360
కాబట్టి అన్ని హాష్ విధి ఉంది, ఇది
ఒక ఇన్పుట్ లో పడుతుంది, మీరు ఒక ఇస్తుంది

57
00:03:12,360 --> 00:03:14,490
హాష్ పట్టిక లోకి సూచిక.

58
00:03:14,490 --> 00:03:18,530
మేము NUM_BUCKETS ద్వారా modding గమనించవచ్చు
కాబట్టి హాష్ విలువ తిరిగి

59
00:03:18,530 --> 00:03:21,730
నిజానికి హాష్ పట్టిక ఒక సూచి ఉంది
మరియు చేస్తుంది దాటి సూచిక

60
00:03:21,730 --> 00:03:24,320
శ్రేణి యొక్క సరిహద్దులు.

61
00:03:24,320 --> 00:03:27,855
>> కాబట్టి హాష్ విధి, మేము వెళుతున్న ఇచ్చిన
మేము చదివే పదం హాష్తో

62
00:03:27,855 --> 00:03:31,700
నిఘంటువు నుండి మరియు అప్పుడు మేము చూడాలని
ఆ ఉపయోగించడానికి ఇన్సర్ట్ ఉంది

63
00:03:31,700 --> 00:03:33,750
హాష్ పట్టిక ప్రవేశం.

64
00:03:33,750 --> 00:03:38,830
ఇప్పుడు, hashtable హాష్ ప్రస్తుత ఉంది
లింక్ హాష్ పట్టిక లో జాబితా, మరియు

65
00:03:38,830 --> 00:03:41,410
ఇది కేవలం NULL అని చాలా అవకాశం ఉంది.

66
00:03:41,410 --> 00:03:45,640
మేము మా ఎంట్రీ ఇన్సర్ట్
ఈ లింక్ జాబితా ప్రారంభం, అందువలన

67
00:03:45,640 --> 00:03:48,910
మేము మా ప్రస్తుత ఎంట్రీ చూడాలని
ప్రస్తుతం ఏమి హాష్ పట్టిక సూచించడానికి

68
00:03:48,910 --> 00:03:54,030
పాయింట్లకు ఆపై మేము నిల్వ చూడాలని
హాష్ వద్ద హాష్ పట్టిక లో

69
00:03:54,030 --> 00:03:55,350
ప్రస్తుత ఎంట్రీ.

70
00:03:55,350 --> 00:03:59,320
>> కాబట్టి ఈ రెండు పంక్తులు విజయవంతంగా ఇన్సర్ట్
ప్రారంభంలో ఎంట్రీ

71
00:03:59,320 --> 00:04:02,270
ఆ సూచిక వద్ద లింక్ జాబితా
హాష్ పట్టిక లో.

72
00:04:02,270 --> 00:04:04,900
మేము పూర్తి చేసిన తర్వాత, మేము తెలుసు
మేము మరొక పదం దొరకలేదు

73
00:04:04,900 --> 00:04:07,800
నిఘంటువు మరియు మేము తిరిగి పెంచడం.

74
00:04:07,800 --> 00:04:13,960
కాబట్టి మేము చేస్తున్న కొనసాగించండి fscanf వరకు
చివరకు వద్ద కాని ఏదో 1 తిరిగి

75
00:04:13,960 --> 00:04:18,560
ఇది పాయింట్ మేము అవసరం గుర్తుంచుకోవాలి
ఉచిత ప్రవేశం, కాబట్టి ఇక్కడ, మేము ఒక malloced

76
00:04:18,560 --> 00:04:21,329
ఎంట్రీ మరియు మేము ఏదో చదవడానికి ప్రయత్నించారని
నిఘంటువు నుండి.

77
00:04:21,329 --> 00:04:24,110
మరియు మేము విజయవంతంగా చదవలేదు
నిఘంటువు నుండి ఏదో దీనిలో

78
00:04:24,110 --> 00:04:27,440
కేసు మనం ఎంట్రీ విడిపించేందుకు అవసరం
నిజానికి హాష్ పట్టిక చాలు ఎప్పుడూ

79
00:04:27,440 --> 00:04:29,110
చివరకు బ్రేక్.

80
00:04:29,110 --> 00:04:32,750
>> మేము అధిగమిస్తే, మేము, బాగా, చూడండి అవసరం
మేము ఎందుకంటే అక్కడ పోగొట్టుకున్నారు

81
00:04:32,750 --> 00:04:35,840
లోపం ఫైలు చదవడం, లేదా
మేము చేరుకున్నందున మేము పోగొట్టుకున్నారు

82
00:04:35,840 --> 00:04:37,120
ఫైలు చివర?

83
00:04:37,120 --> 00:04:40,150
లోపం ఉంది, అప్పుడు మేము మీరు
లోడ్ ఎందుకంటే తప్పుడు తిరిగి

84
00:04:40,150 --> 00:04:43,260
విజయవంతం, ఈవిడ, మేము మీరు
మేము చదివే అన్ని పదాలు దించుతున్న

85
00:04:43,260 --> 00:04:45,670
మరియు లో నిఘంటువు ఫైలు దగ్గరగా.

86
00:04:45,670 --> 00:04:48,740
మేము విజయం సాధించాడు ఊహించి తర్వాత మేము
ఇప్పటికీ నిఘంటువు దగ్గరగా అవసరం

87
00:04:48,740 --> 00:04:51,970
ఫైల్, మరియు చివరకు నుండి నిజమైన తిరిగి
మేము విజయవంతంగా లోడ్ చేసిన

88
00:04:51,970 --> 00:04:53,040
నిఘంటువు.

89
00:04:53,040 --> 00:04:54,420
మరియు ఆ లోడ్ కోసం ఇది.

90
00:04:54,420 --> 00:04:59,020
>> కాబట్టి ఇప్పుడు ఒక లోడ్ హాష్ పట్టిక ఇచ్చిన, తనిఖీ,
ఇలా అన్నారు.

91
00:04:59,020 --> 00:05:02,690
కాబట్టి, ఇది ఒక bool తిరిగి, తనిఖీ ఇది
సూచించడానికి అన్నారు లేదో

92
00:05:02,690 --> 00:05:07,530
ఆమోదించింది ఇన్ చార్ * పదం, అని
ఆమోదించింది ఇన్ స్ట్రింగ్ మా నిఘంటువులో లో ఉంది.

93
00:05:07,530 --> 00:05:10,530
నిఘంటువులో ఇది, కనుక ఉంటే
మా హాష్ పట్టిక లో, మేము తిరిగి

94
00:05:10,530 --> 00:05:13,380
నిజమైన, మరియు అది కాదు ఉంటే,
మేము తప్పుడు తిరిగి ఉంటుంది.

95
00:05:13,380 --> 00:05:17,770
ఈ ఆమోదించింది ఇన్ పదం ఇచ్చిన, మేము ఉన్నాము
పదం హాష్ అన్నారు.

96
00:05:17,770 --> 00:05:22,020
>> ఇప్పుడు, గుర్తించడానికి ఒక ముఖ్యమైన విషయం
లోడ్, మేము తెలుసు ఆ అన్ని

97
00:05:22,020 --> 00:05:25,820
పదాలు తక్కువ కేసు మాత్రం,
కానీ ఇక్కడ, మేము ఖచ్చితంగా లేదు.

98
00:05:25,820 --> 00:05:29,510
మేము మా హాష్ ఫంక్షన్ను పరిశీలించి ఉంటే,
నిజానికి మా హాష్ ఫంక్షన్ను

99
00:05:29,510 --> 00:05:32,700
ప్రతి పాత్ర lowercasing ఉంది
పదం యొక్క.

100
00:05:32,700 --> 00:05:37,580
కాబట్టి సంబంధం లేకుండా మూలధనీకరణ
పదం, మా హాష్ ఫంక్షన్ను అన్నారు

101
00:05:37,580 --> 00:05:42,270
సంసార కోసం అదే ఇండెక్స్ తిరిగి
క్యాపిటలైజేషన్ ఇది కలిగి ఉంటుంది ఉంది

102
00:05:42,270 --> 00:05:45,280
ఒక పూర్తిగా చిన్న కోసం తిరిగి
పదం యొక్క ప్రతి.

103
00:05:45,280 --> 00:05:45,950
అన్ని కుడి.

104
00:05:45,950 --> 00:05:47,410
>> కాబట్టి మా సూచిక ఉంది.

105
00:05:47,410 --> 00:05:49,790
ఈ పదం కోసం హాష్ పట్టిక యొక్క.

106
00:05:49,790 --> 00:05:52,940
ఇప్పుడు, లూప్ ఈ అన్నారు
అనుబంధ జాబితా పైగా కు

107
00:05:52,940 --> 00:05:55,000
ఆ సూచిక వద్ద ఉంది.

108
00:05:55,000 --> 00:05:59,630
కాబట్టి మేము ప్రవేశ ప్రారంభించడం గమనిస్తారు
ఆ సూచిక సూచించడానికి.

109
00:05:59,630 --> 00:06:03,480
మేము ఎంట్రీ ఉన్నప్పటికీ కొనసాగించడానికి వెళుతున్న
సమాన NULL, మరియు గుర్తు

110
00:06:03,480 --> 00:06:08,350
మా లింక్ జాబితాలో పాయింటర్ నవీకరించడాన్ని
ఎంట్రీ తదుపరి ప్రవేశ> సమానం, కాబట్టి కలిగి

111
00:06:08,350 --> 00:06:13,840
మా ప్రస్తుత ఎంట్రీ పాయింట్
లింక్ జాబితాలోని తదుపరి అంశాన్ని.

112
00:06:13,840 --> 00:06:14,400
అన్ని కుడి.

113
00:06:14,400 --> 00:06:19,150
>> కాబట్టి లింక్ జాబితాలో ప్రతి ఎంట్రీ కోసం,
మేము strcasecmp ఉపయోగించడానికి వెళుతున్న.

114
00:06:19,150 --> 00:06:23,780
ఇది strcmp కాదు ఎందుకంటే మరోసారి, మేము
insensitively విషయాలు కేసు చేయాలనుకుంటున్నారా.

115
00:06:23,780 --> 00:06:28,830
కాబట్టి మేము, పదం పోల్చడానికి strcasecmp ఉపయోగించడానికి
ఈ ఫంక్షన్ జారీ చేశారు

116
00:06:28,830 --> 00:06:31,860
పదం వ్యతిరేకంగా
ఈ ఎంట్రీ లో ఉంది.

117
00:06:31,860 --> 00:06:35,570
ఇది 0 తిరిగి, ఆ ఉంది అర్థం
మేము కోరుకుంటున్న సందర్భంలో ఒక మ్యాచ్,

118
00:06:35,570 --> 00:06:36,630
నిజమైన తిరిగి.

119
00:06:36,630 --> 00:06:39,590
ఉలవపాడు దొరకలేదు
మా హాష్ పట్టిక లో పదం.

120
00:06:39,590 --> 00:06:43,040
>> ఒక మ్యాచ్ లేదు, అప్పుడు మేము
మళ్ళీ లూప్ వెళ్లి చూడండి

121
00:06:43,040 --> 00:06:43,990
తదుపరి ఎంట్రీ.

122
00:06:43,990 --> 00:06:47,640
మరియు మేము అయితే మళ్ళీ వెతికినా చేస్తాము
ఈ లింక్ జాబితాలో ప్రవేశాలు.

123
00:06:47,640 --> 00:06:50,160
మేము బ్రేక్ ఏమవుతుంది
లూప్ ఈ బయటకు?

124
00:06:50,160 --> 00:06:55,110
మేము ప్రవేశమును కనుగొనలేదు అంటే
ఈ సందర్భంలో, ఈ పదం సరిపోలే

125
00:06:55,110 --> 00:07:00,220
మేము సూచించడానికి తప్పుడు తిరిగి మా
హాష్ పట్టిక ఈ పదం కలిగి లేదు.

126
00:07:00,220 --> 00:07:01,910
మరియు ఆ చెక్ కోసం ఇది.

127
00:07:01,910 --> 00:07:02,540
అన్ని కుడి.

128
00:07:02,540 --> 00:07:04,790
>> కాబట్టి యొక్క పరిమాణం పరిశీలించి వీలు.

129
00:07:04,790 --> 00:07:09,280
ఇప్పుడు, పరిమాణం అందంగా సాధారణ అన్నారు
నుండి ప్రతి పదం కోసం, లోడ్ గుర్తు

130
00:07:09,280 --> 00:07:12,880
మేము ఒక ప్రపంచ పెరుగుదల దొరకలేదు
వేరియబుల్ hashtable_size.

131
00:07:12,880 --> 00:07:15,830
కాబట్టి పరిమాణం ఫంక్షన్ కేవలం ఉంది
ప్రపంచ తిరిగి వెళుతున్న

132
00:07:15,830 --> 00:07:18,150
వేరియబుల్, అంతే.

133
00:07:18,150 --> 00:07:22,300
>> ఇప్పుడు చివరకు, మేము దించుతున్న అవసరం
నిఘంటువు ప్రతిదీ ఒకసారి.

134
00:07:22,300 --> 00:07:25,340
కాబట్టి మేము ఎలా అలా వెళ్తున్నారు?

135
00:07:25,340 --> 00:07:30,440
ఇక్కడే, మేము అన్ని పైగా మళ్ళీ వెతికినా
మా హాష్ పట్టిక బకెట్లు.

136
00:07:30,440 --> 00:07:33,240
కాబట్టి NUM_BUCKETS బకెట్లు ఉన్నాయి.

137
00:07:33,240 --> 00:07:37,490
మరియు మా హాష్ లో ప్రతి లింక్ జాబితా కోసం
పట్టిక, మేము లూప్ చూడాలని

138
00:07:37,490 --> 00:07:41,070
అనుబంధ జాబితా యొక్క మొత్తం
ప్రతి మూలకం ఉండండి.

139
00:07:41,070 --> 00:07:46,070
ఇప్పుడు, మేము జాగ్రత్తగా ఉండాలి, ఇక్కడ మేము
ఒక తాత్కాలిక వేరియబుల్

140
00:07:46,070 --> 00:07:49,740
తదుపరి పాయింటర్ నిల్వ
లింక్ జాబితాలో మూలకం.

141
00:07:49,740 --> 00:07:52,140
మరియు తర్వాత మేము ఉచిత చూడాలని
ప్రస్తుత మూలకం.

142
00:07:52,140 --> 00:07:55,990
>> మేము మేము నుండి దీన్ని ఖచ్చితంగా ఉండాలి
కేవలం ప్రస్తుత మూలకం ఉచితం కాదు

143
00:07:55,990 --> 00:07:59,260
తరువాత పాయింటర్ యాక్సెస్ ప్రయత్నించండి
నుండి ఒకసారి మేము విముక్తి

144
00:07:59,260 --> 00:08:00,870
మెమరీ చెల్లని అవుతుంది.

145
00:08:00,870 --> 00:08:04,990
కాబట్టి మేము ఒక పాయింటర్ చుట్టూ ఉంచడానికి అవసరం
తదుపరి మూలకం, అప్పుడు మేము పొందగలరు

146
00:08:04,990 --> 00:08:08,360
ప్రస్తుత మూలకం, మరియు అప్పుడు మేము నవీకరించవచ్చు
సూచించడానికి మా ప్రస్తుత మూలకం

147
00:08:08,360 --> 00:08:09,590
తదుపరి మూలకం.

148
00:08:09,590 --> 00:08:12,770
>> మేము అంశాలను లూప్ ఉన్నాయి ఉన్నప్పుడు
ఈ లింక్ జాబితాలో.

149
00:08:12,770 --> 00:08:16,450
మేము అన్ని లింక్ జాబితాలు ఆ చేస్తాను
హాష్ పట్టిక, మరియు మేము పూర్తి చేశాక

150
00:08:16,450 --> 00:08:20,180
ఆ, మేము పూర్తిగా గుళ్ళను చేసిన
హాష్ పట్టిక, మరియు మేము పూర్తి చేసిన.

151
00:08:20,180 --> 00:08:24,050
కనుక ఇది unloads కోసం ఎప్పుడూ అసాధ్యం
తప్పుడు తిరిగి, మరియు మేము పూర్తి చేసినప్పుడు, మేము

152
00:08:24,050 --> 00:08:25,320
కేవలం నిజమైన తిరిగి.

153
00:08:25,320 --> 00:08:27,563