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 ಸೂಚಿಸುವ. ಮತ್ತು ನಾವು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿದ್ದಾರೆ. 

ಇದರಿಂದ ಕೇವಲ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ, ಆದರೆ ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಇಡೀ ರಚನೆಯ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು. ಹಾಗೆಯೇ, ನಾವು ಅದೇ ನೋಡ್ ಹೊಂದಿರುತ್ತದೆ ಮೊದಲು ರಚಿಸುವುದು. ಆದರೆ ನಾವು ನಿಜವಾದ ಹ್ಯಾಷ್ ಟೇಬಲ್ ಬಯಸಿದರೆ, ನಾವು ಕೇವಲ ಒಂದು ನೋಡ್ ಪಾಯಿಂಟರ್ ಮಾಡಬಹುದು ಇಲ್ಲಿ ಸರಣಿ. ಉದಾಹರಣೆಗೆ, ಗಾತ್ರ 500. 

ಈಗ ಗಮನಕ್ಕೆ, ವ್ಯಾಪಾರ ಇರುವಂತೆ ವಿಶೇಷವೇನು ಗಾತ್ರ ನಡುವೆ ಆಫ್ ನಿಮ್ಮ ಹ್ಯಾಷ್ ಟೇಬಲ್ ಮತ್ತು ಗಾತ್ರ ನಿಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿಗಳ. ನೀವು ನಿಜವಾಗಿಯೂ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಹೊಂದಿದ್ದರೆ ಬಕೆಟ್, ಓಡಬೇಕು ಹೊಂದುವ ಇಮ್ಯಾಜಿನಿಂಗ್ ಮತ್ತು ಮುಂದಕ್ಕೆ ಒಂದು ಸಾಲಿನಲ್ಲಿ ನಿಮ್ಮ ಬಕೆಟ್ ಹೇಗೆ. ಆದರೆ ನೀವು ಒಂದು ಸಣ್ಣ ಸಂಖ್ಯೆಯ ಬಯಸುವುದಿಲ್ಲ ಬಕೆಟ್, ನಾವು ಮರಳಿ ಆರ್ ಏಕೆಂದರೆ ಹೊಂದಿರುವ ಹೇಗೆ ಮೂಲ ಸಮಸ್ಯೆ ನಮ್ಮ ಬಕೆಟ್ ತುಂಬಾ ಅನೇಕ ಚೆಂಡುಗಳನ್ನು. 

ಸರಿ, ಆದರೆ ಅಲ್ಲಿ ನಮ್ಮ ಚೆಂಡನ್ನು ಹೋಗುತ್ತದೆ? ಹಾಗೆಯೇ, ನಾವು ಮೊದಲ ಅಗತ್ಯವಿದೆ ಬಲ, ಒಂದು ಚೆಂಡು? ಆದ್ದರಿಂದ ಪ್ರತಿ ಒಂದು ನೋಡ್ malloc ಅವಕಾಶ ನಾವು ಹೊಂದಿರುವ ಹೊಸ ಪದ. ನೋಡ್ * new_node ಸಮ malloc (sizeof (ನೋಡ್)). 

ನಾವು ಈ ರಚನೆಯನ್ನು ಹೊಂದಿವೆ ಈಗ, ನಾವು ಕಾರ್ಯ ಬಳಸಿಕೊಂಡು, ಸ್ಕ್ಯಾನ್ ಮಾಡಬಹುದು fscanf ನಮ್ಮ ಫೈಲ್ ಸ್ಟ್ರಿಂಗ್, ವೇಳೆ ಎಂದು ಒಳಗೆ, ಒಂದು ನಿಘಂಟು ಕಡತ new_node ಬಾಣದ ಪದ, ಅಲ್ಲಿ new_node ಬಾಣದ ಪದ ನಮ್ಮ ಆಗಿದೆ ಆ ಪದದ ತಾಣವಾಗಿದೆ. 

ಮುಂದೆ, ನಾವು ಹ್ಯಾಶ್ ಬಯಸುವಿರಿ ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಬಳಸಿ ಪದ. ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಸ್ಟ್ರಿಂಗ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಒಂದು ಸೂಚ್ಯಂಕ ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸೂಚ್ಯಂಕ ಹೊಂದಿದೆ ಸಂಖ್ಯೆ ಕಡಿಮೆ ನೀವು ಹೊಂದಿರುವ ಬಕೆಟ್. 

ಈಗ, ಹ್ಯಾಶ್ ಕ್ರಿಯೆಗಳನ್ನು ನೀವು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಒಂದು ಹುಡುಕಲು ಮತ್ತು ಒಂದು ರಚಿಸಲು ನಿಮ್ಮ ಸ್ವಂತ, ನೆನಪು ಅವರು ನಿಯಂತ್ರಣವಾದದ ಇರಬೇಕು. ಅದೇ ಮೌಲ್ಯವನ್ನು ಅಗತ್ಯವಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥ ಒಂದೇ ಬಕೆಟ್ ಪ್ರತಿ ಬಾರಿ ನಕ್ಷೆ ನೀವು ಇದು ಹ್ಯಾಶ್ ಎಂದು. 

