[Powered by Google Translate] [ದರ್ಶನ - ಸಮಸ್ಯೆ ಸೆಟ್ 6] [Zamyla ಚಾನ್ - ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ] [ಈ CS50 ಹೊಂದಿದೆ. - CS50.TV] 

ಹಲೋ, ಎಲ್ಲರೂ, ಮತ್ತು ದರ್ಶನ 6 ಸ್ವಾಗತ: Huff'n ಪಫ್. Huff'n ಪಫ್ ನಾವು ಏನು ಒಂದು ಹಫ್ಮನ್ ಸಂಕುಚಿತ ಕಡತ ವ್ಯವಹರಿಸುವಾಗ ಏರಲಿದೆ ನಂತರ, ಮತ್ತೆ ಅದನ್ನು puffing ಅದು decompressing ನಾವು 0 ಸೆ ಮತ್ತು 1 ಬಳಕೆದಾರ ನಮಗೆ ಕಳುಹಿಸುತ್ತದೆ ಭಾಷಾಂತರಿಸಿ ಇದರಿಂದ ಮೂಲ ಪಠ್ಯ ಅದನ್ನು ಪುನಃ ಪರಿವರ್ತಿಸಬಹುದು. ನೀವು ಉಪಕರಣಗಳು ಕೆಲವು ನೋಡಲು ನೀನು ಏಕೆಂದರೆ Pset 6 ಸುಂದರವಾಗಿದೆ ಎಂದು ಹೋಗುತ್ತದೆ ನೀವು 1 ಬಹಳ ಅಚ್ಚುಕಟ್ಟಾಗಿ ಪರಿಕಲ್ಪನೆಯನ್ನು ಅವುಗಳನ್ನು ಸಂಯೋಜಿಸಿದರೆ pset 4 ಮತ್ತು pset 5 ಮತ್ತು ರೀತಿಯ ಬಳಸಿದ ನೀವು ಅದರ ಬಗ್ಗೆ ಯೋಚಿಸುವುದು ಬಂದಾಗ. 

ಸಹ ವಾದಯೋಗ್ಯವಾಗಿ, pset 4 ಮತ್ತು 5 ನಾವು ನೀಡುವ ಅತ್ಯಂತ ಸವಾಲಿನ psets ಇದ್ದರು. ಈಗ ನಾವು, ಸಿ ಈ 1 ಹೆಚ್ಚು pset ಹೊಂದಿವೆ ಮತ್ತು ಆ ನಂತರ ನಾವು ವೆಬ್ ಕಾರ್ಯಕ್ರಮವನ್ನು ಇದ್ದೇವೆ. ಆದ್ದರಿಂದ CS50 ಅತೀ ಕಠಿಣವಾದ ದಿಣ್ಣೆ ಮೇಲೆ ಪಡೆಯಲು ನಿಮ್ಮನ್ನು ಅಭಿನಂದಿಸುತ್ತೇನೆ. 

Huff'n ಪಫ್ ಮೇಲೆ ಮೂವಿಂಗ್, ಈ pset ನಮ್ಮ ಉಪಕರಣ, ಹಫ್ಮನ್ ಮರಗಳು ಮುಂದುವರೆಸುತ್ತೇವೆ ಆದ್ದರಿಂದ ಬೈನರಿ ಮರಗಳು ಕೆಲಸ ಆದರೆ ನಿರ್ದಿಷ್ಟವಾಗಿ ಹಫ್ಮನ್ ಮರಗಳು ಕೇವಲ ಹೇಗೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಹೇಗೆ ಅವರು ನಿರ್ಮಿಸಿದ ಮಾಡುತ್ತಿದ್ದೇವೆ. ನಂತರ ನಾವು, ಈ pset ವಿತರಿಸುವ ಕೋಡ್ ಒಂದು ಬಹಳಷ್ಟು ಎಂದು ನೀನು ಮತ್ತು ನಾವು ಕೋಡ್ ಕೆಲವು ಎಂದು ವಾಸ್ತವವಾಗಿ ನೋಡಲು ಬಂದು ವಿಲ್ ನಾವು, ಸಂಪೂರ್ಣವಾಗಿ ಇನ್ನೂ ತಿಳಿಯಲು ಸಾಧ್ಯವಾಗದೆ ಇರಬಹುದು ಮತ್ತು ಆದ್ದರಿಂದ ಆ ನಂತರ ಅವುಗಳ ಜೊತೆಗೆ. H ಕಡತಗಳನ್ನು. ಸಿ ಕಡತಗಳನ್ನು ಇರಬಹುದು ಆದರೆ ನಮಗೆ ನಾವು ಆ ಕಾರ್ಯಗಳನ್ನು ಕೆಲಸ ಗೊತ್ತಿಲ್ಲ ಆದ್ದರಿಂದ ಅಗತ್ಯವಿರುವ ಸಾಕಷ್ಟು ತಿಳುವಳಿಕೆಯನ್ನು ನೀಡುತ್ತದೆ ಅಥವಾ ಕನಿಷ್ಠ ತಾವು ಮಾಡಲು ನಿಯಮವಿದೆ - ಅವುಗಳ ಆದಾನಗಳು ಮತ್ತು - ನಾವು ಕಪ್ಪು ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ ಏನು ಸಂಭವಿಸುತ್ತಿದೆ ಗೊತ್ತಿಲ್ಲ ಸಹ ಅಥವಾ ಒಳಗೆ ಕಪ್ಪು ಬಾಕ್ಸ್ ನಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಅರ್ಥವಾಗುತ್ತಿಲ್ಲ. ತದನಂತರ ಅಂತಿಮವಾಗಿ, ಎಂದಿನಂತೆ, ನಾವು, ಹೊಸ ದತ್ತಾಂಶ ರಚನೆಗಳು ವ್ಯವಹರಿಸುತ್ತದೆ ಆ ಗ್ರಂಥಿಗಳು ನಿರ್ದಿಷ್ಟ ರೀತಿಯ ಕೆಲವು ವಿಷಯಗಳನ್ನು ಬೆರಳು ಮತ್ತು ಇಲ್ಲಿ ವಿನ್ಯಾಸ ಪ್ರಕ್ರಿಯೆಗೆ ಕೇವಲ ಒಂದು ಪೆನ್ ಮತ್ತು ಪೇಪರ್ ಹೊಂದಿರುವ ಮತ್ತು ನೀವು ನಿಮ್ಮ pset ಕೆಲಸ ಎಂಬುದನ್ನು ಊಹಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಆದರೆ ಡೀಬಗ್ ಸಮಯದಲ್ಲಿ. ನೀವು ಮೌಲ್ಯಗಳನ್ನು ಏನು ಕೆಳಗೆ ಸ್ವಲ್ಪ ನಿಮ್ಮ ಪೆನ್ ಮತ್ತು ಪೇಪರ್ ಜೊತೆಗೆ GDB ಹೊಂದಬಹುದು ಅಲ್ಲಿ ನಿಮ್ಮ ಬಾಣಗಳನ್ನು ಸೂಚಿಸುವ, ಮತ್ತು ಆ ತರಹದ ವಸ್ತುಗಳನ್ನು ನೀಡಲಾಗುತ್ತದೆ. 

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

ನೀವು ಹಫ್ಮನ್ ಮರದ ನಿರ್ಮಿಸಲು ಆ ರೀತಿಯಲ್ಲಿ ಪಠ್ಯ ಕಂಡುಬರುವ ಪಾತ್ರಗಳು ಎಲ್ಲಾ ಇರಿಸುವ ಮೂಲಕ ಮತ್ತು ಅವುಗಳ ಆವರ್ತನ ಲೆಕ್ಕ, ಎಷ್ಟು ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ. ಈ ಎರಡೂ ಪತ್ರಗಳನ್ನು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ ಎಷ್ಟು ಬಾರಿ ಎಣಿಕೆ ಇರಬಹುದು ಅಥವಾ ಬಹುಶಃ ಪ್ರತಿ ಒಂದು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಎಷ್ಟು ಎಲ್ಲಾ ಪಾತ್ರಗಳ ಔಟ್ ಶೇಕಡಾವಾರು. ಆದ್ದರಿಂದ ನೀವು ಏನು, ಒಮ್ಮೆ ಆ ಮ್ಯಾಪ್ ಔಟ್ ಎಲ್ಲಾ ಹೊಂದಿದೆ ನಂತರ ನೀವು 2 ಕಡಿಮೆ ಆವರ್ತನಗಳಲ್ಲಿ ನೋಡಿ ತದನಂತರ ಒಡಹುಟ್ಟಿದವರ ಅವರನ್ನು ಸೇರಲು ಅಲ್ಲಿ ನಂತರ ಪೋಷಕ ನೋಡ್ ತನ್ನ 2 ಮಕ್ಕಳು ಮೊತ್ತವು ಆವರ್ತನದಲ್ಲಿ ಹೊಂದಿದೆ. ತದನಂತರ ನೀವು ರೂಢಿ ಹೇಳುತ್ತಾರೆ ಎಡ ನೋಡ್ ನೀವು 0 ಶಾಖೆಯ ನಂತರ ಮೂಲಕ ಅನುಸರಿಸಿ ತದನಂತರ ಬಲತುದಿಯಲ್ಲಿ ನೋಡ್ 1 ಶಾಖೆಯಾಗಿದೆ. ನಾವು ಮೋರ್ಸ್ ಸಂಕೇತದಲ್ಲಿ ಕಂಡಿದ್ದರಿಂದ, ಒಂದು gotcha ಎಂದು ನೀವು ಕೇವಲ ಒಂದು ಬೀಪ್ ಶಬ್ದ ಮತ್ತು ಬೀಪ್ ಶಬ್ದ ಹೊಂದಿದ್ದರೆ ಇದು ಅಸ್ಪಷ್ಟವಾಗಿತ್ತು. ಇದು 1 ಅಕ್ಷರದ ಆಗಿರಬಹುದು ಅಥವಾ ಇದು 2 ಅಕ್ಷರಗಳ ಅನುಕ್ರಮ ಆಗಿರಬಹುದು. ಆದ್ದರಿಂದ ಯಾವ ಹಫ್ಮನ್ ಮರಗಳು ಹೊಂದಿದವರಿಗೆ ಪಾತ್ರಗಳ ಸ್ವಭಾವತಃ ಏಕೆಂದರೆ ಅಥವಾ ನಮ್ಮ ಅಂತಿಮ ನಿಜವಾದ ಪಾತ್ರಗಳು ಶಾಖೆ ಕೊನೆಯ ನೋಡ್ ಎಂದು - ನಾವು ಎಲೆಗಳನ್ನು ಆ ನೋಡಿ - ಆ ಕಾರಣದಿಂದ ಯಾವುದೇ ದ್ವಂದ್ವಾರ್ಥತೆಯನ್ನು ಇರುತ್ತದೆ ಸಾಧ್ಯವಿಲ್ಲ ನೀವು ಬಿಟ್ಗಳು ಸರಣಿ ಎನ್ಕೋಡ್ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಇದು ಅಕ್ಷರದ ಪರಿಭಾಷೆಯಲ್ಲಿ ಏಕೆಂದರೆ 1 ಅಕ್ಷರದ ಪ್ರತಿನಿಧಿಸುವ ಬಿಟ್ಗಳು ಉದ್ದಕ್ಕೂ ಎಲ್ಲಿಯೂ ನೀವು ಇನ್ನೊಂದು ಇಡೀ ಅಕ್ಷರದ ಎದುರಿಸಿದರೆ, ಮತ್ತು ಯಾವುದೇ ಗೊಂದಲ ಇರುವುದಿಲ್ಲ. ಆದರೆ ನಾವು ನೀವು ಹುಡುಗರಿಗೆ ವಾಸ್ತವವಾಗಿ ಕಾಣಬಹುದಾಗಿದೆ ಉದಾಹರಣೆಗಳು ಆಗಿ ಹೋಗುತ್ತೇನೆ ಎಂದು ಬದಲು ನಮಗೆ ಕೇವಲ ಸತ್ಯ ಎಂದು ತಿಳಿಸುವ. 

ನ ಒಂದು ಹಫ್ಮನ್ ಮರದ ಒಂದು ಸರಳ ಉದಾಹರಣೆ ನೋಡೋಣ. ನಾನು 12 ಪಾತ್ರಗಳು ಉದ್ದವಾಗಿದೆ ಇಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಿರುತ್ತವೆ. ನಾನು 6 Bs, ಮತ್ತು 2 ಸಿ, 4 ಹೊಂದಿರುತ್ತವೆ. ನನ್ನ ಮೊದಲ ಹೆಜ್ಜೆ ಎಣಿಸಲು ಎಂದು. ಎ ಎಷ್ಟು ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ? ಇದು ಸಾಲಿನಲ್ಲಿ 4 ಬಾರಿ ಕಂಡುಬರುತ್ತದೆ. ಬಿ 6 ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು C 2 ಬಾರಿ ಕಂಡುಬರುತ್ತದೆ. ಸ್ವಾಭಾವಿಕವಾಗಿ, ನಾನು, ಹೆಚ್ಚಾಗಿ ಬಿ ಬಳಸಿ ನಾನು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ ಆದ್ದರಿಂದ ನಾನು ಬಿಟ್ಗಳ fewest ಸಂಖ್ಯೆ, 0 ಸೆ ಮತ್ತು 1 ಗಳ fewest ಸಂಖ್ಯೆಯ ಬಿ ಪ್ರತಿನಿಧಿಸಲು ಬಯಸುತ್ತೇನೆ. ತದನಂತರ ನಾನು ಸಿ ಹಾಗೂ 0 ಸೆ ಮತ್ತು 1 ಹೆಚ್ಚಿನ ಪ್ರಮಾಣವನ್ನು ಅಗತ್ಯವಿದೆ ನಿರೀಕ್ಷೆ ಪಡೆಯಲಿದ್ದೇನೆ. ಮೊದಲ ನಾನು ಇಲ್ಲಿ ಏನು ನಾನು ಆವರ್ತನ ಪರಿಭಾಷೆಯಲ್ಲಿ ಏರುವ ಇರಿಸಿತು ಇದೆ. ನಾವು ಸಿ ಮತ್ತು ಎ, ಆ ನಮ್ಮ 2 ಕಡಿಮೆ ಆವರ್ತನಗಳಲ್ಲಿ ಎಂದು ನೋಡಿ. , ನಾವು ಮೂಲ ನೋಡ್ ರಚಿಸಿ, ಮತ್ತು ಪೋಷಕ ನೋಡ್ ಇದು ಸಂಬಂಧಿಸಿದ ಪತ್ರವನ್ನು ಹೊಂದಿಲ್ಲ ಆದರೆ ಮೊತ್ತವು ಆವರ್ತನದಲ್ಲಿ, ಹೊಂದಿದೆ. ಮೊತ್ತ 6 ಇದು 2 + 4, ಆಗುತ್ತದೆ. ನಂತರ ನಾವು ಎಡ ಶಾಖೆ ಅನುಸರಿಸಿ. ನಾವು 6 ನೋಡ್ನಲ್ಲಿ ಆಗಿದ್ದರೆ, ಆಗ ಸಿ ಪಡೆಯಲು 0 ಅನುಸರಿಸಿ ನಂತರ 1 ಎ ಪಡೆಯಲು ಈಗ ನಾವು 2 ನೋಡ್ಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ನಾವು ಮೌಲ್ಯವನ್ನು 6 ಮತ್ತು ನಂತರ ನಾವು ಮೌಲ್ಯವನ್ನು 6 ಇನ್ನೊಂದು ನೋಡ್ ಹೊಂದಿರುತ್ತವೆ. ಮತ್ತು ಆದ್ದರಿಂದ ಆ 2 ಕಡಿಮೆ 2 ಆದರೆ ಬಿಡಲಾಗಿದೆ ಎಂದು ಕೇವಲ 2, ಕೇವಲ ಆದ್ದರಿಂದ ನಾವು ಮೊತ್ತವು 12 ಎಂಬ ಮತ್ತೊಂದು ಪೋಷಕರು ಆ ಸೇರಲು. ಇಲ್ಲಿ ನಾವು ನಮ್ಮ ಹಫ್ಮನ್ ಮರದ ಹೊಂದಿವೆ ಬಿ ಪಡೆಯಲು ಅಲ್ಲಿ, ಕೇವಲ ಬಿಟ್ 1 ಎಂದು ಮತ್ತು ನಂತರ ಒಂದು ಪಡೆಯಲು ನಾವು ಸಿ 00 ಹೊಂದಿರುವ ನಂತರ 01 ಮತ್ತು ಎಂದು. ಇಲ್ಲಿ ನಾವು ಮೂಲಭೂತವಾಗಿ ನಾವು 1 ಅಥವಾ 2 ಬಿಟ್ಗಳು ಎರಡೂ ಈ ಅಕ್ಷರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ನೀವು ನೋಡಿ ಅಲ್ಲಿ ಭವಿಷ್ಯ ಬಿ, ಕನಿಷ್ಠ ಹೊಂದಿದೆ. ನಂತರ, ನಾವು ಸಿ ಬಹುತೇಕ ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ, ಆದರೆ ಇದು ಒಂದು ಸಣ್ಣ ಹಫ್ಮನ್ ಮರದ ರಿಂದ ನಂತರ ಒಂದು ಸಹ ಎಲ್ಲೋ ಮಧ್ಯದಲ್ಲಿ ವಿರುದ್ಧವಾಗಿ 2 ಬಿಟ್ಗಳು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. 

