ZAMYLA చాన్: యొక్క లెట్ ఒక స్పెల్ చెక్కర్. మీరు speller.c తెరిచి, మీరు చూస్తారు ఆ కోసం కార్యాచరణ యొక్క అత్యంత ఒక వ్యతిరేకంగా ఒక టెక్స్ట్ ఫైల్ తనిఖీ నిఘంటువు ఇప్పటికే మీరు తయారు. ఒక నిఘంటువు టెక్స్ట్ లో ప్రయాణిస్తున్న. / స్పెల్లర్, ఫైల్ మరియు వేరొక టెక్స్ట్ ఫైల్, టెక్స్ట్ ఫైల్ తనిఖీ చేస్తుంది నిఘంటువు వ్యతిరేకంగా. 

ఇప్పుడు, నిఘంటువు టెక్స్ట్ ఫైళ్లు ఉంటాయి చెల్లుబాటు అయ్యే పదాలు, లైనుకు ఒక. అప్పుడు speller.c లోడ్ కాల్ చేస్తుంది నిఘంటువు టెక్స్ట్ ఫైల్ లో. ఇది అనే ఫంక్షన్ తనిఖీ పిలుస్తాను ఇన్పుట్ టెక్స్ట్ ఫైల్ లో ప్రతి పదం, అన్ని తప్పుగా పదాలు ప్రింటింగ్. 

Speller.c కూడా పరిమాణం కాల్ చేస్తుంది పదాల సంఖ్య నిర్ణయించడానికి నిఘంటువు మరియు కాల్ దించుతున్న మెమరీ వరకు ఉచితం. speller.c కూడా ఎలా ట్రాక్ చేస్తుంది ఎక్కువ సమయం వీటిలో నిర్వహించడానికి ఉపయోగించబడుతుంది ప్రక్రియలు, కాని మేము చేస్తాము ఆ ను. 

కాబట్టి మేము ఏమి చేయాలి? మేము dictionary.c పూరించడానికి అవసరం. Dictionary.c, మేము సహాయక కలిగి లోడుచేస్తుంది ఫంక్షన్ లోడ్, నిఘంటువు. ఉంటే తనిఖీ ఫంక్షన్ తనిఖీ, ఒక నిఘంటువులో పదం. ఫంక్షన్ సైజు సంఖ్య తిరిగి నిఘంటువు పదాలు. చివరకు, మేము, దించుతున్న ఇది మెమరీ నుంచి నిఘంటువు కాపాడి. 

కాబట్టి మొదటి, యొక్క లోడ్ పరిష్కరించడానికి వీలు. నిఘంటువు టెక్స్ట్ ప్రతి పదం కోసం ఫైలు, లోడ్ లో ఆ పదాలు నిల్వ ఉంటుంది నిఘంటువు డేటా నిర్మాణం మీ కిష్టమైన, ఒక యొక్క పట్టిక లేదా ఒక trie హాష్. నేను రెండు వెళ్తారో ఈ నడవడానికి. 

మొదటి యొక్క హాష్ పట్టికలు గురించి చర్చ తెలియజేయండి. మీరు 10 బిలియర్డ్స్ బంతులు చెప్పారో మీరు వాటిని నిల్వ అనుకున్నారు. మీరు ఒక బకెట్ వాటిని అన్ని ఉంచారు, మరియు మీరు ఒక నిర్దిష్ట అవసరమైనప్పుడు బంతి సంఖ్య, మీరు ఒక తీసుకుని కావలసిన ఒక సమయంలో బకెట్ బయటకు బంతి కోసం చూస్తున్న. మరియు మాత్రమే 10 బంతుల్లో తో, మీరు ఉండాలి ఒక సహేతుకమైన లో మీ బంతి కనుగొనగలరు సమయం. 

కానీ మీరు 20 బంతుల్లో కలిగి ఉంటే? అది ఇప్పుడు చిన్న ఇక పడుతుంది. ఏ 100 గురించి? 1,000? ఇప్పుడు, చాలా సులభంగా ఉంటుంది ఉంటే మీరు బహుళ బకెట్లు కలిగి. బహుశా బంతుల్లో ఒక బకెట్ సున్నా సంఖ్య తొమ్మిది, కోసం మరొక బకెట్ ద్వారా బంతుల్లో 10 ద్వారా సంఖ్య 19, అందువలన న. 

