[Powered by Google Translate] ಪ್ರೋಗ್ರಾಮಿಂಗ್, ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಅಗತ್ಯವಿದೆ ಅಂತಹ ಒಂದು ವಿಭಾಗದಲ್ಲಿ ವಿದ್ಯಾರ್ಥಿಗಳು ಹೆಸರುಗಳು ಇತ್ತೀಚಿನ ರಸಪ್ರಶ್ನೆ ಅಥವಾ ಅವರ ಅಂಕಗಳು. 

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

ನಾವು ಅವರನ್ನು ಘೋಷಿಸಿದ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಬೇಕಾದ ನೀವು ಅವರು ಎಷ್ಟು ದೊಡ್ಡ ಮುಂದೆ ಅಪ್, ಎಂದು ಅವರು ಸಂಗ್ರಹಿಸಬಹುದು ಎಷ್ಟು ಅಂಶಗಳನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಹೇಗೆ ದೊಡ್ಡ ಈ ಅಂಶಗಳು, ಅವರ ಪ್ರಕಾರ ನಿರ್ಧರಿಸಲ್ಪಡುತ್ತದೆ ಇದು. ಉದಾಹರಣೆಗೆ, ಇಂಟ್ ಆಗ (10) 10 ಐಟಂಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು ಒಂದು ಇಂಟ್ ಗಾತ್ರವನ್ನು ಹೊಂದಿವೆ. 

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

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

ಇಲ್ಲಿ ಪೂರ್ಣಾಂಕಗಳ ಸರಳ ಲಿಂಕ್ ಪಟ್ಟಿ ಕೆಲವು ಸಿ ಕೋಡ್ ಇಲ್ಲಿದೆ. ನಾವು ಪ್ರತಿ ನೋಡ್ ನಿರೂಪಿಸಲಾಗಿದೆ ಎಂದು ನೋಡಬಹುದು 2 ವಿಷಯಗಳನ್ನು ಒಳಗೊಂಡಿರುವ struct ಮಾಹಿತಿ ಪಟ್ಟಿಯಲ್ಲಿ, 'ವಾಲ್' ಎಂಬ ಶೇಖರಿಸಿಡಲು ಒಂದು ಪೂರ್ಣಾಂಕ ಪಟ್ಟಿಯಲ್ಲಿ ಮುಂದಿನ ನೋಡ್ ಮತ್ತು ಲಿಂಕ್ ನಾವು ಎಂಬ ಪಾಯಿಂಟರ್ ಪ್ರತಿನಿಧಿಸುವಂತೆ ಇದು 'ಮುಂದಿನ.' ಈ ರೀತಿಯಲ್ಲಿ, ನಾವು ಸಂಪೂರ್ಣ ಪಟ್ಟಿ ಟ್ರ್ಯಾಕ್ ಮಾಡಬಹುದು 1 ನೋಡ್ ಕೇವಲ ಒಂದು ಪಾಯಿಂಟರ್, ನಂತರ ನಾವು ಮುಂದಿನ ಪಾಯಿಂಟರ್ಸ್ ಅನುಸರಿಸಬಹುದು 2 ನೋಡ್ ಗೆ, 3 ನೋಡ್ಗೆ, 4 ನೋಡ್ಗೆ, ಹೀಗೆ, ನಾವು ಪಟ್ಟಿಯ ಕೊನೆಯಲ್ಲಿ ಪಡೆಯಲು ತನಕ. 

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

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

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

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

ಈಗ ಕೆಲವು ಕೋಡ್ ಬರೆಯೋಣ ಆ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನಮಗೆ ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಬಯಸುವ ಹೇಳುತ್ತಾರೆ. ನಾವು ಮತ್ತೆ ನಮ್ಮ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ನೋಡ್ ಪ್ರತಿನಿಧಿಸಬಹುದು 2 ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಒಂದು struct ಮಾಹಿತಿ, 'ವಾಲ್' ಎಂಬ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯ ಮತ್ತು ಪಟ್ಟಿಯ ಮುಂದಿನ ನೋಡ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್ ಮುಂದಿನ. ಅಲ್ಲದೆ, ಸಾಕಷ್ಟು ಸರಳ ತೋರುತ್ತದೆ. 

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

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

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

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

