[ಸಂಗೀತ] 

ರಾಬ್ ಬೌಡೆನ್: ಹಾಯ್. ನಾನು ರಾಬ್ ಮನುಷ್ಯ. ಮತ್ತು ಇದನ್ನು ಪರಿಹಾರ ಹೊರಬಂದರು. ಇಲ್ಲಿ ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನೀನು ಸಾಮಾನ್ಯ ಟೇಬಲ್. ನಾವು ನೋಡಿ ಎಂದು ನಮ್ಮ Struct ನೋಡ್ನ ಟೇಬಲ್ ಈ ರೀತಿ ಹೋಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಒಂದು ಚಾರ್ ಪದ ಹೋಗುವುದಿಲ್ಲ ಗಾತ್ರ ಉದ್ದ + 1 ರಚನೆಯ. + 1 ಮರೆಯಬೇಡಿ ರಿಂದ ಗರಿಷ್ಠ ನಿಘಂಟು ಪದ 45 ಪಾತ್ರಗಳು. ನಂತರ ನಾವು ಒಂದು ಹೆಚ್ಚುವರಿ ಅಗತ್ಯವಿದೆ ನೀನು ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಶೂನ್ಯ ಪಾತ್ರದ. 

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

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

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

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

ಈಗ ನಾವು ನೀನು ಒಂದು ನೋಡ್ malloc. ಮತ್ತು ಸಹಜವಾಗಿ ನಾವು ಅಗತ್ಯವಿದೆ ಗಾಳಿಗೆ ಮತ್ತೆ ಪರಿಶೀಲಿಸಿ. ಆದ್ದರಿಂದ mallocing ಯಶಸ್ವಿಯಾಗಲಿಲ್ಲ ವೇಳೆ, ನಂತರ ನಾವು ನಾವು ಯಾವುದೇ ನೋಡ್ ಇಳಿಸುವುದನ್ನು ಬಯಸುವ ಮೊದಲು malloc ಗೆ ಏನಾಯಿತು, ಮುಚ್ಚಿ ನಿಘಂಟು ಸುಳ್ಳು ಹಿಂತಿರುಗಿ. ಆದರೆ ನಿರ್ಲಕ್ಷಿಸಿ, ಊಹಿಸಿಕೊಂಡು ನಾವು ಯಶಸ್ವಿಯಾದರು, ನಾವು fscanf ಬಳಸಲು ಬಯಸುವ ಒಂದೇ ಒಂದು ಪದ ಓದಲು ನಮ್ಮ ನಮ್ಮ ನೋಡ್ ಡಿಕ್ಷನರಿ. ಆದ್ದರಿಂದ ಪ್ರವೇಶ> ಪದ ನೆನಪು ಚಾರ್ + 1 ಗಾತ್ರ LENGHTH ಪದ ಬಫರ್ ನಾವು ಸೈನ್ ಪದ ಶೇಖರಿಸಿಡಲು ನೀನು 

ಆದ್ದರಿಂದ fscanf ಎಲ್ಲಿಯವರೆಗೆ, 1 ಮರಳಲು ಹೋಗುತ್ತದೆ ಇದು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಯಶಸ್ವಿಯಾಗಿ ಎಂದು ಕಡತದಿಂದ ಪದ ಓದಲು. ದೋಷ ಎರಡೂ ಸಂಭವಿಸಿದಲ್ಲಿ, ಅಥವಾ ನಾವು ಕಡತದ ಕೊನೆಯಲ್ಲಿ ತಲುಪಲು, ಇದು 1 ಹಿಂತಿರುಗುವುದಿಲ್ಲ. ಇದು, 1 ಮರಳಲು ಇದು ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಅಂತಿಮವಾಗಿ ಔಟ್ ಮುರಿಯಲು ನೀನು ಈ ಸಮಯದಲ್ಲಿ ಲೂಪ್. ಆದ್ದರಿಂದ ನಾವು ನೋಡಿ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಒಮ್ಮೆ ಒಂದು ಪದ ಓದಲು ಪ್ರವೇಶ> ಪದ, ಆಗ ನೀನು ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಬಳಸಿ ಪದ. 