ಕೇವಲ ಹಫ್ಮನ್ ಮರದ ಇನ್ನೊಂದು ಸರಳ ಉದಾಹರಣೆಗೆ ಮೇಲೆ ಹೋಗಿ, ನೀವು ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಿವೆ ಹೇಳುತ್ತಾರೆ "ಹಲೋ." ನೀವು ಏನು ನೀವು ಎಷ್ಟು ಬಾರಿ ಎಚ್ ಈ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಹೇಳುತ್ತಿದ್ದರು ಮೊದಲ? ಎಚ್ ಒಮ್ಮೆ ತದನಂತರ ಇ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಒಮ್ಮೆ ಮತ್ತು ನಾವು ಎರಡು ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುವ L ಹೊಂದಿವೆ ಮತ್ತು ಒ ಬಾರಿ ಕಾಣಿಸಿಕೊಂಡರು. ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಬಿಟ್ಗಳು ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯ ಮೂಲಕ ನಿರೂಪಿಸಲಾಗಿದೆ ಯಾವ ಅಕ್ಷರದ ನಿರೀಕ್ಷಿಸಬಹುದು? [ವಿದ್ಯಾರ್ಥಿ] ಎಲ್. >> ಎಲ್. ಹೌದು. L ಹಕ್ಕು. ನಾವು L ಬಿಟ್ಗಳು ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯ ನಿರೂಪಿಸಲಾಗಿದೆ ಎಂಬ ನಂಬುಗೆ ಏಕೆಂದರೆ L "ಹಲೋ." ಸ್ಟ್ರಿಂಗ್ ಅತ್ಯಂತ ಬಳಸಲಾಗುತ್ತದೆ ಈಗ ನಾನು ಹೋಗುವ ನನಗೆ ಈ ಗ್ರಂಥಿಗಳು ಅವಾಂತ ಇದೆ. ನಾನು ಒ ಇದು ಇ ಇದು ಮತ್ತೊಂದು 1, ಮತ್ತು ನಂತರ ಒಂದು 1, ಎಚ್ ಇದು, 1, ಮತ್ತು - L ಇದು, ನಂತರ 2 - ಈಗ ನಾನು ಸಲುವಾಗಿ ಅವರನ್ನು ಇರಿಸುವ ನುಡಿದರು. ಆಗ ನಾನು ಒಂದು ಹಫ್ಮನ್ ಟ್ರೀಯನ್ನು ರಚಿಸುವುದು ರೀತಿಯಲ್ಲಿ ಕನಿಷ್ಠ ಫ್ರೀಕ್ವೆನ್ಸೀಸ್ 2 ಘಟಕಗಳು ಪಡೆಯುವುದು ಎಂದು ಹೇಳುತ್ತಾರೆ ಮತ್ತು ಪೋಷಕ ನೋಡ್ ರಚಿಸುವ ಮೂಲಕ ಒಡಹುಟ್ಟಿದವರ ಮಾಡಿ. ಇಲ್ಲಿ ನಾವು ಕಡಿಮೆ ತರಂಗಾಂತರ ಜೊತೆ 3 ನೋಡ್ಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ಅವರು ಎಲ್ಲಾ 1 ಆರ್. ಇಲ್ಲಿ ನಾವು ಮೊದಲ ಲಿಂಕ್ ಎಂದು ನೀನು ಆಯ್ಕೆ. ಲೆಟ್ಸ್ ನಾನು H ಮತ್ತು ಇ ಆಯ್ಕೆ ಹೇಳುತ್ತಾರೆ. 1 ಮೊತ್ತವು + 1 2, ಆದರೆ ಈ ನೋಡ್ ಇದಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಪತ್ರವನ್ನು ಹೊಂದಿಲ್ಲ. ಇದು ಕೇವಲ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ. ಈಗ ನಾವು ಮುಂದಿನ 2 ಕಡಿಮೆ ಆವರ್ತನಗಳಲ್ಲಿ ನೋಡಲು. ಆ 2 ಮತ್ತು 1. ಆ ಎರಡೂ ಆ 2 ಆಗಿರಬಹುದು, ಆದರೆ ನಾನು ಈ ಒಂದು ಆಯ್ಕೆ ಪಡೆಯಲಿದ್ದೇನೆ. ಮೊತ್ತ 3. ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನಾನು ಮಾತ್ರ ಆದ್ದರಿಂದ 5 ಆಗುತ್ತದೆ ಎಂದು, 2 ಉಳಿದಿದೆ. ನಾನು ಆ ಎನ್ಕೋಡಿಂಗ್ ಭರ್ತಿ ವೇಳೆ ನಂತರ ಇಲ್ಲಿ, ಎಂದು ನಿರೀಕ್ಷಿಸಲಾಗಿತ್ತು, 1 ಸೆ ಯಾವಾಗಲೂ ಬಲ ಶಾಖೆ ಮತ್ತು 0 ಸೆ ಎಡ ಒಂದು ಅವು. ನಾವು 2 ರಿಂದ ಕೇವಲ 1 ಬಿಟ್ ಮತ್ತು ನಂತರ O ಅದಕ್ಕೆ ನಿರೂಪಿಸಲಾಗಿದೆ L ಹೊಂದಿವೆ ನಂತರ 2 ಇ ಮತ್ತು ನಂತರ H 3 ಬಿಟ್ಗಳ ಕೆಳಗೆ ಬೀಳುತ್ತದೆ. ಆದ್ದರಿಂದ ನೀವು "ಹಲೋ" ಈ ಸಂದೇಶವನ್ನು ಹರಡಬಹುದು ಬದಲಿಗೆ ವಾಸ್ತವವಾಗಿ ಅಕ್ಷರಗಳನ್ನು ಬಳಸಿ ಕೇವಲ 0 ಸೆ ಮತ್ತು 1 ರಿಂದ. ಆದಾಗ್ಯೂ, ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ನಾವು ನಮ್ಮ ಆವರ್ತನ ಜೊತೆಗೂ ನಂಟು ಹೊಂದಿದ್ದರು ಎಂದು ನೆನಪಿಡಿ. ನಾವು ಎರಡೂ ಬಹುಶಃ ಮೊದಲ ಎಚ್ ಮತ್ತು O ಸೇರಿದರು ಸಾಧ್ಯವಿಲ್ಲ. ಅಥವಾ ನಂತರ ನಾವು 2 ನಿರೂಪಿಸಲಾಗಿದೆ L ಬೀರಿದ ಮೇಲೆ ಅಲ್ಲದೇ 2 ರಿಂದ ನಿರೂಪಿಸಲಾಗಿದೆ ಒಂದು ಸೇರಿದರು, ನಾವು ಎರಡೂ ಒಂದು ಲಿಂಕ್ ಇರಬಹುದು. 

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

ಇಲ್ಲಿ ನಾವು, ನಿಜವಾದ ಎಣಿಕೆ ಆಧರಿಸಿ ಉದಾಹರಣೆಗಳು ಮಾಡಿದಿರಿ ಆದರೆ ಕೆಲವೊಮ್ಮೆ ನೀವು ಒಂದು ಹಫ್ಮನ್ ಮರದ ಹೊಂದಬಹುದು ಆವರ್ತನೆಯ ಆಧಾರದಲ್ಲಿ ಅಕ್ಷರಗಳು ಕಂಡುಬರುತ್ತವೆ, ಮತ್ತು ನಿಖರವಾದ ಅದೇ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ ಇದು. ಇಲ್ಲಿ ನಾನು, ಶೇಕಡಾವಾರು ಅಥವಾ ಭಿನ್ನರಾಶಿ ಪರಿಭಾಷೆಯಲ್ಲಿ ಅದು ವ್ಯಕ್ತಪಡಿಸುವ ನಾನು ಮತ್ತು ಇಲ್ಲಿ ಸರಿಯಾದ ಒಂದೇ. ನಾನು, 2 ಕಡಿಮೆ, ಅವುಗಳನ್ನು ಒಟ್ಟಾರೆಯಾಗಿ, ಕಡಿಮೆ ಮುಂದಿನ 2, ಅವುಗಳನ್ನು ಒಟ್ಟಾರೆಯಾಗಿ ಹೇಗೆ ನಾನು ಸಂಪೂರ್ಣ ಮರದ ತನಕ. ನಾವು ನಾವು ಶೇಕಡಾವಾರು ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಿದಾಗ ಯಾವುದೇ ರೀತಿ, ಇಲ್ಲ ಸಹ ನಾವು ವಸ್ತುಗಳ ವಿಭಜಿತ ಮತ್ತು ದಶಮಾಂಶಗಳು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ಅರ್ಥ ಅಥವಾ ಬದಲಿಗೆ ತೇಲುತ್ತದೆ ಎಂದು ನಾವು ಒಂದು ತಲೆಯ ಅಕ್ಷಾಂಶ ರಚನೆಗಳ ಬಗ್ಗೆ ಥಿಂಕಿಂಗ್. ನಾವು ಫ್ಲೋಟ್ಗಳು ಬಗ್ಗೆ ಏನು ಗೊತ್ತು? ನಾವು ಫ್ಲೋಟ್ಗಳು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ಒಂದು ಸಾಮಾನ್ಯ ತೊಂದರೆ ಏನು? [ವಿದ್ಯಾರ್ಥಿ] ನಿಖರವಲ್ಲದ ಅಂಕಗಣಿತದ. >> ಹೌದು. ನಿಖರವಲ್ಲದಿರುವಿಕೆ. ಏಕೆಂದರೆ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ನಿಖರವಲ್ಲದಿರುವಿಕೆ ಈ pset ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಎಷ್ಟು ನಾವು ಯಾವುದೇ ಮೌಲ್ಯಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ ಎಂದು, ನಾವು ವಾಸ್ತವವಾಗಿ ಎಣಿಕೆ ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೀನು. ನೀವು ಇಲ್ಲಿ ರಚನೆ ಮತ್ತೆ ನೋಡಿದರೆ, ಒಂದು ಹಫ್ಮನ್ ನೋಡ್ ಆಲೋಚಿಸಬೇಕು ಎಂದು ಹಾಗಿದ್ದಲ್ಲಿ ನೀವು ಹಸಿರು ಚರಾಂಕಗಳ ನೋಡಿದರೆ ಇದು ಸಂಬಂಧಿಸಿದ ಒಂದು ಆವರ್ತನ ಹೊಂದಿದೆ ಹಾಗೆಯೇ ಅದರ ಎಡಕ್ಕೆ ಒಂದು ನೋಡ್ ಮತ್ತು ಅದರ ಬಲಕ್ಕೆ ಒಂದು ನೋಡ್ ಸೂಚಿತವಾಗಿರುತ್ತದೆ. ತದನಂತರ ಕೆಂಪು ಬಣ್ಣದವು ಸಹ ಅವುಗಳನ್ನು ಸಂಬಂಧಿಸಿದ ಗುಣಲಕ್ಷಣವನ್ನು ಹೊಂದಿದೆ. ನಾವು, ಪೋಷಕರು ಮತ್ತು ನಂತರ ಅಂತಿಮ ಗ್ರಂಥಿಗಳು ಪ್ರತ್ಯೇಕ ಬಿಡಿಗಳ ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ ಇದು ನಾವು ಎಲೆಗಳು ಎಂದು ನೋಡಿ, ಆದರೆ ಆ ಕೇವಲ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಪ್ರತಿ ನೋಡ್ ನಾವು ಒಂದು ಅಕ್ಷರ, ಆ ನೋಡ್ ಪ್ರತಿನಿಧಿಸುವ ಚಿಹ್ನೆ ನಿಮಗಿದೆ ನಂತರ ಒಂದು ಆವರ್ತನ ಮತ್ತು ಅದರ ಎಡ ಮಗು ಮತ್ತು ಅದರ ಬಲ ಮಗುವಿಗೆ ಒಂದು ಪಾಯಿಂಟರ್. ಅತ್ಯಂತ ಕೆಳಭಾಗದಲ್ಲಿ ಅವು ಎಲೆಗಳು ಕೂಡ ನೋಡ್ ಪಾಯಿಂಟರ್ಸ್ ಹೊಂದಿರುತ್ತದೆ ತಮ್ಮ ಎಡ ಮತ್ತು ಅವರ ಬಲಕ್ಕೆ, ಆದರೆ ಆ ಮೌಲ್ಯಗಳು ನಿಜವಾದ ಗ್ರಂಥಿಗಳು ತೋರುತ್ತಿರುವಂತೆ ಕಾರಣ, ತಮ್ಮ ಮೌಲ್ಯವನ್ನು ಏನು? >> [ವಿದ್ಯಾರ್ಥಿ] ಸಾಂಕೇತಿಕಕೊಂಡಿಯು. >> ಸಾಂಕೇತಿಕಕೊಂಡಿಯು. ನಿಖರವಾಗಿ. ಇಲ್ಲಿ ನೀವು ಫ್ಲೋಟ್ಗಳು ರಲ್ಲಿ ತರಂಗಾಂತರ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಎಂಬುದರ ಒಂದು ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ ಆದರೆ, ಪೂರ್ಣಾಂಕಗಳು ಜೊತೆ ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೀನು ಆದ್ದರಿಂದ ನಾನು ಎಲ್ಲಾ ದತ್ತಾಂಶವನ್ನು ರೀತಿಯ ಬದಲಾವಣೆ. 