ಇದು ರೀತಿಯ ಒಂದು ಗ್ರಂಥಾಲಯದ ಅನಿಸುತ್ತದೆ. ನೀವು ಆಧರಿಸಿ ಪುಸ್ತಕ ತೆಗೆದುಕೊಳ್ಳಲು ವೆನ್ ಲೇಖಕ, ನಿಮಗೆ ಇದು ಶೆಲ್ಫ್ ಇದನ್ನು ಇದು ಶೆಲ್ಫ್ ಸಂಖ್ಯೆ ಎಂಬುದನ್ನು, ಹೋಗಿ ಒಂದು, ಎರಡು ಅಥವಾ ಮೂರು. ಮತ್ತು ಆ ಪುಸ್ತಕದ ಯಾವಾಗಲೂ ಮೇಲೆ ಸೇರಿರುವ ಶೆಲ್ಫ್ ಒಂದು, ಎರಡು, ಮೂರು ಅಥವಾ ಎರಡೂ. 

ಆದ್ದರಿಂದ, new_node ಬಾಣದ ಪದ ಹೊಂದಿದೆ ನಿಮ್ಮ ಡಿಕ್ಷನರಿ ಪದವನ್ನು ನಂತರ ಹ್ಯಾಶಿಂಗ್ new_node ಬಾಣದ ಪದ ತಿನ್ನುವೆ ನಮಗೆ ಸೂಚ್ಯಂಕ ನೀಡಿ ಹ್ಯಾಷ್ ಟೇಬಲ್ ಬಕೆಟ್. ನಂತರ ನಾವು ಒಳಗೆ ಸೇರಿಸಲು ಮಾಡುತ್ತೇವೆ ಸೂಚಿಸಲಾಗುತ್ತದೆ ನಿರ್ದಿಷ್ಟ ಲಿಂಕ್ ಪಟ್ಟಿ ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಮೌಲ್ಯವನ್ನು ಮರಳಲು. 

ನ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ ಒಂದು ನೋಡ್ ತೂರಿಸುವ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಆರಂಭದಲ್ಲಿ. ತಲೆ ಸೂಚಿಸುತ್ತದೆ ಒಂದು ನೋಡ್ ಪಾಯಿಂಟರ್ ವೇಳೆ ಒಂದು ಲಿಂಕ್ ಆರಂಭದಲ್ಲಿ ಪಟ್ಟಿ, ಮತ್ತು new_node ಹೊಸ ಸೂಚಿಸುತ್ತದೆ ನೀವು, ಪ್ರವೇಶಿಸಲು ಬಯಸುವ ಎಂದು ನೋಡ್ new_node ತಲೆ ನಿಯೋಜಿಸುವ ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ ಪಟ್ಟಿಯಲ್ಲಿ ಉಳಿದ ಲಿಂಕ್. ಆದ್ದರಿಂದ ನಾವು ಇದನ್ನು ಬಯಸುವುದಿಲ್ಲ. 

ಬದಲಿಗೆ, ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುವ ನಾವು ಪ್ರತಿ ಮೇಲೆ ನಡೆಸುವ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಸಿಂಗಲ್ ನೋಡ್. ಆದ್ದರಿಂದ ಚಾಲನೆಯಲ್ಲಿರುವ new_node ಬಾಣ ಮುಂದಿನ ಸಮ ತಲೆ ಮತ್ತು ನಂತರ ತಲೆ new_node ಸಮನಾಗಿರುತ್ತದೆ ಎಲ್ಲಾ ಸಂರಕ್ಷಿಸುತ್ತದೆ ಕೊಂಡಿಗಳು ಮತ್ತು ಯಾವುದೇ ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ. 

ಆದರೆ ನಿಮ್ಮ ಪಟ್ಟಿಯಲ್ಲಿ ಎಂದು ಬಯಸಿದರೆ ಏನು ಒಂದು ವಿಂಗಡಿಸಲಾದ ಸಂಪರ್ಕಿತ ನಂತರ ಏಕೆಂದರೆ, ವಿಂಗಡಿಸಲಾದ ಪಟ್ಟಿಗಾಗಿ ಸುಲಭ ಇರಬಹುದು ನಂತರ ಅದನ್ನು ಹುಡುಕುವ? ಅಲ್ಲದೆ, ಆ, ನೀವು ತಿಳಿಯಲು ಅಗತ್ಯವಾಗಿದೆ ಹೇಗೆ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಸಂಚರಿಸುತ್ತಾರೆ. 

ಲಿಂಕ್ ಪಟ್ಟಿ ಸಂಚರಿಸುತ್ತಾರೆ, ನ ಹೊಂದಿವೆ ಅವಕಾಶ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ನೋಡ್ ಪಾಯಿಂಟರ್ ಒಂದು ನೋಡ್ *, ಸೂಚಿಸುವ ನಿಮ್ಮ ಕರ್ಸರ್, ಇದು ನೀವು ಆರಂಭಿಸಿ, ಆರ್ ನೋಡ್ ಮೊದಲ ಅಂಶ. ಕರ್ಸರ್ ರವರೆಗೆ ಆವರ್ತನಕ್ಕೆ ನಾವು, ಶೂನ್ಯ ನಂತರ ಕೆಲವು ಪ್ರಕ್ರಿಯೆಗಳು ಮತ್ತು ನಡೆಸಲು ನಾವು ಬೇಕಾದಾಗ ಕರ್ಸರ್ ಮುನ್ನಡೆ ಕರ್ಸರ್ ಬಾಣದ ಮೌಲ್ಯ ಬಳಸಿ. 