ನಲ್ಲಿ ಅವಲೋಕಿಸೋಣ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ. ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಅಗತ್ಯವಿಲ್ಲ ಈ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು. ಮತ್ತು ವಾಸ್ತವವಾಗಿ ನಾವು ಈ ಹ್ಯಾಶ್ ಎಳೆದ ಇಂಟರ್ನೆಟ್ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ನೀವು ಗುರುತಿಸಲು ಅಗತ್ಯವಿದೆ ಮಾತ್ರ ವಿಷಯ ಈ ಒಂದು const ಚಾರ್ * ಪದ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಆದ್ದರಿಂದ ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ತೆಗೆದುಕೊಳ್ಳುವ, ಮತ್ತು ಔಟ್ಪುಟ್ ಒಂದು ಇಂಟ್ ರುಜುಮಾಡದ ಹಿಂದಿರುಗಿದ. ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಇಲ್ಲಿದೆ, ಇದು ಒಂದು ಆದಾನ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ನೀವು ನೀಡುತ್ತದೆ hashtable ಒಳಗೆ ಸೂಚ್ಯಂಕ. 

ನಾವು NUM_BUCKETS ಮೂಲಕ moding ನೀವು ಗಮನಿಸಬಹುದು, ಆದ್ದರಿಂದ ಮೌಲ್ಯವನ್ನು ಮರಳಿದರು ವಾಸ್ತವವಾಗಿ hashtable ಒಳಗೆ ಸೂಚ್ಯಂಕ ಮತ್ತು ಮಾಡುತ್ತದೆ ಮೀರಿ ಸೂಚ್ಯಂಕ ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು. ಆ ಕ್ರಿಯೆಯ ಆದ್ದರಿಂದ, ನಾವು ನೀನು ನೀಡಿದ ನಾವು ಓದುವ ಪದ ಹ್ಯಾಶ್ ನಿಘಂಟು. ನಂತರ ನಾವು ಬಳಸಲು ನೀನು ಸೇರಿಸಲು ಹ್ಯಾಶ್ hashtable ಪ್ರವೇಶ. 

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

ನಾವು ಪೂರೈಸಿದ ನಂತರ, ನಾವು ತಿಳಿದಿರುವಂತೆ ನಾವು ಮತ್ತೊಂದು ಪದ ಕಂಡು ನಿಘಂಟು, ಮತ್ತು ನಾವು ಮತ್ತೆ ಹೆಚ್ಚಿಸಲು. ನಾವು ನಡೆಸುವ ಎಂದು fscanf ರವರೆಗೆ ಅಂತಿಮವಾಗಿ ಅಲ್ಲದ 1 ಏನೋ ಮರಳಿದರು ಪಾಯಿಂಟ್ ನೆನಪು ನಾವು ಪ್ರವೇಶ ಮುಕ್ತಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ. ಆದ್ದರಿಂದ ಇಲ್ಲಿ ನಾವು ಒಂದು ನಮೂದನ್ನು malloced. ನಾವು ಏನೋ ಓದಲು ಪ್ರಯತ್ನಿಸಿದ ನಿಘಂಟು ನಿಂದ. ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಓದಲು ಮಾಡಲಿಲ್ಲ ರಲ್ಲಿ ನಿಘಂಟು ಏನನ್ನೋ, ನಾವು ಪ್ರವೇಶ ಮುಕ್ತಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ವಾಸ್ತವವಾಗಿ ಆರಂಭವಾಯಿತು ಎಂದಿಗೂ ಎಂದು hashtable, ಮತ್ತು ಅಂತಿಮವಾಗಿ ಮುರಿಯಲು. 

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

ನಾವು ಯಶಸ್ವಿಯಾಗಲು ಮಾಡಲಿಲ್ಲ ಭಾವಿಸಿಕೊಂಡು, ನಂತರ ನಾವು ಇನ್ನೂ ನಿಘಂಟು ಮುಚ್ಚಲು ಅಗತ್ಯ ಫೈಲ್, ಮತ್ತು ಅಂತಿಮವಾಗಿ ನಿಜವಾದ ಹಿಂತಿರುಗಿ ರಿಂದ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ನಿಘಂಟು ಲೋಡ್. ಮತ್ತು ಲೋಡ್ ಅದು. ಈಗ, ಒಂದು ಲೋಡ್ hashtable ನೀಡಿದ ಪರಿಶೀಲಿಸಿ ಈ ರೀತಿ ಹೋಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಇದು, ಇದು ಒಂದು bool ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಪರಿಶೀಲಿಸಿ ಜಾರಿಗೆ ಎಂಬುದನ್ನು ಹೋಗುವ ಚಾರ್ * ಪದದ, ಎಂಬುದನ್ನು ಜಾರಿಗೆ ಸ್ಟ್ರಿಂಗ್ ನಮ್ಮ ನಿಘಂಟು ಹೊಂದಿದೆ. , ಇದು ನಿಘಂಟು ಆದ್ದರಿಂದ ವೇಳೆ ಇದು ನಮ್ಮ hashtable ವೇಳೆ, ನಾವು ನಿಜವಾದ ಹಿಂತಿರುಗುವುದು. ಇದು ಅಲ್ಲ, ನಾವು ತಪ್ಪು ಹಿಂತಿರುಗುವುದು. 

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

