TList ವರ್ಗವು ವಿಳಾಸ ಜಾಗದಲ್ಲಿರುವ ರಚನೆಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ (ವಸ್ತುಗಳು, ಡೈನಾಮಿಕ್ ಅರೇಗಳು, ವೇರಿಯಬಲ್‌ಗಳು). TstringList ನಂತೆಯೇ, ಪಾಯಿಂಟರ್ ಪಟ್ಟಿಯು ಒದಗಿಸುತ್ತದೆ ಪರಿಣಾಮಕಾರಿ ಕೆಲಸಪಟ್ಟಿ ಅಂಶಗಳೊಂದಿಗೆ.

ಟಿಲಿಸ್ಟ್ ವರ್ಗ

TList ವರ್ಗದ ಕೋರ್ ಪಾಯಿಂಟರ್‌ಗಳ ಪಟ್ಟಿಯಾಗಿದೆ. ಪಟ್ಟಿಯು ಸ್ವತಃ ಸೂಚ್ಯಂಕ ಆಸ್ತಿಯ ಮೂಲಕ ಪ್ರವೇಶಿಸಬಹುದಾದ ಪಾಯಿಂಟರ್‌ಗಳ ಡೈನಾಮಿಕ್ ಶ್ರೇಣಿಯಾಗಿದೆ
ಆಸ್ತಿ ವಸ್ತುಗಳು: ಪಾಯಿಂಟರ್;
ಅಂಶಗಳ ಸಂಖ್ಯೆಯು ಶೂನ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.
ರಚನೆಯ ಅಂಶಗಳಿಗೆ ನೇರ ಪ್ರವೇಶವು ಆಸ್ತಿಯ ಮೂಲಕ ಸಾಧ್ಯ
ರೀತಿಯ
PPointerList = ^TPointerList;
TPointerList = ಪಾಯಿಂಟರ್‌ನ ಶ್ರೇಣಿ;
ಆಸ್ತಿ ಪಟ್ಟಿ: PPointerList;
ಇದು ಓದಲು-ಮಾತ್ರ ಗುಣಲಕ್ಷಣವನ್ನು ಹೊಂದಿದೆ.
ಪಟ್ಟಿಯ ಅಂಶಗಳು ಕೆಲವು ರಚನೆಗಳಿಗೆ ಪಾಯಿಂಟರ್ ಆಗಿರುವುದರಿಂದ, ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಲಾಗುತ್ತಿದೆ ಘಟಕಗಳುವಸ್ತುಗಳ ಮೂಲಕ ಈ ರಚನೆಗಳ ಆಸ್ತಿ ಸಾಧ್ಯವಿಲ್ಲ.

ಇದನ್ನು ಹೇಗೆ ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ.

ಗಮನಿಸಿ
ಪಟ್ಟಿಯು ವೈವಿಧ್ಯಮಯ ರಚನೆಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು. ಪಟ್ಟಿಯಲ್ಲಿರುವ ವಸ್ತುಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳು ಅಥವಾ ದಾಖಲೆಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಮಾತ್ರ ಸಂಗ್ರಹಿಸುವುದು ಅನಿವಾರ್ಯವಲ್ಲ.
TList ವರ್ಗದಲ್ಲಿ ಅಳವಡಿಸಲಾದ ಪಟ್ಟಿ ಕಾರ್ಯಾಚರಣೆಗಳು ಡೆವಲಪರ್‌ನ ಅಗತ್ಯಗಳನ್ನು ಪೂರೈಸುತ್ತವೆ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಪಟ್ಟಿಯ ಕಾರ್ಯಾಚರಣೆಗಳೊಂದಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತವೆ.
ಪಟ್ಟಿಯ ಅಂತ್ಯಕ್ಕೆ ಹೊಸ ಪಾಯಿಂಟರ್ ಅನ್ನು ಸೇರಿಸಲು, ವಿಧಾನವನ್ನು ಬಳಸಿ
ಕಾರ್ಯ ಸೇರಿಸಿ (ಐಟಂ: ಪಾಯಿಂಟರ್): ಪೂರ್ಣಾಂಕ;
ಸೇರಿಸುವ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಇನ್ನೂ ರಚಿಸದಿರುವ ಅಂಶಕ್ಕೆ ನೇರವಾಗಿ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸುವುದು ರನ್-ಟೈಮ್ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ.
ಪಟ್ಟಿಯಲ್ಲಿ ಬಯಸಿದ ಸ್ಥಳಕ್ಕೆ ಹೊಸ ಸೂಚ್ಯಂಕವನ್ನು ಸೇರಿಸಬಹುದು. ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ
ಕಾರ್ಯವಿಧಾನವನ್ನು ಸೇರಿಸು (ಸೂಚ್ಯಂಕ: ಪೂರ್ಣಾಂಕ; ಐಟಂ: ಪಾಯಿಂಟರ್);
ಸೂಚ್ಯಂಕ ನಿಯತಾಂಕವು ಪಟ್ಟಿಯಲ್ಲಿ ಅಗತ್ಯವಿರುವ ಅನುಕ್ರಮ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಅಂಶವನ್ನು ಹೊಸ ಸ್ಥಳಕ್ಕೆ ವರ್ಗಾಯಿಸುವುದು ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ
ಕಾರ್ಯವಿಧಾನ ಮೂವ್ (ಕರ್ಲ್‌ಂಡೆಕ್ಸ್, ನ್ಯೂಲ್‌ಂಡೆಕ್ಸ್: ಪೂರ್ಣಾಂಕ);
CurIndex ನಿಯತಾಂಕವು ಹಳೆಯ ಪಾಯಿಂಟರ್ ಸ್ಥಾನವನ್ನು ಸೂಚಿಸುತ್ತದೆ. NewIndex ನಿಯತಾಂಕವು ಅದರ ಹೊಸ ಸ್ಥಾನವನ್ನು ಸೂಚಿಸುತ್ತದೆ.
Indexl ಮತ್ತು Index2 ನಿಯತಾಂಕಗಳಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಎರಡು ಅಂಶಗಳನ್ನು ನೀವು ವಿನಿಮಯ ಮಾಡಿಕೊಳ್ಳಬಹುದು:
ಕಾರ್ಯವಿಧಾನ ವಿನಿಮಯ (ಇಂಡೆಕ್ಸ್, ಇಂಡೆಕ್ಸ್2: ಪೂರ್ಣಾಂಕ);
ಪಟ್ಟಿಯಿಂದ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಎರಡು ವಿಧಾನಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಸೂಚ್ಯಂಕ ತಿಳಿದಿದ್ದರೆ, ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ
ವಿಧಾನ ಅಳಿಸುವಿಕೆ (ಸೂಚ್ಯಂಕ: ಪೂರ್ಣಾಂಕ);
ಪಾಯಿಂಟರ್ ಸ್ವತಃ ತಿಳಿದಿದ್ದರೆ, ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ
ಈ ವಿಧಾನಗಳು ಪಟ್ಟಿಗೆ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿಯ ಪ್ರಮಾಣವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದಿಲ್ಲ. ಅಗತ್ಯವಿದ್ದರೆ, ಇದನ್ನು ಮಾಡಲು ನೀವು ಸಾಮರ್ಥ್ಯದ ಆಸ್ತಿಯನ್ನು ಬಳಸಬೇಕು. ಪಟ್ಟಿಯ ಪ್ರಸ್ತುತ ಗಾತ್ರವನ್ನು ಅವಲಂಬಿಸಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿಯನ್ನು ಹೆಚ್ಚಿಸುವ ವಿಸ್ತರಣೆ ವಿಧಾನವೂ ಇದೆ.
ಕಾರ್ಯವನ್ನು ವಿಸ್ತರಿಸಿ: TList;
ವಿಧಾನವು ಕಾರ್ಯನಿರ್ವಹಿಸಲು, ಎಣಿಕೆ = ಸಾಮರ್ಥ್ಯದ ಅಗತ್ಯವಿದೆ.
ವಿಧಾನ
ಕಾರ್ಯವಿಧಾನ ಸ್ಪಷ್ಟ; ಕ್ರಿಯಾತ್ಮಕ;
ಎಲ್ಲಾ ಪಟ್ಟಿ ಅಂಶಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ತೆಗೆದುಹಾಕಲು ಬಳಸಲಾಗುತ್ತದೆ. ಪಾಯಿಂಟರ್ ಅನ್ನು ಅದರ ಮೌಲ್ಯದಿಂದ ಹುಡುಕಲು, ವಿಧಾನವನ್ನು ಬಳಸಿ
ಫಂಕ್ಷನ್ ಇಂಡೆಕ್ಸ್ಆಫ್(ಐಟಂ: ಪಾಯಿಂಟರ್): ಪೂರ್ಣಾಂಕ;
ವಿಧಾನವು ಪಟ್ಟಿಯಲ್ಲಿ ಕಂಡುಬರುವ ಅಂಶದ ಸೂಚಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಹುಡುಕಾಟವು ವಿಫಲವಾದರೆ, ಅದು ಹಿಂತಿರುಗುತ್ತದೆ - 1.
ಪಟ್ಟಿ ಅಂಶಗಳನ್ನು ವಿಂಗಡಿಸಲು, ವಿಧಾನವನ್ನು ಬಳಸಿ