ನೆನಪಿಡಿ, ಈ ಅದೇ ವಿಷಯ dereferencing, ಸ್ಟಾರ್ ಕರ್ಸರ್ ಹೇಳುವ ನಂತರ ಬಳಸಿ, ಕರ್ಸರ್ ಡಾಟ್ ಆಯೋಜಕರು ಮೌಲ್ಯ. ಆದ್ದರಿಂದ ನಿಯೋಜಿಸುವ ಮೂಲಕ ಕರ್ಸರ್ ಅಪ್ಡೇಟ್ ಮುಂದಿನ ಕರ್ಸರ್ ಬಾಣದ ಕರ್ಸರ್. 

ನೀವು ಡಿ ಆಗುತ್ತದೆ ಎಂದು ನಿರ್ಧರಿಸಲು ಸೇ ಸಿ ಮತ್ತು ಇ ನೋಡ್ ಸೇರಿಸಲು ನಡುವೆ, ಗೆ new_node ಡಿ ಅಂಶಗಳಿಲ್ಲ ಮುಂದಿನ ಕರ್ಸರ್ ಇದು ನೋಡ್ ಇ,. ನಂತರ ಸಿ, ಕರ್ಸರ್, ನಂತರ ಬೆಟ್ಟು ಮಾಡಬಹುದು ಡಿ ಆ ರೀತಿಯಲ್ಲಿ, ನೀವು ಒಂದು ಪಟ್ಟಿ ನಿರ್ವಹಿಸಲು. ನಿಮ್ಮ ಕೊಂಡಿಗಳು ಕಳೆದುಕೊಳ್ಳುವ ಎಚ್ಚರಿಕೆ ಮುಂದಿನ ಡಿ ಕರ್ಸರ್ ಬಾಣ ಚಲಿಸುವ ಈಗಿನಿಂದಲೇ. 

ಸರಿ. ಆದ್ದರಿಂದ, ನೀವು ಗ್ರಂಥಿಗಳು ಸೇರಿಸಲು ಎಂಬುದರ ಇಲ್ಲಿದೆ ಆ ಒಳಗೆ, ಲೋಡ್ ಪದಗಳನ್ನು ಅವುಗಳನ್ನು ಲೋಡ್ ಗ್ರಂಥಿಗಳು, ಮತ್ತು ಅವುಗಳನ್ನು ಸೇರಿಸಲು ನಿಮ್ಮ ಹ್ಯಾಶ್ ಟೇಬಲ್ಲಿಗೆ. ಈಗ ಅವರ ಪ್ರಯತ್ನಗಳ ನೋಡೋಣ. 

ಒಂದು trie, ಪ್ರತಿ ನೋಡ್ ಒಂದು ಹೊಂದಿರುತ್ತವೆ ನೋಡ್ ಪಾಯಿಂಟರ್ಸ್, ಪ್ರತಿ ಒಂದು ರಚನೆಯ ವರ್ಣಮಾಲೆಯ ಅಕ್ಷರದ ಜೊತೆಗೆ ಅಪಾಸ್ಟ್ರಫಿ. ಮತ್ತು ರಚನೆಯ ಪ್ರತಿ ಅಂಶ ಇನ್ನೊಂದು ನೋಡ್ ತೋರಿಸಲು ಕಾಣಿಸುತ್ತದೆ. ಎಂದು ನೋಡ್ ಶೂನ್ಯ, ನಂತರ ಪತ್ರವನ್ನು ವೇಳೆ ಮುಂದಿನ ಅಕ್ಷರದ ಹಿಂದಿರುಗಬಹುದೆಂದು ಇದೆ ಅನುಕ್ರಮ ಯಾವುದೇ ಪದವನ್ನು ಏಕೆಂದರೆ ಪ್ರತಿ ಪದ ಇದು ಕಳೆದ ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ ಒಂದು ಪದ ಅಥವಾ ಪಾತ್ರ. 

