>> ರಾಬ್ ಬೌಡೆನ್: ಹಾಯ್.
ನಾನು ರಾಬ್ ಮನುಷ್ಯ, ಮತ್ತು ಲೆಟ್ಸ್ ಹ್ಯಾಶ್ ಈ ಪರಿಹಾರ ಔಟ್.
ಇಲ್ಲಿ ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನೀನು ಸಾಮಾನ್ಯ ಹ್ಯಾಷ್ ಟೇಬಲ್.
ನಾವು ನೋಡಿ ನಮ್ಮ ಹ್ಯಾಶ್ Struct ನೋಡ್ನ ಟೇಬಲ್ ಈ ರೀತಿ ಹೋಗುತ್ತದೆ.
ಆದ್ದರಿಂದ ಒಂದು ಚಾರ್ ಪದ ಹೋಗುವುದಿಲ್ಲ ಗಾತ್ರ ಉದ್ದ ಜೊತೆಗೆ 1 ರಚನೆಯ.
ಗರಿಷ್ಠ ರಿಂದ 1 ಮರೆಯಬೇಡಿ ನಿಘಂಟು ಪದ 45
ಪಾತ್ರಗಳು, ನಂತರ ನಾವು ನೀನು ಒಂದು ಹೆಚ್ಚುವರಿ ಪಾತ್ರ ಅಗತ್ಯವಿದೆ
ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0.
>> ತದನಂತರ ಪ್ರತಿ ನಮ್ಮ ಹ್ಯಾಷ್ ಟೇಬಲ್ ಬಕೆಟ್ ಶೇಖರಿಸಿಡಲು ಹೋಗುತ್ತದೆ ಒಂದು
ನೋಡ್ಗಳ ಲಿಂಕ್ ಪಟ್ಟಿ.
ನಾವು ಇಲ್ಲಿ ತನಿಖೆಯನ್ನು ರೇಖೀಯ ಏನು ಇಲ್ಲ.
ಆದ್ದರಿಂದ ಸಲುವಾಗಿ ಮುಂದಿನ ಲಿಂಕ್ ಬಕೆಟ್ ಅಂಶ, ನಾವು ಒಂದು ಅಗತ್ಯವಿದೆ
struct ನೋಡ್ * ಮುಂದಿನ.
ಆದ್ದರಿಂದ ಒಂದು ನೋಡ್ ಕಾಣುತ್ತದೆ.
ಈಗ, ಇಲ್ಲಿ ಘೋಷಣೆಯಾಗಿದೆ ನಮ್ಮ ಹ್ಯಾಶ್ ಮೇಜಿನ.
ಇದು 16.384 ಬಕೆಟ್ ಮಾಡಲಿಕ್ಕೆ, ಆದರೆ ಎಂದು ನಿಜವಾಗಿಯೂ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ.
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಹೊಂದಿರುವ ನೀನು ಜಾಗತಿಕ ವೇರಿಯಬಲ್ hashtable_size, ಇದು
0 ಎಂದು ಆಫ್ ಆರಂಭಿಸಲು ಹೋಗುವ, ಮತ್ತು ಅದು ಇದೆ ಟ್ರ್ಯಾಕ್ ಹೋಗುವ ಎಷ್ಟು ಪದಗಳ
ನಮ್ಮ ನಿಘಂಟು ಇದ್ದವು.
ಸರಿ.
>> ಆದ್ದರಿಂದ ಲೋಡ್ ಅವಲೋಕಿಸೋಣ.
ಆದ್ದರಿಂದ ಲೋಡ್ ಗಮನಕ್ಕೆ, ಇದು ಒಂದು bool ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
ಇದು ಯಶಸ್ವಿಯಾಗಿ ವೇಳೆ ನೀವು ನಿಜವಾದ ಮರಳಿ ಇಲ್ಲದಿದ್ದರೆ ಲೋಡ್ ಮತ್ತು ತಪ್ಪು.
ಮತ್ತು ಇದು ಒಂದು const ಚಾರ್ * ಸ್ಟಾರ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ನಿಘಂಟು ಇದು ನಿಘಂಟು,
ನಾವು ತೆರೆಯಲು ಬಯಸುವ.
ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ ನಾವು ಮಾಡಲು ನೀನು.
ನಾವು ನಿಘಂಟು fopen ನೀನು ಓದುವ, ಮತ್ತು ನಾವು ನೀನು
ಅದು ವೇಳೆ ಯಶಸ್ವಿಯಾದರು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿದರು, ನಂತರ ನಾವು ಮಾಡಲಿಲ್ಲ
ಯಶಸ್ವಿಯಾಗಿ ನಿಘಂಟು ತೆರೆಯಲು ಮತ್ತು ನಾವು ತಪ್ಪು ಹಿಂದಿರುಗಿಸಬೇಕಾಗುತ್ತದೆ.
>> ಆದರೆ ಯಶಸ್ವಿಯಾಗಿ ಮಾಡಿದರು ಎಂದು ಊಹಿಸಿಕೊಂಡು ಮುಕ್ತ, ನಾವು ಓದಲು ಬಯಸುವ
ನಿಘಂಟು.
ನಾವು ಕೆಲವು ಹೇಗೆ ರವರೆಗೆ ಆದ್ದರಿಂದ ಲೂಪಿಂಗ್ ಇರಿಸಿಕೊಳ್ಳಲು ಈ ಔಟ್ ಮುರಿಯಲು ಕಾರಣ
ನಾವು ನೋಡುತ್ತಾರೆ ಲೂಪ್.
ಆದ್ದರಿಂದ ಲೂಪಿಂಗ್ ಇರಿಸಿಕೊಳ್ಳಲು, ಮತ್ತು ಈಗ ನಾವು ನೀನು ಒಂದು ನೋಡ್ malloc ಗೆ.
ಮತ್ತು ಸಹಜವಾಗಿ, ನಾವು ಚೆಕ್ ದೋಷಕ್ಕೆ ಅಗತ್ಯವಿದೆ ಮತ್ತೆ mallocing ಯಶಸ್ವಿಯಾಗಲಿಲ್ಲ ಹಾಗಾಗಿ
ಮತ್ತು ನಾವು ನಾವು ಯಾವುದೇ ನೋಡ್ ಇಳಿಸುವುದನ್ನು ಬಯಸುವ ಮೊದಲು malloc ಗೆ ಏನಾಯಿತು, ಮುಚ್ಚಿ
ನಿಘಂಟು ಸುಳ್ಳು ಹಿಂತಿರುಗಿ.
>> ಆದರೆ ನಿರ್ಲಕ್ಷಿಸಿ, ಊಹಿಸಿಕೊಂಡು ನಾವು ಯಶಸ್ವಿಯಾದರು, ನಾವು fscanf ಬಳಸಲು ಬಯಸುವ
ಒಂದೇ ಒಂದು ಪದ ಓದಲು ನಮ್ಮ ನಮ್ಮ ನೋಡ್ ಡಿಕ್ಷನರಿ.
ಆದ್ದರಿಂದ ಪ್ರವೇಶ> ಪದ ನೆನಪು ಚಾರ್ ಪದ ಗಾತ್ರ ಉದ್ದದ ಬಫರ್ ಜೊತೆಗೆ
ನಾವು ನೀನು ಒಂದು ಸೈನ್ ಪದ ಶೇಖರಿಸಿಡಲು
ಆದ್ದರಿಂದ fscanf 1 ಎಲ್ಲಿಯವರೆಗೆ ಮರಳಲು ಹೋಗುತ್ತದೆ ಯಶಸ್ವಿಯಾಗಿ ಓದಲು ಸಾಧ್ಯವಾಯಿತು ಎಂದು
ಕಡತದಿಂದ ಪದ.
>> ದೋಷ ಎರಡೂ ಸಂಭವಿಸುತ್ತದೆ ಅಥವಾ ನಾವು ತಲುಪಿದಲ್ಲಿ ಕಡತದ ಕೊನೆಯಲ್ಲಿ, ಇದು ತಿನ್ನುವೆ
ಇದು ಇದ್ದರೆ ಸಂದರ್ಭದಲ್ಲಿ 1 ಮರಳಲು 1 ಮರಳಲು, ನಾವು ಅಂತಿಮವಾಗಿ ಮುರಿಯಲು ನೀನು
ಈ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಔಟ್.
ಆದ್ದರಿಂದ ನಾವು ನೋಡಿ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಒಮ್ಮೆ ಒಂದು ಪದ ಓದಲು
ಪ್ರವೇಶ> ಪದ, ನಾವು ಹ್ಯಾಶ್ ನೀನು ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಬಳಸಿ ಆ ಪದ.
ನಲ್ಲಿ ಅವಲೋಕಿಸೋಣ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ.
>> ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಅಗತ್ಯವಿಲ್ಲ ಈ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು.
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನಾವು ಈ ಎಳೆದ ಇಂಟರ್ನೆಟ್ ಕಾರ್ಯ ಹ್ಯಾಶ್.
ನೀವು ಗುರುತಿಸಲು ಅಗತ್ಯವಿದೆ ಮಾತ್ರ ವಿಷಯ ಈ ಒಂದು const ಚಾರ್ * ಪದ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ,
ಆದ್ದರಿಂದ ಇನ್ಪುಟ್ ಆಗಿ ಸ್ಟ್ರಿಂಗ್ ಪಡೆದು ವಿಶೇಷವೇನು ಔಟ್ಪುಟ್ ಒಂದು ಇಂಟ್ ರುಜುಮಾಡದ ಹಿಂದಿರುಗಿದ.
ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಇಲ್ಲಿದೆ, ಇದು ಒಂದು ಆದಾನ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ನೀವು ಒಂದು ನೀಡುತ್ತದೆ
ಹ್ಯಾಶ್ ಟೇಬಲ್ಲಿಗೆ ಸೂಚ್ಯಂಕ.
ನಾವು NUM_BUCKETS ಮೂಲಕ ಮೊಡ್ಡಿಂಗ್ ನೀವು ಗಮನಿಸಬಹುದು ಆದ್ದರಿಂದ ಹ್ಯಾಶ್ ಮೌಲ್ಯವನ್ನು ಮರಳಿದರು
ವಾಸ್ತವವಾಗಿ ಹ್ಯಾಶ್ ಟೇಬಲ್ಲಿಗೆ ಸೂಚ್ಯಂಕ ಮತ್ತು ಮಾಡುತ್ತದೆ ಮೀರಿ ಸೂಚ್ಯಂಕ
ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು.
>> ಆದ್ದರಿಂದ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ, ನಾವು ನೀನು ಕೊಟ್ಟಿರುವ ನಾವು ಓದುವ ಪದ ಹ್ಯಾಶ್
ನಿಘಂಟು ಮತ್ತು ನಂತರ ನಾವು ನೀನು ಎಂದು ಬಳಸಲು ಸೇರಿಸಲು ಹೊಂದಿದೆ
ಹ್ಯಾಶ್ ಟೇಬಲ್ಲಿಗೆ ಪ್ರವೇಶ.
ಈಗ, hashtable ಹ್ಯಾಶ್ ಪ್ರಸ್ತುತ ಲಿಂಕ್ ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಲ್ಲಿ ಪಟ್ಟಿ, ಮತ್ತು
ಇದು ಕೇವಲ ಶೂನ್ಯ ಎಂದು ತುಂಬಾ ಸಂಭಾವ್ಯ.
ನಾವು ನಮ್ಮ ನಮೂದನ್ನು ಸೇರಿಸಲು ಬಯಸುವ ಈ ಲಿಂಕ್ ಪಟ್ಟಿ ಆರಂಭದಲ್ಲಿ, ಮತ್ತು ಆದ್ದರಿಂದ
ನಾವು ನಮ್ಮ ಪ್ರಸ್ತುತ ಪ್ರವೇಶ ಮಾಡಲಿಕ್ಕೆ ಪ್ರಸ್ತುತ ಯಾವ ಹ್ಯಾಷ್ ಟೇಬಲ್ ಬೆಟ್ಟು
ಅಂಕಗಳ ನಂತರ ನಾವು ಶೇಖರಿಸಿಡಲು ನೀನು ಹ್ಯಾಶ್ ನಲ್ಲಿ ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಲ್ಲಿ
ಈಗಿರುವ ನಮೂದನ್ನು.
>> ಆದ್ದರಿಂದ ಈ ಎರಡು ಸಾಲುಗಳನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಸೇರಿಸಲು ಆರಂಭದಲ್ಲಿ ಪ್ರವೇಶ
ಎಂದು ಇಂಡೆಕ್ಸ್ನಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಲ್ಲಿ.
ನಾವು ಪೂರೈಸಿದ ನಂತರ, ನಾವು ತಿಳಿದಿರುವಂತೆ ನಾವು ಮತ್ತೊಂದು ಪದ ಕಂಡು
ನಿಘಂಟು ಮತ್ತು ನಾವು ಮತ್ತೆ ಹೆಚ್ಚಿಸಲು.
ನಾವು ನಡೆಸುವ ಎಂದು fscanf ರವರೆಗೆ ಅಂತಿಮವಾಗಿ ಅಲ್ಲದ ಏನಾದರೂ 1 ಹಿಂದಿರುಗಿಸುತ್ತದೆ
ಪಾಯಿಂಟ್ ನಾವು ಅಗತ್ಯವಿದೆ ಎಂದು ನೆನಪಿಡಿ ಉಚಿತ ಪ್ರವೇಶ, ಆದ್ದರಿಂದ ಇಲ್ಲಿ, ನಾವು ಒಂದು malloced
ಪ್ರವೇಶ ಮತ್ತು ನಾವು ಏನನ್ನಾದರೂ ಓದಲು ಪ್ರಯತ್ನಿಸಿದ ನಿಘಂಟು ನಿಂದ.
ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಓದಲು ಮಾಡಲಿಲ್ಲ ನಿಘಂಟು ಏನನ್ನೋ ಇದರಲ್ಲಿ
ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ನಾವು ಪ್ರವೇಶ ಮುಕ್ತಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ ವಾಸ್ತವವಾಗಿ ಹ್ಯಾಶ್ ಟೇಬಲ್ಲಿಗೆ ಯಾವತ್ತೂ
ಮತ್ತು ಅಂತಿಮವಾಗಿ ಮುರಿಯಲು.
>> ನಾವು ಭೇದಿಸಿ ಒಮ್ಮೆ ನಾವು, ಚೆನ್ನಾಗಿ, ನೋಡಿ ಅಗತ್ಯವಿದೆ ನಾವು ಏಕೆಂದರೆ ಅಲ್ಲಿ ಮುರಿದಿದ್ದಾರೆ
ದೋಷ ಕಡತ ಓದುವ, ಅಥವಾ ನಾವು ತಲುಪಿತು ಏಕೆಂದರೆ ನಾವು ಮುರಿದಿದ್ದಾರೆ
ಕಡತದ ಕೊನೆಯಲ್ಲಿ?
ದೋಷವಿತ್ತು ವೇಳೆ, ನಾವು ಬಯಸುವ ಲೋಡ್ ಏಕೆಂದರೆ ತಪ್ಪು ಹಿಂತಿರುಗಿ
ಯಶಸ್ಸು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ನಾವು ಬಯಸುವ ನಾವು ಓದಲು ಎಲ್ಲಾ ಪದಗಳನ್ನು ಇಳಿಸುವುದನ್ನು
ಮತ್ತು ನಿಘಂಟು ಕಡತ ಮುಚ್ಚಿ.
ನಾವು ಯಶಸ್ವಿಯಾಗಲು ಮಾಡಲಿಲ್ಲ ಭಾವಿಸಿಕೊಂಡು, ನಂತರ ನಾವು ಇನ್ನೂ ನಿಘಂಟು ಮುಚ್ಚಲು ಅಗತ್ಯ
ಫೈಲ್, ಮತ್ತು ಅಂತಿಮವಾಗಿ ರಿಂದ ನಿಜವಾದ ಹಿಂತಿರುಗಿ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಲೋಡ್ ಮಾಡಿದ
ನಿಘಂಟು.
ಮತ್ತು ಲೋಡ್ ಅದು.
>> ಈಗ ಹೊತ್ತ ಹ್ಯಾಷ್ ಟೇಬಲ್ ನೀಡಿದ ಪರಿಶೀಲಿಸಿ, ಈ ರೀತಿ ಹೋಗುತ್ತದೆ.
ಆದ್ದರಿಂದ, ಇದು ಒಂದು bool ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಪರಿಶೀಲಿಸಿ ಇದು ಸೂಚಿಸಲು ಹೋಗುವ ಎಂಬುದನ್ನು
ಜಾರಿಗೆ ಇನ್ ಚಾರ್ * ಪದ, ಎಂಬುದನ್ನು ಜಾರಿಗೆ ಇನ್ ಸ್ಟ್ರಿಂಗ್ ನಮ್ಮ ನಿಘಂಟು ಹೊಂದಿದೆ.
ನಿಘಂಟಿನಲ್ಲಿ ಅದು ಹಾಗಿದ್ದರೆ, ವೇಳೆ ನಮ್ಮ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದಲ್ಲಿ, ನಾವು ಹಿಂದಿರುಗುವ
ನಿಜವಾದ, ಮತ್ತು ಇದು ಅಲ್ಲ, ನಾವು ತಪ್ಪು ಹಿಂತಿರುಗುವುದು.
ಈ ಜಾರಿಗೆ ಇನ್ ಪದ ನೀಡಲಾಗಿದೆ, ನಾವು ಕೋರುತ್ತೇವೆ ಪದ ಹ್ಯಾಶ್ ಹೋಗುವ.
>> ಈಗ, ಗುರುತಿಸಲು ಪ್ರಮುಖ ವಿಷಯ ಲೋಡ್, ನಾವು ತಿಳಿದಿದ್ದು ಆ ಎಲ್ಲಾ
ಪದಗಳನ್ನು ಕಡಿಮೆ ಕೇಸ್ ಎಂದು ಹೊರಟಿದ್ದ, ಆದರೆ ಇಲ್ಲಿ, ನಾವು ಖಚಿತವಾಗಿ ಇಲ್ಲ.
ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ನೋಡೋಣ ವೇಳೆ, ವಾಸ್ತವವಾಗಿ ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ
ಪ್ರತಿ ಪಾತ್ರದ lowercasing ಇದೆ ಪದದ.
ಆದ್ದರಿಂದ ಲೆಕ್ಕಿಸದೆ ಬಂಡವಾಳದ ಪದ, ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಹೋಗುತ್ತದೆ
ಏನೇ ಅದೇ ಸೂಚ್ಯಂಕ ಹಿಂದಿರುಗುತ್ತಿದ್ದವು ಬಂಡವಾಳೀಕರಣ ಇದು ಎಂದು ಎಂದು ಹೊಂದಿದೆ
ಒಂದು ಸಂಪೂರ್ಣವಾಗಿ ಸಣ್ಣ ಮರಳಿದರು ಪದ ಆವೃತ್ತಿ.
ಸರಿ.
>> ಆದ್ದರಿಂದ ನಮ್ಮ ಸೂಚ್ಯಂಕ.
ಇದು ಈ ಪದ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕವನ್ನು.
ಈಗ, ಲೂಪ್ ಈ ಹೋಗುತ್ತದೆ ಲಿಂಕ್ ಪಟ್ಟಿ ಮೇಲೆ ಗೆ
ಆ ಸೂಚ್ಯಂಕ ಆಗಿತ್ತು.
ನಾವು ಪ್ರವೇಶ ಆರಂಭಿಸುವಲ್ಲಿ ಗಮನಕ್ಕೆ ಸೂಚ್ಯಂಕ ತೋರಿಸಲು.
ನಾವು ಪ್ರವೇಶ ಮಾಡುತ್ತದೆ ಮುಂದುವರಿಯಲು ನೀನು ಸಮಾನ ಶೂನ್ಯ, ಮತ್ತು ನೆನಪು
ನಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಪಾಯಿಂಟರ್ ಅಪ್ಡೇಟ್ ಪ್ರವೇಶ ಮುಂದಿನ ಪ್ರವೇಶ> ಸಮ, ಆದ್ದರಿಂದ ಹೊಂದಿವೆ
ನಮ್ಮ ಪ್ರಸ್ತುತ ಪ್ರವೇಶ ಬಿಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಮುಂದಿನ ಐಟಂ.
ಸರಿ.
>> ಆದ್ದರಿಂದ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿಯೊಂದು ನಮೂದು, ನಾವು strcasecmp ಬಳಸಲು ನೀನು.
ಇದು strcmp ಏಕೆಂದರೆ ಮತ್ತೊಮ್ಮೆ, ನಾವು ತೋರದಂತೆ ವಿಷಯಗಳನ್ನು ಸಂದರ್ಭದಲ್ಲಿ ಮಾಡಲು ಬಯಸುವ.
ನಾವು ಪದ ಹೋಲಿಸಿ strcasecmp ಬಳಸಲು ಈ ಕಾರ್ಯ ರವಾನಿಸಲಾಗಿದೆ
ಪದ ವಿರುದ್ಧದ ಈ ನಮೂದನ್ನು ರಲ್ಲಿ ಆಗಿದೆ.
ಇದು 0 ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಇರಲಿಲ್ಲ ಅರ್ಥ ನಾವು ಬಯಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಪಂದ್ಯದಲ್ಲಿ,
ನಿಜವಾದ ಹಿಂತಿರುಗಿ.
ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಕಂಡು ನಮ್ಮ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದಲ್ಲಿ ಪದ.
>> ಪಂದ್ಯದಲ್ಲಿ ಇರಲಿಲ್ಲ, ಆಗ ನಾವು ಆರ್ ಮತ್ತೆ ಲೂಪ್ ಹೋಗುವ ಮತ್ತು ನೋಡಲು
ಮುಂದಿನ ಪ್ರವೇಶ.
ನಾವು ಹಾಗೆಯೇ ಇಲ್ಲ ಆವರ್ತಿಸುವ ಮುಂದುವರಿಸುತ್ತೇವೆ ಈ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ನಮೂದುಗಳು.
ನಾವು ಮುರಿಯಲು ಏನಾಗುತ್ತದೆ ಲೂಪ್ ಈ ಔಟ್?
ನಾವು ಒಂದು ನಮೂದನ್ನು ಕಾಣಲಿಲ್ಲ ಅರ್ಥ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಪದ ದಾಖಲೆಗಳುಸರಿಹೊಂದಿವೆ
ನಾವು ಸೂಚಿಸಲು ತಪ್ಪು ಹಿಂತಿರುಗಿ ನಮ್ಮ ಹ್ಯಾಷ್ ಟೇಬಲ್ ಈ ಪದ ಹೊಂದಿರುವುದಿಲ್ಲ.
ಮತ್ತು ಚೆಕ್ ಅದು.
ಸರಿ.
>> ಆದ್ದರಿಂದ ಗಾತ್ರದಲ್ಲಿ ಅವಲೋಕಿಸೋಣ.
ಈಗ, ಗಾತ್ರ ಬಹಳ ಸರಳ ಏರಲಿದೆ ರಿಂದ ಪ್ರತಿ ಪದಕ್ಕೆ, ಲೋಡ್ ನೆನಪು
ನಾವು ಜಾಗತಿಕ ವೃದ್ಧಿಯಾಗಲ್ಪಡಬಹುದು ಕಂಡು ವೇರಿಯಬಲ್ hashtable_size.
ಆದ್ದರಿಂದ ಗಾತ್ರ ಕಾರ್ಯ ಕೇವಲ ಜಾಗತಿಕ ಮರಳಿ ಹೋಗುವ
ವೇರಿಯಬಲ್, ಮತ್ತು ಅದು ಇಲ್ಲಿದೆ.
>> ಈಗ ಅಂತಿಮವಾಗಿ, ನಾವು ಇಳಿಸುವುದನ್ನು ಅಗತ್ಯವಿದೆ ನಿಘಂಟು ಎಲ್ಲವೂ ಮಾಡಲಾಗುತ್ತದೆ ಒಮ್ಮೆ.
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಏನು ಮಾಡೋಣ?
ಇಲ್ಲಿಯೇ, ನಾವು ಎಲ್ಲಾ ಮೇಲೆ ಲೂಪ್ ನೀವು ನಮ್ಮ ಹ್ಯಾಶ್ ಮೇಜಿನ ಬಕೆಟ್.
ಆದ್ದರಿಂದ NUM_BUCKETS ಬಕೆಟ್ ಇವೆ.
ಮತ್ತು ನಮ್ಮ ಹ್ಯಾಶ್ ಪ್ರತಿ ಲಿಂಕ್ ಪಟ್ಟಿ ಟೇಬಲ್, ನಾವು ಮೇಲೆ ಲೂಪ್ ನೀನು
ಲಿಂಕ್ ಪಟ್ಟಿ ಸಂಪೂರ್ಣ ಪ್ರತಿ ಅಂಶ ಮುಕ್ತಗೊಳಿಸಿದ.
ಈಗ, ನಾವು ಎಚ್ಚರಿಕೆಯಿಂದ ಮಾಡಬೇಕಾಗುತ್ತದೆ, ಇಲ್ಲಿ ನಾವು ಎಂದು ತಾತ್ಕಾಲಿಕ ವೇರಿಯಬಲ್
ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಸಂಗ್ರಹಿಸುವ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಅಂಶ.
ನಂತರ ನಾವು ಉಚಿತ ನೀನು ಪ್ರಸ್ತುತ ಅಂಶ.
>> ನಾವು ಈ ಮಾಡಲು ಮರೆಯಬೇಡಿ ಅಗತ್ಯವಿದೆ ಕೇವಲ ಪ್ರಸ್ತುತ ಅಂಶ ಮುಕ್ತಗೊಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ
ತದನಂತರ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿ ಕಾರಣ ಒಮ್ಮೆ ನಾವು ಬಿಡುಗಡೆ
ಮೆಮೊರಿ ಅಮಾನ್ಯ ಆಗುತ್ತದೆ.
ನಾವು ಒಂದು ಪಾಯಿಂಟರ್ ಸುಮಾರು ಇರಿಸಿಕೊಳ್ಳಲು ಅಗತ್ಯವಿದೆ ಮುಂದಿನ ಅಂಶ, ನಾವು ಮುಕ್ತಗೊಳಿಸಲು
ಪ್ರಸ್ತುತ ಅಂಶ, ಮತ್ತು ನಂತರ ನಾವು ಅಪ್ಡೇಟ್ ತೋರಿಸಲು ನಮ್ಮ ಪ್ರಸ್ತುತ ಅಂಶ
ಮುಂದಿನ ಅಂಶ.
>> ನಾವು ಅಂಶಗಳನ್ನು ಲೂಪ್ ಇವೆ ವಿಲ್ ಈ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ.
ನಾವು ಎಲ್ಲಾ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಹಾಗೆ ಮಾಡುತ್ತೇವೆ ಹ್ಯಾಷ್ ಟೇಬಲ್, ಮತ್ತು ನಾವು ಪೂರೈಸಿದ ಒಮ್ಮೆ
, ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ಕೆಳಗಿಳಿಸಲಾಯಿತು ಬಂದಿದೆ ಹ್ಯಾಷ್ ಟೇಬಲ್, ಮತ್ತು ನಾವು ಮುಗಿಸಿದ್ದೀರಿ.
ಆದ್ದರಿಂದ unloads ಫಾರ್ ಎಂದಿಗೂ ಅಸಾಧ್ಯ ಸುಳ್ಳು ಹಿಂತಿರುಗಿ ನಾವು ಪೂರೈಸಿದಾಗ, ನಾವು
ಕೇವಲ ನಿಜವಾದ ಹಿಂತಿರುಗಿ.