ವಿಧಾನ ವಿಂಗಡಣೆ (ಹೋಲಿಸಿ: TListSortCompare);
ಪಟ್ಟಿಯ ಅಂಶ ಬಿಂದುಗಳ ರಚನೆಯ ಸಂಯೋಜನೆಯನ್ನು ಮುಂಚಿತವಾಗಿ ಸಾಮಾನ್ಯೀಕರಿಸಲಾಗುವುದಿಲ್ಲವಾದ್ದರಿಂದ, ವಿಂಗಡಣೆಯನ್ನು ನಿರ್ವಹಿಸುವ ಕಾರ್ಯವಿಧಾನದ ಅಭಿವೃದ್ಧಿಯನ್ನು ಪ್ರೋಗ್ರಾಮರ್ಗೆ ವಹಿಸಿಕೊಡಲಾಗುತ್ತದೆ. ವಿಂಗಡಣೆ ವಿಧಾನವು ಪ್ರೋಗ್ರಾಮರ್ ರಚಿಸಿದ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಆಧರಿಸಿ ಪಾಯಿಂಟರ್‌ಗಳ ಜೋಡಿಯಾಗಿ ಹೋಲಿಕೆಯನ್ನು ಮಾತ್ರ ಒದಗಿಸುತ್ತದೆ (ವಿಂಗಡಣೆಯ ಉದಾಹರಣೆಗಾಗಿ, ಮೇಲಿನ "TStringList ಕ್ಲಾಸ್" ವಿಭಾಗದಲ್ಲಿ ನೋಡಿ).
TList ವರ್ಗದ ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಕೋಷ್ಟಕದಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ. 7.2
ಕೋಷ್ಟಕ 7.2. TList ವರ್ಗದ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳು
ಘೋಷಣೆ