ನ ಸಂಕೀರ್ಣ ಉದಾಹರಣೆಗೆ ಒಂದು ಸ್ವಲ್ಪ ಮೇಲೆ ಹೋಗಿ ನೋಡೋಣ. ಆದರೆ ಈಗ ನಾವು ಸರಳ ಸೋನಾರ್ಗಳು ಮಾಡಿದ ಅದು ಕೇವಲ ಒಂದೇ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ. ನೀವು 2 ಕಡಿಮೆ ಆವರ್ತನಗಳಲ್ಲಿ ಹುಡುಕಲು, ಆವರ್ತನಗಳಲ್ಲಿ ಮೊತ್ತವು ಮತ್ತು, ನಿಮ್ಮ ಮೂಲ ನೋಡ್ ಹೊಸ ಆವರ್ತನ ಇಲ್ಲಿದೆ ಇದು ನಂತರ 1 ಶಾಖೆ 0 ಶಾಖೆ ಮತ್ತು ಬಲ ತನ್ನ ಎಡ ಸೂಚಿತವಾಗಿರುತ್ತದೆ. ನಾವು ಸ್ಟ್ರಿಂಗ್ "ಈ cs50 ಹೊಂದಿದೆ," ಇದ್ದರೆ ನಾವು, ಟಿ ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ ಎಷ್ಟು ಬಾರಿ ಲೆಕ್ಕ H ಪ್ರಸ್ತಾಪಿಸಿದ್ದಾರೆ, ಇ, ಎಸ್, ಸಿ, 5, 0. ನಂತರ ಏನು ನಾನು ಇಲ್ಲಿ ಮಾಡಿದರು, ನಾನು ನೆಟ್ಟ ಕೆಂಪು ನೋಡ್ಗಳ ಜೊತೆ ಆಗಿದೆ ನಾನು ನನ್ನ ಮರದ ಕೆಳಭಾಗದಲ್ಲಿ ಅಂತಿಮವಾಗಿ ಈ ಪಾತ್ರಗಳು ಹೊಂದಿರುವ ಪಡೆಯಲಿದ್ದೇನೆ ಹೇಳಿದರು. ಆ ಎಲೆಗಳನ್ನು ಎಲ್ಲಾ ಮುಂದುವರೆಸುತ್ತೇವೆ. ನಂತರ ಏನು ನಾನು, ನಾನು ಏರಿಕೆಯ ಕ್ರಮದಲ್ಲಿ ತರಂಗಾಂತರ ಮೂಲಕ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಡುತ್ತವೆ ಮತ್ತು ಈ ವಾಸ್ತವವಾಗಿ pset ಕೋಡ್ ಅದು ಹೇಳಿದರು ಇದು ಆವರ್ತನ ಅದಕ್ಕೆ ರೀತಿಯ ಇದು ತದನಂತರ ವರ್ಣಮಾಲೆಯ ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ ಆವರ್ತನ ಅದಕ್ಕೆ ವರ್ಣಮಾಲೆಯ ಮೊದಲ ತದನಂತರ ಸಂಖ್ಯೆಗಳನ್ನು ಹೊಂದಿದೆ. ನಂತರ ಏನು ನಾನು ಎಂದು ನಾನು 2 ಕಡಿಮೆ ಕಂಡುಕೊಳ್ಳಲಿರುವ ಹೊಂದಿದೆ. ಆ 0 ಮತ್ತು 5 ರ. ನಾನು ಅವುಗಳನ್ನು ಒಟ್ಟಾರೆಯಾಗಿ, ಮತ್ತು ಆ 2 ನ. ನಂತರ ನಾನು ಮುಂದಿನ 2 ಕಡಿಮೆ ಪತ್ತೆ, ಮುಂದುವರಿಯಿತು. ಆ ಎರಡು 1 ಸೆ, ಮತ್ತು ಆ ಜೊತೆಗೆ 2 ಸ್ಥಾನವನ್ನು ಪಡೆಯಿತು. ಈಗ ನನ್ನ ಮುಂದಿನ ಹಂತದಲ್ಲಿ, ಕಡಿಮೆ ಸಂಖ್ಯೆಯ ಸೇರುವ ಏರಲಿದೆ ತಿಳಿದಿದೆ ಇದು, 1 ಟಿ, ಮತ್ತು ನಂತರ ಆವರ್ತನ ಎಂದು 2 ಹೊಂದಿರುವ ನೋಡ್ಗಳು ಒಂದು ಆಯ್ಕೆ. ಇಲ್ಲಿ ನಾವು 3 ಆಯ್ಕೆಗಳಿವೆ. ನಾನು ಸ್ಲೈಡ್ಗಾಗಿ ಮಾಡಲು ಹೋಗುವ ನನಗೆ ಕೇವಲ ದೃಷ್ಟಿ ನೀವು ಅವುಗಳನ್ನು ಮರುಹೊಂದಿಸಿ ಇದೆ ಆದ್ದರಿಂದ ನೀವು ಅದನ್ನು ನಿರ್ಮಿಸುವ ನಾನು ಹೇಗೆ ನೋಡಬಹುದು. ಕೋಡ್ ಮತ್ತು ನಿಮ್ಮ ವಿತರಣೆ ಕೋಡ್ ಮಾಡಲು ಏನಾಗುತ್ತಿದೆ ಟಿ ಒಂದು ಸೇರಲು ಎಂದು 0 ಮತ್ತು 5 ಘಟಕ. ಆದ್ದರಿಂದ ನಂತರ 3 ಸಂಕಲನವನ್ನು, ಮತ್ತು ನಾವು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮುಂದುವರಿಸಲು ನಾವು. 2 ಮತ್ತು 2 ಈಗ ಆದ್ದರಿಂದ, 4 ಆ ಮೊತ್ತವು ಕಡಿಮೆ. ಎಲ್ಲರೂ ಇಲ್ಲಿಯವರೆಗೆ ನಂತರ? ಸರಿ. ಆ ನಂತರ ನಾವು, 3 ಮತ್ತು ಸೇರಿಸಲಾಗಿದೆ ಬೇಕಿರುವ 3 ನೀವು ತುಂಬಾ ಗೊಂದಲಮಯ ಪಡೆಯಲು ಅದು ದೃಷ್ಟಿ ಆದ್ದರಿಂದ ನೋಡಬಹುದು ಆದ್ದರಿಂದ ಆದ್ದರಿಂದ ಮತ್ತೆ ನಾನು ಅದನ್ನು ಬದಲಿಸುವ ನುಡಿದರು. ನಾವು ಕೇವಲ 2 ಗ್ರಂಥಿಗಳು ಹೊಂದಿರುವ ನಂತರ ನಾವು 6 ಹೊಂದಿವೆ, ಮತ್ತು ನಂತರ ನಮ್ಮ ಅಂತಿಮ ಹಂತದ ಈಗ ನಾವು 10 ಇದು ನಮ್ಮ ಮರ, ಮೂಲ ಮಾಡಲು ಆ ಮೊತ್ತ. ಪ್ರತಿ ನೋಡ್ ನಿರೂಪಿಸಲಾಗಿದೆ ಏಕೆಂದರೆ ಮತ್ತು ಸಂಖ್ಯೆ 10, ಅರ್ಥವಿಲ್ಲ ತಮ್ಮ ಮೌಲ್ಯವನ್ನು ಅವುಗಳ ಆವರ್ತನ ಸಂಖ್ಯೆ, ಅವರು ಪಂಕ್ತಿಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಂಡರು ಎಷ್ಟು ಪಟ್ಟು ತದನಂತರ ನಮ್ಮ ಸಾಲಿನಲ್ಲಿ 5 ಅಕ್ಷರಗಳು ಉಳಿದಿವೆ, ಅರ್ಥವನ್ನು ನೀಡುವ ಹಾಗೆ. ನಾವು ವಾಸ್ತವವಾಗಿ ಎನ್ಕೋಡ್ ಹೇಗೆ ನಲ್ಲಿ ಹುಡುಕುವ, ವೇಳೆ ನಿರೀಕ್ಷೆಯಂತೆ, ನಾನು ಮತ್ತು ಹೆಚ್ಚಾಗಿ ಕಂಡುಬರುವ ರು, ಬಿಟ್ಗಳ fewest ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. 

ಇಲ್ಲಿ ಜಾಗರೂಕರಾಗಿರಿ. ಹಫ್ಮನ್ ಮರಗಳಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ ವಾಸ್ತವವಾಗಿ ಮ್ಯಾಟರ್ಸ್. ಒಂದು ದೊಡ್ಡಕ್ಷರ ಎಸ್ ಒಂದು ಸಣ್ಣ ರು ಭಿನ್ನವಾದುದಾಗಿದೆ. ನಾವು ಹೊಂದಿದ್ದರೆ, ಸಣ್ಣ ರು ಕೇವಲ ಎರಡು ಕಾಣುತ್ತದೆ ನಂತರ, ದೊಡ್ಡ ಅಕ್ಷರಗಳಲ್ಲಿ "ಈ CS50 ಹೊಂದಿದೆ" ಅದರ ಮೌಲ್ಯ 2 ಒಂದು ನೋಡ್ ಎಂದು, ತದನಂತರ ದೊಡ್ಡಕ್ಷರ ಎಸ್ ಒಮ್ಮೆ ಮಾತ್ರ ಎಂದು. ನೀವು ವಾಸ್ತವವಾಗಿ ಇಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಎಲೆ ಏಕೆಂದರೆ ಆದ್ದರಿಂದ ನಿಮ್ಮ ಮರದ ರಚನೆಗಳು ಬದಲಾಯಿತು. ಆದರೆ ಮೊತ್ತ ಇನ್ನೂ 10 ಎಂದು. ಎಂದು, ನಾವು ವಾಸ್ತವವಾಗಿ checksum ಕರೆ ಮಾಡಲು ನೀನು ಇಲ್ಲಿದೆ ಎಣಿಕೆಗಳು ಎಲ್ಲಾ ಜೊತೆಗೆ. 

ಈಗ ನಾವು ಹಫ್ಮನ್ ಮರಗಳು ಒಳಗೊಂಡಿದೆ ಎಂಬುದನ್ನು ನಾವು Huff'n ಪಫ್, pset ಆಗಿ ಆಳಕ್ಕೆ ಡೈವ್ ಮಾಡಬಲ್ಲದು. ನಾವು, ಪ್ರಶ್ನೆಗಳನ್ನು ಒಂದು ವಿಭಾಗ ಆರಂಭವಾಗಬೇಕು ಎಂದು ನೀನು ಮತ್ತು ಈ ನೀವು ಬೈನರಿ ಮರಗಳು ಮತ್ತು ಹೇಗೆ ಎಂದು ಸುಮಾರು ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಜೊತೆ ಒಗ್ಗಿಕೊಂಡಿರಲಿಲ್ಲವಾದ್ದರಿಂದ ಕಾಣುವುದು ಇದೆ: ರೇಖಾಚಿತ್ರ ಗ್ರಂಥಿಗಳು, ಒಂದು ನೋಡ್ ನಿಮ್ಮ ಸ್ವಂತ typedef struct ಸೃಷ್ಟಿಸುತ್ತದೆ ಮತ್ತು ನೀವು ಒಂದು ಬೈನರಿ ಮರದ ಪ್ರತಿಗಳ ಮಾಡಿದ್ದೇವೆ ಸೇರಿಸಲು ಎಂಬುದರ ನೋಡಿದ, ಇದು, ಮತ್ತು ಆ ವಿಷಯಗಳನ್ನು ಗ್ಯಾಲರಿ. ಜ್ಞಾನ ಖಂಡಿತವಾಗಿಯೂ Huff'n ಪಫ್ ಭಾಗದ ಮೇಲೆ ನೀವು ಡೈವ್ ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲಿದ್ದಾನೆ pset ನ. Pset ಪ್ರಮಾಣಿತ ಆವೃತ್ತಿಯಲ್ಲಿ, ನಿಮ್ಮ ಕೆಲಸವನ್ನು, ಪಫ್ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಆಗಿದೆ ಮತ್ತು ಹ್ಯಾಕರ್ ಆವೃತ್ತಿಯಲ್ಲಿ ನಿಮ್ಮ ಕೆಲಸವನ್ನು ಹಫ್ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಹೊಂದಿದೆ. ಹಫ್ ಹೊಂದಿದೆ ಏನು, ಅದು ಪಠ್ಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದು 0 ಸೆ ಮತ್ತು 1 ಅದನ್ನು ಭಾಷಾಂತರಿಸಿದರೆ ಆದ್ದರಿಂದ ನಾವು ಆವರ್ತನಗಳ ಎಣಿಕೆ ಅಲ್ಲಿ ನಾವು ಮೇಲೆ ಆ ಪ್ರಕ್ರಿಯೆ ನಂತರ ಮರದ ಮಾಡಿದ ನಂತರ ಹೇಳಿದರು "ನಾನು ಹೇಗೆ ಟಿ ಸಿಗುತ್ತವೆ?" ಟಿ 100 ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಇಂತಹ ವಿಷಯಗಳನ್ನು, ತದನಂತರ ಹಫ್ ಪಠ್ಯ ಮತ್ತು ನಂತರ ಔಟ್ಪುಟ್ ಎಂದು ಅವಳಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಆದರೆ ನಾವು ನಮ್ಮ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುವವರ ಅನುಮತಿಸಲು ಬಯಸುವ ತಿಳಿದಿರುವ ಕಾರಣ ಅದೇ ಮರದ ಮರುಸೃಷ್ಟಿಸಲು, ಇದು ಆವರ್ತನ ಎಣಿಕೆಗಳು ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ. ನಂತರ ಪಫ್ ನಾವು 0 ಸೆ ಮತ್ತು 1 ಗಳ ಒಂದು ದ್ವಿಮಾನ ಕಡತ ನೀಡಲಾಗಿದೆ ಮತ್ತು ತರಂಗಾಂತರಗಳನ್ನು ಬಗ್ಗೆ ಮಾಹಿತಿ ನೀಡಲಾಗುತ್ತದೆ. ನಾವು, ಮೂಲ ಸಂದೇಶಕ್ಕೆ ಆ 0 ಸೆ ಮತ್ತು 1 ಮತ್ತೆ ಎಲ್ಲಾ ಭಾಷಾಂತರಿಸಿ ಆದ್ದರಿಂದ ನಾವು decompressing ಮಾಡುತ್ತಿದ್ದೇವೆ. ನೀವು ಪ್ರಮಾಣಿತ ಆವೃತ್ತಿ ಮಾಡುವುದರಿಂದ, ನೀವು, ಹಫ್ ಜಾರಿಗೆ ಅಗತ್ಯವಿಲ್ಲ ಆದ್ದರಿಂದ ನೀವು ಹಫ್ ಸಿಬ್ಬಂದಿ ಅನುಷ್ಠಾನಕ್ಕೆ ಬಳಸಬಹುದು. ಹಾಗೆ ಹೇಗೆ ವಿಶೇಷ ಸೂಚನೆಗಳನ್ನು ಇವೆ. ನೀವು ನಿರ್ದಿಷ್ಟ ಪಠ್ಯ ಕಡತ ಮೇಲೆ ಹಫ್ ಸಿಬ್ಬಂದಿ ಅನುಷ್ಠಾನ ಚಲಾಯಿಸಬಹುದು ತದನಂತರ ಪಫ್ ನಿಮ್ಮ ಇನ್ಪುಟ್ ಎಂದು ಔಟ್ಪುಟ್ ಅನ್ನು. 

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