ಆದ್ದರಿಂದ, ಸಂಚಾರಿ → ಮುಂದಿನ ಶೂನ್ಯ ವೇಳೆ, ಬಾಣದ ವಾಕ್ಯ dereferencing ಒಂದು ಶಾರ್ಟ್ಕಟ್ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ ಒಂದು struct ಒಂದು ಪಾಯಿಂಟರ್, ನಂತರ ಪ್ರವೇಶಿಸುವ ಎಡವಟ್ಟಾದ ಸಮಾನವಾದ ಅದರ ಮುಂದಿನ ಕ್ಷೇತ್ರ: (* ಸಂಚಾರಿ). ಮುಂದಿನ. ಒಮ್ಮೆ ನಾವು, ಕೊನೆಯ ನೋಡ್ ಕಂಡುಬಂದರೆ ನಾವು, ಸಂಚಾರಿ → Val ಮುದ್ರಿಸಲು ಬಯಸುವ ಪ್ರಸ್ತುತ ನೋಡ್ನಲ್ಲಿ ಮೌಲ್ಯ ಇದು ನಾವು ತಿಳಿದಿರುವ ಕೊನೆಯಾಗಿ ಒಂದಾಗಿದೆ. ಇಲ್ಲವಾದರೆ, ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಕೊನೆಯ ನೋಡ್ ಇನ್ನೂ ಇಂತಹ, ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಮುಂದಿನ ನೋಡ್ ಗೆ ಸ್ಥಳಾಂತರಿಸಲು ಕಳೆದ ಒಂದಾಗಿದೆ ವೇಳೆ ಮತ್ತು ಪರಿಶೀಲಿಸಿ. ಇದನ್ನು ಮಾಡಲು, ನಾವು ನಮ್ಮ ಕ್ರಾಲರ್ ಪಾಯಿಂಟರ್ ಸೆಟ್ ಪ್ರಸ್ತುತ ನೋಡ್ ಮುಂದಿನ ಮೌಲ್ಯಕ್ಕೆ ತೋರಿಸಲು, ಎಂದು, ಪಟ್ಟಿಯಲ್ಲಿ ಮುಂದಿನ ನೋಡ್. ಈ ಸೆಟ್ಟಿಂಗ್ ಮಾಡಲಾಗುತ್ತದೆ ಸಂಚಾರಿ = ಕ್ರಾಲರ್ → ಮುಂದಿನ. ನಂತರ ನಾವು, ಉದಾಹರಣೆಗೆ ಒಂದು ಲೂಪ್ ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸುವಂತೆ ನಾವು ಕೊನೆಯ ನೋಡ್ ಹೇಗೆ ರವರೆಗೆ. ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ, ಸಂಚಾರಿ ತಲೆಗೆ ತೋರುಗಡ್ಡಿ ಎಂದು, ನಾವು, ಸಂಚಾರಿ → ಮುಂದಿನ ತೋರಿಸಲು ಕ್ರಾಲರ್ ಸೆಟ್ ಇದು 1 ನೋಡ್ ಮುಂದಿನ ಕ್ಷೇತ್ರ ಅದೇ ಆಗಿದೆ. ಆದ್ದರಿಂದ, ಈಗ ನಮ್ಮ ಕ್ರಾಲರ್, 2 ನೋಡ್ ತೋರುತ್ತಿರುವಂತೆ ಇದೆ ಮತ್ತು, ಮತ್ತೆ, ನಾವು, ಲೂಪ್ ಈ ಪುನರಾವರ್ತಿಸಲು ನಾವು ಕೊನೆಯ ನೋಡ್ ಕಂಡುಬಂದರೆ ತನಕ, ಅಂದರೆ, ಅಲ್ಲಿ ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಶೂನ್ಯ ತೋರುತ್ತಿರುವಂತೆ ಇದೆ. ಮತ್ತು ನಾವು, ಅದರ ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಕೊನೆಯ ನೋಡ್ ಕಂಡುಬಂದರೆ, ಮತ್ತು ಅದರ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸಲು, ನಾವು ಕ್ರಾಲರ್ → Val ಬಳಸಿ. 