ತಂದೆಯ ರೇಖಾಚಿತ್ರ ನೋಡೋಣ. ಆಶಾದಾಯಕವಾಗಿ ವಿಷಯಗಳನ್ನು ತಿನ್ನುವೆ ಸ್ವಲ್ಪ ಸ್ಪಷ್ಟವಾಗಿರುತ್ತದೆ. ಈ ಚಿತ್ರದಲ್ಲಿ, ನಾವು ನೋಡಿ ಮಾತ್ರ ಕೆಲವು ಅಕ್ಷರಗಳು ಮತ್ತು ಕೆಲವು ಉಪಸಾಲುಗಳಿಗಾಗಿನ ಔಟ್ ಪಟ್ಟಿ ಮಾಡಲಾಗುತ್ತಿದೆ. ಆದ್ದರಿಂದ ನೀವು ಕೆಲವು ಮಾರ್ಗಗಳನ್ನು ಅನುಸರಿಸಿ, ಮತ್ತು ಆ ಮಾರ್ಗಗಳು ಎಲ್ಲಾ ನೀವು ಕಾರಣವಾಗುತ್ತದೆ ವಿಭಿನ್ನ ಪದಗಳನ್ನು. 

ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಸಿ ಈ ಪ್ರತಿನಿಧಿಸಲು ಇಲ್ಲ? ಅಲ್ಲದೆ, ಪ್ರತಿ ನೋಡ್ ಈಗ ಮಾಡಲಿಕ್ಕೆ ಇದೆ ಎಂಬುದನ್ನು ಸೂಚಿಸುವ ಒಂದು ಬೂಲಿಯನ್ ಮೌಲ್ಯವನ್ನು ಆ ನೋಡ್ ಅಂತ್ಯ ಒಂದು ಪದ ಅಥವಾ. ಮತ್ತು ನಂತರ ಇದು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ ನೋಡ್ ಮಕ್ಕಳು ಪಾಯಿಂಟರ್ಸ್, ಮತ್ತು ಅವರಲ್ಲಿ 27 ಇರುವಂತೆ ಹೋಗುವ. ಮತ್ತು ನೀವು ಬಯಸುವಿರಿ, ನೆನಪು ನಿಮ್ಮ ಮೊದಲ ನೋಡ್ ಟ್ರ್ಯಾಕ್. ನಾವು ಮೂಲ ಕರೆಯಲು ನೀನು. 

ಆದ್ದರಿಂದ ಒಂದು trie ರಚನೆ ಇಲ್ಲಿದೆ. ಹೇಗೆ ನಾವು ಈ ಪ್ರತಿನಿಧಿಸಲು ಇಲ್ಲ ಒಂದು ನಿಘಂಟು ಎಂದು? ಅಲ್ಲದೆ, ಪ್ರತಿ ಪದಗಳನ್ನು ಲೋಡ್ ನಿಘಂಟು ಪದ, ನೀವು ಬಯಸುವ ಎಂದು ನೀನು trie ಮೂಲಕ ಮರಳಿ. ಮತ್ತು ಮಕ್ಕಳು ಪ್ರತಿ ಅಂಶ ಒಂದು ಬೇರೊಂದು ಅಕ್ಷರವನ್ನು ಸೂಚಿಸುತ್ತದೆ. 

ಆದ್ದರಿಂದ ಮಕ್ಕಳ ಮೌಲ್ಯವನ್ನು ಪರೀಕ್ಷಿಸುವ ನಾನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಸೂಚ್ಯಂಕ ನಾನು, ಅಕ್ಷರದ ನಿರ್ದಿಷ್ಟ ಸೂಚ್ಯಂಕ ಎಂದು ನೀವು ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ. ಅಲ್ಲದೆ, ಇದು ಶೂನ್ಯ ಇದ್ದರೆ, ನಂತರ ನೀವು ಬಯಸುವಿರಿ ಒಂದು ಹೊಸ ನೋಡ್ malloc ಮತ್ತು ಮಕ್ಕಳು ನಾನು ನೋಡ್ ತೋರಿಸಲು. 

ಇದು ಶೂನ್ಯ ಅಲ್ಲ, ಆ ಅರ್ಥ ಕೊಟ್ಟಿರುವ ಶಾಖೆ, ಕೊಟ್ಟಿರುವ ಸಬ್, ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ. ಆದ್ದರಿಂದ ನೀವು ಕೇವಲ ಸರಿಸಲು ಮಾಡುತ್ತೇವೆ ಹೊಸ ನೋಡ್ ಮತ್ತು ಮುಂದುವರೆಯಲು. ನೀವು ಪದದ ಕೊನೆಯಲ್ಲಿ ನೀವು ಎಂದು ನೀವು ಲೋಡ್ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ನಿಘಂಟು, ನಂತರ ನೀವು ಹೊಂದಿಸಬಹುದು ನೀವು ನಿಜವಾದ ಇದ್ದೇವೆ ಎಂದು ಪ್ರಸ್ತುತ ನೋಡ್. 

ಆದ್ದರಿಂದ ತೂರಿಸುವ ಒಂದು ಉದಾಹರಣೆ ನೋಡೋಣ ಒಳಗೆ ಪದ "ನರಿ" ನಮ್ಮ ನಿಘಂಟು. ನಾವು ಆರಂಭವಾಗಬೇಕು ನಟಿಸುವುದು ಖಾಲಿ ನಿಘಂಟು. ಮೊದಲ ಪತ್ರ, ಎಫ್, ಇದೆ ಮಾಡಲಾಗುತ್ತದೆ ಮಕ್ಕಳ ಸೂಚ್ಯಂಕದಲ್ಲಿ ಬೇರುಗಳ ಐದು ಮಕ್ಕಳ ರಚನೆಯ. ನಾವು ಸೈನ್ ಸೇರಿಸಲು 

