>> రాబ్ బౌడెన్: ఎక్కువ.
నేను రాబ్ ఉన్నాను, మరియు లెట్స్ హాష్ ఈ పరిష్కారాన్ని.
కాబట్టి ఇక్కడ అమలు చూడాలని ఒక సాధారణ హాష్ పట్టిక.
మేము చూడండి మా హాష్ Struct నోడ్ పట్టిక ఇలా అన్నారు.
కనుక ఇది ఒక చార్ పదం కలిగి జరగబోతోంది పరిమాణం పొడవు ప్లస్ 1 శ్రేణి.
గరిష్ట నుండి 1 మరువకండి నిఘంటువులో పదాన్ని 45 ఉంది
అక్షరాలు, ఆపై మేము చూడాలని ఒక అదనపు పాత్ర అవసరం
బాక్ స్లాష్ 0.
>> ఆపై ప్రతి లో మా హాష్ పట్టిక బకెట్ నిల్వ అన్నారు ఒక
ల లింక్ జాబితా.
మేము ఇక్కడ పరిశీలించకుండా సరళ చేయడం లేదు.
అందువలన క్రమంలో తదుపరి లింక్ బకెట్ లో మూలకం, మేము ఒక అవసరం
struct నోడ్ * తదుపరి.
కాబట్టి ఒక నోడ్ కనిపిస్తోంది ఉంది.
ఇప్పుడు, ఇక్కడ ప్రకటన మా హాష్ పట్టిక.
ఇది 16.384 బకెట్లు కలిగి జరగబోతోంది కానీ ఆ సంఖ్య నిజంగా పట్టింపు లేదు.
చివరకు, మేము చూడాలని ప్రపంచ వేరియబుల్ hashtable_size, ఇది
0 గా కాకుండా ప్రారంభించు అన్నారు, మరియు అది ఉంది ట్రాక్ అన్నారు ఎన్ని పదాలు
మా నిఘంటువులో లో ఉన్నాయి.
అన్ని కుడి.
>> కాబట్టి యొక్క లోడ్ పరిశీలించి వీలు.
కాబట్టి ఆ లోడ్ గమనించి, ఇది ఒక bool తిరిగి.
ఇది విజయవంతంగా ఉంటే మీరు నిజమైన తిరిగి లేకపోతే లోడ్ మరియు తప్పుడు.
మరియు అది ఒక కాన్స్ట్ చార్ * స్టార్ పడుతుంది నిఘంటువు ఇది నిఘంటువు,
మేము తెరవడానికి కావలసిన.
కాబట్టి ఆ మొదటి విషయం మేము చేయబోతున్నామని.
మేము కోసం నిఘంటువులో fopen చూడాలని చదవడం, మరియు మేము చూడాలని
ఇది అయితే విజయం నిర్ధారించుకోండి ఇది NULL తిరిగి, అప్పుడు మేము కాదు
విజయవంతంగా నిఘంటువు తెరిచి మరియు మేము తప్పుడు తిరిగి.
>> కానీ విజయవంతంగా అని ఊహిస్తూ ఓపెన్, అప్పుడు మేము చదవాలనుకుంటున్న
నిఘంటువు.
మేము కొన్ని కనుగొనేందుకు వరకు మళ్ళీ వెతికినా ఉంచడానికి ఈ బయటకు కారణం
మేము చూస్తారు లూప్.
కాబట్టి మళ్ళీ వెతికినా ఉంచడానికి, మరియు ఇప్పుడు మేము చూడాలని ఒక నోడ్ malloc కు.
మరియు కోర్సు యొక్క, మేము చెక్ తప్పొప్పులకు అవసరం మళ్ళీ mallocing విజయవంతం కాలేదు కనుక
మరియు మేము ఆ మేము ఏ నోడ్ దించుతున్న మీరు ముందు malloc జరిగింది, దగ్గరగా
నిఘంటువు మరియు తప్పుడు తిరిగి.
>> కానీ ఆ విస్మరించి, ఊహిస్తూ మేము విజయం, అప్పుడు మేము fscanf ఉపయోగించడానికి
నుండి ఒకే పదం చదవడానికి మా మా నోడ్ నిఘంటువు.
కాబట్టి ఆ ప్రవేశ> పదం గుర్తు చార్ పదం పరిమాణం పొడవు బఫర్ ప్లస్
మేము చూడాలని ఒక సైన్ పదాన్ని నిల్వ
కాబట్టి fscanf 1 కాలం తిరిగి అన్నారు ఇది విజయవంతంగా ఒక చదవగలిగాను వంటి
ఫైలు నుండి పదం.
>> లోపం గాని జరుగుతుంది లేదా మేము చేరే ఫైలు చివర, అది లేదు
అది కాకపోతే సందర్భంలో 1 తిరిగి 1 తిరిగి, మేము చివరకు బ్రేక్ చూడాలని
ఈ సమయంలో లూప్ బయటకు.
కాబట్టి మేము, మేము విజయవంతంగా ఉంటాయి ఒక పదాన్ని చదవడానికి
ప్రవేశ> పదం, అప్పుడు మేము హాష్ చూడాలని మా హాష్ ఫంక్షన్ను ఉపయోగించి ఆ పదం.
యొక్క పరిశీలించి లెట్ హాష్ ఫంక్షన్ను.
>> కాబట్టి మీరు నిజంగా అవసరం లేదు ఈ అర్థం.
మరియు వాస్తవానికి, మేము ఈ లాగి ఇంటర్నెట్ నుండి ఫంక్షన్ హాష్.
మీరు గుర్తించడానికి అవసరం మాత్రమే విషయం ఈ ఒక కాన్స్ట్ చార్ * పదం పడుతుంది,
ఇది ఇన్పుట్ వంటి స్ట్రింగ్ తీసుకుని యొక్క అవుట్పుట్ ఒక Int సైన్ చేయని తిరిగి.
కాబట్టి అన్ని హాష్ విధి ఉంది, ఇది ఒక ఇన్పుట్ లో పడుతుంది, మీరు ఒక ఇస్తుంది
హాష్ పట్టిక లోకి సూచిక.
మేము NUM_BUCKETS ద్వారా modding గమనించవచ్చు కాబట్టి హాష్ విలువ తిరిగి
నిజానికి హాష్ పట్టిక ఒక సూచి ఉంది మరియు చేస్తుంది దాటి సూచిక
శ్రేణి యొక్క సరిహద్దులు.
>> కాబట్టి హాష్ విధి, మేము వెళుతున్న ఇచ్చిన మేము చదివే పదం హాష్తో
నిఘంటువు నుండి మరియు అప్పుడు మేము చూడాలని ఆ ఉపయోగించడానికి ఇన్సర్ట్ ఉంది
హాష్ పట్టిక ప్రవేశం.
ఇప్పుడు, hashtable హాష్ ప్రస్తుత ఉంది లింక్ హాష్ పట్టిక లో జాబితా, మరియు
ఇది కేవలం NULL అని చాలా అవకాశం ఉంది.
మేము మా ఎంట్రీ ఇన్సర్ట్ ఈ లింక్ జాబితా ప్రారంభం, అందువలన
మేము మా ప్రస్తుత ఎంట్రీ చూడాలని ప్రస్తుతం ఏమి హాష్ పట్టిక సూచించడానికి
పాయింట్లకు ఆపై మేము నిల్వ చూడాలని హాష్ వద్ద హాష్ పట్టిక లో
ప్రస్తుత ఎంట్రీ.
>> కాబట్టి ఈ రెండు పంక్తులు విజయవంతంగా ఇన్సర్ట్ ప్రారంభంలో ఎంట్రీ
ఆ సూచిక వద్ద లింక్ జాబితా హాష్ పట్టిక లో.
మేము పూర్తి చేసిన తర్వాత, మేము తెలుసు మేము మరొక పదం దొరకలేదు
నిఘంటువు మరియు మేము తిరిగి పెంచడం.
కాబట్టి మేము చేస్తున్న కొనసాగించండి fscanf వరకు చివరకు వద్ద కాని ఏదో 1 తిరిగి
ఇది పాయింట్ మేము అవసరం గుర్తుంచుకోవాలి ఉచిత ప్రవేశం, కాబట్టి ఇక్కడ, మేము ఒక malloced
ఎంట్రీ మరియు మేము ఏదో చదవడానికి ప్రయత్నించారని నిఘంటువు నుండి.
మరియు మేము విజయవంతంగా చదవలేదు నిఘంటువు నుండి ఏదో దీనిలో
కేసు మనం ఎంట్రీ విడిపించేందుకు అవసరం నిజానికి హాష్ పట్టిక చాలు ఎప్పుడూ
చివరకు బ్రేక్.
>> మేము అధిగమిస్తే, మేము, బాగా, చూడండి అవసరం మేము ఎందుకంటే అక్కడ పోగొట్టుకున్నారు
లోపం ఫైలు చదవడం, లేదా మేము చేరుకున్నందున మేము పోగొట్టుకున్నారు
ఫైలు చివర?
లోపం ఉంది, అప్పుడు మేము మీరు లోడ్ ఎందుకంటే తప్పుడు తిరిగి
విజయవంతం, ఈవిడ, మేము మీరు మేము చదివే అన్ని పదాలు దించుతున్న
మరియు లో నిఘంటువు ఫైలు దగ్గరగా.
మేము విజయం సాధించాడు ఊహించి తర్వాత మేము ఇప్పటికీ నిఘంటువు దగ్గరగా అవసరం
ఫైల్, మరియు చివరకు నుండి నిజమైన తిరిగి మేము విజయవంతంగా లోడ్ చేసిన
నిఘంటువు.
మరియు ఆ లోడ్ కోసం ఇది.
>> కాబట్టి ఇప్పుడు ఒక లోడ్ హాష్ పట్టిక ఇచ్చిన, తనిఖీ, ఇలా అన్నారు.
కాబట్టి, ఇది ఒక bool తిరిగి, తనిఖీ ఇది సూచించడానికి అన్నారు లేదో
ఆమోదించింది ఇన్ చార్ * పదం, అని ఆమోదించింది ఇన్ స్ట్రింగ్ మా నిఘంటువులో లో ఉంది.
నిఘంటువులో ఇది, కనుక ఉంటే మా హాష్ పట్టిక లో, మేము తిరిగి
నిజమైన, మరియు అది కాదు ఉంటే, మేము తప్పుడు తిరిగి ఉంటుంది.
ఈ ఆమోదించింది ఇన్ పదం ఇచ్చిన, మేము ఉన్నాము పదం హాష్ అన్నారు.
>> ఇప్పుడు, గుర్తించడానికి ఒక ముఖ్యమైన విషయం లోడ్, మేము తెలుసు ఆ అన్ని
పదాలు తక్కువ కేసు మాత్రం, కానీ ఇక్కడ, మేము ఖచ్చితంగా లేదు.
మేము మా హాష్ ఫంక్షన్ను పరిశీలించి ఉంటే, నిజానికి మా హాష్ ఫంక్షన్ను
ప్రతి పాత్ర lowercasing ఉంది పదం యొక్క.
కాబట్టి సంబంధం లేకుండా మూలధనీకరణ పదం, మా హాష్ ఫంక్షన్ను అన్నారు
సంసార కోసం అదే ఇండెక్స్ తిరిగి క్యాపిటలైజేషన్ ఇది కలిగి ఉంటుంది ఉంది
ఒక పూర్తిగా చిన్న కోసం తిరిగి పదం యొక్క ప్రతి.
అన్ని కుడి.
>> కాబట్టి మా సూచిక ఉంది.
ఈ పదం కోసం హాష్ పట్టిక యొక్క.
ఇప్పుడు, లూప్ ఈ అన్నారు అనుబంధ జాబితా పైగా కు
ఆ సూచిక వద్ద ఉంది.
కాబట్టి మేము ప్రవేశ ప్రారంభించడం గమనిస్తారు ఆ సూచిక సూచించడానికి.
మేము ఎంట్రీ ఉన్నప్పటికీ కొనసాగించడానికి వెళుతున్న సమాన NULL, మరియు గుర్తు
మా లింక్ జాబితాలో పాయింటర్ నవీకరించడాన్ని ఎంట్రీ తదుపరి ప్రవేశ> సమానం, కాబట్టి కలిగి
మా ప్రస్తుత ఎంట్రీ పాయింట్ లింక్ జాబితాలోని తదుపరి అంశాన్ని.
అన్ని కుడి.
>> కాబట్టి లింక్ జాబితాలో ప్రతి ఎంట్రీ కోసం, మేము strcasecmp ఉపయోగించడానికి వెళుతున్న.
ఇది strcmp కాదు ఎందుకంటే మరోసారి, మేము insensitively విషయాలు కేసు చేయాలనుకుంటున్నారా.
కాబట్టి మేము, పదం పోల్చడానికి strcasecmp ఉపయోగించడానికి ఈ ఫంక్షన్ జారీ చేశారు
పదం వ్యతిరేకంగా ఈ ఎంట్రీ లో ఉంది.
ఇది 0 తిరిగి, ఆ ఉంది అర్థం మేము కోరుకుంటున్న సందర్భంలో ఒక మ్యాచ్,
నిజమైన తిరిగి.
ఉలవపాడు దొరకలేదు మా హాష్ పట్టిక లో పదం.
>> ఒక మ్యాచ్ లేదు, అప్పుడు మేము మళ్ళీ లూప్ వెళ్లి చూడండి
తదుపరి ఎంట్రీ.
మరియు మేము అయితే మళ్ళీ వెతికినా చేస్తాము ఈ లింక్ జాబితాలో ప్రవేశాలు.
మేము బ్రేక్ ఏమవుతుంది లూప్ ఈ బయటకు?
మేము ప్రవేశమును కనుగొనలేదు అంటే ఈ సందర్భంలో, ఈ పదం సరిపోలే
మేము సూచించడానికి తప్పుడు తిరిగి మా హాష్ పట్టిక ఈ పదం కలిగి లేదు.
మరియు ఆ చెక్ కోసం ఇది.
అన్ని కుడి.
>> కాబట్టి యొక్క పరిమాణం పరిశీలించి వీలు.
ఇప్పుడు, పరిమాణం అందంగా సాధారణ అన్నారు నుండి ప్రతి పదం కోసం, లోడ్ గుర్తు
మేము ఒక ప్రపంచ పెరుగుదల దొరకలేదు వేరియబుల్ hashtable_size.
కాబట్టి పరిమాణం ఫంక్షన్ కేవలం ఉంది ప్రపంచ తిరిగి వెళుతున్న
వేరియబుల్, అంతే.
>> ఇప్పుడు చివరకు, మేము దించుతున్న అవసరం నిఘంటువు ప్రతిదీ ఒకసారి.
కాబట్టి మేము ఎలా అలా వెళ్తున్నారు?
ఇక్కడే, మేము అన్ని పైగా మళ్ళీ వెతికినా మా హాష్ పట్టిక బకెట్లు.
కాబట్టి NUM_BUCKETS బకెట్లు ఉన్నాయి.
మరియు మా హాష్ లో ప్రతి లింక్ జాబితా కోసం పట్టిక, మేము లూప్ చూడాలని
అనుబంధ జాబితా యొక్క మొత్తం ప్రతి మూలకం ఉండండి.
ఇప్పుడు, మేము జాగ్రత్తగా ఉండాలి, ఇక్కడ మేము ఒక తాత్కాలిక వేరియబుల్
తదుపరి పాయింటర్ నిల్వ లింక్ జాబితాలో మూలకం.
మరియు తర్వాత మేము ఉచిత చూడాలని ప్రస్తుత మూలకం.
>> మేము మేము నుండి దీన్ని ఖచ్చితంగా ఉండాలి కేవలం ప్రస్తుత మూలకం ఉచితం కాదు
తరువాత పాయింటర్ యాక్సెస్ ప్రయత్నించండి నుండి ఒకసారి మేము విముక్తి
మెమరీ చెల్లని అవుతుంది.
కాబట్టి మేము ఒక పాయింటర్ చుట్టూ ఉంచడానికి అవసరం తదుపరి మూలకం, అప్పుడు మేము పొందగలరు
ప్రస్తుత మూలకం, మరియు అప్పుడు మేము నవీకరించవచ్చు సూచించడానికి మా ప్రస్తుత మూలకం
తదుపరి మూలకం.
>> మేము అంశాలను లూప్ ఉన్నాయి ఉన్నప్పుడు ఈ లింక్ జాబితాలో.
మేము అన్ని లింక్ జాబితాలు ఆ చేస్తాను హాష్ పట్టిక, మరియు మేము పూర్తి చేశాక
ఆ, మేము పూర్తిగా గుళ్ళను చేసిన హాష్ పట్టిక, మరియు మేము పూర్తి చేసిన.
కనుక ఇది unloads కోసం ఎప్పుడూ అసాధ్యం తప్పుడు తిరిగి, మరియు మేము పూర్తి చేసినప్పుడు, మేము
కేవలం నిజమైన తిరిగి.