ఇప్పుడు మీరు నిర్దిష్ట కోసం చూడండి అవసరం ఉన్నప్పుడు బంతి, మీరు స్వయంచాలకంగా అని ఒక నిర్దిష్ట బకెట్ వెళ్లి ఆ బకెట్ ద్వారా శోధించండి. మరియు ప్రతి బకెట్ సుమారు 10 కలిగి ఉంటే బంతుల్లో, మీరు సులభంగా అన్వేషణ కాలేదు ఇది ద్వారా. 

ఇప్పుడు, మేము వ్యవహరించే ఉన్నందున నిఘంటువులు, ఒక్క బకెట్ నిఘంటువు పదాలు అన్ని రెడీ బహుశా చాలా కొద్ది బకెట్లు ఉంటుంది. కాబట్టి యొక్క హాష్ పట్టికలు పరిశీలించి వీలు. 

బకెట్లు వ్యూహం గా భావిస్తారు. మరియు ఈ సందర్భంలో, బకెట్లు మా అనుబంధ జాబితాలు ఉన్నాయి. మరియు మేము మా పదాలు అన్ని పంపిణీ చేస్తాము ఈ అనేక లింక్ జాబితాలు లో మధ్య ఒక హాష్ ఫంక్షన్ను ఉపయోగించి ఒక వ్యవస్థీకృత విధంగా, మాకు చేస్తుంది ఇది ఒక కీ బకెట్ ఇచ్చిన పదం, చెందుతుంది. 

యొక్క చిత్రరూపంలో ఈ భావించండి. ఇక్కడ నీలం రంగు బాక్స్ విలువలు కలిగి మరియు ఎరుపు బాక్సులను మరొక విలువ సూచించడానికి పాయింటర్ జత. మేము ఈ జతల నోడ్స్ పిలుస్తాను. ఇప్పుడు, ప్రతి బకెట్, నేను చెప్పారు ముందు, ఒక అనుబంధ జాబితా ఉంది. లింక్ జాబితాలు, ప్రతి నోడ్ ఒక విలువ, అలాగే ఒక పాయింటర్ తదుపరి విలువ. 

ఇప్పుడు, లింక్ జాబితాలు వ్యవహరించే, ఇది చాలా ముఖ్యం మీరు ఆ ఏ లింకులు కోల్పోతారు లేదు. మరియు గుర్తుంచుకోవడానికి మరొక నిజానికి అని చివరి నోడ్, అది సూచించడానికి లేదు మరొక నోడ్, పాయింట్లు శూన్యం కు. 

కాబట్టి మేము ఎలా సి ఈ ప్రతిబింబించవు? మేము ఇక్కడ మా struct నిర్వచించే. మరియు ఈ సందర్భంలో విలువ పొడవు చార్ శ్రేణి. పొడవు ఉన్న పొడవు ప్లస్ 1, గరిష్ట ఏ పదం యొక్క పొడవు, ప్లస్ 1 కోసం శూన్య టెర్మినేటర్. మరియు తర్వాత మేము ఒక పాయింటర్ తదుపరి అని మరొక నోడ్. 

కాబట్టి యొక్క ఒక చిన్న లింక్ జాబితా చేయడానికి వీలు. మొదట, మీరు మీ నోడ్ malloc చెయ్యవచ్చును, మెమరీలో స్పేస్ సృష్టించడానికి ఇది మీ నోడ్ రకం పరిమాణం. మరియు మరొక నోడ్ తయారు, మళ్ళీ mallocing. 

ఇప్పుడు మీరు ఒక ఒక లెక్కించాల్సి అనుకుంటే పదం, అప్పుడు మేము node1 బాణం అనవచ్చు పదం "హలో." సమానం ఈ బాణం ఆపరేటర్లు పాయింటర్ మరియు dereferences struct యొక్క వేరియబుల్స్ యాక్సెస్. ఈ విధంగా, మేము రెండు ఉపయోగించడానికి లేదు డాట్ మరియు స్టార్ ఆపరేటర్లు. 