ಅಕ್ಷರದ ಒ ನಂತರ ಮಕ್ಕಳು ಇರುತ್ತದೆ ನಂತರ ಎಫ್ ನಂತರ ಸೂಚ್ಯಂಕ 15, ಮತ್ತು X ಕವಲೊಡೆಯುವ, ಆ ಕೆಳಗೆ ಇರುತ್ತದೆ ಓ ಮಕ್ಕಳು ಆಫ್. ತದನಂತರ ಎಕ್ಸ್ ಕೊನೆಯ ಅಕ್ಷರವಾಗಿದೆ ಏಕೆಂದರೆ ಪದದ "ನರಿ," ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ ಸೂಚಿಸಲು ಹಸಿರು ಬಣ್ಣ ಇದು ಪದದ ಕೊನೆಯಲ್ಲಿ ಇಲ್ಲಿದೆ. ಸಿ, ಎಂದು ನಿಗದಿಪಡಿಸಿ ಎಂದು ಪದಗಳ ನಿಜವಾದ ಮೌಲ್ಯವನ್ನು ಬೂಲಿಯನ್. 

ಈಗ ನೀವು ಎಂಬುದನ್ನು ಮುಂದಿನ ಪದ ಲೋಡ್ ಪದ "ಫೂ" ಆಗಿದೆ? ಅಲ್ಲದೆ, ನೀವು ಯಾವುದೇ malloc ಅಗತ್ಯವಿಲ್ಲ ಎಫ್ ಅಥವಾ ಒ ಜಾಗ, ಏಕೆಂದರೆ ಆ ಈಗಾಗಲೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ. ಆದರೆ foo, ಕಳೆದ ಒ? ಒಂದು, ನೀವು malloc ಹೊಂದಿರುತ್ತದೆ. ಹೊಂದಿಸುವ, ಎಂದು ಒಂದು ಹೊಸ ನೋಡ್ ಮಾಡಲು ನಿಜವಾದ ಪದ ಬೂಲಿಯನ್. 

ಈಗ ಸೇರಿಸಲು ಅವಕಾಶ "ನಾಯಿ." ಡಾಗ್ ತಿನ್ನುವೆ ಬೇರುಗಳ ಸೂಚ್ಯಂಕ ಮೂರು ಆರಂಭವಾಗಬೇಕು ಮಕ್ಕಳು, ಡಿ ಕಾರಣ ಇನ್ನೂ ದಾಖಲಿಸಿದವರು. ನಾವು ಇದೇ ಪ್ರಕ್ರಿಯೆ ಅನುಸರಿಸಿ ಮಾಡುತ್ತೇವೆ ಮೊದಲು, ಸಬ್ ನಾಯಿ ಸೃಷ್ಟಿಸುತ್ತದೆ ಅಲ್ಲಿ ಗ್ರಾಂ ಹಸಿರು ಏಕೆಂದರೆ ಬಣ್ಣದ ವಿಶೇಷವೇನು ಒಂದು ಪದದ ಕೊನೆಯಲ್ಲಿ ಇಲ್ಲಿದೆ. 

ಈಗ, ನಾವು "ಏನು" ಸೇರಿಸಲು ಏನು ಬಯಸಿದರೆ? ಅಲ್ಲದೆ, ಈ ನಾಯಿ ಒಂದು ಸಬ್, ಆದ್ದರಿಂದ ನಾವು ಎಂದಿಗೂ malloc ಅಗತ್ಯವಿಲ್ಲ. ಆದರೆ ನಾವು ಮಾಡಿದ ಅಲ್ಲಿ ಸೂಚಿಸುತ್ತದೆ ಬೇಕು ಪದದ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿತು. ಆದ್ದರಿಂದ ಓ ಹಸಿರು ಬಣ್ಣದ ಮಾಡಲಾಗುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ಆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮುಂದುವರಿಕೆ ನಿಮ್ಮ ನಿಘಂಟು ಪದ, ನೀವು ಮಾಡಿದ ಎರಡೂ ನಿಮ್ಮ ಒಳಗೆ ಅವುಗಳನ್ನು ಲೋಡ್ ಟೇಬಲ್ ಅಥವಾ ನಿಮ್ಮ trie ಹ್ಯಾಶ್. 

speller.c ಫಾರ್ ತಂತಿಗಳನ್ನು ಹಾದು ಅವುಗಳನ್ನು ಪರಿಶೀಲಿಸಿ dictionary.c. ಈಗ, ಚೆಕ್ ಕಾರ್ಯ ನಿರ್ವಹಿಸುತ್ತವೆ ಹೊಂದಿದೆ ಸಂದರ್ಭದಲ್ಲಿ ಅಸಂವೇದನೆ ಅಡಿಯಲ್ಲಿ. ಅರ್ಥ ಅಕ್ಷರಗಳಲ್ಲಿ ಮತ್ತು ಸಣ್ಣ ಅಕ್ಷರಗಳ ಮತ್ತು ಎರಡರ ಮಿಶ್ರಣವನ್ನು ಎಲ್ಲಾ ನಿಜವಾದ ಪೂರಕವಾಗಿಲ್ಲ ಮಾಡಬೇಕು ಯಾವುದೇ ವೇಳೆ ಆ ಸಂಯೋಜನೆಯನ್ನು ಹೊಂದಿದೆ ನಿಘಂಟು. ನೀವು ತಂತಿಗಳನ್ನು ಎಂದು ಭಾವಿಸಬಹುದು ಮಾತ್ರ ವರ್ಣಮಾಲೆಯ ಅನ್ನು ಹೋಗಿ ಅಕ್ಷರಗಳನ್ನು ಅಥವಾ ಅಪಾಸ್ಟ್ರಫಿ. 