Huffile.h ಗಮನಿಸುತ್ತಿದ್ದೇವೆ ಕಾಮೆಂಟ್ಗಳನ್ನು ಅದನ್ನು ಹಫ್ಮನ್ ಕೋಡೆಡ್ ಕಡತಗಳನ್ನು ಅಮೂರ್ತತೆಯ ಪದರವನ್ನು ಘೋಷಿಸುತ್ತದೆ. ನಾವು ಕೆಳಗೆ ಹೋದರೆ, ನಾವು ಕೋಡ್ಗಳನ್ನು ಅಗತ್ಯವಿದೆ ಎಂದು 256 ಚಿಹ್ನೆಗಳನ್ನು ಗರಿಷ್ಠ ಎಂದು ನೋಡಿ. ದೊಡ್ಡಕ್ಷರ ಮತ್ತು ಸಣ್ಣ - - ಈ ವರ್ಣಮಾಲೆಯ ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ತದನಂತರ ಚಿಹ್ನೆಗಳು ಮತ್ತು ಸಂಖ್ಯೆಗಳ, ಇತ್ಯಾದಿ ನಂತರ ಇಲ್ಲಿ ನಾವು ಹಫ್ಮನ್ ಕೋಡೆಡ್ ಫೈಲ್ ಗುರುತಿಸಿಕೊಂಡ ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆಯ. ಒಂದು ಹಫ್ಮನ್ ಕೋಡ್ ಒಳಗೆ ಅವರು ಕೆಲವು ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆಯ ಎಂದು ನೀನು ಶಿರೋಲೇಖ ಸಂಬಂಧವಿಲ್ಲ. ಇದು ಕೇವಲ ಒಂದು ಯಾದೃಚ್ಛಿಕ ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆ ರೀತಿ ಇರಬಹುದು ನೀವು ನಿಜವಾಗಿಯೂ ASCII ಅದನ್ನು ಭಾಷಾಂತರಿಸಲು ಆದರೆ, ಅದು ವಾಸ್ತವವಾಗಿ ಹಫ್ ಔಟ್ ವಿವರಿಸುತ್ತದೆ. ಇಲ್ಲಿ ನಾವು ಒಂದು ಹಫ್ಮನ್-ಎನ್ಕೋಡ್ ಮಾಡಿದ ಫೈಲ್ ಒಂದು struct ಹೊಂದಿರುತ್ತವೆ. ಒಂದು ಹಫ್ ಕಡತದೊಂದಿಗೆ ಈ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಎಲ್ಲಾ ಇಲ್ಲ. ನಂತರ ಕೆಳಗೆ ಇಲ್ಲಿ ನಾವು ಹಫ್ ಕಡತ ಹೆಡರ್ ಹೊಂದಿರುತ್ತವೆ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು Huffeader ಕರೆ ಬದಲಿಗೆ ಅದು ಹೇಗಾದರೂ ಅದೇ ಶಬ್ದಗಳನ್ನು ಏಕೆಂದರೆ ಹೆಚ್ಚುವರಿ H ಸೇರಿಸಲು. Cute. ನಾವು ಸಂಬಂಧಿಸಿದ ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆಯ. ಇದು ನಿಜವಾದ ಹಫ್ ಕಡತ ಅದನ್ನು, ಮೇಲಿನ ಈ ಮ್ಯಾಜಿಕ್ ಒಂದು ಸಂಖ್ಯೆಯಾಗಿರಬೇಕು ಹೋಗುವುದಿಲ್ಲ. ಮತ್ತು ನಂತರ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಆದ್ದರಿಂದ ಪ್ರತಿ ಚಿಹ್ನೆಯ, ಇದರಲ್ಲಿ 256 ಇವೆ ಇದು ಆ ಚಿಹ್ನೆಗಳು ಆವರ್ತನ ಹಫ್ ಕಡತ ಒಳಗೆ ಏನು ಪಟ್ಟಿಗೆ ವಿಶೇಷವೇನು. ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನಾವು, ಆವರ್ತನಗಳ ಒಂದು checksum ಹೊಂದಿವೆ ಆ ಆವರ್ತನಗಳಲ್ಲಿ ಮೊತ್ತವು ಆಗಿರಬೇಕು. ಆದ್ದರಿಂದ ಏನನ್ನು ಒಂದು Huffeader ಹೊಂದಿದೆ. ನಂತರ ನಾವು ಹಫ್ ಕಡತ ಮುಂದಿನ ಬಿಟ್ ಹಿಂದಿರುಗಲು ಕೆಲವು ಕಾರ್ಯಗಳನ್ನು ಹಾಗೆಯೇ hfclose, ಇಲ್ಲಿ ಈ ಕ್ರಿಯೆಯ ನಂತರ, ಹಫ್ ಕಡತಕ್ಕೆ ಒಂದು ಬಿಟ್ ಬರೆಯುತ್ತಾರೆ, ಮತ್ತು ಎಂದು ವಾಸ್ತವವಾಗಿ ಹಫ್ ಕಡತ ಮುಚ್ಚಲ್ಪಡುತ್ತದೆ. ಮೊದಲು, ನಾವು ನೇರವಾಗಿ ಕೇವಲ fclose ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಲಾಯಿತು ಆದರೆ ನೀವು ಹಫ್ ಕಡತ ಹೊಂದಿರುವಾಗ, ಬದಲಿಗೆ ಇದು fclosing ಆಫ್ ನಿಮಗೆ ನಿಜವಾಗಿ ಏನು ಎಂದು ನೀನು hfclose ಮತ್ತು hfopen ಹೊಂದಿದೆ. ಆ ನಾವು ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೀನು ಆ ಹಫ್ ಕಡತಗಳನ್ನು ನಿರ್ದಿಷ್ಟವಾದ ಕ್ರಿಯೆಗಳು. ನಂತರ ಇಲ್ಲಿ ನಾವು ಹೆಡರ್ ನಲ್ಲಿ ಓದಿ ನಂತರ ಹೆಡರ್ ಬರೆಯಲು. 

ಕೇವಲ. H ಕಡತವನ್ನು ಓದುವ ಮೂಲಕ ನಾವು, ಒಂದು ಹಫ್ ಕಡತ ಇರಬಹುದು ಎಂಬುದರ ಅರ್ಥ ಪಡೆಯಲು ರೀತಿಯ ಮಾಡಬಹುದು ಇದು ವಾಸ್ತವವಾಗಿ huffile.c ಹಂತಕ್ಕೆ ಹೋಗದೆ ಏನು ಗುಣಲಕ್ಷಣಗಳು ಇದು ನಾವು ಧುಮುಕುವುದಿಲ್ಲ ವೇಳೆ, ಒಂದು ಬಿಟ್ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಎಂದು ಹೋಗುತ್ತದೆ. ಇದು I / O ಇಲ್ಲಿ ಪಾಯಿಂಟರ್ಸ್ ವ್ಯವಹರಿಸುವಾಗ ಕಡತ ಎಲ್ಲಾ ಹೊಂದಿದೆ. ಇಲ್ಲಿ ನಾವು hfread ಕರೆ ಮಾಡಿದಾಗ, ಉದಾಹರಣೆಗೆ, ಇದು ಇನ್ನೂ fread ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೋಡಿ. ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ಆ ಕಾರ್ಯಗಳನ್ನು ತೊಡೆದುಹಾಕಿದ್ದೇವೆ ಇಲ್ಲ, ಆದರೆ ನಾವು ಆರೈಕೆ ತೆಗೆದುಕೊಂಡು ಆ ಕಳುಹಿಸಲು ನೀವು ಬದಲಿಗೆ ಇದು ನಾವೇ ಎಲ್ಲಾ ಮಾಡುವ ಹಫ್ ಕಡತ ಒಳಗೆ. ನೀವು ಕುತೂಹಲದಿಂದ, ನೀವು ಈ ಮೂಲಕ ಸ್ಕ್ಯಾನ್ ಮುಕ್ತವಾಗಿರುವ ಮತ್ತು ಹೋಗಿ ಮರಳಿ ಪದರವು ಸ್ವಲ್ಪ ಸಿಪ್ಪೆ. 

ನಾವು ನೋಡಲು ನೀನು ಮುಂದಿನ ಕಡತ tree.h. ಆಗಿದೆ ದರ್ಶನ ಸ್ಲೈಡ್ಸ್ ಮೊದಲು ನಾವು ಒಂದು ಹಫ್ಮನ್ ನೋಡ್ ನಿರೀಕ್ಷಿಸಬಹುದು ಹೇಳಿದರು ಮತ್ತು ನಾವು typedef struct ನೋಡ್ ಮಾಡಿದ. ನಾವು ಒಂದು ಚಿಹ್ನೆ ಒಂದು ಆವರ್ತನ, ತದನಂತರ 2 ನೋಡ್ ನಕ್ಷತ್ರಗಳಂತೆ ನಿರೀಕ್ಷಿಸಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಮಾಡುತ್ತಿರುವುದು ಈ ಅದೇ ಆಗಿದೆ ಬದಲಿಗೆ ನೋಡ್ನ ಹೊರತುಪಡಿಸಿ ನಾವು ಅವುಗಳನ್ನು ಮರಗಳು ಕರೆಯಲು ನೀನು. ನೀವು ಮರದ ಮಾಡಲು ಕರೆ ಮಾಡಿದಾಗ ಅದು ಒಂದು ಮರದ ಪಾಯಿಂಟರ್ ಮರಳಿಸುವ ಒಂದು ಫಂಕ್ಷನ್. ನೀವು ಒಂದು ಹೊಸ ನೋಡ್ ಮಾಡುವ ಸಂದರ್ಭದಲ್ಲಿ, ಸ್ಪೆಲ್ಲರ್ ಹಿಂತಿರುಗಿ ನೀವು ಹೇಳಿದ ನೋಡ್ * ಹೊಸ ಪದ = malloc (sizeof) ಮತ್ತು ವಿಷಯಗಳನ್ನು. ಮೂಲತಃ, mktree ನೀವು ಆ ವ್ಯವಹರಿಸುವಾಗ ಏರಲಿದೆ. ಹಾಗೆಯೇ, ನೀವು ಒಂದು ಮರ ತೆಗೆಯಲು ಬಯಸಿದಾಗ, ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ, ನೀವು ಪೂರೈಸಿದ ಮೇಲೆ ಮರದ ಮುಕ್ತಗೊಳಿಸಿದ ವಿಶೇಷವೇನು ಬದಲಿಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಮೇಲೆ ಉಚಿತ ಕರೆ ಆಫ್, ನೀವು ವಾಸ್ತವವಾಗಿ ಕೇವಲ rmtree ಕಾರ್ಯವನ್ನು ಬಳಸಲು ನೀನು ನೀವು ಆ ಮರದ ದಿಕ್ಸೂಚಕ ರವಾನಿಸಲು ಮತ್ತು ಅಲ್ಲಿ tree.c ನೀವು ಆ ಆರೈಕೆಯನ್ನು ಕಾಣಿಸುತ್ತದೆ. 

ನಾವು tree.c. ತನಿಖೆ ನಾವು ಹಾಗೂ ಅನುಷ್ಠಾನದ ನೋಡಲು ಹೊರತುಪಡಿಸಿ ಅದೇ ಕಾರ್ಯಗಳನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು. ನಾವು ನಿರೀಕ್ಷಿಸಿದಂತೆ, ನೀವು mktree ಕರೆ ಮಾಡಿದಾಗ ಅದು ಒಂದು ಪಾಯಿಂಟರ್ ಒಂದು ಮರದ ಗಾತ್ರ mallocs ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮೌಲ್ಯ, ಆದ್ದರಿಂದ 0 ಸೆ ಅಥವಾ NULLs, ಮೌಲ್ಯವನ್ನು ಎಲ್ಲಾ ಆರಂಭಿಸುತ್ತದೆ ತದನಂತರ ನೀವು ನಿಮಗೆ malloc'd ನೀವು ಆ ಮರದ ಪಾಯಿಂಟರ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಇಲ್ಲಿ ನೀವು ಮರ ತೆಗೆದು ಕರೆ ಅದು ಮೊದಲ ನೀವು ಡಬಲ್ ಮುಕ್ತಗೊಳಿಸಿದ ಇಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ನೀವು ನಿಜವಾಗಿ ನೀವು ತೆಗೆದುಹಾಕಲು ನೀವು ಒಂದು ಮರ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಒಂದು ಮರ ತನ್ನ ಮಕ್ಕಳು ಒಳಗೊಂಡಿದೆ, ಇಲ್ಲಿ ಏಕೆಂದರೆ ಇದು ಏನು ಇದು ಪುನರಾವರ್ತಿತವಾಗಿ ಮರದ ಎಡ ನೋಡ್ ಮರದ ತೆಗೆದುಹಾಕಲು ಕರೆಗಳು ಅಲ್ಲದೇ ಬಲ ನೋಡ್ ಮಾಹಿತಿ. ಇದು ಮೂಲ ಬಿಡುಗಡೆ ಮೊದಲು, ಇದನ್ನು ಮಕ್ಕಳಿಗೆ ಮುಕ್ತಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ. ಪೋಷಕ ಸಹ ಮೂಲ ಜೊತೆ ಪರಸ್ಪರ ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ ಮುತ್ತಾತನ ಮುತ್ತಾತನ ತಾತ ನಂತಹ ಪ್ರಥಮ ಮೂಲ, ಅಥವಾ ಅಜ್ಜಿ ಮರ, ಮೊದಲ ನಾವು ಮೊದಲ ಮಟ್ಟದ ಕೆಳಗೆ ಮುಕ್ತಗೊಳಿಸಲು ಹೊಂದಿರುತ್ತವೆ. ಆದ್ದರಿಂದ ಆ ಉಚಿತ, ಕೆಳಕ್ಕೆ ಚಲಿಸುವಾಗ, ಮತ್ತು ಆ, ಇತ್ಯಾದಿ, ಮತ್ತೆ ಉಚಿತ ಬರಲು ಆ ಮರದ. 

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

ನಾವು forest.c ನೋಡೋಣ, ನಾವು, ಅಲ್ಲಿ ಕನಿಷ್ಠ 1 rmtree ಆಜ್ಞೆಯನ್ನು ನೋಡಿ ನಿರೀಕ್ಷೆ ಮಾಡುತ್ತೇವೆ ಏಕೆಂದರೆ ಅರಣ್ಯ ಇದು ಮರಗಳು ವೇಳೆ ಅರಣ್ಯ ಮುಕ್ತ ಸ್ಮರಣೆಗೆ, ನಂತರ ಅಂತಿಮವಾಗಿ ನೀವು ತುಂಬಾ ಆ ಮರಗಳು ತೆಗೆದುಹಾಕಲು ಹೊಂದಿರುವ ನೀನು. ನಾವು forest.c ತನಿಖೆ ವೇಳೆ, ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು ಎಂದು ಇದು ನಮ್ಮ mkforest ಹೊಂದಿರುತ್ತವೆ. ನಾವು malloc ವಿಷಯಗಳು. ಆರಂಭದಲ್ಲಿ ಅದು ಖಾಲಿ ಏಕೆಂದರೆ ನಾವು, ಶೂನ್ಯ ಎಂದು ಅರಣ್ಯ ಮೊದಲ ಕಥಾವಸ್ತುವಿನ ಆರಂಭಿಸಲು ಆಗ ಅತೀ ಕಡಿಮೆ ತೂಕ ಹೊಂದಿರುವ ಮರದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಇದು ಆಯ್ಕೆ, ಕಡಿಮೆ ಆವರ್ತನ, ನೋಡಿ ತದನಂತರ ನಿರ್ದಿಷ್ಟ ನೋಡ್ ಹೋಗಲಾಡಿಸಲು ಗಳಿಸುವ ಒಂದು ಮರದ ಅಂಕಗಳನ್ನು ಮತ್ತು ಮುಂದಿನ ಒಂದು, ಆದ್ದರಿಂದ ಅರಣ್ಯ ಲಿಂಕ್ ಪಟ್ಟಿ ಎಂದು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ತದನಂತರ ಇಲ್ಲಿ ನಾವು ಯಾವ ಲಿಂಕ್ ಪಟ್ಟಿ ಒಳಸೇರಿಸಿದನು ಮರದ ಸಸ್ಯ ಹೊಂದಿರುತ್ತವೆ. ಯಾವ ಕಾಡಿನ ಇದು ಉತ್ತಮವಾಗಿ ಅದು ನಮಗೆ ವಿಂಗಡಿಸಲಾದ ಇಡುತ್ತದೆ ಹೊಂದಿದೆ ಮಾಡುವುದಿಲ್ಲ. ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನಾವು ನಿರೀಕ್ಷಿಸಿದಂತೆ, ನಾವು ಇಲ್ಲ ಎಂದು rmtree ಹೊಂದಿವೆ, rmforest ಮತ್ತು. 