కాబట్టి నేను node2 బాణం పదం సమానం కలిగి "ప్రపంచ." మరియు, విలువలు నా నోడ్స్ జనావాస. లింకులు చేయడానికి, నేను node1 లో పాస్ చేస్తాము తదుపరి బాణం ఆ నోడ్ స్టార్ యాక్సెస్, ఆ నోడ్ పాయింటర్, node2 సమానం, రెండు node2 కు node1 పై. మరియు అక్కడ మేము లింక్ జాబితా. 

కాబట్టి కేవలం ఒక లింక్ జాబితా ఉంది, కానీ ఒక హాష్ పట్టిక వ్యూహరచనలు ఉంది లింక్ జాబితాలు. Well, మేము అదే నోడ్ ఉంటుంది ముందు రూపకల్పన చేస్తారు. కానీ మేము ఒక వాస్తవ హాష్ పట్టిక కోరుకుంటే, అప్పుడు మేము ఒక నోడ్ పాయింటర్ చేయవచ్చు ఇక్కడ శ్రేణి. ఉదాహరణకు, పరిమాణం 500. 

గమనించండిప్పుడు, ఒక వాణిజ్య ఉన్నట్లు జరగబోతోంది యొక్క పరిమాణం మధ్య మీ హాష్ పట్టిక మరియు పరిమాణం మీ లింక్ జాబితాలు. మీరు ఒక నిజంగా అధిక సంఖ్యలో కలిగి ఉంటే బకెట్లు, తిరిగి అమలు అవసరం ఊహించుకుని ముందుకు ఒక లైన్ లో మీ బకెట్ కనుగొనేందుకు. కానీ మీరు కూడా ఒక చిన్న సంఖ్య వద్దు బకెట్లు, అప్పుడు మేము తిరిగి ఉన్నారు ఎందుకంటే కలిగి ఎలా అసలు సమస్య మా బకెట్ లో చాలా బంతుల్లో. 

OK, కానీ మా బంతిని గడిచిపోయింది? బాగా, మేము మొదటి అవసరం కుడి, ఒక బంతిని? కాబట్టి యొక్క ప్రతి కోసం ఒక నోడ్ malloc తెలియజేయండి మేము కలిగి కొత్త పదం. నోడ్ * new_node సమానం malloc (sizeof (నోడ్)). 

మేము ఈ ఆకృతి ఇప్పుడు, మేము ఫంక్షన్ను ఉపయోగించి, లో స్కాన్ fscanf మా ఫైలు నుండి స్ట్రింగ్, ఉంటే ఆ లోకి, నిఘంటువు ఫైలు ఉంది new_node బాణం పదం, పేరు new_node బాణం పదం మా ఉంది ఆ పదం యొక్క గమ్యం. 

తదుపరి, మేము ఆ హాష్ చెయ్యవచ్చును ఒక హాష్ ఫంక్షన్ను ఉపయోగించి పదం. ఒక హాష్ ఫంక్షన్ను ఒక స్ట్రింగ్ తీసుకుని మరియు ఒక ఇండెక్స్ తిరిగి. ఈ సందర్భంలో, ఇండెక్స్ ఉంది సంఖ్య కంటే తక్కువ మీరు కలిగి బకెట్లు. 

ఇప్పుడు, హాష్ విధులు, మీరు ప్రయత్నిస్తున్న సమయంలో వారు కనుగొని ఒకటి సృష్టించడానికి మీ సొంత, గుర్తు వారు నిర్ణాయక ఉండాలి. అదే విలువ అవసరం ఉంది అదే బకెట్ ప్రతిసారీ మ్యాప్ మీరు హాష్ అని. 

ఇది రకమైన ఒక లైబ్రరీ వంటిది. మీరు ఒక పుస్తకాన్ని, తీసుకోవడం రచయిత, మీకు తెలిసిన ఇది షెల్ఫ్ అది ఇది షెల్ఫ్ సంఖ్య కావచ్చు, కొనసాగుతాయి ఒకటి, రెండు, లేదా మూడు. ఆ పుస్తకం ఎల్లప్పుడూ ఆన్ చెందిన ఉంటుంది షెల్ఫ్ ఒక రెండు, లేదా మూడు గాని. 