ವಿವರಣೆ
ಆಸ್ತಿ ಸಾಮರ್ಥ್ಯ: ಪೂರ್ಣಾಂಕ;
ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಲಾದ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ
ಆಸ್ತಿ ಎಣಿಕೆ: ಪೂರ್ಣಾಂಕ;
ಪಟ್ಟಿಯಲ್ಲಿರುವ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಆಸ್ತಿ ವಸ್ತುಗಳು : ಪಾಯಿಂಟರ್;
ಸೂಚಕಗಳ ಪಟ್ಟಿ
ರೀತಿಯ
TPointerList = ಪಾಯಿಂಟರ್‌ನ ಶ್ರೇಣಿ;
PPointerList = ATPointerList; ಆಸ್ತಿ ಪಟ್ಟಿ: PPointerList;
ಡೈನಾಮಿಕ್ ಅರೇಪಾಯಿಂಟರ್ಸ್
ಕಾರ್ಯ ಸೇರಿಸಿ (ಐಟಂ: ಪಾಯಿಂಟರ್): ಪೂರ್ಣಾಂಕ;
ಪಟ್ಟಿಗೆ ಹೊಸ ಪಾಯಿಂಟರ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ
ಕಾರ್ಯವಿಧಾನ ಸ್ಪಷ್ಟ; ಕ್ರಿಯಾತ್ಮಕ;
ಪಟ್ಟಿಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತೆರವುಗೊಳಿಸುತ್ತದೆ
ಕಾರ್ಯವಿಧಾನ ಅಳಿಸುವಿಕೆ (ಸೂಚ್ಯಂಕ: ಪೂರ್ಣಾಂಕ:;
ಸೂಚ್ಯಂಕದೊಂದಿಗೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಅಳಿಸುತ್ತದೆ
ಸೂಚ್ಯಂಕ
ವರ್ಗ ಕಾರ್ಯವಿಧಾನದ ದೋಷ (const Ksg: ಸ್ಟ್ರಿಂಗ್; ಡೇಟಾ: ಪೂರ್ಣಾಂಕ); ವಾಸ್ತವ;
ಅಸಾಧಾರಣವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ
EListError ಪರಿಸ್ಥಿತಿ.
ದೋಷ ಸಂದೇಶವನ್ನು Msg ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಸಂಖ್ಯಾ ಡೇಟಾ ಪ್ಯಾರಾಮೀಟರ್‌ನಿಂದ ರಚಿಸಲಾಗಿದೆ
ಕಾರ್ಯವಿಧಾನ ವಿನಿಮಯ (ಇಂಡೆಕ್ಸ್, ಇಂಡೆಕ್ಸ್2: ಪೂರ್ಣಾಂಕ);
Indexl ಮತ್ತು Index2 ನೊಂದಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ
ಕಾರ್ಯವನ್ನು ವಿಸ್ತರಿಸಿ: TList;
ಪಟ್ಟಿಗಾಗಿ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿಯ ಗಾತ್ರವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ
ಮೊದಲ ಕಾರ್ಯ: ಪಾಯಿಂಟರ್;
ಪಟ್ಟಿಯಿಂದ ಮೊದಲ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಫಂಕ್ಷನ್ ಇಂಡೆಕ್ಸ್ಆಫ್(ಐಟಂ: ಪಾಯಿಂಟರ್): ಪೂರ್ಣಾಂಕ;
ಪಾಯಿಂಟರ್‌ನ ಸೂಚಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ನಿಯತಾಂಕದಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆಐಟಂ
ಕಾರ್ಯವಿಧಾನವನ್ನು ಸೇರಿಸಿ (ಸೂಚ್ಯಂಕ: ಪೂರ್ಣಾಂಕ; ಐಟಂ: ಪಾಯಿಂಟರ್) ;
ಒಳಸೇರಿಸುತ್ತದೆ ಹೊಸ ಅಂಶಐಟಂಗಳ ಸ್ಥಾನ ಸೂಚ್ಯಂಕ
ಕಾರ್ಯ ಕೊನೆಯದು: ಪಾಯಿಂಟರ್;
ಪಟ್ಟಿಯಲ್ಲಿರುವ ಕೊನೆಯ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಕಾರ್ಯವಿಧಾನ ಮೂವ್ (ಕರ್ಲ್‌ಂಡೆಕ್ಸ್, ನ್ಯೂಲ್‌ಂಡೆಕ್ಸ್: ಪೂರ್ಣಾಂಕ);
ಪಟ್ಟಿ ಐಟಂ ಅನ್ನು ಹೊಸ ಸ್ಥಳಕ್ಕೆ ಸರಿಸುತ್ತದೆ
ಕಾರ್ಯವಿಧಾನದ ಪ್ಯಾಕ್;
ಪಟ್ಟಿಯಿಂದ ಎಲ್ಲಾ ಶೂನ್ಯ (ನಿಲ್) ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ
ಫಂಕ್ಷನ್ ರಿಮೂವ್ (ಐಟಂ: ಪಾಯಿಂಟರ್): ಪೂರ್ಣಾಂಕ;
ಪಟ್ಟಿಯಿಂದ ಪಾಯಿಂಟರ್ ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ
ಐಟಂ
ಟೈಪ್ TListSortCompare = ಫಂಕ್ಷನ್ (ಐಟಂ, ಐಟಂ 2: ಪಾಯಿಂಟರ್): ಪೂರ್ಣಾಂಕ;
ವಿಧಾನ ವಿಂಗಡಣೆ (ಹೋಲಿಸಿ: TListSortCompare);
ಪಟ್ಟಿ ಐಟಂಗಳನ್ನು ವಿಂಗಡಿಸುತ್ತದೆ

ಪಾಯಿಂಟರ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಬಳಸುವ ಉದಾಹರಣೆ

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

ಬಿಂದುಗಳ ಪಟ್ಟಿಯನ್ನು X ನಿರ್ದೇಶಾಂಕದಿಂದ ಆರೋಹಣ ಕ್ರಮದಲ್ಲಿ ವಿಂಗಡಿಸಬಹುದು.

ಪಟ್ಟಿ ಮಾಡುವುದು. ಡೆಮೊಲಿಸ್ಟ್ ಯೋಜನೆಯ ಮುಖ್ಯ ರೂಪದ ಮಾಡ್ಯೂಲ್
ಘಟಕ ಮುಖ್ಯ;
ಇಂಟರ್ಫೇಸ್
ಬಳಸುತ್ತದೆ
ವಿಂಡೋಸ್, ಸಂದೇಶಗಳು, SysUtils, ತರಗತಿಗಳು, ಗ್ರಾಫಿಕ್ಸ್, ನಿಯಂತ್ರಣಗಳು, ಫಾರ್ಮ್‌ಗಳು,
ರೀತಿಯ
ಸಂವಾದಗಳು, StdCtrls, ಗುಂಡಿಗಳು;
TMMainForm = ವರ್ಗ (TForm)
ListBtn: TBitBtn;
ClearBtn: TBitBtn;
DelBtn: TBitBtn;
SortBtn: TBitBtn;
ಕಾರ್ಯವಿಧಾನ ಫಾರ್ಮ್‌ಕ್ರಿಯೇಟ್ (ಕಳುಹಿಸುವವರು: TObject);
ಕಾರ್ಯವಿಧಾನ ಫಾರ್ಮ್‌ಕ್ಲೋಸ್ (ಕಳುಹಿಸುವವರು: TObject; var ಕ್ರಿಯೆ: TCLoseAction);

ವಿಧಾನ FormMouseDown(ಕಳುಹಿಸುವವರು: TObject; ಬಟನ್: TMousButton;
ಕಾರ್ಯವಿಧಾನ ListBtnClick (ಕಳುಹಿಸುವವರು: TObject);
ಕಾರ್ಯವಿಧಾನ ClearBtnClick (ಕಳುಹಿಸುವವರು: TObject);
ವಿಧಾನ DelBtnClick (ಕಳುಹಿಸುವವರು: TObject);
ವಿಧಾನ SortBtnClick (ಕಳುಹಿಸುವವರು: TObject);
ಖಾಸಗಿ
PixList: TList;
PixNum: ಪೂರ್ಣಾಂಕ; ಸಾರ್ವಜನಿಕ
(ಸಾರ್ವಜನಿಕ ಘೋಷಣೆಗಳು)
ಅಂತ್ಯ;
TMyPixel = ವರ್ಗ(TObject)
fx:ಪೂರ್ಣಾಂಕ;
FY: ಪೂರ್ಣಾಂಕ;
FText: ಪೂರ್ಣಾಂಕ;
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ರಚಿಸಿ(X, Y, ಸಂಖ್ಯೆ: ಪೂರ್ಣಾಂಕ);
(ಸಾರ್ವಜನಿಕ ಘೋಷಣೆಗಳು)
ವಿಧಾನ SetPixel;
var
ಮುಖ್ಯ ರೂಪ: ಟಿಮೇನ್ಫಾರ್ಮ್;
ಅನುಷ್ಠಾನ
($R *.DFM)
const PixColor = clRed;
var CurPixel: TMyPixel;
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ TMyPixel.Create(X, Y, Num: Integer);
ಆರಂಭಿಸಲು
ಆನುವಂಶಿಕವಾಗಿ ರಚಿಸಿ;
ಎಫ್ಎಕ್ಸ್: = ಎಕ್ಸ್;
FY:= Y;
FText:= ಸಂಖ್ಯೆ;
(ಸಾರ್ವಜನಿಕ ಘೋಷಣೆಗಳು)
ಸೆಟ್ಪಿಕ್ಸೆಲ್;
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ TMyPixel.Create(X, Y, Num: Integer);
ವಿಧಾನ TMyPixel.SetPixel;
MainForm.Canvas.PolyLine();
(ಸಾರ್ವಜನಿಕ ಘೋಷಣೆಗಳು)
MainForm.Canvas.TextOut(FX +1, FY + 1, IntToStr(FText));
ಕಾರ್ಯ PixCompare(ಐಟಂ, ಐಟಂ2: ಪಾಯಿಂಟರ್): ಪೂರ್ಣಾಂಕ;
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ TMyPixel.Create(X, Y, Num: Integer);
var Pixl, Pix2: TMyPixel;
Pixl:= ಐಟಂ;
Pix2:= ಐಟಂ2;
(ಸಾರ್ವಜನಿಕ ಘೋಷಣೆಗಳು)
ಫಲಿತಾಂಶ:= Pixl.FX - Pix2.FX;
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ TMyPixel.Create(X, Y, Num: Integer);
ಕಾರ್ಯವಿಧಾನ TMainForm.FormCreate(ಕಳುಹಿಸುವವರು: TObject);
PixList:= TList.Create;
PixNum:= 1; (ಪಾಯಿಂಟ್ ಕೌಂಟರ್)
Canvas.Pen.Color:= PixColor; (ಡಾಟ್ ಬಣ್ಣ)
Canvas.Pen.Width:= 3; (ಡಾಟ್ ಗಾತ್ರ)
(ಸಾರ್ವಜನಿಕ ಘೋಷಣೆಗಳು)
Canvas.Brush.Color:= ಬಣ್ಣ; (ಪಠ್ಯದ ಹಿನ್ನೆಲೆ ಬಣ್ಣವು ಫಾರ್ಮ್ ಬಣ್ಣಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ)
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ TMyPixel.Create(X, Y, Num: Integer);
ಕಾರ್ಯವಿಧಾನ TMainForm.FormClose(ಕಳುಹಿಸುವವರು: TObject; var ಕ್ರಿಯೆ: TCLoseAction);
(ಸಾರ್ವಜನಿಕ ಘೋಷಣೆಗಳು)
PixList.Free;
ಶಿಫ್ಟ್: ಟಿಶಿಫ್ಟ್ ಸ್ಟೇಟ್; X, Y: ಪೂರ್ಣಾಂಕ);
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ TMyPixel.Create(X, Y, Num: Integer);
PixList.Add(TMyPixel.Create(X, Y, PixNum));
Inc (PixNum);
(ಸಾರ್ವಜನಿಕ ಘೋಷಣೆಗಳು)
ಕಾರ್ಯವಿಧಾನ TMainForm.ListBtnClick(ಕಳುಹಿಸುವವರು: TObject);
var i: ಪೂರ್ಣಾಂಕ;
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ TMyPixel.Create(X, Y, Num: Integer);
PixList ನೊಂದಿಗೆ
i:= 0 ಗೆ ಎಣಿಕೆ - 1 do
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ TMyPixel.Create(X, Y, Num: Integer);
CurPixel:= ಐಟಂಗಳು[i]; CurPixel.SetPixel;
ಅಂತ್ಯ; ಅಂತ್ಯ;
ಕಾರ್ಯವಿಧಾನ TMainForm.ClearBtnClick(ಕಳುಹಿಸುವವರು: TObject);
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ TMyPixel.Create(X, Y, Num: Integer);
Canvas.FillRect(ರೆಕ್ಟ್(0, 0, ಅಗಲ, ಎತ್ತರ));
(ಸಾರ್ವಜನಿಕ ಘೋಷಣೆಗಳು)
ಕಾರ್ಯವಿಧಾನ TMainForm.DelBtnClick(ಕಳುಹಿಸುವವರು: TObject);
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ TMyPixel.Create(X, Y, Num: Integer);
PixList.Clear;
PixNum:= 1;
(ಸಾರ್ವಜನಿಕ ಘೋಷಣೆಗಳು)
ಕಾರ್ಯವಿಧಾನ TMainForm.SortBtnClick(ಕಳುಹಿಸುವವರು: TObject);
var i: ಪೂರ್ಣಾಂಕ;
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ TMyPixel.Create(X, Y, Num: Integer);
PixList.Sort(PixCompare);
PixList ನೊಂದಿಗೆ
i:= 0 ರಿಂದ ಎಣಿಕೆಗೆ - 1 ಮಾಡಲು TMyPixel(ಐಟಂಗಳು[i]).FText:= i + 1;
(ಸಾರ್ವಜನಿಕ ಘೋಷಣೆಗಳು)
ಅಂತ್ಯ.
TMyPixel ವರ್ಗವು ಸರಣಿಯಲ್ಲಿ ಒಂದು ಬಿಂದು ಮತ್ತು ಅದರ ಸರಣಿ ಸಂಖ್ಯೆಯ ನಿರ್ದೇಶಾಂಕಗಳ ಸಂಗ್ರಹವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ನಿಯತಾಂಕಗಳನ್ನು ವರ್ಗ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ ರವಾನಿಸಲಾಗುತ್ತದೆ. ಸೆಟ್‌ಪಿಕ್ಸೆಲ್ ವಿಧಾನವು ಫಾರ್ಮ್ ಔಟ್‌ಲೈನ್‌ನಲ್ಲಿ ಒಂದು ಬಿಂದುವನ್ನು ಎಳೆಯಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಪ್ರತಿಯೊಂದಕ್ಕೂ ವರ್ಗದ ನಿದರ್ಶನವನ್ನು ರಚಿಸಲಾಗಿದೆ ಹೊಸ ಪಾಯಿಂಟ್ FormMouseDown ಹ್ಯಾಂಡ್ಲರ್ ವಿಧಾನದಲ್ಲಿ ಮೌಸ್ ಬಟನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ. ಇಲ್ಲಿ ಒಂದು ಪಾಯಿಂಟರ್ ಇದೆ ಹೊಸ ವಸ್ತುಸೇರಿಸುವ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ರಚಿಸಲಾದ PixList ಪಟ್ಟಿ ಅಂಶದಲ್ಲಿ ಉಳಿಸಲಾಗಿದೆ.
ಹೀಗಾಗಿ, ಪ್ರೋಗ್ರಾಂ ಬಿಂದುಗಳ ಸ್ಥಳ ಮತ್ತು ಕ್ರಮವನ್ನು "ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತದೆ".
ListBtnClick ಹ್ಯಾಂಡ್ಲರ್ ವಿಧಾನವು ಅಂಕಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ಲೂಪ್‌ನಲ್ಲಿ, ಪ್ರಸ್ತುತ ಪಟ್ಟಿ ಪಾಯಿಂಟರ್ ಅನ್ನು ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಕಾರದ ಕರ್ಪಿಕ್ಸೆಲ್‌ನ ವೇರಿಯೇಬಲ್‌ಗೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ, ಈ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಎಲ್ಲಾ ರಚಿಸಿದ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಂದ "ಭೇಟಿ" ಮಾಡಲಾಗುತ್ತದೆ, ಪಟ್ಟಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಪಾಯಿಂಟರ್‌ಗಳು.
ವಸ್ತುಗಳ ಗುಣಲಕ್ಷಣಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಪಡೆಯುವ ಸಲುವಾಗಿ ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ (ಇದನ್ನು ನೇರವಾಗಿ ಪಾಯಿಂಟರ್ ಮೂಲಕ ಮಾಡಲಾಗುವುದಿಲ್ಲ). ಎರಡನೇ ವಿಧದ ಎರಕದ ವಿಧಾನವನ್ನು SortBtnClick ಹ್ಯಾಂಡ್ಲರ್ ವಿಧಾನದಲ್ಲಿ ಚರ್ಚಿಸಲಾಗಿದೆ.
ಅಂಕಗಳನ್ನು ಮತ್ತೊಮ್ಮೆ ಪ್ರದರ್ಶಿಸುವ ಮೊದಲು, ಫಾರ್ಮ್ನ ಮೇಲ್ಮೈಯನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಬೇಕು.
ಈ ಕಾರ್ಯಾಚರಣೆಯನ್ನು clearBtnClick ಹ್ಯಾಂಡ್ಲರ್ ವಿಧಾನದಿಂದ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ. ಬಿಂದುಗಳ ಪಟ್ಟಿಯನ್ನು X ನಿರ್ದೇಶಾಂಕದಿಂದ ಆರೋಹಣ ಕ್ರಮದಲ್ಲಿ ವಿಂಗಡಿಸಬಹುದು.ಇದನ್ನು ಮಾಡಲು, PixList ನ ವಿಂಗಡಣೆ ವಿಧಾನವನ್ನು SortBtnClick ಹ್ಯಾಂಡ್ಲರ್ ವಿಧಾನದಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ. ವಿಧಾನ ಪ್ಯಾರಾಮೀಟರ್ (ಕಾರ್ಯವಿಧಾನದ ಪ್ರಕಾರದ ವೇರಿಯೇಬಲ್) PixCompare ಕಾರ್ಯವನ್ನು ಹಾದುಹೋಗುತ್ತದೆ, ಇದು ಎರಡು ಪಕ್ಕದ ಅಂಶಗಳ ಪ್ರಾಶಸ್ತ್ಯವನ್ನು ನಿರ್ಧರಿಸಲು ಅಲ್ಗಾರಿದಮ್‌ನೊಂದಿಗೆ ಪಟ್ಟಿ ಅಂಶಗಳನ್ನು ಎಣಿಸಲು ವಿಂಗಡಣೆ ವಿಧಾನದಲ್ಲಿ ಸುತ್ತುವರಿದ ಕಾರ್ಯವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಕಾರ್ಯವು ಹಿಂತಿರುಗಿದರೆಧನಾತ್ಮಕ ಸಂಖ್ಯೆ
ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಎರಡು ಬಿಂದುಗಳ X ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಹೋಲಿಸಲಾಗಿದೆ. ಈ ಆರೋಹಣ ವಿಂಗಡಣೆಯ ಪರಿಣಾಮವಾಗಿ, ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಜೋಡಿಸಲಾಗಿದೆ ಆದ್ದರಿಂದ ಪಟ್ಟಿಯ ಮೊದಲ ಅಂಶವು ಕನಿಷ್ಠ X ನಿರ್ದೇಶಾಂಕದೊಂದಿಗೆ ವಸ್ತುವನ್ನು ಸೂಚಿಸುತ್ತದೆ ಮತ್ತು ಕೊನೆಯ ಅಂಶವು ಗರಿಷ್ಠ X ನಿರ್ದೇಶಾಂಕದೊಂದಿಗೆ ವಸ್ತುವನ್ನು ಸೂಚಿಸುತ್ತದೆ.
ವಿಂಗಡಿಸಿದ ನಂತರ, ಎಲ್ಲಾ ಅಂಕಗಳನ್ನು ಮರು-ಸಂಖ್ಯೆ ಮಾಡುವುದು ಮಾತ್ರ ಉಳಿದಿದೆ. ಇದು SortBtnclick ಹ್ಯಾಂಡ್ಲರ್ ವಿಧಾನದಲ್ಲಿ ಲೂಪ್ ಮಾಡುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಬಳಸಿದ ಎರಕದ ಪ್ರಕಾರವನ್ನು ಗಮನಿಸಿ, ಇದು TMypixel ವರ್ಗದ ನಿದರ್ಶನಗಳ ಗುಣಲಕ್ಷಣಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಒದಗಿಸುತ್ತದೆ.
DeiBtnClick ಹ್ಯಾಂಡ್ಲರ್ ವಿಧಾನವು ಒದಗಿಸುತ್ತದೆ ಸಂಪೂರ್ಣ ಶುಚಿಗೊಳಿಸುವಿಕೆಪಟ್ಟಿ pixList.

ಪರಿಚಯ

1. ADT ಯ ವ್ಯಾಖ್ಯಾನ

2. ಸಾಮಾನ್ಯ ನಿಬಂಧನೆಗಳು

3. ಕಾರ್ಯಾಚರಣೆಗಳ ವಿವರಣೆ

3.1 ಅಂಶ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಸೇರಿಸಿ

3.2 ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ನಂತರ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸುವ ಕಾರ್ಯಾಚರಣೆ

3.3 ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಅಳಿಸಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಅಂಶ

3.4 ಪಟ್ಟಿ ಪ್ರವೇಶ ಮುದ್ರಣ ಕಾರ್ಯಾಚರಣೆ

4. ADT-ಪಟ್ಟಿಯ ಅನುಷ್ಠಾನ

4.1 ಮುಖ್ಯ ಕಾರ್ಯ

4.2 ಇಂಟರ್ಫೇಸ್

4.3 ವಿಧಾನಗಳ ಅನುಷ್ಠಾನ

ತೀರ್ಮಾನ

ಉಲ್ಲೇಖಗಳು

ಅನುಬಂಧ A: ಅಲ್ಗಾರಿದಮ್ ಗ್ರಾಫ್‌ಗಳು

ಪರಿಚಯ

ಸಮಸ್ಯೆಯ ಪ್ರಕಾರವನ್ನು ಪರಿಹರಿಸಲಾಗಿದ್ದರೂ, ಯಾವುದೇ ಪ್ರೋಗ್ರಾಂ ಕೆಲವು ರೀತಿಯ ಡೇಟಾದ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಸ್ವತಃ ಈ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುವ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ವಿಧಾನಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಪ್ರೋಗ್ರಾಂ ನೀಡಿದ ಕಾರ್ಯವನ್ನು ಪೂರ್ಣಗೊಳಿಸುವ ವೇಗವು ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಬಳಸುವ ಅಲ್ಗಾರಿದಮ್‌ಗಳ ಮೇಲೆ ಮಾತ್ರವಲ್ಲದೆ ಡೇಟಾದ ಸಂಘಟನೆಯ ಮೇಲೂ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ. ಹೀಗಾಗಿ, ನಾವು ಡೇಟಾ ರಚನೆಗಳ ಪರಿಕಲ್ಪನೆಗೆ ಬರುತ್ತೇವೆ.

ಬಳಕೆದಾರರು ಮತ್ತು ಡೇಟಾ ರಚನೆಗಳ ಮೂಲಕ ಪ್ರೋಗ್ರಾಂ ನಡುವಿನ ನೇರ ಸಂವಹನವು ಬಹಳಷ್ಟು ಡೇಟಾವನ್ನು ತೆರೆಯುತ್ತದೆ, ಅದರ ಮಾರ್ಪಾಡು ಕಾನೂನುಬಾಹಿರ ರೀತಿಯಲ್ಲಿ (ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಬೈಪಾಸ್ ಮಾಡುವುದು) ಅನಪೇಕ್ಷಿತ ಪರಿಣಾಮಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಹಿಂದೆ ಬರಲು ಈ ಸಮಸ್ಯೆಡೇಟಾ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ನಡುವೆ "ಗೋಡೆಗಳನ್ನು ನಿರ್ಮಿಸಲು" ಅವಶ್ಯಕವಾಗಿದೆ, ಇಂಟರ್ಫೇಸ್ ರೂಪದಲ್ಲಿ "ವಿಂಡೋ" ಅನ್ನು ಮಾತ್ರ ಬಿಟ್ಟುಬಿಡುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ಈ ಗೋಡೆಗಳನ್ನು ನಿರ್ಮಿಸುವ ಅಮೂರ್ತ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಅವಶ್ಯಕ.

ಈ ಕೆಲಸದಲ್ಲಿ, ಅಮೂರ್ತ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು (ಎಡಿಟಿ) ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ - ಪಟ್ಟಿಯನ್ನು ತರುವಾಯ ಲಿಂಕ್ ಪಟ್ಟಿಯಾಗಿ ಅಳವಡಿಸಲಾಗಿದೆ, ಪಾಯಿಂಟರ್-ಆಧಾರಿತ ಪರೋಕ್ಷವನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ADT ಯ ಅಭಿವೃದ್ಧಿಯನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ಚರ್ಚಿಸಲಾಗಿದೆ.

1. ADT ಯ ವ್ಯಾಖ್ಯಾನ

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

1. ಚಿಪ್‌ನ ಹೆಸರು

2. ವೆಚ್ಚ

3. ಪ್ರಮಾಣ

ಕೆಳಗಿನ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅವುಗಳ ಮೇಲೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ:

1.ಆರ್ಡರ್ ಮಾಡದ ಪಟ್ಟಿಗೆ ಅಂಶವನ್ನು ಸೇರಿಸುವುದು

2.ಆರ್ಡರ್ ಮಾಡದ ಪಟ್ಟಿಯಿಂದ ನಿರ್ದಿಷ್ಟ ಕ್ಷೇತ್ರದೊಂದಿಗೆ ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕುವುದು

3. ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ನಂತರ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸುವುದು

4. ನಿರ್ದಿಷ್ಟ ಕ್ಷೇತ್ರದೊಂದಿಗೆ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಅಳಿಸುವುದು

5.ಪಟ್ಟಿಯನ್ನು ಮುದ್ರಿಸಿ

ಈ ಸೆಟ್ಕಾರ್ಯದಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಡೇಟಾದ ಮೇಲೆ ಅನುಮತಿಸುವ ಕಾರ್ಯಾಚರಣೆಗಳ ಗುಂಪನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಅಂದರೆ. ನಮಗೆ ಅಮೂರ್ತ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ನೀಡಲಾಗಿದೆ.

2. ಸಾಮಾನ್ಯ ನಿಬಂಧನೆಗಳು

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

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

ಅಂಶ ವರ್ಗಾವಣೆಯನ್ನು ಬಳಸದ ಪಟ್ಟಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ತತ್ವವು ಪರೋಕ್ಷ ವಿಳಾಸವನ್ನು ಆಧರಿಸಿದೆ. ಅಮೂರ್ತ ಪಟ್ಟಿಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇತರ ಮಾರ್ಗಗಳನ್ನು ವಿವರವಾಗಿ ವಿವರಿಸಲಾಗಿದೆ.

ಪ್ರತಿ ನೋಡ್ ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿಎರಡು ಭಾಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ: ಡೇಟಾ ಸ್ವತಃ ಮತ್ತು ಮುಂದಿನ ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್ - ಅದೇ ನೋಡ್ ಅಥವಾ NULL ಸ್ಥಿರ.

ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್ ತತ್ವದ ಪ್ರಕಾರ, ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ವಿಧಾನಗಳ ಮೂಲಕ ಮಾತ್ರ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಬೇಕು, ಡೇಟಾಗೆ ಖಾಸಗಿ ಪ್ರವೇಶ ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ.

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

ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ತತ್ವಗಳ ಬಗ್ಗೆ ನೀವು ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಬಹುದು.

ಪಟ್ಟಿಯ ತಲೆ ಮತ್ತು ಬಾಲಕ್ಕೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಪಟ್ಟಿ ವರ್ಗದಲ್ಲಿ ಘೋಷಿಸಲಾಗಿದೆ ಏಕೆಂದರೆ ಅವುಗಳು ADT ವಿಧಾನಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮೂಲಭೂತವಾಗಿ ಅವಶ್ಯಕವಾಗಿವೆ, ಆದರೆ ಡೇಟಾ ರಚನೆಗೆ ಅವು ಸ್ವಲ್ಪ ಅರ್ಥವನ್ನು ನೀಡುವುದಿಲ್ಲ.

ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಡೇಟಾವನ್ನು ಮಾರ್ಪಡಿಸದ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಘೋಷಿಸಲಾಗಿದೆ ಕೀವರ್ಡ್ಸ್ಥಿರ

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

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

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

ಪವರ್ (ಪ್ರೊಸೆಸರ್ಗಳನ್ನು ಬದಲಿಸಿ), ಸಾಮರ್ಥ್ಯವನ್ನು ವಿಸ್ತರಿಸಿ RAM, ಸೇರಿಸಿ ಬಾಹ್ಯ ಸಾಧನಗಳು. ಯಂತ್ರಗಳು ದೊಡ್ಡ ಸೂಚನಾ ಸೆಟ್‌ಗಳನ್ನು ಹೊಂದಿವೆ, ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ವ್ಯವಸ್ಥೆಯನ್ನು ಹೊಂದಿವೆ ತಂತ್ರಾಂಶ, ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಿಗೆ ಅನುವಾದಕರು ಸೇರಿದಂತೆ ಅಸೆಂಬ್ಲಿ, ಫೋರ್ಟ್ರಾನ್, PL/1, COBOL, ALGOL, PASCAL, ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳುವಿಭಿನ್ನ ಕ್ರಿಯಾತ್ಮಕತೆಯೊಂದಿಗೆ. ಕಂಟ್ರೋಲ್ ಕಂಪ್ಯೂಟರ್‌ಗಳ ಮುಖ್ಯ ಲಕ್ಷಣ...

ಪಟ್ಟಿ ಸಂಗ್ರಹವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಕ್ರಿಯಾತ್ಮಕ ವಸ್ತುಗಳುಅದೇ ರೀತಿಯ, ಲಿಂಕ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಆಯೋಜಿಸಲಾಗಿದೆ.

ವಸ್ತುಗಳನ್ನು ಪಟ್ಟಿ ಅಂಶಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಪಟ್ಟಿಯ ಒಂದು ಅಂಶವು ಸಾಮಾನ್ಯವಾಗಿ ನಮೂದಾಗಿದೆ, ಕನಿಷ್ಠ, ಎರಡು ಕ್ಷೇತ್ರಗಳು (ಚಿತ್ರ 2.13):

ಮಾಹಿತಿ;

ಪಾಯಿಂಟರ್.

ಪಟ್ಟಿಯನ್ನು ಸ್ವತಃ ಅಂಜೂರದ ರೂಪದಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ. 2.14.

ಪ್ರತಿಯೊಂದು ಪಟ್ಟಿಯ ಅಂಶವನ್ನು ಹೊಂದಿದೆ ಪಾಯಿಂಟರ್ನೆರೆಯ ಮೇಲೆ. ಕೊನೆಯ ಅಂಶವು ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೊಂದಿದೆ - ಶೂನ್ಯ. ಪಟ್ಟಿಯ ಅಂಶಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಈ ಕೆಳಗಿನಂತೆ ವಿವರಿಸಲಾಗಿದೆ:

ಸೂಚ್ಯಂಕ = ^El_List;(ಮುಂಗಡ ವಿವರಣೆ)

(ಈ ಸಂದರ್ಭದಲ್ಲಿ ಮಾತ್ರ ಅನುಮತಿಸಲಾಗಿದೆ)

ಇ-ಪಟ್ಟಿ = ದಾಖಲೆ

Inf._ ಕ್ಷೇತ್ರ: Field_Info_Type;

ಸೂಚ್ಯಂಕ_ಕ್ಷೇತ್ರ: ಸೂಚ್ಯಂಕ; (ಈ ಪ್ರಕಾರವನ್ನು ಈಗಾಗಲೇ ಮೇಲೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ)

ಮಾಹಿತಿ ಅಂಶದ ಪ್ರಕಾರವು ಯಾವುದಾದರೂ (ಸ್ಕೇಲಾರ್, ಸ್ಟ್ರಿಂಗ್, ಅರೇ, ಇತ್ಯಾದಿ).

ಉದಾಹರಣೆ. ಟಿಹೌದು

Ptr = ^El;

ಎಲ್ = ದಾಖಲೆ

ಬುಕ್: ಚಾರ್;

Ukaz: Ptr;

tUk, PrUk, NUk,q:Ptr;(ಪಟ್ಟಿ ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್‌ಗಳು)

ಎಲ್ಎಸ್ಪಿ : ಎಲ್; (ಪಟ್ಟಿ ಅಂಶ (ದಾಖಲೆ ಪ್ರಕಾರ ಎಲ್) }

ಪಟ್ಟಿಗಳು ಪ್ರಸ್ತುತಪಡಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ ಸಾಲುಗಳು.

ಸರತಿಕಂಪ್ಯೂಟಿಂಗ್‌ನಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುವ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ. ಸರದಿಯಲ್ಲಿ ಅಂಶಗಳನ್ನು ಸೇರಿಸುವ ಮತ್ತು ಅದರಿಂದ ಆಯ್ಕೆ ಮಾಡುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾದರಿ ಮಾಡಲು ಪಟ್ಟಿಯು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಪಟ್ಟಿಗಳಲ್ಲಿ ಮೂಲ ಕಾರ್ಯಾಚರಣೆಗಳು:

1) ಒಂದು ಅಂಶದಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಪರಿವರ್ತನೆ (ಮುಂದೆ);