ಇಲ್ಲಿಯವರೆಗೆ ವಿತರಣೆ ಕೋಡ್ ಗಮನಿಸುತ್ತಿದ್ದೇವೆ huffile.c, ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ದೂರದ ಕಠಿಣ ಅದಕ್ಕೆ ಕರೆದಿರಬಹುದು ಇತರ ಫೈಲ್ಗಳನ್ನು ಆದರೆ ತಮ್ಮನ್ನು ಅನುಸರಿಸಲು ಬಹಳ ಸರಳವಾಗಿದ್ದವು. ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ಸಂಬಂಧಿತ ಪಟ್ಟಿಗಳನ್ನು ಮತ್ತು ನಮ್ಮ ಜ್ಞಾನ, ನಾವು ಬಹಳ ಚೆನ್ನಾಗಿ ಅನುಸರಿಸಲು ಸಮರ್ಥರಾಗಿದ್ದರು. ಆದರೆ ನಿಜವಾಗಿಯೂ ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಖಚಿತವಾಗಿ ಅಗತ್ಯವಿದೆ ಎಲ್ಲಾ. H ಫೈಲ್ಗಳನ್ನು ನೀವು ಆ ಹಿಂದಿರುಗುವ ಮೌಲ್ಯಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ, ಆ ಕಾರ್ಯಗಳನ್ನು ಕರೆ ಅಗತ್ಯವಿದೆ ಏಕೆಂದರೆ ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಕೈಗೊಳ್ಳಲಾಗುವುದು ಹೋಗುವ ಯಾವ ಕ್ರಮ ಅರ್ಥ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ನೀವು ಆ ಕಾರ್ಯಗಳನ್ನು ಒಂದು ಕರೆ ಮಾಡಿದಾಗ. ಆದರೆ ವಾಸ್ತವವಾಗಿ ಇದು ಒಳಗೆ ಅರ್ಥೈಸಿಕೊಳ್ಳಲು ನಾವು ಆ ಕಾರಣ ಸಾಕಷ್ಟು ಅನಿವಾರ್ಯವಲ್ಲ. H ಕಡತಗಳು. ನಮ್ಮ ವಿತರಣಾ ಕೋಡ್ ಉಳಿದ 2 ಹೆಚ್ಚು ಕಡತಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. 

ನ ಡಂಪ್ ನೋಡೋಣ. ಇಲ್ಲಿ ಅದರ ಕಾಮೆಂಟ್ ಮೂಲಕ ಡಂಪ್ ಒಂದು ಹಫ್ಮನ್-ಸಂಕುಚಿತ ಕಡತ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ತದನಂತರ ಅನುವಾದಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಡಂಪ್ ಅದರ ಎಲ್ಲಾ ಔಟ್. ಇಲ್ಲಿ ನಾವು hfopen ಕರೆ ಎಂದು ನೋಡಿ. ಈ, * ಇನ್ಪುಟ್ = fopen ಸಲ್ಲಿಸುವಂತೆ ಪ್ರತಿಬಿಂಬಿಸುವ ರೀತಿಯ ತದನಂತರ ನೀವು ಮಾಹಿತಿಯನ್ನು ರವಾನಿಸಲು. ಇದು ಬದಲಾಗಿ ನೀವು Huffile ಸಾಗುವ ಮಾಡಲಾಗಿರುವ ಕಡತ * ಹೊರತುಪಡಿಸಿ ಬಹುತೇಕ ಒಂದೇ ಆಗಿದೆ; ಬದಲಿಗೆ fopen ನಿಮಗೆ hfopen ಸಾಗುವ ನೀವು. ಇಲ್ಲಿ ನಾವು ವಿಧದ ನಾವು ಹೆಡರ್ ಓದಲು ಹೇಗೆ ಹೋಲುತ್ತದೆ ಇದು ಮೊದಲ ಹೆಡರ್ ನಲ್ಲಿ ಓದಿ ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತ. ನಾವು ಇಲ್ಲಿ ಮಾಡುತ್ತಿರುವುದು ನೋಡಲು ಪರೀಕ್ಷಿಸುವ ಎಂಬುದನ್ನು ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ಇದು ನಿಜವಾದ ಹಫ್ ಕಡತ ಎಂದು ಸೂಚಿಸುತ್ತದೆ ಬಲ ಮ್ಯಾಜಿಕ್ ಹೊಂದಿದೆ, ನಂತರ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈ ಪರೀಕ್ಷೆಗಳಿಗೆ ಎಲ್ಲಾ ನಾವು ಮುಕ್ತ ವಾಸ್ತವಿಕ huffed ಕಡತ ಅಥವಾ ಆ ಕಡತವನ್ನು ಎಂದು. ಏನು ಮಾಡುತ್ತದೆ ನಾವು ನೋಡಬಹುದು ಸಂಕೇತಗಳನ್ನು ಎಲ್ಲಾ ಆವರ್ತನಗಳ ಹೊರತರುವ ಆಗಿದೆ ಒಂದು ಚಿತ್ರಾತ್ಮಕ ಟೇಬಲ್ಲಿಗೆ ಟರ್ಮಿನಲ್ ಒಳಗೆ. ಈ ಭಾಗವು ಉಪಯುಕ್ತ ಎಂದು ಹೋಗುತ್ತದೆ. ಇದು ಒಂದು ಬಿಟ್ ಮತ್ತು ವೇರಿಯಬಲ್ ಬಿಟ್ ಆಗಿ ಬಿಟ್ ಬಿಟ್ ಓದುತ್ತದೆ ಮತ್ತು ನಂತರ ಅದನ್ನು ತೋರಿಸುತ್ತದೆ. ನಾನು ಫೈಲ್ huffing ಪರಿಣಾಮವಾಗಿ ಇದು hth.bin ಮೇಲೆ ಡಂಪ್ ಕರೆಯಲು ಅವು ಆದ್ದರಿಂದ ಸಿಬ್ಬಂದಿ ಪರಿಹಾರವನ್ನು ಬಳಸಿಕೊಂಡು, ಈ ಪಡೆಯುತ್ತೀರಿ. ಈ ಪಾತ್ರಗಳು ಎಲ್ಲಾ ಉತ್ಪಾದಿಸುವ ಮತ್ತು ನಂತರ ಅವರು ಕಂಡುಬರುವ ತರಂಗಾಂತರಗಳ ಪುಟ್ಟಿಂಗ್ ನ. ನಾವು ನೋಡಿದರೆ, ಅವುಗಳಲ್ಲಿ ಈ ಹೊರತುಪಡಿಸಿ 0 ಸೆ ಇವೆ: ಎರಡು ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಎಚ್, ಮತ್ತು ನಂತರ ಒಮ್ಮೆ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಟಿ. ತದನಂತರ ಇಲ್ಲಿ ನಾವು 0 ಸೆ ಮತ್ತು 1 ನೈಜ ಸಂದೇಶವನ್ನು ಹೊಂದಿದೆ. ನಾವು hth.txt ನೋಡಿದರೆ, ಇದು ಸಂಭಾವ್ಯವಾಗಿ huffed ಎಂದು ಮೂಲ ಸಂದೇಶ ನಾವು ಅಲ್ಲಿ ಕೆಲವು ಎಚ್ಗಳು ಮತ್ತು ಟಿಗಳು ನೋಡಿ ನಿರೀಕ್ಷೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ, ನಾವು ಕೇವಲ 1 ಟಿ ಮತ್ತು 2 ಎಚ್ಗಳು ನೋಡಿ ನಿರೀಕ್ಷೆ. ಇಲ್ಲಿ ನಾವು hth.txt ಇವೆ. ಇದು ನಿಜಕ್ಕೂ HTH ಹೊಂದಿದೆ. ನಾವು ನೋಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಆದರೂ, ಇಲ್ಲ ಸೇರಿಸಲಾಗಿದೆ, ಒಂದು ಹೊಸಸಾಲು ಪಾತ್ರವಾಗಿದೆ. ಹಫ್ ಕಡತ hth.bin ಸಹ ಹೊಸಸಾಲು ಅಕ್ಷರ ಎನ್ಕೋಡಿಂಗ್ ಇದೆ. ಇಲ್ಲಿ ನಾವು, ಆದೇಶ ಹೊಸಸಾಲು ನಂತರ HTH ಮತ್ತು ಎಂದು ತಿಳಿದಿರುವ ಕಾರಣ ನಾವು ಕೇವಲ ಒಂದು 1 ಬಹುಶಃ ಎಚ್ ನಿರೂಪಿಸಲಾಗಿದೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ನೋಡಬಹುದು ನಂತರ ಟಿ ಬಹುಶಃ 01 ಮತ್ತು ನಂತರ ಮುಂದಿನ ಎಚ್ 1 ಹಾಗು ಮತ್ತು ನಾವು ಎರಡು 0 ಸೆ ಸೂಚಿಸಲಾಗುತ್ತದೆ ಒಂದು ಹೊಸಸಾಲು ಹೊಂದಿರುತ್ತವೆ. ಕೂಲ್. 

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

ಆ ಮೂಲಕ ಪಡೆದ ಒಮ್ಮೆ, ನಂತರ ಇಲ್ಲಿ ಮತ್ತೊಂದು ಜ್ಞಾಪನೆ ಇಲ್ಲಿದೆ ಹೇಗೆ ನಾವು ಹಫ್ಮನ್ ಗ್ರಂಥಿಗಳು ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೀನು. ನಾವು ಅವುಗಳನ್ನು ಇನ್ನು ಮುಂದೆ ಘಟಕಗಳು ಕರೆ ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ; ನಾವು ಅವುಗಳನ್ನು ಮರಗಳು ಕರೆ ಮಾಡಲು ನೀನು ನಾವು ಚಾರ್ ತಮ್ಮ ಚಿಹ್ನೆಯಾಗಿ ಪ್ರತಿನಿಧಿಸುವ ಎಂದು ನೀನು ಅಲ್ಲಿ, ಅವುಗಳ ಆವರ್ತನ, ಒಂದು ಪೂರ್ಣಾಂಕದೊಂದಿಗೆ ಸಂಭವಿಸುವಿಕೆಗಳ ಸಂಖ್ಯೆ. ಇದು ಒಂದು ಫ್ಲೋಟ್ ಹೆಚ್ಚು ನಿಖರ ಏಕೆಂದರೆ ನಾವು ಬಳಸುತ್ತಿದ್ದೀರಿ. ನಂತರ ನಾವು ಎಡ ಮಗುವಿನ ಜೊತೆಗೆ ಸರಿಯಾದ ಮಗುವಿಗೆ ಇನ್ನೊಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಿರುತ್ತವೆ. ಒಂದು ಕಾಡು, ನಾವು ಕಂಡುಕೊಂಡ, ಕೇವಲ ಮರಗಳ ಲಿಂಕ್ ಪಟ್ಟಿ. ಅಂತಿಮವಾಗಿ, ನಾವು ನಮ್ಮ ಹಫ್ ಕಡತವನ್ನು ನಿರ್ಮಿಸುವ ಮಾಡಿದಾಗ, ನಮ್ಮ ಅರಣ್ಯ ಕೇವಲ 1 ವೃಕ್ಷವನ್ನು ಬಯಸುವ - 1 ಮರ, ಅನೇಕ ಮಕ್ಕಳು 1 ಮೂಲ. ಮೊದಲು ನಾವು ನಮ್ಮ ಹಫ್ಮನ್ ಮರಗಳು ಮಾಡುವ ಸಂದರ್ಭದಲ್ಲಿ ಮೇಲೆ, ನಮ್ಮ ಪರದೆಯ ಮೇಲೆ ನೋಡ್ಗಳ ಎಲ್ಲಾ ಮೂಲಕ ಆರಂಭವಾಯಿತು ಮತ್ತು, ಈ ನೋಡ್ಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಎಂದು ನೀನು ಹೇಳುವ ಅಂತಿಮವಾಗಿ ಅವು ಎಲೆಗಳು ಎಂದು ನೀನು, ಮತ್ತು ಈ ತಮ್ಮ ಸಂಕೇತವಾಗಿದೆ, ಈ ಅವುಗಳ ಆವರ್ತನ. ನಾವು 3 ಅಕ್ಷರಗಳು ಹೊಂದಿದ್ದರೆ ನಮ್ಮ ಕಾಡಿನಲ್ಲಿ, ಆ 3 ಮರಗಳ ಕಾಡಿನ. ನಂತರ ನಾವು ಮೊದಲ ಪೋಷಕ ಸೇರಿಸಿದಾಗ, ಮೇಲೆ ಹೋಗಿ ಎಂದು ನಾವು 2 ಮರಗಳ ಕಾಡು ಮಾಡಿದ. ನಮ್ಮ ಕಾಡು ಆ ಮಕ್ಕಳ 2 ತೆಗೆದು ನಂತರ ಪೋಷಕ ನೋಡ್ ಬದಲಾಯಿಸಿಕೊಂಡವು ಮಕ್ಕಳು ಆ 2 ಗ್ರಂಥಿಗಳು ಹೊಂದಿತ್ತು. ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನಮ್ಮ ಕಳೆದ ಹಾಗೆ, Bs ನಮ್ಮ ಉದಾಹರಣೆಗೆ ತಯಾರಿಸುವ ಹಂತದ, ಮತ್ತು ಸಿ ಅಂತಿಮ ಮೂಲ ಮಾಡಲು ಎಂದು, ಮತ್ತು ಆದ್ದರಿಂದ 1 ಕಾಡಿನಲ್ಲಿ ಮರಗಳ ನಮ್ಮ ಒಟ್ಟು ಎಣಿಕೆ ತರುವುದನ್ನು. ಎಲ್ಲರೂ ನಿಮ್ಮ ಕಾಡಿನಲ್ಲಿ ಅನೇಕ ಮರಗಳು ಜೊತೆ ಸ್ಟಾರ್ಟ್ ಔಟ್ ಹೇಗೆ ನೋಡಿ ಇಲ್ಲ ಮತ್ತು 1 ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು? ಸರಿ. ಕೂಲ್. 

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