ಆದ್ದರಿಂದ ನೀವು ಪರಿಶೀಲಿಸಿ ಎಂಬುದರ ನೋಡೋಣ ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ರಚನೆ. ಅಲ್ಲದೆ, ಪದ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ, ಅದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಕಾಣಬಹುದು. ಆದ್ದರಿಂದ ನೀವು ಹುಡುಕಲು ಪ್ರಯತ್ನಿಸಿ ಸಂಬಂಧಿತ ಬಕೆಟ್ ಪದ. 

ಆದ್ದರಿಂದ ಇದು ಬಕೆಟ್ ಪದ ಎಂದು? ಅಲ್ಲದೆ, ನೀವು ಸಂಖ್ಯೆ, ಸೂಚ್ಯಂಕ ಹೋಗಬಹುದು ಬಕೆಟ್, ಆ ಪದ ಹ್ಯಾಶಿಂಗ್ ಮೂಲಕ ತದನಂತರ ಆ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಹುಡುಕಲು, ಇಡೀ ಮೂಲಕ ಹಾದು ಸ್ಟ್ರಿಂಗ್ ಬಳಸಿ ಲಿಂಕ್ ಪಟ್ಟಿ, ಕಾರ್ಯ ಹೋಲಿಸಿ. 

ಲಿಂಕ್ ಪಟ್ಟಿಯ ಕೊನೆಯಲ್ಲಿ ವೇಳೆ ಅಂದರೆ ತಲುಪಿದ ನಿಮ್ಮ ಕರ್ಸರ್ ಶೂನ್ಯ ತಲುಪುತ್ತದೆ, ನಂತರ ಪದ ಅಲ್ಲ ನಿಘಂಟು ಕಂಡುಬಂದ. ಇದು ಇತರ ಯಾವುದೇ ಬಕೆಟ್ ಸಾಧ್ಯವಿಲ್ಲ. ಇಲ್ಲಿ, ನೀವು ಎಂಬುದರ ನೋಡಲು ಇರಬಹುದು ಎರಡೂ ಹೊಂದುವುದರ ನಡುವೆ ತುಲನೆಯನ್ನು ವಿಂಗಡಿಸಲಾದ ಸಂಪರ್ಕಿತ ಪಟ್ಟಿಗಳನ್ನು ಅಥವಾ ಆಯ್ದ ಪದಗಳಿಗಿಂತ. ಒಂದೋ ಸಮಯದಲ್ಲಿ ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಚೆಕ್ ಸಮಯದಲ್ಲಿ ಲೋಡ್ ಅಥವಾ ಹೆಚ್ಚು. 

ನೀವು ಹೇಗೆ ಪರಿಶೀಲಿಸಿ ಇರಬಹುದು ಒಂದು trie ರಚನೆ? ನಾವು ಕೆಳಕ್ಕೆ ಪ್ರಯಾಣ ನೀನು trie, ರಲ್ಲಿ. ಇನ್ಪುಟ್ ಪದ ಪ್ರತಿ ಪತ್ರವನ್ನು ನಾವು ಪರೀಕ್ಷಿಸುವ ನೀವು, ನಾವು ಹೋಗುತ್ತೇನೆ ಮಕ್ಕಳಲ್ಲಿ ಅಂಶ ಅನುಗುಣವಾದ. 

ಆ ಅಂಶ ಶೂನ್ಯ ವೇಳೆ, ನಂತರ ಅಂದರೆ ಯಾವುದೇ ಉಪಸಾಲುಗಳಿಗಾಗಿನ ಇವೆ ನಮ್ಮ ಶಬ್ದ ಹೊಂದಿರುವ, ಆದ್ದರಿಂದ ಈ ಪದವು ತಪ್ಪಾಗಿದ್ದಲ್ಲಿ. ಇದು ಶೂನ್ಯ ಅಲ್ಲ, ನಾವು ಚಲಿಸಬಹುದು ನಾವು ಆ ಪದದ ಮುಂದಿನ ಅಕ್ಷರದ ಈ ಪ್ರಕ್ರಿಯೆ ಪರೀಕ್ಷಿಸುವ ಮತ್ತು ಮುಂದುವರೆಯಲು ನಾವು ಕೊನೆಯಲ್ಲಿ ತಲುಪುವವರೆಗೆ ಇನ್ಪುಟ್ ಪದದ. ನಂತರ ನಾವು ಪರಿಶೀಲಿಸಬಹುದು ಪದ ನಿಜವಾದ ವೇಳೆ. ಇದು, ನಂತರ ಹೆಚ್ಚಿನ ವೇಳೆ. ಪದ ಸರಿ. ಆದರೆ ಒಂದು ವೇಳೆ, ಸಹ ಸಬ್ trie, ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ, ಪದ ತಪ್ಪಾಗಿ. 