2) ಪಟ್ಟಿಯಲ್ಲಿ ಹೊಸ ಅಂಶವನ್ನು ಸೇರಿಸುವುದು;

3) ಪಟ್ಟಿಯಿಂದ ಒಂದು ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕುವುದು.

1) ಮೊದಲ ಕಾರ್ಯಾಚರಣೆಯು ಸರಳವಾಗಿದೆ: ಪಾಯಿಂಟರ್ ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವು ಈಗ ನಿರ್ದಿಷ್ಟ ಅಂಶವನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಈ ಅಂಶದ ಪಾಯಿಂಟರ್ ಕ್ಷೇತ್ರದಲ್ಲಿ ಇರುವ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಬೇಕು (ಚಿತ್ರ 2.15 ನೋಡಿ):

tUk := tUk^. ಉಕಾಜ್

IN ಫಲಿತಾಂಶ tUkಮುಂದಿನ ಅಂಶಕ್ಕೆ ಲಿಂಕ್ ಆಗುತ್ತದೆ ಅಥವಾ ಶೂನ್ಯ, ಅಂಶವು ಕೊನೆಯದಾಗಿದ್ದರೆ.

2) ತೆಗೆಯುವಿಕೆಅಂಶಕ್ಕೆ ಲಿಂಕ್ (ಪಾಯಿಂಟರ್) ಇದ್ದಲ್ಲಿ ಪಟ್ಟಿಯಿಂದ ಅಂಶವನ್ನು ಸರಳವಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ, ಹಿಂದಿನ ಅಳಿಸಲು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಲಿಂಕ್‌ಗಳನ್ನು ಮೊದಲು ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ ಅಂಶವನ್ನು ಅಳಿಸಲಾಗುತ್ತದೆ (ಅದು ಆಕ್ರಮಿಸಿಕೊಂಡಿರುವ ಡೈನಾಮಿಕ್ ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸಲಾಗುತ್ತದೆ). ಅಳಿಸಲಾದ ಅಂಶದ ಉಲ್ಲೇಖವು ನಾಶವಾಗುವವರೆಗೆ ಅಥವಾ ಇನ್ನೊಂದು ಪಟ್ಟಿಯಲ್ಲಿ ಸೇರಿಸುವವರೆಗೆ ಕಳೆದುಹೋಗಬಾರದು, ಇಲ್ಲದಿದ್ದರೆ ಅದು "ಕಸ" ಆಗುತ್ತದೆ.