ಸರಿಯಾದ ಬಳಕೆಯ ಖಚಿತಪಡಿಸುವುದು ಈಗ ನಮಗೆ ಹಳೆಯ Hat ಹೊಂದಿದೆ. ನಾವು ಆದಾನ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಇದು ಹೊಗಳಿಕೆ ಫೈಲ್ ಹೆಸರು ಎಂದು ಹೋಗುತ್ತದೆ, ಮತ್ತು ನಾವು, ಒಂದು ಔಟ್ಪುಟ್ ಸೂಚಿಸಿ ಆದ್ದರಿಂದ ಪಠ್ಯ ಫೈಲ್ ಇದು puffed ಔಟ್ಪುಟ್, ಕಡತ ಹೆಸರು. ಆ ಬಳಕೆಯು ಇಲ್ಲಿದೆ. ಮತ್ತು ಈಗ ನಾವು ಇನ್ಪುಟ್ huffed ಅಥವಾ ಖಚಿತಪಡಿಸಲು ಬಯಸುವ. ಯೋಚಿಸುವಾಗ, ನಮಗೆ ಎಂದು ವಿತರಣೆ ಕೋಡ್ ರಲ್ಲಿ ಏನು ಎಂದು ಒಂದು ಕಡತ huffed ಅಥವಾ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ? Huffeader ಬಗ್ಗೆ huffile.c ಮಾಹಿತಿ ಇರಲಿಲ್ಲ. ನಾವು ಪ್ರತಿ ಹಫ್ ಫೈಲ್ ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆ ಅದನ್ನು ಸಂಬಂಧಿಸಿದ Huffeader ಹೊಂದಿದೆ ತಿಳಿದಿದೆ ಪ್ರತಿ ಚಿಹ್ನೆಯ ಆವರ್ತನಗಳ ಮತ್ತು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಾಗೆಯೇ ಒಂದು checksum ಮಾಹಿತಿ. ನಮಗೆ ತಿಳಿದಿರುವುದು, ಆದರೆ ನಾವು, dump.c ಒಂದು ಪೀಕ್ ತೆಗೆದುಕೊಂಡಿತು ಇದರಲ್ಲಿ ಒಂದು ಹಫ್ ಫೈಲ್ ಆಗಿ ಓದುವ. ಹೀಗೆ ಮಾಡಲು, ಇದು ನಿಜವಾಗಿಯೂ huffed ಅಥವಾ ಎಂದು ಪರಿಶೀಲಿಸಲು ಹೊಂದಿತ್ತು. ಆದ್ದರಿಂದ ಬಹುಶಃ ನಮ್ಮ puff.c. ಒಂದು ರಚನೆ ಎಂದು dump.c ಬಳಸಬಹುದಿತ್ತು ಬ್ಯಾಕ್ pset 4 ನಾವು RGB ಮೂರು ರಲ್ಲಿ ನಕಲು ಫೈಲ್ copy.c ಪಡೆದಾಗ ಮತ್ತು ನಾವು, ವೊಡುನಿಟ್ ಮತ್ತು ಗಣಕತೆರೆ ಆ ತಿಳಿಯುತ್ತದೆ ಹಾಗೆಯೇ, ನೀವು ಏನು ಮಾಡಬಹುದು ಕೇವಲ CP dump.c puff.c ನಂತಹ ಆಜ್ಞೆಯನ್ನು ಇದೆ ಅಲ್ಲಿಯೇ ಕೋಡ್ ಕೆಲವು ಬಳಸಿ. ಆದಾಗ್ಯೂ, ಇದು ಒಂದು ಪ್ರಕ್ರಿಯೆಯ ಮಾಹಿತಿ ನೇರ ಎಂದು ಹಿಂದಿರುಗಬಹುದೆಂದು puff.c ನಿಮ್ಮ dump.c ಅನುವಾದ ಫಾರ್, ಆದರೆ ಕನಿಷ್ಠ ಆರಂಭಿಸಲು ಎಲ್ಲೋ ನೀವು ನೀಡುತ್ತದೆ ಇನ್ಪುಟ್ ವಾಸ್ತವವಾಗಿ huffed ಅಥವಾ ಖಚಿತಪಡಿಸಲು ಹೇಗೆ ಹಾಗೆಯೇ ಕೆಲವು ಸಂಗತಿಗಳು. ನಾವು ಸರಿಯಾದ ಬಳಕೆಯ ಖಾತರಿ ಮತ್ತು ಇನ್ಪುಟ್ huffed ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಖಾತ್ರಿಪಡಿಸಿದೆ. ನಾವು ನಮ್ಮ ಸರಿಯಾದ ದೋಷ ತಪಾಸಣೆ ಮಾಡಿದ ಮಾಡಿದ ಪ್ರತಿ ಸಮಯ, ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ಇರುವ ವೇಳೆ, ಹಿಂದಿರುಗಿದ ಮತ್ತು ಕೆಲವು ವೈಫಲ್ಯ ಉಂಟಾದರೆ ಕಾರ್ಯ ತೊರೆದು. 

ಈಗ ನಾವು ಬಯಸುವ ವಾಸ್ತವಿಕ ಟ್ರೀಯನ್ನು ರಚಿಸುವುದು ಆಗಿದೆ. ನಾವು ಫಾರೆಸ್ಟ್ ನೋಡಿದರೆ, 2 ಮುಖ್ಯ ಕಾರ್ಯಗಳು ಇವೆ ನಾವು ಅತ್ಯಂತ ಪರಿಚಿತ ಆಗಲು ಬಯಸುವ ಹೋಗಿ ನೀವು. ಇಲ್ಲ ಬೂಲಿಯನ್ ಕಾರ್ಯ ಸಸ್ಯದ ನಮ್ಮ ಕಾಡಿನಲ್ಲಿನ ಒಂದು ಅಲ್ಲದ 0 ಆವರ್ತನ ಮರ ಸಸ್ಯಗಳು. ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಒಂದು ಕಾಡು ಮತ್ತು ಒಂದು ಮರದ ಒಂದು ಪಾಯಿಂಟರ್ ಒಂದು ದಿಕ್ಸೂಚಕ ಹಾದುಹೋಗುತ್ತವೆ. ತ್ವರಿತ ಪ್ರಶ್ನೆ: ನೀವು ಹಫ್ಮನ್ ಮರದ ನಿರ್ಮಿಸಲು ಮಾಡಿದಾಗ ಎಷ್ಟು ಕಾಡುಗಳ ನೀವು ಹೊಂದಿರುವಿರಿ? ನಮ್ಮ ಅರಣ್ಯ ಹಕ್ಕು, ನಮ್ಮ ಕ್ಯಾನ್ವಾಸ್ ಹಾಗೆ? ನಾವು ಕೇವಲ 1 ಅರಣ್ಯ ಹೊಂದಿರುವ ನೀನು, ಆದರೆ ಅನೇಕ ಮರಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ ಎಂದು ನೀನು. ನೀವು ಸಸ್ಯ ಕರೆ ಆದ್ದರಿಂದ ಮೊದಲು, ನೀವು ಬಹುಶಃ ನಿಮ್ಮ ಅರಣ್ಯ ಮಾಡಲು ಬಯಸುವ ಎಂದು ನೀನು. ನೀವು ಒಂದು ಅರಣ್ಯ ಮಾಡಬಹುದು ಹೇಗೆ forest.h ಕುರಿತು ಒಂದು ಆಜ್ಞೆಯನ್ನು ಆ ಇಲ್ಲ. ನೀವು ಮರದ ಸಸ್ಯಗಳಿಗೆ ಮಾಡಬಹುದು. ನಾವು ಹೇಗೆ ಗೊತ್ತು. ಮತ್ತು ನಂತರ ನೀವು, ಕಾಡು ಮರದ ಆಯ್ಕೆ ಮಾಡಬಹುದು ಕಡಿಮೆ ತೂಕದ ಒಂದು ಮರ ತೆಗೆದು ಮತ್ತು ನಿಮ್ಮನ್ನು ಪಾಯಿಂಟರ್ ನೀಡುವ. ನಾವು ಉದಾಹರಣೆಗಳು ನಾವೇ ಮಾಡುವ ಸಂದರ್ಭದಲ್ಲಿ ಯೋಚಿಸುವಾಗ, ನಾವು ಬರೆಯುವ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಸರಳವಾಗಿ ಕೇವಲ ಕೊಂಡಿಗಳು ಸೇರಿಸಲಾಗಿದೆ. ಆದರೆ ಇಲ್ಲಿ ಬದಲಿಗೆ ಕೇವಲ, ಲಿಂಕ್ಗಳನ್ನು ಸೇರಿಸಿ ಆ ನೋಡ್ಗಳ 2 ತೆಗೆದು ನಂತರ ಮತ್ತೊಂದು ಮೂಲಕ ಬದಲಿಗೆ ನೀವು ಹೆಚ್ಚು ತಿಳಿಯುತ್ತಾರೆ. ಉಂಟಾಗದಂತೆ ಮತ್ತು ನಾಟಿ ಪರಿಭಾಷೆಯಲ್ಲಿ ಎಂದು ವ್ಯಕ್ತಪಡಿಸಲು, ನೀವು 2 ಮರಗಳು ಉಂಟಾಗದಂತೆ ಮತ್ತು ನಂತರ ಮತ್ತೊಂದು ಮರವನ್ನು ನೆಟ್ಟು ನೀವು ನೀವು ಮಕ್ಕಳಿಗೆ ಎಂದು ಆಯ್ಕೆ ಆ 2 ಮರಗಳನ್ನು ಹೊಂದಿದೆ. ಹಫ್ಮನ್ ನ ಮರದ ನಿರ್ಮಿಸಲು, ನೀವು ಸಲುವಾಗಿ ಚಿಹ್ನೆಗಳು ಮತ್ತು ತರಂಗಾಂತರಗಳನ್ನು ನಲ್ಲಿ ಓದಬಹುದು Huffeader ನೀವು ಆ ನೀಡುತ್ತದೆ ಏಕೆಂದರೆ, ನೀವು ಆವರ್ತನಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನೀಡುತ್ತದೆ. ಆದ್ದರಿಂದ ನೀವು ಮುಂದೆ ಹೋಗಿ ಮತ್ತು ಅದನ್ನು 0 ಜೊತೆ ಏನು ನಿರ್ಲಕ್ಷಿಸಿ ನಾವು ಕೊನೆಯಲ್ಲಿ 256 ಎಲೆಗಳು ಬಯಸುವ ಕಾರಣ. ನಾವು ಕೇವಲ ಪಾತ್ರಗಳು ಎಂದು ಎಲೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಬಯಸುವ ಎಂದು ವಾಸ್ತವವಾಗಿ ಕಡತ ಬಳಸಲಾಗುತ್ತದೆ. ನೀವು ಆ ಚಿಹ್ನೆಗಳಲ್ಲಿ ಓದಲು, ಮತ್ತು 0 ಆವರ್ತನಗಳನ್ನು ಹೊಂದಿರುವ ಆ ಸಂಕೇತಗಳ ಪ್ರತಿ ಮಾಡಬಹುದು ಆ ಮರಗಳು ಮುಂದುವರೆಸುತ್ತೇವೆ. ನೀವು ಏನು ಮಾಡಬಹುದು, ನೀವು 0 ಆವರ್ತನ ಸಂಕೇತ ಓದಲು ಪ್ರತಿ ಸಮಯ ನೀವು ಅರಣ್ಯ ಆ ಮರದ ಸಸ್ಯಗಳಿಗೆ ಮಾಡಬಹುದು. ನೀವು ಕಾಡಿನಲ್ಲಿ ಮರಗಳ ಸಸ್ಯಗಳಿಗೆ ಒಮ್ಮೆ ಒಡಹುಟ್ಟಿದವರ ಆ ಮರಗಳನ್ನು ಸೇರಿ, ಮಾಡಬಹುದು ಆದ್ದರಿಂದ, ನಾಟಿ ಮತ್ತು ನೀವು ಆಯ್ಕೆ ಅಲ್ಲಿ ಉಂಟಾಗದಂತೆ 2 ಮತ್ತು ನಂತರ PLANT 1 ಹಿಂದಕ್ಕೆ ಹೋಗಿ ಅಲ್ಲಿ 1 ನೀವು ಸಸ್ಯ ನೀವು ಆಯ್ಕೆ ಎಂದು 2 ಮಕ್ಕಳ ಮೂಲ ಎಂದು. ಆದ್ದರಿಂದ ನಿಮ್ಮ ಅಂತಿಮ ಪರಿಣಾಮವಾಗಿ ನಿಮ್ಮ ಕಾಡಿನಲ್ಲಿ ಒಂದು ಮರದ ಏರಲಿದೆ. ನೀವು ನಿಮ್ಮ ಟ್ರೀಯನ್ನು ರಚಿಸುವುದು ಹೇಗೆ. 