ಈಗ ಲೂಪ್ ಈ ಹೋಗುತ್ತದೆ ಲಿಂಕ್ ಪಟ್ಟಿ ಮೇಲೆ ಮರಳಿ ಆ ಸೂಚ್ಯಂಕ ಆಗಿತ್ತು. ನಾವು ಪ್ರವೇಶ ಆರಂಭಿಸುವಲ್ಲಿ ಗಮನಕ್ಕೆ ಸೂಚ್ಯಂಕ ತೋರಿಸಲು. ನಾವು ಮುಂದುವರಿಯಲು ನೀನು ಪ್ರವೇಶ! = ನಲ್ ಮಾಡುವಾಗ. ಮತ್ತು ನೆನಪಿಡಿ ಎಂದು ಪಾಯಿಂಟರ್ ಅಪ್ಡೇಟ್ ಮುಂದಿನ ನಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿ ಪ್ರವೇಶ = ಪ್ರವೇಶ>. ಆದ್ದರಿಂದ ನಮ್ಮ ಪ್ರಸ್ತುತ ಪ್ರವೇಶ ಬಿಂದು ಹೊಂದಿವೆ ಲಿಂಕ್ ಪಟ್ಟಿ ಮುಂದಿನ ಐಟಂ. 

ಆದ್ದರಿಂದ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿಯೊಂದು ನಮೂದು, ನಾವು strcasecmp ಬಳಸಲು ನೀನು. ಇದು strcomp ಅಲ್ಲ. ಮತ್ತೊಮ್ಮೆ, ನಾವು ಬಯಸುವ ಏಕೆಂದರೆ ತೋರದಂತೆ ವಿಷಯಗಳನ್ನು ಸಂದರ್ಭದಲ್ಲಿ ಮಾಡಲು. ನಾವು ಹೋಲಿಸಲು strcasecmp ಬಳಸಲು ಈ ಮೂಲಕ ರವಾನಿಸಲಾಗಿದೆ ಎಂದು ಪದ ಪದ ವಿರುದ್ಧ ಕಾರ್ಯ ಈ ನಮೂದನ್ನು ರಲ್ಲಿ ಆಗಿದೆ. ಇದು ಶೂನ್ಯ ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಇರಲಿಲ್ಲ ಅರ್ಥ ನಾವು ಬಯಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಪಂದ್ಯದಲ್ಲಿ, ನಿಜವಾದ ಹಿಂತಿರುಗಿ. ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಕಂಡು ನಮ್ಮ hashtable ಪದ. 

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

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

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

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

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

ಈ ಪರಿಹಾರ ಪ್ರಯತ್ನಿಸಬಹುದು ಲೆಟ್. ಆದ್ದರಿಂದ ನಮ್ಮ ನೋಡೋಣ ಅವಕಾಶ struct ನೋಡ್ ರೀತಿ ಕಾಣಿಸುತ್ತದೆ. ಇಲ್ಲಿ ನಾವು ಒಂದು bool ಮಾಡಲಿಕ್ಕೆ ನೋಡಿ ಪದ ಮತ್ತು struct ನೋಡ್ * ಮಕ್ಕಳು ಬ್ರಾಕೆಟ್ ಆಲ್ಫಾಬೆಟ್. ನೀವು ಇರಬಹುದು ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ ಚಕಿತಗೊಳಿಸುತ್ತದೆ, ಏಕೆ ವರ್ಣಮಾಲೆಯಾಗಿದೆ ಎಡ್ 27 ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ? ಸರಿ, ನಮಗೆ ನೀನು ನೆನಪು ಅಪಾಸ್ಟ್ರಫಿ ನಿರ್ವಹಣೆ ಎಂದು. ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ಆಫ್ ಎಂದು ವಿಶೇಷವೇನು ಈ ಕಾರ್ಯಕ್ರಮದ ಉದ್ದಕ್ಕೂ ವಿಶೇಷ ಸಂದರ್ಭದಲ್ಲಿ. 

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

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

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