ಲಿಂಕ್ ಮೂಲಕ ಸೂಚಿಸಿದ ಅಂಶದ ನಂತರ ಪಟ್ಟಿಯಲ್ಲಿರುವ ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕುವ ಪ್ರಕ್ರಿಯೆ PrUk, ಅಂಜೂರದಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ. 2.16, ಮತ್ತು ಅನುಗುಣವಾದ ಪ್ರೋಗ್ರಾಂನ ಒಂದು ತುಣುಕು ಕೆಳಗಿನಂತೆ ಕಾಣಿಸಬಹುದು.

{ಅಳಿಸಬೇಕಾದ ಅಂಶದ ಪಾಯಿಂಟರ್ ಅನ್ನು ನೆನಪಿಡಿ)

tUk:= PrUk^.Ukaz;

(ಅಳಿಸಬೇಕಾದ ಅಂಶದ ಹಿಂದಿನ ಅಂಶದ ಪಾಯಿಂಟರ್ ಕ್ಷೇತ್ರವನ್ನು ನಿಯೋಜಿಸಿ)

(ತೆಗೆಯಬೇಕಾದ ಅಂಶದ ಪಾಯಿಂಟರ್ ಕ್ಷೇತ್ರದ ಮೌಲ್ಯ)

PrUk^.Ukaz:= PrUk^.Ukaz^.Ukaz;