ಗ್ಯಾಲರಿ ಆದ್ದರಿಂದ ಕೆಟ್ಟ, ಆದರೆ ಏನು ಅಳವಡಿಸುವುದರ ಬಗ್ಗೆ? ಅನುಮತಿಸುತ್ತದೆ ನಾವು 4 ನೇ ಸ್ಥಾನಕ್ಕೆ ಒಂದು ಪೂರ್ಣಾಂಕ ಸೇರಿಸಲು ಬಯಸುವ ಹೇಳುತ್ತಾರೆ ಒಂದು ಪೂರ್ಣಾಂಕ ಪಟ್ಟಿಯಲ್ಲಿ. ಪ್ರಸ್ತುತ 3 ನೇ ಮತ್ತು 4 ನೇ ಘಟಕಗಳು ನಡುವೆ. ಮತ್ತೆ, ನಾವು ಪಟ್ಟಿಯನ್ನು ಹಾದುಹೋಗಬೇಕಾದರೆ ಹೊಂದಿವೆ 3 ಅಂಶ, ನಾವು ನಂತರ ತೂರಿಸುವ ನೀವು ಒಂದು ಪಡೆಯಲು. ಆದ್ದರಿಂದ, ನಾವು, ಪಟ್ಟಿ ಹಾದುಹೋಗಬೇಕಾದರೆ ಮತ್ತೆ ಕ್ರಾಲರ್ ಪಾಯಿಂಟರ್ ರಚಿಸಲು ನಮ್ಮ ತಲೆಯ ಪಾಯಿಂಟರ್ ಶೂನ್ಯ ವೇಳೆ, ಪರಿಶೀಲಿಸಿ ಇದು ಅಲ್ಲ ವೇಳೆ ಮತ್ತು, ತಲೆ ನೋಡ್ ನಮ್ಮ ಕ್ರಾಲರ್ ಪಾಯಿಂಟರ್ ಸೂಚಿಸುತ್ತಾರೆ. ಆದ್ದರಿಂದ, ನಾವು 1 ಅಂಶ ನಲ್ಲಿ ಆರ್. ನಾವು ಸೇರಿಸಲು ಮೊದಲು 2 ಹೆಚ್ಚು ಅಂಶಗಳನ್ನು ಮುಂದೆ ಹೋಗಬೇಕಾಗುತ್ತದೆ ಆದ್ದರಿಂದ ನಾವು ಲೂಪ್ ಒಂದು ಬಳಸಬಹುದು ಇಂಟ್ I = 1; ನಾನು <3; ನಾನು + + ಮತ್ತು ಲೂಪ್ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ ರಲ್ಲಿ, 1 ನೋಡ್ ಮುಂದಕ್ಕೆ ನಮ್ಮ ಕ್ರಾಲರ್ ಪಾಯಿಂಟರ್ ಮುನ್ನಡೆ ಪ್ರಸ್ತುತ ನೋಡ್ ಮುಂದಿನ ಕ್ಷೇತ್ರ ಶೂನ್ಯ ವೇಳೆ ಪರಿಶೀಲಿಸುವ ಮೂಲಕ, ಇದು ಅಲ್ಲ ವೇಳೆ ಮತ್ತು ಮುಂದಿನ ನೋಡ್ ನಮ್ಮ ಕ್ರಾಲರ್ ಪಾಯಿಂಟರ್ ಸರಿಸಲು ಪ್ರಸ್ತುತ ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಇದು ಸಮಾನ ಹೊಂದಿಸುವ ಮೂಲಕ. ಆದ್ದರಿಂದ, ನಮ್ಮ ಕಾಲ ಲೂಪ್ ಮಾಡಲು ಹೇಳುತ್ತಾರೆ ರಿಂದ ಎರಡು ಬಾರಿ, ನಾವು, 3 ನೋಡ್ ತಲುಪಿದ್ದೀರಿ ಮತ್ತು ಒಮ್ಮೆ ನಮ್ಮ ಕ್ರಾಲರ್ ಪಾಯಿಂಟರ್ ನಂತರ ನೋಡ್ ತಲುಪಿದೆ ಇದು ನಾವು, ನಮ್ಮ ಹೊಸ ಪೂರ್ಣಾಂಕ ಸೇರಿಸಲು ಬಯಸುವ ಹೇಗೆ ನಾವು ವಾಸ್ತವವಾಗಿ ತೂರಿಸುವ ಮಾಡುತ್ತೀರಾ? 