ಇಲ್ಲಿ ತಪ್ಪು ಹೋಗಿ ಎಂದು ಅನೇಕ ವಿಷಯಗಳನ್ನು ಏಕೆಂದರೆ ನಾವು ಹೊಸ ಮರಗಳು ಮಾಡುವ ಹಾಗೆ ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ವಿಷಯಗಳನ್ನು ವ್ಯವಹರಿಸುವ ಮಾತಾಡುತ್ತಿದ್ದೀರಿ. ನಾವು ಪಾಯಿಂಟರ್ಸ್ ವ್ಯವಹರಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಮೊದಲು, ನಾವು malloc'd ಬಂದಾಗಲೆಲ್ಲಾ ನಾವು ನಮಗೆ ನಲ್ ಪಾಯಿಂಟರ್ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸಿದರು. ಈ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಹಲವಾರು ಹಂತಗಳನ್ನು ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇರುವಂತೆ ಹೋಗುವ ಅಲ್ಲಿ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ವಿಫಲರಾಗಬಹುದಾದ. ನೀವು ಏನು ಮಾಡಲು ಬಯಸುವ, ನೀವು ಆ ದೋಷಗಳು ನಿರ್ವಹಿಸುವ ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಬೇಕಾಗಿದೆ ಆಗಿದೆ ಮತ್ತು ವಿಶೇಷ ಇದು, ಆಕರ್ಷಕವಾಗಿ ಅವುಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಹೇಳುತ್ತಾರೆ ಆದ್ದರಿಂದ ಪ್ರೋಗ್ರಾಂ ನಿರ್ಗಮಿಸುವ ಹೊಂದಿದೆ ಏಕೆ ಅವುಗಳನ್ನು ಹೇಳುವ ಬಳಕೆದಾರನಿಗೆ ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಇಷ್ಟ ನಂತರ ಕೂಡಲೇ ಅದನ್ನು ತ್ಯಜಿಸಿದರು. ಈ ದೋಷ ನಿರ್ವಹಣೆ ಮಾಡಲು, ನೀವು ಪರಿಶೀಲಿಸಲು ಬಯಸುವ ನೆನಪಿಡಿ ಒಂದು ವೈಫಲ್ಯ ಎಂಬುದನ್ನು ಪ್ರತಿಯೊಂದು ಸಮಯ. ನೀವು ಒಂದು ಹೊಸ ಪಾಯಿಂಟರ್ ಮಾಡುತ್ತಿದ್ದೀಯ ಪ್ರತಿಯೊಂದು ಸಮಯ ನೀವು ಯಶಸ್ವಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುತ್ತೇನೆ. ನಾವು ಹೊಸ ಪಾಯಿಂಟರ್ ಮತ್ತು malloc ಒದಗಿಸಿ ಇದೆ ಮಾಡಲು ಯಾವ ಮೊದಲು, ನಂತರ ನಾವು ಪಾಯಿಂಟರ್ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಎಂದು ಪರಿಶೀಲಿಸಿ ಎಂದು. ಆದ್ದರಿಂದ, ನೀವು ಹಾಗೆ ಕೇವಲ ಮಾಡಬಹುದು ಅಲ್ಲಿ ಕೆಲವು ನಿದರ್ಶನಗಳು ಇರುವಂತೆ ಹೋಗುವ ಆದರೆ ಕೆಲವೊಮ್ಮೆ ನೀವು ವಾಸ್ತವವಾಗಿ ಒಂದು ಕ್ರಿಯೆ ಎಂದು ನೀವು ಮತ್ತು ಆ ಕಾರ್ಯವನ್ನು ಒಳಗೆ ಆ mallocing ಮಾಡುತ್ತಿದ್ದಾರೆ ಎಂದು ಒಂದಾಗಿದೆ. ಆ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಕೋಡ್ ಕಾರ್ಯಗಳನ್ನು ಕೆಲವು ಮತ್ತೆ ನೋಡಿದರೆ, ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಬೂಲಿಯನ್ ಕ್ರಿಯೆಗಳು. ಅಮೂರ್ತ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು foo ಎಂಬ ಬೂಲಿಯನ್ ಫಂಕ್ಷನ್ ವೇಳೆ, ಮೂಲತಃ, ನಾವು, foo ಮಾಡುತ್ತದೆ ಕೆಲಸದಲ್ಲಿರುವಾಗ ಜೊತೆಗೆ ನೀವು ಭಾವಿಸಬಹುದು ಇದು ಒಂದು ಬೂಲಿಯನ್ ಕಾರ್ಯ ರ ಇದು ಸರಿ ಅಥವಾ ತಪ್ಪು ಹಿಂದಿರುಗಿಸುತ್ತದೆ - ವೇಳೆ ನಿಜವಾದ ಯಶಸ್ಸು, ತಪ್ಪು ಇಲ್ಲದಿದ್ದರೆ. ನಾವು foo ಆಫ್ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ನಿಜವಾದ ಅಥವಾ ಸುಳ್ಳು ಎಂದು ಪರಿಶೀಲಿಸಲು ಬಯಸುವ. ಇದು ಸುಳ್ಳು ಆಗಿದ್ದರೆ, ನಾವು ಸಂದೇಶವನ್ನು ರೀತಿಯ ಮುದ್ರಿಸಲು ಬಯಸುವ ಎಂದು ನೀನು ಅರ್ಥ ತದನಂತರ ಪ್ರೋಗ್ರಾಂ ತ್ಯಜಿಸಿದರು. ನಾವು ಮಾಡಲು ಬಯಸುವ foo ಆಫ್ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸಿ ಆಗಿದೆ. Foo ಸುಳ್ಳು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಆಗ ನಾವು ದೋಷ ರೀತಿಯ ಎದುರಿಸಿದೆ ತಿಳಿದಿದೆ ಮತ್ತು ನಾವು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ನಿರ್ಗಮಿಸುವ ಅವಶ್ಯಕತೆ. ಇದನ್ನು ಮಾಡಲು ಒಂದು ರೀತಿಯಲ್ಲಿ ನಿಜವಾದ ಕಾರ್ಯ ಸ್ವತಃ ನಿಮ್ಮ ಪರಿಸ್ಥಿತಿ ಅಲ್ಲಿ ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿದೆ. Foo X ರಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಸೇ. ನಾವು ಒಂದು ಸ್ಥಿತಿ ಎಂದು ಹೊಂದಿವೆ (foo (x)). Foo ಪಾಲಿಸಲು ಕೊನೆಯಲ್ಲಿ ಇದು ನಿಜವಾದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ವೇಳೆ ಮೂಲತಃ, ಎಂದು, ಅಂದರೆ ಕಾರ್ಯ foo ​​ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಏಕೆಂದರೆ ನಾವು ಈ ಮಾಡಬಹುದು ಇಡೀ ಪರಿಸ್ಥಿತಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಸಲುವಾಗಿ. ಆದ್ದರಿಂದ ಆ ಕಾರ್ಯ ನಿಜವಾದ ಮರಳಿ ಯಶಸ್ವಿ ವೇಳೆ ನೀವು ಏನಾದರೂ ಮಾಡಬಹುದು ಹೇಗೆ. ಆದರೆ ನೀವು ದೋಷ ಪರಿಶೀಲನೆ ಇರುವಾಗ, ನಿಮ್ಮ ಕಾರ್ಯವನ್ನು ಸುಳ್ಳು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ವೇಳೆ ಬಿಟ್ಟು ಬಯಸುವ. ನೀವು ಏನು ಮಾಡಬಹುದು ಕೇವಲ ಸೇರಿಸಿ ಒಂದು == ಸುಳ್ಳು ಅಥವಾ ಇದು ಮುಂದೆ ಒಂದು ಬ್ಯಾಂಗ್ ಸೇರಿಸಿ ತದನಂತರ ನೀವು (! foo) ವೇಳೆ ಹೊಂದಿರುತ್ತವೆ. ಸೂಕ್ತ ದೇಹದ ಒಳಗೆ ನೀವು ದೋಷ ನಿಭಾಯಿಸುವ ಎಲ್ಲಾ ಹೊಂದಿರುತ್ತದೆ ಆದ್ದರಿಂದ "ಈ ಮರದ ರಚಿಸಲಾಗಲಿಲ್ಲ", ಹಾಗೆ ನಂತರ 1 ಅಥವಾ ಸ್ವಲ್ಪ ಹಿಂತಿರುಗಿ. ಅದು ಏನು, ಆದರೂ, foo ಸುಳ್ಳು ಮರಳಿದರು ಸಹ ಎಂದು ಹೊಂದಿದೆ - Foo ನಿಜವಾದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಸೇ. ನಂತರ ನೀವು ಮತ್ತೆ foo ಕರೆಯಲು ಹೊಂದಿಲ್ಲ. ಒಂದು ಸಾಮಾನ್ಯ ತಪ್ಪುಗ್ರಹಿಕೆಯಾಗಿದೆ ಇಲ್ಲಿದೆ. ನಿಮ್ಮ ಸ್ಥಿತಿಯನ್ನು ಏಕೆಂದರೆ, ಇದು ಈಗಾಗಲೇ ಮೌಲ್ಯಮಾಪನ ಮಾಡಿದ, ನೀವು ಮರದ ಅಥವಾ ಆ ತರಹದ್ದನ್ನು ಮಾಡುವ ಬಳಸುತ್ತಿದ್ದರೆ ನೀವು ಈಗಾಗಲೇ ಪರಿಣಾಮವಾಗಿ ಹೊಂದಿವೆ ಅಥವಾ ಸಸ್ಯ ಅಥವಾ ಪಿಕ್ ಅಥವಾ ಏನೋ. ಇದು ಈಗಾಗಲೇ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ. ಇದು ಈಗಾಗಲೇ ಕಾರ್ಯರೂಪಕ್ಕೆ ನ. ಆದ್ದರಿಂದ ಸ್ಥಿತಿಯಂತೆ ಬೂಲಿಯನ್ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲು ಉಪಯುಕ್ತವಾಗಿರುವ ಏಕೆಂದರೆ ಅಥವಾ ನಿಜವಾಗಿಯೂ ಲೂಪ್ ದೇಹದ ಕಾರ್ಯಗತಗೊಳಿಸುವುದಿಲ್ಲ, ಅದು ಹೇಗಾದರೂ ಕಾರ್ಯ ನಿರ್ವಹಿಸುವಾಗ. 

ಕೊನೆಯ ಹಂತದ ನಮ್ಮ ಎರಡನೇ ಕಡತಕ್ಕೆ ಸಂದೇಶ ಬರೆಯಲು ಇದೆ. ಒಮ್ಮೆ ನಾವು ಹಫ್ಮನ್ ಟ್ರೀಯನ್ನು ರಚಿಸುವುದು, ನಂತರ ಫೈಲ್ ಸಂದೇಶವನ್ನು ಬರೆಯಲು ಬಹಳ ನೇರವಾಗಿದೆ. ಅದು 0 ಸೆ ಮತ್ತು 1 ಅನುಸರಿಸಲು ಈಗ ಬಹಳ ನೇರ ಇಲ್ಲಿದೆ. ಮತ್ತು ಆದ್ದರಿಂದ ಸಂಪ್ರದಾಯದಂತೆ ನಾವು ಹಫ್ಮನ್ ವೃಕ್ಷದಲ್ಲಿ 0 ಸೆ ಬಿಟ್ಟು ಸೂಚಿಸುವಲ್ಲಿ ತಿಳಿದಿದೆ ಮತ್ತು 1 ಹಕ್ಕು ಸೂಚಿಸುತ್ತವೆ. ನೀವು 0 ಪಡೆಯಲು ನೀವು ಬಿಟ್ ಬಿಟ್ ಓದಲು ಆದ್ದರಿಂದ ವೇಳೆ, ಪ್ರತಿ ಬಾರಿ ನೀವು 1 ಓದಲು ಪ್ರತಿ ಬಾರಿ ನಂತರ ಎಡ ಶಾಖೆ ಅನುಸರಿಸಿ, ಮತ್ತು ನೀವು ನೀವು ಬಲ ಶಾಖೆ ಅನುಸರಿಸಲು ನೀನು. ನೀವು ಎಲೆ ಹಿಟ್ ತನಕ ಮುಂದುವರಿಯಲು ನೀನು ಎಲೆಗಳು ಶಾಖೆಗಳನ್ನು ಕೊನೆಯಲ್ಲಿರಬೇಕು ಹೋಗುವ ಕಾರಣ. ನಾವು ಒಂದು ಎಲೆ ಅಥವಾ ಹಿಟ್ ಎಂಬುದನ್ನು ನಾವು ಹೇಗೆ ಹೇಳಬಹುದು? ನಾವು ಮೊದಲು ಹೇಳಿದರು. [ವಿದ್ಯಾರ್ಥಿ] ಪಾಯಿಂಟರ್ಸ್ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಇದ್ದರೆ. >> ಹೌದು. ಎಡ ಮತ್ತು ಬಲ ಎರಡೂ ಮರಗಳು ಪಾಯಿಂಟರ್ಸ್ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಇದ್ದರೆ ನಾವು ಎಲೆ ಹೊಡೆಯಲು ನೀವು ನಮಗೆ. ಪರಿಪೂರ್ಣ. ನಾವು ನಮ್ಮ ಹಫ್ ಫೈಲ್ ಆಗಿ ಬಿಟ್ ಬಿಟ್ ಓದಲು ಬಯಸುವ ತಿಳಿದಿದೆ. ನಾವು dump.c ಮೊದಲು ಕಂಡಿತು ಎಂದು, ಅವರು ಏನು ಅವರು ಹಫ್ ಫೈಲ್ ಆಗಿ ಬಿಟ್ ಬಿಟ್ ಓದಲು ಆಗಿದೆ ಮತ್ತು ಆ ಬಿಟ್ಗಳು ಬಗ್ಗೆ ಔಟ್ ಮುದ್ರಿತ. ನಾವು ಏನು ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ. ನಾವು ಸ್ವಲ್ಪ ಸಂಕೀರ್ಣ ಹೊಂದಿರುವ ವಿಷಯ ಏನು ಎಂದು ನೀನು. ಆದರೆ ನಾವು ಮಾಡಬಹುದು ನಾವು ಬಿಟ್ ಗೆ ಓದುವ ಕೋಡ್ ಆ ಬಿಟ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಹೊಂದಿದೆ. ಇಲ್ಲಿ ನಾವು ಇದ್ದೇವೆ ಎಂದು ಪ್ರಸ್ತುತ ಬಿಟ್ ಪ್ರತಿನಿಧಿಸುವ ಪೂರ್ಣಾಂಕ ಬಿಟ್ ಹೊಂದಿವೆ. ನೀವು ಕಡತದ ಕೊನೆಯಲ್ಲಿ ಹಿಟ್ ಈ ಕಡತದಲ್ಲಿ ಬಿಟ್ಗಳು ಎಲ್ಲಾ iterating ನೋಡಿಕೊಳ್ಳುತ್ತಾರೆ. ಆ ಆಧಾರದ ಮೇಲೆ, ನಂತರ ನೀವು iterator ರೀತಿಯ ಬೇಕು ಎಂದು ನೀನು ನಿಮ್ಮ ಮರದ ಹಾದುಹೋಗಬೇಕಾದರೆ. ತದನಂತರ, ಬಿಟ್ 0 ಅಥವಾ 1 ಎಂಬುದನ್ನು ಆಧರಿಸಿದೆ ನೀವು ಎಡಕ್ಕೆ ಎಂದು iterator ಚಲಿಸುವಂತೆ ಅಥವಾ ಬಲಕ್ಕೆ ಇದು ಚಲಿಸಬೇಕೆಂದಿರುವ ಎಂದು ನೀನು ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ನೀವು ಎಲೆ ಹಿಟ್ ರವರೆಗೆ, ಆದ್ದರಿಂದ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ನೀವು ನೀವು ಆ ನೋಡ್ ರವರೆಗೆ ಯಾವುದೇ ಗ್ರಂಥಿಗಳು ಬೆಟ್ಟು ಮಾಡುವುದಿಲ್ಲ. ಏಕೆ ನಾವು ಹಫ್ಮನ್ ಫೈಲ್ ಆದರೆ ಮೋರ್ಸ್ ಕೋಡ್ ಈ ಮಾಡಬಹುದು? ಮೋರ್ಸ್ ಕೋಡ್ ದ್ವಂದ್ವಾರ್ಥತೆಯನ್ನು ಒಂದು ಬಿಟ್ ಇರುವುದರಿಂದ. ನಾವು ಕಾದು ಓಹ್, ಹಾಗೆ ಇರಬಹುದು, ನಾವು ಹಾದಿಯಲ್ಲಿ ಪತ್ರದಲ್ಲಿ ಹಿಟ್ ಮಾಡಿದ, ಆದ್ದರಿಂದ ಬಹುಶಃ ಇದು ನಮ್ಮ ಪತ್ರ ನಾವು ಸ್ವಲ್ಪ ಮುಂದೆ ಮುಂದುವರೆಯಿತು ವೇಳೆ, ನಂತರ ಮತ್ತೊಂದು ಪತ್ರ ತಾಗುವ ಆದರೆ. ಆದರೆ, ಹಫ್ಮನ್ ಎನ್ಕೋಡಿಂಗ್ ನಡೆಯುತ್ತಿಲ್ಲ ಹಿಂದಿರುಗಬಹುದೆಂದು ಆದ್ದರಿಂದ ನಾವು ನೀನು ಒಂದೇ ರೀತಿಯಲ್ಲಿ ಒಂದು ಪಾತ್ರ ಹೊಡೆಯಲು ಎಂದು ಖಚಿತವಾಗಿರಿ ಮಾಡಬಹುದು ಆ ನೋಡ್ ನ ಎಡ ಮತ್ತು ಬಲ ಮಕ್ಕಳು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಎಂದು ಆಗಿದೆ. 