కాబట్టి, ఉంటే new_node బాణం పదం ఉంది మీ నిఘంటువు నుండి పదం, అప్పుడు హ్యాషింగ్ new_node బాణం పదం రెడీ మాకు ఇండెక్స్ ఇవ్వాలని హాష్ పట్టిక బకెట్. మరియు తర్వాత ఆ లోకి ఇన్సర్ట్ చేస్తాము సూచించిన నిర్దిష్ట అనుబంధ జాబితా మా హాష్ ఫంక్షన్ను విలువ తిరిగి. 

యొక్క ఒక ఉదాహరణ చూద్దాం ఒక నోడ్ ఇన్సర్ట్ ఒక లింక్ జాబితా ప్రారంభం. తల సూచించే ఒక నోడ్ పాయింటర్ ఉంటే ఒక లింక్ ప్రారంభంలో జాబితా, మరియు new_node కొత్త సూచిస్తుంది మీరు, లో నమోదు కావలసిన నోడ్ new_node తల కేటాయించి కోల్పోతుంది జాబితా మిగిలిన లింక్. కాబట్టి మేము ఈ అనుకుంటున్న. 

అయితే, మేము నిర్ధారించుకోవాలి మేము ప్రతి నిలిపివుంచే మా కార్యక్రమంలో ఒకే నోడ్. కాబట్టి అమలు new_node బాణం తర్వాత సమానం తల మరియు అప్పుడు తల new_node సమానం అన్ని జాగ్రత్తపరుస్తుంది లింకులు మరియు ఏ కోల్పోవద్దు. 

కానీ మీరు మీ జాబితా అని ఏమి అనుకుంటే ఒక క్రమబద్ధీకరించబడతాయి అనుసంధాన కలిగి ఎందుకంటే, క్రమబద్ధీకరించబడింది జాబితా కోసం సులభంగా ఉంటుంది తరువాత దీన్ని సంప్రదించండి బాగా, ఆ కోసం, మీరు తెలిసిన చేయాలి ఎలా లింక్ జాబితాలు ప్రయాణించేందుకు. 

ఒక లింక్ జాబితా సంచరిస్తారు, యొక్క వివరించారు వ్యవహరించడానికి ఒక నోడ్ పాయింటర్, ఒక నోడ్ *, సూచిస్తూ, మీ కర్సర్, ఇది మీరు మొదలు, ఎట్ నోడ్ మొదటి మూలకం వద్ద. కర్సర్ వరకు మళ్ళీ వెతికినా మేము శూన్య అప్పుడు కొన్ని ప్రక్రియలు మరియు నిర్వహించడం మేము అవసరం కర్సర్ ముందుకు కర్సర్ బాణం విలువ ఉపయోగించి. 

గుర్తుంచుకో, ఈ అదే విషయం dereferencing, స్టార్ కర్సర్ చెప్పడం అప్పుడు ఉపయోగించి, కర్సర్ డాట్ ఆపరేటర్లు విలువ. కాబట్టి కేటాయించి కర్సర్ ఉంది నవీకరించుటకు తదుపరి కర్సర్ బాణం కర్సర్ను. 

మీరు D లో అవుతుంది అని నిర్ణయించడానికి సే సి మరియు E. నోడ్ ఛాయాచిత్రం మధ్య, కు new_node D పాయింట్ కలిగి తదుపరి కర్సర్ ఇది నోడ్ E,. ఆపై సి, కర్సర్, అప్పుడు సూచిస్తుంది డి ఆ విధంగా, మీరు జాబితా నిర్వహించడానికి. ద్వారా మీ లింకులు కోల్పోతారు కాదు జాగ్రత్తగా ఉండండి తదుపరి D కర్సర్ను బాణం కదిలే వెంటనే. 

అన్ని కుడి. కాబట్టి, మీరు నోడ్స్ ఇన్సర్ట్ ఎలా ఉంది ఆ లోకి, లోడ్ పదాలు వాటిని లో లోడ్ నోడ్స్, మరియు వాటిని ఇన్సర్ట్ మీ హాష్ పట్టిక లోకి. కాబట్టి ఇప్పుడు యొక్క ప్రయత్నాలు చూద్దాం. 