ಅಲ್ಲದೆ, ನಮ್ಮ ಹೊಸ ಪೂರ್ಣಾಂಕ ಪಟ್ಟಿಯಲ್ಲಿ ಸೇರಿಸಿದ ಮಾಡಬೇಕು ತನ್ನದೇ ನೋಡ್ struct ಭಾಗವಾಗಿ, ಈ ನಿಜವಾಗಿಯೂ ನೋಡ್ ಅನುಕ್ರಮ ಕಾರಣ. ಆದ್ದರಿಂದ, ನ ನೋಡ್ಗೆ ಹೊಸ ಪಾಯಿಂಟರ್ ಮಾಡೋಣ 'new_node,' ಎಂದು ಮತ್ತು ಸೆಟ್ ನಾವು ಈಗ ನಿಯೋಜಿಸಿ ಎಂದು ಮೆಮೊರಿ ತೋರಿಸಲು ನೋಡ್ ಸ್ವತಃ ರಾಶಿ ಮೇಲೆ, ಮತ್ತು ನಾವು ನಿಗದಿಪಡಿಸಬೇಕಾಗುತ್ತದೆ ಎಷ್ಟು ಮೆಮೊರಿ ಬೇಕು? ಅಲ್ಲದೆ, ಒಂದು ನೋಡ್ ಗಾತ್ರವನ್ನು, ಮತ್ತು ನಾವು ಸೇರಿಸಲು ಬಯಸುವ ಪೂರ್ಣಾಂಕ ತನ್ನ Val ಕ್ಷೇತ್ರದಲ್ಲಿ ಹೊಂದಿಸಲು ಬಯಸುವ. ಲೆಟ್ಸ್ 6, ಹೇಳುತ್ತಾರೆ. ಈಗ, ನೋಡ್ ನಮ್ಮ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯ ಹೊಂದಿದೆ. ಹೊಸ ನೋಡ್ ಮುಂದಿನ ಕ್ಷೇತ್ರ ಆರಂಭಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸ ಇಲ್ಲಿದೆ ಶೂನ್ಯ ತೋರಿಸಲು, ಆದರೆ ಈಗ? 

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

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

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

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

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

ಹೆಚ್ಚಿನ ಅಭ್ಯಾಸಕ್ಕೆ, ಗೆ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಲು ಪ್ರಯತ್ನಿಸಿ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಿಂದ ಗ್ರಂಥಿಗಳು ಅಳಿಸಿ - ನೀವು ಜೋಡಣೆಯನ್ನು ಕ್ರಮದಲ್ಲಿ ಎಚ್ಚರದಿಂದ ಮರೆಯದಿರಿ ನಿಮ್ಮ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ಚಂಕ್ ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ ಖಚಿತಪಡಿಸಲು ನಿಮ್ಮ ಮುಂದಿನ ಪಾಯಿಂಟರ್ಸ್ - ಅಥವಾ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ನೋಡ್ ಎಣಿಸಲು ಒಂದು ಕ್ರಿಯೆ, ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ನೋಡ್ಗಳ ಎಲ್ಲಾ ಕ್ರಮವನ್ನು ಬದಲಾಯಿಸುವ ಅಥವಾ ಒಂದು ಮೋಜಿನ ಒಂದು. 

ನನ್ನ ಹೆಸರು ಜಾಕ್ಸನ್ STEINKAMP ಹೊಂದಿದೆ, ಈ CS50 ಹೊಂದಿದೆ.