ಸರಿ. ಈಗ ನಾವು trie, ಎಂಬುದನ್ನು ತಿಳಿದಿರುವುದರಿಂದ ನೋಡಲು ಹೋಗುವ, ನ ನೋಡೋಣ ಕಾರ್ಯ ಲೋಡ್. ಆದ್ದರಿಂದ ಲೋಡ್ ಒಂದು bool ಮರಳಲು ಹೋಗುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಅಥವಾ ಯಶಸ್ವಿಯಾಗಲಿಲ್ಲ ನಿಘಂಟು ಲೋಡ್. ಈ ನಿಘಂಟು ಏರಲಿದೆ ನಾವು ಲೋಡ್ ಬಯಸುವ. 

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

ನಾವು ನೀನು ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ ಮಾಡಲು ಬಯಸುವ ನಾವು ಈ ಹೊಂದಿವೆ ಇದೆ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಮೂಲ. ಈಗ ಮೂಲ * ಒಂದು ನೋಡ್ ಏರಲಿದೆ. ಇದು ನಾವು ನೀವು ನಮ್ಮ trie ಅಗ್ರ ಇಲ್ಲಿದೆ ಮೂಲಕ iterating ಮಾಡಲು ಹೋಗುತ್ತಿದ್ದೇನೆ. ನಾವು ನೀನು ಎಷ್ಟು ಮೊದಲನೆಯದಾಗಿ ಮಾಡಲು ಬಯಸುವ ನಿಯೋಜಿಸಿ ಆಗಿದೆ ನಮ್ಮ ಮೂಲ ಮೆಮೊರಿ. ನಾವು calloc, ಬಳಸುತ್ತಿರುವ ಗಮನಿಸಿ ಮೂಲತಃ ಅದೇ ಕಾರ್ಯ, malloc ಕಾರ್ಯ ಹೊರತುಪಡಿಸಿ ಇದು ಎಂದು ಏನೋ ಮರಳಲು ಭರವಸೆ ಸಂಪೂರ್ಣವಾಗಿ ಔಟ್ zeroed. ನಾವು malloc ಬಳಸಲಾಗುತ್ತದೆ ಆದ್ದರಿಂದ, ನಾವು ಅಗತ್ಯವಿದೆ ರಲ್ಲಿ ಪಾಯಿಂಟರ್ಸ್ ಎಲ್ಲಾ ಮೂಲಕ ಹೋಗಿ ನಮ್ಮ ನೋಡ್, ಮತ್ತು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅವರು ಎಲ್ಲಾ ಶೂನ್ಯ ಆರ್. ಆದ್ದರಿಂದ calloc, ನಮಗೆ ಹಾಗೆ ಕಾಣಿಸುತ್ತದೆ. 

ಈಗ ಕೇವಲ malloc ಹಾಗೆ, ನಾವು ಅಗತ್ಯವಿದೆ ಹಂಚಿಕೆ ವಾಸ್ತವವಾಗಿ ಎಂದು ಖಚಿತವಾಗಿ ಯಶಸ್ವಿ. ಈ ಶೂನ್ಯ ಹಿಂದಿರುಗಿದರು ವೇಳೆ, ನಾವು ಮುಚ್ಚಿ ಅಥವಾ ನಿಘಂಟು ಅಗತ್ಯವಿದೆ ಫೈಲ್ ಸುಳ್ಳು ಹಿಂತಿರುಗಿ. ಆದ್ದರಿಂದ ಹಂಚಿಕೆ ಹೋಗಿದ್ದರೆ ಯಶಸ್ವಿ, ನಾವು * ಒಂದು ನೋಡ್ ಬಳಸಲು ನೀನು ನಮ್ಮ trie ಮೂಲಕ ಮರಳಿ ಕರ್ಸರ್. ಆದ್ದರಿಂದ ನಮ್ಮ ಬೇರುಗಳು ಬದಲಿಸಲು ಹೋಗಿ ಎಂದಿಗೂ, ಆದರೆ ನಾವು ಕರ್ಸರ್ ಬಳಸಲು ನೀನು ವಾಸ್ತವವಾಗಿ ನೋಡ್ನಿಂದ ನೋಡ್ಗೆ ಹೋಗಿ. 