ఒక trie, ప్రతి నోడ్ ఒక ఉంటాయి నోడ్ గమనికలు, ప్రతి ఒక శ్రేణి ఆల్ఫాబెట్ ప్లస్ అపాస్ట్రఫీని. మరియు వ్యూహం ప్రతి మూలకం మరొక నోడ్ కు ఆకర్షిస్తాయి. ఆ నోడ్ శూన్య, ఆ లేఖ ఉంటే తరువాతి అక్షరం మాత్రం లేదు ఒక క్రమంలో ఏ పదం, ఎందుకంటే ప్రతి పదం ఇది గత అయినా సూచిస్తుంది ఒక పదం లేదా యొక్క పాత్ర. 

యొక్క ఒక రేఖాచిత్రం చూద్దాం. ఆశాజనక విషయాలు రెడీ ఒక బిట్ స్పష్టమైన. ఈ చిత్రంలో, మేము చూసే మాత్రమే కొన్ని అక్షరాలు మరియు కొన్ని substrings బయటకు జాబితా చేస్తున్నారు. కాబట్టి మీరు కొన్ని మార్గాలు అనుసరించండి మరియు ఆ మార్గాలు అన్ని మీరు దారి తీస్తుంది వివిధ పదాలు. 

కాబట్టి మేము ఎలా సి ఈ ప్రతిబింబించవు? బాగా, ప్రతి నోడ్ ఇప్పుడు అన్నారు లేదో సూచిస్తుంది బూలియన్ విలువ ఆ నోడ్ ముగింపు ఒక పదం లేదా. అది కూడా యొక్క వ్యూహం ఉంటుంది నోడ్ పిల్లలు అని గమనికలు మరియు వాటిలో 27 ఉన్నట్లు వెళ్తున్నారు. మరియు మీరు కూడా చెయ్యవచ్చును, గుర్తు మీ మొదటి నోడ్ ట్రాక్. మేము రూటు కాల్ చూడాలని. 

కాబట్టి ఒక trie యొక్క నిర్మాణ. ఎలా మేము ఈ ప్రతిబింబించవు ఒక నిఘంటువు వంటి? బాగా, ప్రతి కోసం, పదాలు లోడ్ నిఘంటువు పదం, మీరు చూడాలని trie ద్వారా iterate. మరియు పిల్లలు ప్రతి మూలకం వేరే లేఖ అనుగుణంగా. 

కాబట్టి పిల్లలను విలువ తనిఖీ నేను సూచిస్తుంది పేరు సూచిక నేను, లేఖ యొక్క నిర్దిష్ట ఇండెక్స్ అని మీరు ఇన్సర్ట్ ప్రయత్నిస్తున్న. బాగా, అది శూన్య అయితే, అప్పుడు మీరు చెయ్యవచ్చును ఒక కొత్త నోడ్ malloc మరియు పిల్లలు నేను ఆ నోడ్ సూచించడానికి. 

అది శూన్య కాదు, అప్పుడు అని ఇచ్చిన శాఖ, ఇచ్చిన substring, ఇప్పటికే ఉంది. కాబట్టి మీరు ఆ తరలించడానికి చేస్తాము కొత్త నోడ్ మరియు కొనసాగుతుంది. మీరు పదం చివర అయితే ఆ మీరు లోడ్ ప్రయత్నిస్తున్న నిఘంటువు, అప్పుడు మీరు ఆ సెట్ చేయవచ్చు మీరు నిజమైన ఆన్ అని ప్రస్తుత నోడ్. 

కాబట్టి యొక్క ఇన్సర్ట్ ఒక ఉదాహరణ చూద్దాం లోకి పదం "ఫాక్స్" మా నిఘంటువు. మేము ప్రారంభం నటిస్తారు ఒక ఖాళీ నిఘంటువు. మొదటి అక్షరం, F, ఉన్న పిల్లలు ఇండెక్స్ లో మూలాలు ఐదు పిల్లలు శ్రేణి. కాబట్టి మేము సైన్ ఇన్సర్ట్ 

