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

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

ಆ ನೋಡ್ ನೀಡಿದ, ನಾವು ಮತ್ತೊಮ್ಮೆ ಆರ್ ಮಕ್ಕಳ ರಚನೆಯ ನೋಡಲು ಹೋಗುವ, ಮತ್ತು ನಾವು ಸೂಚ್ಯಂಕ ಶೂನ್ಯ ನೋಡಲು ನೀನು ಬೆಕ್ಕು ಒಂದು ಸಂಬಂಧಿಸಿರುತ್ತದೆ. ಆದ್ದರಿಂದ ನಾವು ಎಂದು ನೋಡ್ ಹೋಗಲು ನೀನು, ಮತ್ತು ಆ ನೋಡ್ ನೀಡಿದ, ನಾವು ನೀನು ಅನುರೂಪವಾಗಿದೆ ಸೂಚ್ಯಂಕ ನೋಡಲು ಟಿ ಮತ್ತು ನೋಡ್ನಲ್ಲಿ ಸ್ಥಳಾಂತರಗೊಳ್ಳುವ, ಗೆ ಅಂತಿಮವಾಗಿ, ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ಕಂಡಿದ್ದೇನೆ ನಮ್ಮ ಪದ ಕ್ಯಾಟ್ ಮೂಲಕ, ಮತ್ತು ಈಗ 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 ಹಿಟ್ ಇರಬಹುದು ಇದು. ದೋಷ ಇಲ್ಲದಿದ್ದರೆ ಮೊದಲ ಇಲ್ಲದಿದ್ದರೆ ಕಡತ ಓದುವ, ಆದ್ದರಿಂದ ದೋಷ, ನಾವು ವಿಶಿಷ್ಟ ಮಾಡಬೇಕಾದ್ದು , ಎಲ್ಲವೂ ಅನ್ಲೋಡ್ ಕಡತ ಮುಚ್ಚಿ, ತಪ್ಪು ಹಿಂತಿರುಗಿ. , ದೋಷ ಇರಲಿಲ್ಲ ಭಾವಿಸಿದರೂ ಕೇವಲ ನಾವು ವಾಸ್ತವವಾಗಿ ಕೊನೆಯಲ್ಲಿ ಹಿಟ್ ಅರ್ಥ ಕಡತ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಮುಚ್ಚಲು ಫೈಲ್ ನಿಜವಾದ ಲಾಭ ರಿಂದ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ನಿಘಂಟು ಲೋಡ್ ನಮ್ಮ trie ಒಳಗೆ. 

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

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

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

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

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

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

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

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