ಕಾರ್ಯ ಗಾತ್ರ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಗಾತ್ರ ಪದಗಳ ಸಂಖ್ಯೆ ಹಿಂತಿರುಗುವುದು ಎಂದು ನಿಮ್ಮ ನೀಡಿದ ನಿಘಂಟು ಇವೆ ಡೇಟಾ ರಚನೆ. ನೀವು, ನೀವು ಒಂದು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದ ಬಳಸುತ್ತಿದ್ದರೆ ಪ್ರತಿಯೊಂದು ನೋಡಬಹುದು ಎರಡೂ ಪ್ರತಿಯೊಂದು ನಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ ಬಕೆಟ್ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುವ ಪದಗಳ ಇವೆ. ನೀವು ಒಂದು trie ಬಳಸುತ್ತಿದ್ದರೆ, ನೀವು ಪ್ರತಿ ಅಲ್ಲದ ಶೂನ್ಯ ಮೂಲಕ ಹೋಗಿ ನಿಮ್ಮ trie ಮಾರ್ಗ. ಅಥವಾ ನೀವು ನಿಘಂಟು ಲೋಡ್ ಮಾಡುತ್ತಲೇ , ಬಹುಶಃ ನೀವು ಹೇಗೆ ಟ್ರ್ಯಾಕ್ ನೀವು ಸೈನ್ ಲೋಡ್ ನೀವು ಅನೇಕ ಪದಗಳನ್ನು 

Speller.c ತಪಾಸಣೆ ಮುಗಿಸಿದ ನಂತರ ನಿಘಂಟು ವಿರುದ್ಧ ಪಠ್ಯ ಕಡತ, ನಂತರ ಇದನ್ನು ಮತ್ತು ಆದ್ದರಿಂದ, ಅನ್ಲೋಡ್ ಕರೆಗಳನ್ನು ಅಲ್ಲಿ ನಿಮ್ಮ ಕೆಲಸ ಏನು ಮುಕ್ತಗೊಳಿಸಲು ಹೊಂದಿದೆ ನೀವು malloced ಎಂಬುದನ್ನು. ನೀವು ನಂತರ, ನೀವು ಒಂದು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದ ಬಳಸಿದರೆ ತಪ್ಪಿಸಲು ವಿಶೇಷವಾಗಿ ಎಚ್ಚರಿಕೆ ಅಗತ್ಯವಿದೆ ಏನು ಮುಕ್ತಗೊಳಿಸಿದ ಮೂಲಕ ಮೆಮೊರಿ ಸೋರುವಿಕೆ ಅಕಾಲಿಕವಾಗಿ ಮತ್ತು ಪ್ರತಿ ಹಿಡಿದುಕೊಳ್ಳುವ ನೀವು ಉಚಿತ ಮೊದಲು ಏಕ ಲಿಂಕ್. 

ಆದ್ದರಿಂದ ಹ್ಯಾಷ್ ಟೇಬಲ್ ಪ್ರತಿ ಅಂಶ ಮತ್ತು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿ ನೋಡ್, ನೀವು ನೋಡ್ ಮುಕ್ತಗೊಳಿಸಲು ಬಯಸುವಿರಿ. ಹೇಗೆ ನೀವು ಮುಕ್ತಗೊಳಿಸಿದ ಬಗ್ಗೆ ಹೋಗಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ? ನಿಮ್ಮ ನೋಡ್ ಪಾಯಿಂಟರ್ ಕರ್ಸರ್ ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ ಆರಂಭಕ್ಕೆ ತಲೆ, ಲಿಂಕ್ ಪಟ್ಟಿ, ನಂತರ ನಿಮ್ಮ ಕರ್ಸರ್ ಸಂದರ್ಭದಲ್ಲಿ ಶೂನ್ಯ ಅಲ್ಲ, ನೀವು ತಾತ್ಕಾಲಿಕ ಹೊಂದಿಸಬಹುದು ನಿಮ್ಮ ಕರ್ಸರ್ ನೋಡ್ ಪಾಯಿಂಟರ್. ನಂತರ ಕರ್ಸರ್ ಮುನ್ನಡೆ. ತದನಂತರ ನೀವು ತಾತ್ಕಾಲಿಕ ಮುಕ್ತಗೊಳಿಸಲು ಮೌಲ್ಯ ಇನ್ನೂ ಅಂಟಿಕೊಂಡಿರುವ ನಂತರ ಎಲ್ಲವೂ. 

ಏನು ನೀವು ಒಂದು trie ಬಳಸುತ್ತಿದ್ದರೆ? ನಂತರ ಇದನ್ನು ಉತ್ತಮ ರೀತಿಯಲ್ಲಿ ಬಹಳ ರಿಂದ ಇಳಿಸುವುದನ್ನು ಹೊಂದಿದೆ ಮೇಲಕ್ಕೆ ಕೆಳಗಿನಿಂದ. ಕಡಿಮೆ ಸಂಭಾವ್ಯ ಪ್ರಯಾಣ ನೋಡ್, ನೀವು ಎಲ್ಲಾ ಪಾಯಿಂಟರ್ಸ್ ಮುಕ್ತಗೊಳಿಸಲು ನಂತರ ಮಕ್ಕಳು ಮತ್ತು backtrack ಮೇಲಕ್ಕೆ, ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಮುಕ್ತಗೊಳಿಸಿದ ಮಕ್ಕಳ ಸಾಲುಗಳು, ರವರೆಗೆ ನಿಮ್ಮ ಅಗ್ರ ರೂಟ್ ನೋಡ್ ಹಿಟ್. ಇಲ್ಲಿ ಅಲ್ಲಿ ಪುನರಾವರ್ತನ HANDY ಬರುತ್ತವೆ. 