లేఖ O తర్వాత పిల్లల్లో ఉంటుంది ఆ F. తరువాత ఇండెక్స్ 15, మరియు X శాఖలు, కూడా ఆ క్రింద ఉంటుంది O యొక్క పిల్లల ఆఫ్. ఆపై X గత లేఖ ఎందుకంటే పదం యొక్క "ఫాక్స్," నేను వెళుతున్న సూచించడానికి ఆ ఆకుపచ్చ రంగు అని పదం యొక్క ముగింపు ఉంది. సి లో, అంటే అమర్చడం వాక్యము విలువ బూలియన్. 

ఇప్పుడు ఏం మీరు తదుపరి పదం లోడ్ పదం "foo" ఉంది? సరే, మీరు ఏ malloc అవసరం లేదు F కోసం లేదా ఓ స్థలాన్ని, ఎందుకంటే ఆ ఇప్పటికే ఉన్నాయి. కానీ foo లో గత O? ఒక, మీరు malloc ఉంటుంది. సెట్, ఆ కోసం ఒక కొత్త నోడ్ తయారు ఒప్పుకు పదం బూలియన్. 

కాబట్టి ఇప్పుడు యొక్క ఇన్సర్ట్ వీలు "కుక్క." అమ్మాయికి మూలాలు ఇండెక్స్ మూడు ప్రారంభం పిల్లలు, D గాబట్టి ఇంకా సృష్టించబడింది. మరియు మేము అదే విధంగా వంటి అనుసరిస్తానని ముందు, substring కుక్క సృష్టిస్తుంది పేరు G ఆకుపచ్చ ఎందుకంటే రంగు అని, ఒక పదం చివర. 

ఇప్పుడు, మేము "ఏమి" ఇన్సర్ట్ ఏమి అనుకుంటే? Well, ఈ కుక్క ఒక substring, కాబట్టి మేము ఇకపై malloc అవసరం లేదు. కానీ మేము చేసిన పేరు సూచిస్తుంది చేయాలి ఆ పదం చివర చేరుకుంది. కాబట్టి O ఆకుపచ్చ రంగు ఉంటుంది. ప్రతి కోసం ఆ విధానాన్ని కొనసాగిస్తూ మీ నిఘంటువు పదం, మీరు చేసిన గాని మీ లోకి వాటిని లోడ్ పట్టిక లేదా మీ trie హాష్. 

speller.c కోసం తీగలను లో పాస్ వాటిని తనిఖీ dictionary.c. ఇప్పుడు, చెక్ ఫంక్షన్ ఆపరేట్ ఉంది కేస్ చురుకుదనాన్ని క్రింద. అని అక్షరాలు మరియు చిన్న అక్షరాలను మరియు రెండు మిశ్రమాన్ని అన్ని నిజమైన సమానంగా ఉండాలి ఏదైనా ఉంటే ఆ కలయిక లో ఉంది నిఘంటువు. మీరు కూడా తీగలను అని ఊహించుకుని మాత్రమే అక్షర కలిగి అన్నారు అక్షరాలు లేదా సంగ్రహంగా రాయడానికి. 

కాబట్టి యొక్క మీరు తనిఖీ ఎలా చూద్దాం ఒక హాష్ పట్టిక నిర్మాణం. బాగా, పదం ఉంటే, అది హాష్ పట్టిక లో చూడవచ్చు. కాబట్టి మీరు తెలుసుకుంటారు ప్రయత్నించవచ్చు సంబంధిత బకెట్ లో పదం. 

కాబట్టి బకెట్ ఆ పదం లో ఉంటుంది? సరే, మీరు సంఖ్య, ఆ సూచిక పొంది బకెట్, ఆ పదం హ్యాషింగ్ ద్వారా ఆపై ఆ లింక్ జాబితా శోధించడం, మొత్తం ద్వారా నదీ ప్రవాహానికి అడ్డంగా ప్రయాణం స్ట్రింగ్ ఉపయోగించి అనుబంధ జాబితా, ఫంక్షన్ సరిపోల్చండి. 