ಅಂತಿಮವಾಗಿ, ನಾವು ನಮ್ಮ ಮೆಮೊರಿ ಎಲ್ಲಾ ಮುಕ್ತಗೊಳಿಸಲು ಬಯಸುತ್ತೇನೆ. ನಾವು ವ್ಯವಹರಿಸುವಾಗ ನಾವು ಎರಡೂ ಹತ್ತಿರದ ಹಫ್ ಕಡತ ಬಯಸುವ ಹಾಗೆಯೇ ನಮ್ಮ ಕಾಡಿನಲ್ಲಿ ಮರಗಳ ಎಲ್ಲಾ ತೆಗೆದು. ನಿಮ್ಮ ಅನುಷ್ಠಾನದ ಆಧಾರದ ಮೇಲೆ, ನೀವು ಬಹುಶಃ ಅರಣ್ಯ ತೆಗೆದುಹಾಕಲು ಕರೆಯಲು ಬಯಸುತ್ತೇನೆ ಎಂದು ನೀನು ಬದಲಿಗೆ ವಾಸ್ತವವಾಗಿ ಮರಗಳು ನಿಮ್ಮ ಎಲ್ಲಾ ಮೂಲಕ ಹೋಗುವ. ನೀವು ಯಾವುದೇ ತಾತ್ಕಾಲಿಕ ಮರಗಳು ಮಾಡಿದರು ಆದರೆ, ಆ ಮುಕ್ತಗೊಳಿಸಲು ಬಯಸುವಿರಿ. ನೀವು ಉತ್ತಮ ನಿಮ್ಮ ಕೋಡ್ ತಿಳಿಯಲು, ನೀವು ಮೆಮೊರಿ ನೀಡಲು ನೀವು ಅಲ್ಲಿ ನಿಮಗೆ. ಮತ್ತು ನೀವು ಹೋಗಿ ಹಾಗಿದ್ದಲ್ಲಿ, malloc ಫಾರ್ F'ing ಸಹ ಕಂಟ್ರೋಲ್ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಿ ನೋಡಿದ ಬಂದಾಗಲೆಲ್ಲಾ ನೀವು malloc ಮತ್ತು ಆ ಎಲ್ಲಾ ಮುಕ್ತಗೊಳಿಸಲು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಆದರೆ ಕೇವಲ, ನಿಮ್ಮ ಕೋಡ್ ಮೂಲಕ ಹೋಗುವ ನೀವು ಮೆಮೊರಿ ಹಂಚಿಕೆ ಮಾಡಿರಬಹುದು ಅಲ್ಲಿ ಅರ್ಥ. ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಕೇವಲ "ಒಂದು ಕಡತದ ಕೊನೆಯಲ್ಲಿ ನಾನು ನನ್ನ ಕಾಡಿನ ಮೇಲೆ ಅರಣ್ಯ ತೆಗೆದುಹಾಕಲು ಪಡೆಯಲಿದ್ದೇನೆ", ಹೇಳಬಹುದು ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ ಉಚಿತ, ಆ ಸ್ಮರಣೆಯ ತೆರವುಗೊಳಿಸಿ ಎಂದು, "ಆಗ ನಾನು ಕೂಡ ಕಡತವನ್ನು ಮುಚ್ಚಲು ಮತ್ತು ನಂತರ ನನ್ನ ಪ್ರೋಗ್ರಾಂನಿಂದ ಹೊರನಡೆ ಹೋಗುವ ಇದೆ ಪಡೆಯಲಿದ್ದೇನೆ." ಆದರೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕ್ವಿಟ್ಸ್ ಎಂದು ಮಾತ್ರ ಸಮಯ? ಇಲ್ಲ, ಏಕೆಂದರೆ ಕೆಲವೊಮ್ಮೆ ಸಂಭವಿಸಿದ ದೋಷವೊಂದು ಇದ್ದಿರಬೇಕು. ಬಹುಶಃ ನಾವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲಾಗಲಿಲ್ಲ ಅಥವಾ ಮತ್ತೊಂದು ಮರ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಅಥವಾ ದೋಷ ರೀತಿಯ ಮೆಮೊರಿ ಹಂಚಿಕೆ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ನಡೆದಿದೆ ಮತ್ತು ಆದ್ದರಿಂದ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿದರು. ದೋಷ ಸಂಭವಿಸಿದ ನಂತರ ನಾವು ಹಿಂದಿರುಗಿ ತ್ಯಜಿಸಿದರು. ಆದ್ದರಿಂದ ನೀವು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಯಾವುದೇ ಸಾಧ್ಯವಾದಷ್ಟು ಸಮಯ ಬಿಟ್ಟು ಆಗುವುದಿಲ್ಲ ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಬೇಕಾಗಿದೆ ನೀವು ನಿಮ್ಮ ಮೆಮೊರಿಯನ್ನು ಎಲ್ಲಾ ಮುಕ್ತಗೊಳಿಸಲು ಬಯಸುತ್ತೇನೆ. ಇದು ಕೇವಲ ನಿಮ್ಮ ಕೋಡ್ ಬಿಟ್ಟು ಪ್ರಮುಖ ಕಾರ್ಯ ಅತ್ಯಂತ ಕೊನೆಯಲ್ಲಿರಬೇಕು ಹಿಂದಿರುಗಬಹುದೆಂದು. ನಿಮ್ಮ ಕೋಡ್ ಸಮರ್ಥವಾಗಿ ಅಕಾಲಿಕವಾಗಿ ಮರಳಿ ಎಂದು ಪ್ರತಿ ಉದಾಹರಣೆಗಾಗಿ ಹಿಂದಕ್ಕೆ ನೋಡಲು ಬಯಸುವ ತದನಂತರ ಉಚಿತ ಏನೇ ಮೆಮೊರಿ ಅರ್ಥವಿಲ್ಲ. ನೀವು ಅರಣ್ಯ ಮಾಡಲು ಮತ್ತು ತಪ್ಪು ಮರಳಿದರು ಎಂದು ತಿಳಿಸಿದ. ನಂತರ ನೀವು ಬಹುಶಃ ನಿಮ್ಮ ಅರಣ್ಯ ತೆಗೆದುಹಾಕಲು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ ನೀವು ಇನ್ನೂ ಅರಣ್ಯ ಹೊಂದಿಲ್ಲ ಏಕೆಂದರೆ. ಆದರೆ ಕೋಡ್ ಪ್ರತಿಯೊಂದು ಹಂತದಲ್ಲಿ ನೀವು ಅಕಾಲಿಕವಾಗಿ ಹಿಂದಿರುಗಲು ಇರಬಹುದು ಅಲ್ಲಿ ನೀವು ಯಾವುದೇ ಸಂಭಾವ್ಯ ಮೆಮೊರಿ ಮುಕ್ತಗೊಳಿಸಲು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುತ್ತೇನೆ. 

ನಾವು ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸಿದ ವ್ಯವಹರಿಸುವ ಮತ್ತು ಸಂಭವನೀಯ ಸೋರಿಕೆಯನ್ನು ಹೊಂದಿರುವ ಮಾಡಿದಾಗ, ನಮ್ಮ ತೀರ್ಪು ಮತ್ತು ನಮ್ಮ ಲಾಜಿಕ್ ಅನ್ನು ಮಾತ್ರ ಬಯಸುವ ಆದರೆ ನಾವು ಸರಿಯಾಗಿ ಅಥವಾ ನಮ್ಮ ಮೆಮೊರಿ ಎಲ್ಲ ಬಿಡುಗಡೆ ಎಂಬುದನ್ನು ದೃಢೀಕರಿಸಲು Valgrind ಬಳಸಿ. ನೀವು ಪಫ್ ಮೇಲೆ Valgrind ರನ್ ಮತ್ತು ನಂತರ ನೀವು ಸಹ ಇದು ಹಾದುಹೋಗಲು ಹೊಂದಿವೆ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಬಲ ಸಂಖ್ಯೆ Valgrind ಗೆ. ನೀವು ಚಲಾಯಿಸಬಹುದು, ಆದರೆ ಉತ್ಪಾದನೆಯ ಸ್ವಲ್ಪ ರಹಸ್ಯ ಹೊಂದಿದೆ. , ನಾವು ಸ್ಪೆಲ್ಲರ್ ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಸ್ವಲ್ಪ ನೆತ್ತಿಗೇರಿದೆ ಮಾಡಿದ್ದೀರಿ, ಆದರೆ ಇನ್ನೂ ಸ್ವಲ್ಪ ಹೆಚ್ಚಿನ ಸಹಾಯ ಬೇಕೇ ಆದ್ದರಿಂದ, ಸೋರಿಕೆ ಪರಿಶೀಲಿಸಿ = ಪೂರ್ಣ ರೀತಿಯಲ್ಲಿ ಕೆಲವು ಧ್ವಜಗಳು ಅದನ್ನು ಚಾಲನೆಯಲ್ಲಿರುವ ಎಂದು ಬಹುಶಃ ನಮಗೆ Valgrind ಕೆಲವು ಹೆಚ್ಚು ಉಪಯುಕ್ತ ಔಟ್ಪುಟ್ ನೀಡುತ್ತದೆ. 

ನಂತರ ನೀವು ಡೀಬಗ್ ಮಾಡಿದಾಗ ಇನ್ನೊಂದು ಉಪಯುಕ್ತ ಸಲಹೆ ವ್ಯತ್ಯಾಸ ಆಜ್ಞೆಯ. ನೀವು, ಹಫ್ ಸಿಬ್ಬಂದಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಪ್ರವೇಶಿಸಲು ರನ್ ಒಂದು ಪಠ್ಯ ಕಡತವನ್ನು ಮೇಲೆ, ಮಾಡಬಹುದು ತದನಂತರ ನಿರ್ದಿಷ್ಟ ಎಂದು, ಒಂದು ದ್ವಿಮಾನ ಕಡತ, ಅವಳಿ ಹಫ್ ಕಡತ ಅದನ್ನು ಔಟ್ಪುಟ್. ನಂತರ ಆ ದ್ವಿಮಾನ ಫೈಲ್ ನಿಮ್ಮ ಸ್ವಂತ ಪಫ್ ರನ್, ವೇಳೆ ನಂತರ ಆದ್ದರಿಂದ ನಿಮ್ಮ outputted ಪಠ್ಯ ಕಡತ ಒಂದೇ ಹಾಕುತ್ತದೆ ನೀವು ಜಾರಿಗೆ ಮೂಲ ಒಂದರಿಂದ ಇಲ್ಲಿ ನಾನು ಉದಾಹರಣೆಯಾಗಿ hth.txt ಬಳಸಿಕೊಂಡು ನಾನು, ಮತ್ತು ನಿಮ್ಮ ವಿಶೇಷ ಸುಮಾರು ಮಾತಾಡಿಕೊಂಡರು ಒಂದಾಗಿದೆ. ಎಂದು ಅಕ್ಷರಶಃ HTH ತದನಂತರ ಹೊಸಸಾಲು ಇಲ್ಲಿದೆ. ಆದರೆ ಖಂಡಿತವಾಗಿಯೂ ಹಿಂಜರಿಯಬೇಡಿ ಮತ್ತು ನೀವು ಖಂಡಿತವಾಗಿಯೂ ಮುಂದೆ ಉದಾಹರಣೆಗಳು ಬಳಸಲು ಸಲಹೆ ಮಾಡಲಾಗುತ್ತದೆ ನಿಮ್ಮ ಪಠ್ಯ ಕಡತ. 

ನೀವು decompressing ನಂತರ ಬಹುಶಃ ಕುಗ್ಗಿಸಿ ಒಂದು ಶಾಟ್ ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಮಾಡಬಹುದು ಯುದ್ಧ ಮತ್ತು ಶಾಂತಿ ನಿಮಗೆ ಸ್ಪೆಲ್ಲರ್ ಬಳಸಲಾಗುವ ಕಡತಗಳನ್ನು ಕೆಲವು ಅಥವಾ ಜೇನ್ ಆಸ್ಟೆನ್ ಅಥವಾ ಸ್ವಲ್ಪ - ತಂಪಾದ ರೀತಿಯ ಎಂದು - ಅಥವಾ ಆಸ್ಟಿನ್ ಪವರ್ಸ್, ನಾವು ಅದನ್ನು ದೊಡ್ಡ ಕಡತಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ ರೀತಿಯ ಕೆಳಗೆ ಬರುವುದಿಲ್ಲ ಏಕೆಂದರೆ ನಾವು ಇಲ್ಲಿ ಮುಂದಿನ ಉಪಕರಣವನ್ನು, ls-l ಬಳಸಿದರೆ. ನಾವು ಮೂಲತಃ ನಮ್ಮ ಪ್ರಸ್ತುತ ಕೋಶದಲ್ಲಿ ಎಲ್ಲಾ ವಿಷಯಗಳ ಪಟ್ಟಿ ಇದು LS, ಬಳಸಲಾಗುತ್ತದೆ ಮಾಡುತ್ತಿದ್ದೇವೆ. ಧ್ವಜ-L ಸಾಗುವ ವಾಸ್ತವವಾಗಿ ಆ ಕಡತಗಳ ಗಾತ್ರಕ್ಕೆ ತೋರಿಸುತ್ತದೆ. ನೀವು pset ನಿರ್ದಿಷ್ಟಪಡಿಸುವಿಕೆಯನ್ನು ಮೂಲಕ ಹೋಗಿ, ಅದು ವಾಸ್ತವವಾಗಿ, ಬೈನರಿ ಕಡತವನ್ನು ರಚಿಸುವ ಮೂಲಕ ನಿಮಗೆ ಪರಿಚಯಿಸುತ್ತದೆ ಅದು huffing, ಮತ್ತು ನೀವು ಸಣ್ಣ ಕಡತಗಳನ್ನು ಎಂದು ನೋಡಿ ಅದನ್ನು ಕುಗ್ಗಿಸಿ ಮತ್ತು ಮಾಹಿತಿಯನ್ನು ಎಲ್ಲಾ ಭಾಷಾಂತರಿಸುವುದು ಸ್ಪೇಸ್ ವೆಚ್ಚ ಆ ರೀತಿಯ ಎಲ್ಲಾ ಆವರ್ತನಗಳ ಮತ್ತು ವಸ್ತುಗಳ ನಿಜವಾದ ಲಾಭ ಮೀರಿಸುತ್ತದೆ ಮೊದಲ ಸ್ಥಳದಲ್ಲಿ ಕಡತ ಕುಗ್ಗಿಸಿ ನ. ನೀವು ಕೆಲವು ಮುಂದೆ ಪಠ್ಯ ಕಡತಗಳನ್ನು ಅದನ್ನು ರನ್ ಆದರೆ, ನಂತರ ನೀವು ಪ್ರಯೋಜನ ಪಡೆದುಕೊಳ್ಳಲು ಆರಂಭಿಸುವ ವೀಕ್ಷಿಸಬಹುದು ಆ ಫೈಲ್ಗಳನ್ನು ಕುಗ್ಗಿಸಿ ರಲ್ಲಿ. 

ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನಾವು ಖಂಡಿತವಾಗಿಯೂ ತುಂಬಾ HANDY ಬರುತ್ತವೆ ಹೋಗುವ ಇದು ನಮ್ಮ ಹಳೆಯ PAL GDB ಹೊಂದಿರುತ್ತವೆ. 

ನಾವು ಮರಗಳು ಮಾಡುವ ಬಹುಶಃ ಹಫ್ ಮರಗಳು ಅಥವಾ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ಮಾಡಬೇಡಿ ಅಥವಾ Huff'n ಪಫ್ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ಸರಿ. ನಾನು ಸ್ವಲ್ಪ ಕಾಲ ಸುಮಾರು ಇರುವೆ. 

ಧನ್ಯವಾದಗಳು, ಎಲ್ಲರೂ. ಈ ದರ್ಶನ 6 ಆಗಿತ್ತು. ಮತ್ತು ಅದೃಷ್ಟ ಉತ್ತಮ. 

[CS50.TV]