ಇದರ ಮೇಲೆ ಅಳಿಸುವಿಕೆಅಂಶ ಪಟ್ಟಿಯಿಂದಮುಗಿದಿದೆ: ಹಿಂದಿನದರೊಂದಿಗೆ ಈ ಅಂಶದ ಸಂಪರ್ಕವು ಮುರಿದುಹೋಗಿದೆ. ಆದರೆ ಅಂಶವು ಮೆಮೊರಿಯನ್ನು ಆಕ್ರಮಿಸಿಕೊಳ್ಳುವುದನ್ನು ಮುಂದುವರೆಸಿದೆ ಮತ್ತು ಅದನ್ನು ಭೌತಿಕವಾಗಿ ಅಳಿಸಲು ನೀವು ಕಾರ್ಯವಿಧಾನವನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ:

ವಿಲೇವಾರಿ (tUk); (ಧಾತುವನ್ನು ಭೌತಿಕವಾಗಿ ತೆಗೆದುಹಾಕಲಾಗಿದೆ)

ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸುವ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ, ಅಳಿಸಿದ ಅಂಶ ಪಾಯಿಂಟರ್ ಕ್ಷೇತ್ರಕ್ಕೆ ಬರೆಯಲು ಇದು ಕೆಲವೊಮ್ಮೆ ಉಪಯುಕ್ತವಾಗಿದೆ ಶೂನ್ಯ:

tUk^.Ukaz:= Nil.

3)ಸಕ್ರಿಯಗೊಳಿಸಲಾಗುತ್ತಿದೆಪಾಯಿಂಟರ್ ಇರುವ ಅಂಶದ ಪಟ್ಟಿಗೆ ಎನ್ಯುಕೆ, ಪಾಯಿಂಟರ್ ಇರುವ ಅಂಶದ ನಂತರ PrUk, ಅಂಜೂರದಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ. 2.17. ಈ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು, ನೀವು ಸೇರಿಸಲಾದ ಅಂಶದಿಂದ ಮುಂದಿನದಕ್ಕೆ ಲಿಂಕ್ ಅನ್ನು ಹೊಂದಿಸಬೇಕಾಗುತ್ತದೆ (ಇದು ಹಿಂದಿನ ಅಂಶದಿಂದ ಮುಂದಿನದಕ್ಕೆ ಲಿಂಕ್‌ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ - ಚಿತ್ರ 2.17, a ನೋಡಿ), ತದನಂತರ ಲಿಂಕ್ ಅನ್ನು ಬದಲಾಯಿಸಿ ಸೇರಿಸಲಾದ ಒಂದಕ್ಕೆ ಹಿಂದಿನ ಅಂಶ (Fig. 2.17, b ನೋಡಿ) . ಅಂಶವನ್ನು ಕಳೆದುಕೊಳ್ಳದಂತೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಸಂಪರ್ಕವು ಕೊನೆಯದಾಗಿ ಮುರಿದುಹೋಗಿದೆ.

ಕಾರ್ಯಕ್ರಮದ ತುಣುಕು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ

ಹೊಸ (NUk);

(ಒಂದು ಸೇರಿಸಲಾದ ಅಂಶವನ್ನು ರಚಿಸಲಾಗಿದೆ)