ಆದ್ದರಿಂದ ಈ ಲೂಪ್ ನಾವು ಓದುತ್ತಿದ್ದಲ್ಲಿ ನಿಘಂಟು ಕಡತ ಮೂಲಕ. ನಾವು fgetc ಬಳಸುತ್ತಿರುವ. Fgetc ಒಂದೇ ದೋಚಿದ ಹೋಗುತ್ತದೆ ಕಡತದಿಂದ ಪಾತ್ರ. ನಾವು ಧರಿಸುವುದನ್ನು ಮುಂದುವರಿಯಲು ನೀನು ಪಾತ್ರಗಳು ನಾವು ತಲುಪಲು ಇಲ್ಲ ಕಡತದ ಕೊನೆಯಲ್ಲಿ. 

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

ಆದ್ದರಿಂದ, ನಾನು ಮೊದಲೇ ಹೇಳಿದ ಹಾಗೆ, ನಾವು ಅಗತ್ಯವಿದೆ ವಿಶೇಷ ಸಂದರ್ಭದಲ್ಲಿ ಅಪಾಸ್ಟ್ರಫಿ. ನಾವು ತ್ರಯಾತ್ಮಕ ಬಳಸುತ್ತಿರುವ ಗಮನಿಸಿ ಇಲ್ಲಿ ಆಯೋಜಕರು. ನಾವು ವೇಳೆ, ಈ ಓದಲು ನೀನು ನಾವು ಓದಲು ಪಾತ್ರ ಒಂದು ಆಗಿತ್ತು ಅಪಾಸ್ಟ್ರಫಿ, ನಾವು ಹೊರಟಿರುವೆ ಸೂಚ್ಯಂಕ = "ವರ್ಣಮಾಲೆ" -1, ಇದು ತಿನ್ನುವೆ ಸೂಚ್ಯಂಕ 26 ಎಂದು. 

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

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

ನಾವು ಮತ್ತೆ calloc, ಬಳಸಲು ನೀನು ಕಾರ್ಯ, ನಾವು ಹೊಂದಿಲ್ಲ ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಪಾಯಿಂಟರ್ಸ್ ಔಟ್ ಸೊನ್ನೆಗೆ. ನಾವು ಮತ್ತೆ ಪರಿಶೀಲಿಸಬೇಕು ಎಂದು calloc, ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. Calloc, ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ವೇಳೆ, ನಂತರ ನಾವು ಅಗತ್ಯವಿದೆ ಎಲ್ಲವೂ ಅನ್ಲೋಡ್, ಮುಚ್ಚಿ ನಮ್ಮ ನಿಘಂಟು, ಸುಳ್ಳು ಹಿಂತಿರುಗಿ. ಆದ್ದರಿಂದ ನಂತರ, ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಎಂದು ಊಹಿಸಿಕೊಂಡು ಈ ನಮಗೆ ಹೊಸ ಮಗುವಿನ ರಚಿಸುತ್ತದೆ. ನಂತರ ನಾವು ಮಗುವಿನ ಹೋಗುತ್ತದೆ. ನಮ್ಮ ಕರ್ಸರ್ ಮರಳಿ ಕಾಣಿಸುತ್ತದೆ ಮಗು ಕೆಳಗೆ. 

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

ಬೇರೆ ಈ ಎಂದರೇನು? ಈ ಸಿ ಆಗಿತ್ತು ಅಲ್ಲಿ ಪರಿಸ್ಥಿತಿ ಸಿ ಹೊಸ ಲೈನ್ ಅಲ್ಲಿ backslash N,. ಈ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಅರ್ಥ ಒಂದು ಪದ ಪೂರ್ಣಗೊಂಡಿತು. ಈಗ ನಾವು ಬಯಸುತ್ತೀರಿ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಪದ ಪೂರ್ಣಗೊಂಡಿತು? ನಾವು ಈ ಪದ ಕ್ಷೇತ್ರ ಬಳಸಲು ನೀನು ನಮ್ಮ struct ನೋಡ್ ಒಳಗೆ. ನಾವು ನಿಜವಾದ ಎಂದು ಹೊಂದಿಸಲು ಬಯಸುವ. ಆದ್ದರಿಂದ ಸೂಚಿಸುತ್ತದೆ ಎಂದು ಈ ನೋಡ್ ಯಶಸ್ವಿ ಸೂಚಿಸುತ್ತದೆ ಪದ, ನಿಜವಾದ ಪದ. 