లింక్ జాబితా చివరిలో ఉంటే అనగా చేరిన మీ కర్సర్ శూన్య చేరుకుంటుంది, అప్పుడు పదం కాదు నిఘంటువు గుర్తించవచ్చు. ఇది ఏ ఇతర బకెట్ లో ఉండదు. ఇక్కడ, మీరు అక్కడ ఎలా చూడవచ్చు గాని కలిగి మధ్య రాజీ ఉంటుంది క్రమబద్ధీకరించబడతాయి అనుసంధాన జాబితాలు లేదా క్రమబద్ధీకరించనిది వాటిని. గాని సమయంలో ఎక్కువ సమయం పడుతుంది చెక్ లో సమయం లోడ్ లేదా ఎక్కువ. 

ఎలా మీరు తనిఖీ ఉండవచ్చు ఒక trie నిర్మాణం? వీటితోపాటు ప్రయాణం చూడాలని trie లో. ఇన్పుట్ పదం లో ప్రతి అక్షరానికి మేము తనిఖీ చేస్తున్న, మేము ఆ వెళ్తాను పిల్లల్లో మూలకం సంబంధిత. 

ఆ మూలకం శూన్య ఉంటే, ఆ మార్గాల ఏ substrings ఉన్నాయి మా ఇన్పుట్ పదం కలిగి, కాబట్టి పదం తప్పుగా. అది శూన్య కాదు, మేము తరలించవచ్చు మేము పదం యొక్క తదుపరి లేఖ ఈ ప్రక్రియ తనిఖీ మరియు కొనసాగుతుంది మేము ముగింపు చేరుకోవడానికి వరకు ఇన్పుట్ పదం యొక్క. మరియు తర్వాత మేము తనిఖీ చేయవచ్చు పదం నిజమైతే. ఇది, అప్పుడు గొప్ప ఉంటే. పదం సరైన ఉంది. కానీ ఒకవేళ, అయినప్పటికీ ఆ substring trie ఉంది, పదం తప్పుగా. 

ఫంక్షన్ సైజు అంటారు, పరిమాణం పదాలు సంఖ్య ఉండాలని మీ ఇచ్చిన నిఘంటువు లో ఉన్నాయి డేటా నిర్మాణం. మీరు, మీరు ఒక హాష్ పట్టిక ఉపయోగిస్తున్నట్లయితే కాబట్టి ప్రతి ద్వారా వెళ్ళి ఫీజ్ ప్రతి లో లింక్ జాబితా బకెట్ సంఖ్యపై పదాల ఉన్నాయి. మీరు ఒక trie ఉపయోగిస్తున్నట్లయితే, మీరు ప్రతి కాని శూన్య ద్వారా వెళ్ళి మీ trie లో మార్గం. లేదా మీరు నిఘంటువు లోడ్ చేస్తున్న సమయంలో లో, బహుశా మీరు ఎలా ట్రాక్ మీరు సైన్ లోడ్ చేస్తున్నాము చాలా పదాలు 

Speller.c తనిఖీ పూర్తి ఒకసారి నిఘంటువు వ్యతిరేకంగా టెక్స్ట్ ఫైల్, అప్పుడు అది పూర్తి మరియు కనుక ఇది, దించుతున్న కాల్స్ పేరు మీ ఉద్యోగం ఏదైనా విముక్తికై ఉంది మీరు malloced చేసిన. మీరు, మీరు ఒక హాష్ పట్టిక ఉపయోగిస్తే కాబట్టి నివారించేందుకు ముఖ్యంగా జాగ్రత్తగా ఉండాలి ఏదైనా విడుదల ద్వారా మెమరీ లీకేజ్ ముందుగానే మరియు ప్రతి దేవరాయలు మీరు ఉచిత ముందు ఒకే లింక్. 