ನೀವು ಬಹುಶಃ ಬಿಡುಗಡೆ ಮಾಡಿದ ಮಾಡಲು ನೀವು malloced ಬಂದಿದೆ ಎಲ್ಲವೂ, ನೀವು Valgrind ಬಳಸಬಹುದು. Valgrind, ರನ್ನಿಂಗ್ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕಾಣಿಸುತ್ತದೆ ಮೆಮೊರಿ ಎಷ್ಟು ಬೈಟ್ಗಳು ಎಣಿಸುವ ನೀವು ಬಳಸಿಕೊಂಡು ನೀವು ಖಚಿತವಾಗಿ ಮಾಡುತ್ತಿದ್ದೀಯ ನೀವು ಹೇಳುವ, ಅವುಗಳನ್ನು ಎಲ್ಲಾ ಬಿಡುಗಡೆ ನೀವು ಹೊಂದಿರಬಹುದು ಅಲ್ಲಿ ಉಚಿತ ಮರೆತು. Valgrind ನೀವು ಹೇಳುತ್ತದೆ ಒಮ್ಮೆ ಆದ್ದರಿಂದ ರನ್ ಮತ್ತು ಮತ್ತು ನೀವು ನಂತರ, ಮುಂದೆ ಹೋಗಿ ನೀಡುತ್ತದೆ ನೀವು ಇಳಿಸುವುದನ್ನು ಮುಕ್ತಾಯಗೊಂಡ. 

ಈಗ, ನೀವು ಸಲಹೆಗಳು ಒಂದೆರಡು ಹೋಗಿ ಮೊದಲು ಆಫ್ ಮತ್ತು ಅನುಷ್ಠಾನಕ್ಕೆ ಆರಂಭಿಸಲು ನಿಮ್ಮ ನಿಘಂಟು. ನಾನು ಒಂದು ಸಣ್ಣ ರವಾನಿಸಲು ಶಿಫಾರಸು ಬಯಸುವ ನೀವು ಪರೀಕ್ಷಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ನಿಘಂಟು ಮಾಡಿದಾಗ ಜಿಡಿಪಿ ಕೆಲಸಗಳನ್ನು ಔಟ್ ಮತ್ತು ಡೀಬಗ್. ಸ್ಪೆಲ್ಲರ್ ಬಳಕೆ ಆಗಿದೆ. / ಕಾಗುಣಿತ, ಒಂದು ಐಚ್ಛಿಕ ನಿಘಂಟು, ಮತ್ತು ನಂತರ ಒಂದು ಪಠ್ಯ. 

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಇದು ಲೋಡ್ ದೊಡ್ಡ ನಿಘಂಟು. ಆದ್ದರಿಂದ ನೀವು ಸಣ್ಣ ಹಾದು ಬಯಸಬಹುದು ನಿಘಂಟು, ಅಥವಾ ಬೇಕೆನ್ನಿಸಿದರೆ ಮಾಡಲು ನಿಮ್ಮ ಸ್ವಂತ, ಕಸ್ಟಮೈಜ್ ನಿಮ್ಮ ನಿಘಂಟು ನಿಮ್ಮ ಪಠ್ಯ ಕಡತ. 

ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನಾನು ಶಿಫಾರಸು ಬಯಸುವ ಒಂದು ಪೆನ್ ಮತ್ತು ಪೇಪರ್ ತೆಗೆದುಕೊಂಡು ಸೆಳೆಯಲು ವಿಷಯಗಳನ್ನು ಔಟ್ ಮೊದಲು, ಮಧ್ಯ ಮತ್ತು ನಂತರ ನಿಮ್ಮ ಕೋಡ್ ಎಲ್ಲಾ ಬರೆದ. ನೀವು ಮಾಡಲೇಬೇಕು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಆ ಪಾಯಿಂಟರ್ಸ್ ಸರಿಯಾದ. 

ನಾನು ನೀವು ಅದೃಷ್ಟದ ಅತ್ಯುತ್ತಮ ಬಯಸುವ. ಮತ್ತು ನೀವು ಮುಕ್ತಾಯಗೊಂಡ ಒಮ್ಮೆ, ನೀವು ಬಯಸಿದಲ್ಲಿ ದೊಡ್ಡ ಬೋರ್ಡ್ ಮತ್ತು ಸವಾಲು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಹೋಲಿಸಿದರೆ ಹೇಗೆ ವೇಗದ ನೋಡಿ ನಿಮ್ಮ ಸಹಪಾಠಿಗಳನ್ನು ', ನಂತರ ನಾನು ಪ್ರೋತ್ಸಾಹಿಸಲು ನೀವು ಎಂದು ಪರಿಶೀಲಿಸಿ. 

ಎಂದು, ನೀವು ಮುಕ್ತಾಯಗೊಂಡ ಕಾಗುಣಿತ PSet. ನನ್ನ ಹೆಸರು Zamyla ಹೊಂದಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.