ಈಗ ನಿಜವಾದ ಸೆಟ್. ನಾವು ಬಿಂದುವಿಗೆ ನಮ್ಮ ಕರ್ಸರ್ ಮರುಹೊಂದಿಸಲು ಮತ್ತೆ trie ಆರಂಭದಲ್ಲಿ ಗೆ. ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಮ್ಮ ನಿಘಂಟು ಹೆಚ್ಚಿಸಲು ಗಾತ್ರ, ನಾವು ಮತ್ತೊಂದು ಕೆಲಸ ಕಂಡು. ಆದ್ದರಿಂದ ನಾವು ಮಾಡುವ ಇರಿಸಿಕೊಳ್ಳಲು ನೀನು, , ಪಾತ್ರದ ಅಕ್ಷರ ಓದುವ ನಮ್ಮ trie ಹೊಸ ಗ್ರಂಥಿಗಳು ನಿರ್ಮಿಸುವ ಮತ್ತು ನಿಘಂಟು ರವರೆಗೆ ಪ್ರತಿ ಪದಕ್ಕೆ ನಾವು ಅಂತಿಮವಾಗಿ ಸಿ ತಲುಪಲು! = EOF, ಇದರಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಕಡತ ಭೇದಿಸಿ. 

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

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

ನಾವು ಇಲ್ಲಿ ನೋಡಿ, ಮೊದಲಿನಂತೆ, ನಾವು ಮರಳಿ ಕರ್ಸರ್ ಬಳಸಲು ನೀನು ನಮ್ಮ trie ಮೂಲಕ. ಈಗ ಇಲ್ಲಿ ನಾವು ತಿರುಗಿ ನೀನು ನಮ್ಮ ಇಡೀ ಪದದ ಮೇಲೆ. ಆದ್ದರಿಂದ, ನಾವು ಕಳೆದ ಇವೆ ಪದ ಮೇಲೆ iterating ನಾವು ನಿರ್ಧರಿಸಲು ನೀನು ಸೂಚ್ಯಂಕ ಮಕ್ಕಳು ರಚನೆಯ ಒಳಗೆ ಎಂದು ಪದ ಬ್ರಾಕೆಟ್ ಐ ಅನುರೂಪವಾಗಿದೆ ಆದ್ದರಿಂದ ಈ ನಿಖರವಾಗಿ ರೀತಿ ಹೋಗುತ್ತದೆ ಲೋಡ್, ಅಲ್ಲಿ ವೇಳೆ ಪದ [ನಾನು] ಅಪಾಸ್ಟ್ರಫಿ, ನಾವು ಬಯಸುವ ಇದೆ ಸೂಚ್ಯಂಕ "ವರ್ಣಮಾಲೆ" ಬಳಸಲು - 1. ನಾವು ನಿರ್ಧರಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಆ ನಾವು ಶೇಖರಿಸಿಡಲು ನೀನು ಅಲ್ಲಿ ಆಗಿದೆ ಅಪಾಸ್ಟ್ರಫಿಗಳನ್ನು. 

ಎಲ್ಸ್ ನಾವು ಎರಡು ಕಡಿಮೆ ಪದ ಬಳಸಲು ನೀನು ಬ್ರಾಕೆಟ್ ಐ ಆ ಪದವು ರಿಮೆಂಬರ್ ಅನಿಯಂತ್ರಿತ ಬಂಡವಾಳ ಹೊಂದಿವೆ. ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ನಾವು ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುವ ವಸ್ತುಗಳ ಸಣ್ಣ ಆವೃತ್ತಿ ಬಳಸಿ. ಮತ್ತು ಆ 'ಒಂದು' ಗೆ ಒಮ್ಮೆ ರಿಂದ ಕಳೆಯಿರಿ ಮತ್ತೆ ನಮಗೆ ವರ್ಣಮಾಲೆಯ ನೀಡಿ ಆ ಪಾತ್ರದ ಸ್ಥಾನವನ್ನು. ಆದ್ದರಿಂದ ನಮ್ಮ ಸೂಚ್ಯಂಕ ಎಂದು ವಿಶೇಷವೇನು ಮಕ್ಕಳ ರಚನೆಯ ಒಳಗೆ. 

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

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

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

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

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

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

[ಸಂಗೀತ]