కాబట్టి హాష్ పట్టిక ప్రతి మూలకం కోసం మరియు లింక్ జాబితా ప్రతి నోడ్ కోసం, మీరు ఆ నోడ్ స్వేచ్ఛను చెయ్యవచ్చును. ఎలా మీరు విడుదల గురించి గో అనుబంధ జాబితా? మీ నోడ్ పాయింటర్ కర్సర్ చేస్తోంది ప్రారంభంలో తల, అనుబంధ జాబితా, అప్పుడు మీ కర్సర్ అయితే శూన్య కాదు, మీరు ఒక తాత్కాలిక సెట్ చేయవచ్చు మీ కర్సర్ కు నోడ్ పాయింటర్. అప్పుడు కర్సర్ ముందుకు. ఆపై మీరు ఆ తాత్కాలిక పొందగలరు విలువ ఇప్పటికీ పట్టుకుని తరువాత ప్రతిదీ. 

మీరు ఒక trie ఉపయోగిస్తున్నట్లయితే? అప్పుడు దీన్ని ఉత్తమ మార్గం చాలా నుండి దించుతున్న ఉంది పైన దిగువ. సాధ్యమైనంత ప్రయాణిస్తూ నోడ్, మీరు అన్ని గమనికలు పొందగలరు అప్పుడు పిల్లలు మరియు చలించు పైకి, అన్ని లో అన్ని అంశాలు ఉండండి పిల్లలు శ్రేణుల యొక్క, వరకు మీ అగ్ర రూట్ నోడ్ హిట్. ఇక్కడ ఎక్కడ సూత్రం ఉపయోగపడుట ఉంటుంది. 

మీరు బహుశా విముక్తి చేసిన చేయడానికి మీరు malloced చేసిన ప్రతిదీ, మీరు Valgrind ఉపయోగించవచ్చు. Valgrind రన్నింగ్ మీ అమలు చేస్తుంది మెమరీ ఎన్ని బైట్లు లెక్కింపు మీరు ఉపయోగించి మరియు మీరు చూసుకోవాలి చేస్తున్నారు మీరు చెప్పే, వాటిని అన్ని విముక్తి మీరు కలిగి ఉండవచ్చు పేరు ఉచిత మర్చి. Valgrind మీరు చెబుతుంది కాబట్టి ఒకసారి అమలు మరియు మరియు మీరు, ముందుకు ఇస్తుంది మీరు దించుతున్న పూర్తి చేసిన. 

ఇప్పుడు, మీరు చిట్కాలు జంట వెళ్ళడానికి ముందు ఆఫ్ మరియు అమలు ప్రారంభం మీ నిఘంటువు. నేను ఒక చిన్న లో పాస్ సిఫార్సు ఇష్టం మీరు పరీక్షించడానికి ప్రయత్నిస్తున్న నిఘంటువు ఉన్నప్పుడు GDP తో విషయాలను మరియు డీబగ్గింగ్. స్పెల్లర్ యొక్క వాడుక ఉంది. / స్పెల్లర్, ఒక ఐచ్ఛిక నిఘంటువు, ఆపై ఒక టెక్స్ట్. 

సాధారణంగా, ఇది లో లోడుచేస్తుంది పెద్ద నిఘంటువు. కాబట్టి మీరు చిన్న లో పాస్ అనుకొనుచున్న నిఘంటువు, లేదా మరింత తయారు మీ సొంత, అనుకూలీకరించడానికి మీ నిఘంటువు మరియు మీ టెక్స్ట్ ఫైల్. 

మరియు తర్వాత చివరకు, నేను కూడా సిఫార్సు ఇష్టం ఒక కలం మరియు కాగితం తీసుకొని డ్రా విషయాలను ముందు, సమయంలో మరియు తర్వాత మీరు మీ కోడ్ అన్ని వ్రాయలేదు. మీరు పొందారు నిర్ధారించుకోండి ఆ గమనికలు సరైన. 

నేను శుభాకాంక్షలు అనుకుంటున్నారా. మరియు మీరు పూర్తి చేసిన, మీరు కావాలనుకుంటే పెద్ద బోర్డు మరియు సవాలు మీ ప్రోగ్రామ్ పోలిస్తే ఎంత వేగంగా చూడండి మీ సహ ', నేను ప్రోత్సహిస్తున్నాము మీరు ఆ తనిఖీ. 

ఆ, మీరు పూర్తి చేసిన స్పెల్లర్ PSet. నా పేరు Zamyla ఉంది, మరియు ఈ CS50 ఉంది.