ಡೈನಾಮಿಕ್ ಡೇಟಾ ರಚನೆಗಳಲ್ಲಿನ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವುದು. ಸುತ್ತೋಲೆ ಏಕ ಲಿಂಕ್ ಪಟ್ಟಿ ಸುತ್ತೋಲೆ ಡಬಲ್ ಲಿಂಕ್ ಪಟ್ಟಿ

ಟಿಪ್ಪಣಿ: ಉಪನ್ಯಾಸವು ವ್ಯಾಖ್ಯಾನಗಳು, ಘೋಷಣೆಯ ವಿಧಾನಗಳು, ಪ್ರಾರಂಭ ಮತ್ತು ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವಾಗ ಸೈಕ್ಲಿಕ್ ಪಟ್ಟಿಗಳು, ಡೆಕ್‌ಗಳು, ಕೆಂಪು-ಕಪ್ಪು ಮರಗಳನ್ನು ಬಳಸುವ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಚರ್ಚಿಸುತ್ತದೆ ಮತ್ತು ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿಗಳು, ಡೆಕ್‌ಗಳು, ಕೆಂಪು-ಕಪ್ಪು ಮರಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವ ಉದಾಹರಣೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಉಪನ್ಯಾಸದ ಉದ್ದೇಶ: ಕೆಲಸ ಮಾಡಲು ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಮತ್ತು ತಂತ್ರಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡಿ ಡೈನಾಮಿಕ್ ಡೇಟಾ ರಚನೆಗಳು, C++ ನಲ್ಲಿ ಅವರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಡೈನಾಮಿಕ್ ಡೇಟಾ ರಚನೆಗಳು ಮತ್ತು ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಕಲಿಯಿರಿ.

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

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

ಆವರ್ತಕ (ರಿಂಗ್) ಪಟ್ಟಿಗಳು

ವೃತ್ತಾಕಾರದ (ರಿಂಗ್) ಪಟ್ಟಿ- ಇದು ಡೇಟಾ ರಚನೆ, ಇದು ಅಂಶಗಳ ಅನುಕ್ರಮವಾಗಿದೆ, ಅದರ ಕೊನೆಯ ಅಂಶವು ಪಟ್ಟಿಯ ಮೊದಲ ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ ಮತ್ತು ಮೊದಲನೆಯದು (ಸಂದರ್ಭದಲ್ಲಿ ದ್ವಿಮುಖಪಟ್ಟಿ) - ಕೊನೆಯದಕ್ಕೆ.

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

ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿಗಳು, ರೇಖೀಯ ಪದಗಳಿಗಿಂತ, ಏಕಮುಖವಾಗಿರಬಹುದು ಮತ್ತು ದ್ವಿಮುಖ.

ರೇಖಾತ್ಮಕ ಏಕಮುಖ ಪಟ್ಟಿಯನ್ನು ಹೋಲುತ್ತದೆ, ಆದರೆ ಅದರ ಕೊನೆಯ ಅಂಶವು ಮೊದಲ ಅಂಶಕ್ಕೆ ಲಿಂಕ್ ಮಾಡುವ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ (ಚಿತ್ರ 32.1).

ಅಂತಹ ಪಟ್ಟಿಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಹಾದುಹೋಗಲು, ಅನಿಯಂತ್ರಿತ ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೊಂದಲು ಸಾಕು, ಮತ್ತು ರೇಖೀಯ ಏಕಮುಖ ಪಟ್ಟಿಯಲ್ಲಿರುವಂತೆ ಮೊದಲನೆಯದಕ್ಕೆ ಅಲ್ಲ. ಇಲ್ಲಿ "ಮೊದಲ" ಅಂಶದ ಪರಿಕಲ್ಪನೆಯು ಸಾಕಷ್ಟು ಅನಿಯಂತ್ರಿತವಾಗಿದೆ ಮತ್ತು ಯಾವಾಗಲೂ ಅಗತ್ಯವಿಲ್ಲ. ಅದರ ಮೇಲೆ ವಿಶೇಷ ಪಾಯಿಂಟರ್ ಅನ್ನು ಇರಿಸುವ ಮೂಲಕ ಕೆಲವು ಅಂಶವನ್ನು "ಮೊದಲ" ಎಂದು ಹೈಲೈಟ್ ಮಾಡಲು ಕೆಲವೊಮ್ಮೆ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಪಟ್ಟಿಯನ್ನು ವೀಕ್ಷಿಸುವಾಗ "ಲೂಪಿಂಗ್" ಅನ್ನು ತಡೆಯಲು ಇದು ಅಗತ್ಯವಿದೆ.

ಅಕ್ಕಿ. 32.1.

ಆವರ್ತಕ ಏಕಮುಖ ಪಟ್ಟಿಯೊಂದಿಗೆ ನಡೆಸಲಾದ ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಗಳು:

• ಪಟ್ಟಿಯನ್ನು ರಚಿಸುವುದು;
• ಪಟ್ಟಿಯನ್ನು ಮುದ್ರಿಸಿ (ವೀಕ್ಷಿಸಿ);
• ಒಂದು ಅಂಶವನ್ನು ಪಟ್ಟಿಗೆ ಸೇರಿಸುವುದು;
• ಒಂದು ಅಂಶವನ್ನು ಅಳಿಸುವುದುಪಟ್ಟಿಯಿಂದ;
• ಪಟ್ಟಿಯಲ್ಲಿರುವ ಅಂಶವನ್ನು ಹುಡುಕಲಾಗುತ್ತಿದೆ;
• ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ;
• ಪಟ್ಟಿಯನ್ನು ಅಳಿಸಲಾಗುತ್ತಿದೆ.

ಈ ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ವಿವರಿಸಲು, ರೇಖಾತ್ಮಕ ಏಕಮುಖ ಪಟ್ಟಿಗಾಗಿ ನಾವು ಅದೇ ಘೋಷಣೆಗಳನ್ನು ಬಳಸುತ್ತೇವೆ.

ಆವರ್ತಕ ಏಕಮುಖ ಪಟ್ಟಿಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಪಟ್ಟಿ ಮಾಡಲಾದ ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಗಳ ಕಾರ್ಯಗಳನ್ನು ನಾವು ಪ್ರಸ್ತುತಪಡಿಸೋಣ.

//ಆವರ್ತಕ ಏಕ ದಿಕ್ಕಿನ ಪಟ್ಟಿಯನ್ನು ಅನೂರ್ಜಿತವಾಗಿ ರಚಿಸುವುದು Make_Circle_Single_List(int n, Circle_Single_List** Head, Circle_Single_List* Loop)( if (n > 0) ((*Head) = ಹೊಸ Circle_Single_List (ಮೆಮೊರಿಗಾಗಿ ಹೊಸ Circle_Single_List(); ಲೂಪ್ = = NULL) ಲೂಪ್ = (*ಹೆಡ್); ಕೌಟ್<< "Введите значение "; cin >> (*ಹೆಡ್)->ಡೇಟಾ; //ಮಾಹಿತಿ ಕ್ಷೇತ್ರದ ಮೌಲ್ಯವನ್ನು ನಮೂದಿಸಿ (*ಹೆಡ್)->ಮುಂದೆ=ಶೂನ್ಯ; //ವಿಳಾಸ ಕ್ಷೇತ್ರವನ್ನು ಶೂನ್ಯಗೊಳಿಸುವುದು Make_Circle_Single_List(n-1,&(*Head)->Next),Loop); ) ಬೇರೆ (*ಹೆಡ್) = ಲೂಪ್; ) // ವೃತ್ತಾಕಾರದ ಏಕಮುಖ ಪಟ್ಟಿಯನ್ನು ಅನೂರ್ಜಿತವಾಗಿ ಮುದ್ರಿಸಿ Print_Circle_Single_List(Circle_Single_List* Head) ( Circle_Single_List* ptr=Head; //Axiliary pointer do ( cout<< ptr->ಡೇಟಾ<< "\t"; ptr=ptr-> << "\n"; } /*вставка элемента после заданного номера в циклический однонаправленный список*/ Circle_Single_List* Insert_Item_Circle_Single_List(Circle_Single_List* Head, int Number, int DataItem){ Circle_Single_List *Current = Head; //встали на первый элемент Circle_Single_List *NewItem = new(Circle_Single_List); //создали новый элемент NewItem->ಡೇಟಾ = DataItem; ಒಂದು ವೇಳೆ (ಹೆಡ್ == NULL) (//ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿದೆ NewItem->ಮುಂದೆ = ಹೊಸ ಐಟಂ; ಹೆಡ್ = ಹೊಸ ಐಟಂ; ) ಬೇರೆ (//ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿಲ್ಲ (int i = 1; i< Number; i++) Current = Current->ಮುಂದೆ; ಹೊಸ ಐಟಂ->ಮುಂದೆ = ಪ್ರಸ್ತುತ->ಮುಂದೆ; ಪ್ರಸ್ತುತ->ಮುಂದೆ = ಹೊಸ ಐಟಂ; ) ತಲೆ ಹಿಂತಿರುಗಿ; ) /*ವೃತ್ತಾಕಾರದ ಏಕಮುಖ ಪಟ್ಟಿಯಿಂದ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಅಂಶವನ್ನು ಅಳಿಸುವುದು*/ Circle_Single_List* Delete_Item_Circle_Single_List (Circle_Single_List* Head, int Number)( if (Head != NULL)( Circle_Single = Head *> ವೇಳೆ< Number; i++) Current = Current->ಮುಂದೆ; Circle_Single_List *ptr = ಹೆಡ್; ಹಾಗೆಯೇ (ptr->ಮುಂದೆ != ಪ್ರಸ್ತುತ) ptr = ptr->ಮುಂದೆ; //ನೇರವಾಗಿ ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕುವುದು ptr->ಮುಂದೆ = ಪ್ರಸ್ತುತ->ಮುಂದೆ; ವೇಳೆ (ಹೆಡ್ = ಕರೆಂಟ್) ಹೆಡ್ = ಕರೆಂಟ್->ಮುಂದೆ; ಅಳಿಸಿ (ಪ್ರಸ್ತುತ); ) else( ಹೆಡ್ = NULL; ಅಳಿಸಿ (ಪ್ರಸ್ತುತ); ) ) ತಲೆ ಹಿಂತಿರುಗಿ; ) //ಆವರ್ತಕ ಒನ್-ವೇ ಪಟ್ಟಿ bool ನಲ್ಲಿ ಅಂಶವನ್ನು ಹುಡುಕಿ Find_Item_Circle_Single_List(Circle_Single_List* Head, int DataItem)( Circle_Single_List *ptr = Head; //ಸಹಾಯಕ ಪಾಯಿಂಟರ್ ಮಾಡಿ (ಡೇಟಾಐಟಂ =Da ptr) ನಿಜವಾಗಿದ್ದರೆ-> ಬೇರೆ ptr = ptr- >ಮುಂದೆ; ) ಹಾಗೆಯೇ (ptr != ತಲೆ); ತಪ್ಪು ಹಿಂತಿರುಗಿ; ) //ವೃತ್ತಾಕಾರದ ಏಕಮುಖ ಪಟ್ಟಿಯ ಬೂಲ್‌ನ ಖಾಲಿತನವನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ Empty_Circle_Single_List(Circle_Single_List* Head)( ಹಿಂತಿರುಗಿ (ಹೆಡ್ != NULL ? ತಪ್ಪು: ನಿಜ); //ವೃತ್ತಾಕಾರದ ಒನ್-ವೇ ಪಟ್ಟಿಯನ್ನು ಅನೂರ್ಜಿತಗೊಳಿಸುವುದು Delete_Circle_Single_List(Circle_Single_List* Head)( if (Head != NULL)( Head = Delete_Item_Circle_Single_List(Head, 1); Delete_Circleist_list_s);

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

ಅಕ್ಕಿ. 32.2.

ಸೈಕ್ಲಿಕ್ನೊಂದಿಗೆ ನಡೆಸಲಾದ ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಗಳು ದ್ವಿಮುಖಪಟ್ಟಿ:

• ಪಟ್ಟಿಯನ್ನು ರಚಿಸುವುದು;
• ಪಟ್ಟಿಯನ್ನು ಮುದ್ರಿಸಿ (ವೀಕ್ಷಿಸಿ);
• ಒಂದು ಅಂಶವನ್ನು ಪಟ್ಟಿಗೆ ಸೇರಿಸುವುದು;
• ಒಂದು ಅಂಶವನ್ನು ಅಳಿಸುವುದುಪಟ್ಟಿಯಿಂದ;
• ಪಟ್ಟಿಯಲ್ಲಿರುವ ಅಂಶವನ್ನು ಹುಡುಕಲಾಗುತ್ತಿದೆ
• ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ;
• ಪಟ್ಟಿಯನ್ನು ಅಳಿಸಲಾಗುತ್ತಿದೆ.

ಈ ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ವಿವರಿಸಲು ನಾವು ರೇಖಾತ್ಮಕವಾಗಿ ಅದೇ ಘೋಷಣೆಗಳನ್ನು ಬಳಸುತ್ತೇವೆ ದ್ವಿಮುಖಪಟ್ಟಿ.

ಸೈಕ್ಲಿಕ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಪಟ್ಟಿ ಮಾಡಲಾದ ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಗಳ ಕಾರ್ಯಗಳನ್ನು ನಾವು ಪ್ರಸ್ತುತಪಡಿಸೋಣ ದ್ವಿಮುಖಪಟ್ಟಿ.

//ಆವರ್ತಕ ದ್ವಿಗುಣ ಪಟ್ಟಿಯನ್ನು ರಚಿಸುವುದು Circle_Double_List* Make_Circle_Double_List(int n, Circle_Double_List** Head, Circle_Double_List* Loop)( Circle_Double_List* ptr;//Auxiliary pointer = (n*Clead) (ಹೊಸದು) (ಲೂಪ್ == NULL) ಲೂಪ್ = (*ಹೆಡ್); ಕೌಟ್ ಆಗಿದ್ದರೆ ಹೊಸ ಅಂಶಕ್ಕಾಗಿ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಿ<< "Введите значение "; cin >> (*ಹೆಡ್)->ಡೇಟಾ; //ಮಾಹಿತಿ ಕ್ಷೇತ್ರದ ಮೌಲ್ಯವನ್ನು ನಮೂದಿಸಿ (*ಹೆಡ್)->ಮುಂದೆ=NULL; //ವಿಳಾಸ ಕ್ಷೇತ್ರವನ್ನು ಶೂನ್ಯಗೊಳಿಸುವುದು ptr = Make_Circle_Double_List(n-1,&(*Head)->ಮುಂದೆ),ಲೂಪ್); ವೇಳೆ ((*ಹೆಡ್)->ಮುಂದೆ != ಶೂನ್ಯ) (*ಹೆಡ್)->ಮುಂದೆ->ಪೂರ್ವ = (*ಹೆಡ್); ವೇಳೆ ((*ಹೆಡ್)->ಪೂರ್ವ == ಶೂನ್ಯ) (*ಹೆಡ್)->ಪೂರ್ವ = ptr; (ptr == NULL) ಹಿಂತಿರುಗಿಸಿದರೆ *ಹೆಡ್; ಬೇರೆ ಹಿಂತಿರುಗಿ ptr; ) ಬೇರೆ (*ಹೆಡ್) = ಲೂಪ್; NULL ಹಿಂತಿರುಗಿ; ) ) //ವೃತ್ತಾಕಾರದ ದ್ವಿಗುಣ ಪಟ್ಟಿಯನ್ನು ಅನೂರ್ಜಿತವಾಗಿ ಮುದ್ರಿಸಿ Print_Circle_Double_List(Circle_Double_List* Head) ( Circle_Double_List* ptr=Head; // ಆಕ್ಸಿಲರಿ ಪಾಯಿಂಟರ್ ಡು (ಕೌಟ್)<< ptr->ಡೇಟಾ<< "\t"; ptr=ptr->ಮುಂದೆ; ) ಸಂದರ್ಭದಲ್ಲಿ (ptr!=ಹೆಡ್); ಕೌಟ್<< "\n"; } /*вставка элемента после заданного номера в циклический двунаправленный список*/ Circle_Double_List* Insert_Item_Circle_Double_List (Circle_Double_List* Head, int Number, int DataItem){ Circle_Double_List *Current = Head; //встали на первый элемент Circle_Double_List *NewItem = new(Circle_Double_List); //создали новый элемент NewItem->ಡೇಟಾ = DataItem; (Head == NULL) (//ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿದೆ NewItem->ಮುಂದಿನ = ಹೊಸ ಐಟಂ; NewItem->Prior = NewItem; Head = NewItem; ) ಬೇರೆ (//ಪಟ್ಟಿಯು ಖಾಲಿಯಾಗಿಲ್ಲ (int i = 1; i< Number; i++) Current = Current->ಮುಂದೆ; ಹೊಸ ಐಟಂ->ಮುಂದೆ = ಪ್ರಸ್ತುತ->ಮುಂದೆ; ಪ್ರಸ್ತುತ->ಮುಂದೆ = ಹೊಸ ಐಟಂ; ಹೊಸ ಐಟಂ->ಪೂರ್ವ = ಪ್ರಸ್ತುತ; ಹೊಸ ಐಟಂ->ಮುಂದೆ->ಪೂರ್ವ = ಹೊಸ ಐಟಂ; ) ತಲೆ ಹಿಂತಿರುಗಿ; ) /* ಆವರ್ತಕ ದ್ವಿಗುಣ ಪಟ್ಟಿಯಿಂದ ನೀಡಲಾದ ಸಂಖ್ಯೆಯ ಅಂಶವನ್ನು ಅಳಿಸುವುದು*/ Circle_Double_List* Delete_Item_Circle_Double_List(Circle_Double_List* Head, int Number)( if (Head != NULL)( Circle_Double *He_List = ತಲೆ) ( (ಇಂಟ್ i = 1; i< Number; i++) Current = Current->ಮುಂದೆ; Circle_Double_List *ptr = ಪ್ರಸ್ತುತ->ಮುಂದೆ; ಪ್ರಸ್ತುತ->ಪೂರ್ವ->ಮುಂದೆ = ಪ್ರಸ್ತುತ->ಮುಂದೆ; ಪ್ರಸ್ತುತ->ಮುಂದೆ->ಪೂರ್ವ = ಪ್ರಸ್ತುತ->ಪೂರ್ವ; ವೇಳೆ (ಹೆಡ್ = ಕರೆಂಟ್) //ಮೊದಲ ತಲೆಯನ್ನು ಅಳಿಸಿ = ಪ್ರಸ್ತುತ->ಮುಂದೆ; ಅಳಿಸಿ (ಪ್ರಸ್ತುತ); ) else( ಹೆಡ್ = NULL; ಅಳಿಸಿ (ಪ್ರಸ್ತುತ); ) ) ತಲೆ ಹಿಂತಿರುಗಿ; ) //ಆವರ್ತಕ ದ್ವಿ-ನಿರ್ದೇಶಿತ ಪಟ್ಟಿ ಬೂಲ್‌ನಲ್ಲಿ ಅಂಶವನ್ನು ಹುಡುಕಿ Find_Item_Circle_Double_List(Circle_Double_List* Head, int DataItem)( Circle_Double_List *ptr = Head; //ಆಕ್ಸಿಲರಿ ಪಾಯಿಂಟರ್ ಮಾಡಿ (ಒಂದು ವೇಳೆ (ಡೇಟಾಐಟಂ) ನಿಜ;>=D ಬೇರೆ ptr = ptr- >ಮುಂದೆ; ) ಹಾಗೆಯೇ (ptr != ಹೆಡ್); ತಪ್ಪು ಹಿಂತಿರುಗಿ; ) //ಆವರ್ತಕ ದ್ವಿಗುಣ ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ ಖಾಲಿ ಬೂಲ್ Empty_Circle_Double_List(Circle_Double_List* Head)( ಹಿಂತಿರುಗಿ (ಹೆಡ್ != NULL ? ತಪ್ಪು: ನಿಜ) ; ) //ಆವರ್ತಕ ದ್ವಿಗುಣ ಪಟ್ಟಿಯನ್ನು ಅನೂರ್ಜಿತಗೊಳಿಸುವಿಕೆ Delete_Circle_Double_List(Circle_Double_List* Head)( if (Head != NULL)( Head = Delete_Item_Circle_Double_List(Head, 1);(Head_Double_Listing));

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

1. ಆವರ್ತಕ ಪಟ್ಟಿಯಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಗಳು

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

ಆವರ್ತ ಪಟ್ಟಿಗಾಗಿ, ಹೊಸ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಸಹ ಪರಿಚಯಿಸಲಾಗಿದೆ - ಎರಡು ಆವರ್ತ ಪಟ್ಟಿಗಳ ಸಂಯೋಜನೆ - ಕಾನ್ಕ್ಯಾಟ್(ಜೊತೆಗೆ 1,ಜೊತೆಗೆ 2).

1. ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿಯ ಏಕ-ಸಂಯೋಜಿತ ಅನುಷ್ಠಾನ

ಡೈನಾಮಿಕ್ ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು:

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

tCircleList ವರ್ಗವನ್ನು ಈ ಕೆಳಗಿನಂತೆ ವಿವರಿಸಬಹುದು:

tValue= Real; // ಪಟ್ಟಿ ಅಂಶ ಮೌಲ್ಯದ ಪ್ರಕಾರ - ನೈಜ

pItem= ^tItem; // ಪಟ್ಟಿಯ ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್ ಪ್ರಕಾರ

tItem= ದಾಖಲೆ// ಪಟ್ಟಿ ಅಂಶ ಪ್ರಕಾರ

ಮೌಲ್ಯ: tValue; // ಪಟ್ಟಿಯ ಅಂಶದ ವಿಷಯ

ಮುಂದೆ: pItem; // ಪಟ್ಟಿಯ ಮುಂದಿನ ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್

ಅಂತ್ಯ; //ದಾಖಲೆ ಐಟಂ

tCircleList= ವರ್ಗ // ವರ್ಗ - ಆವರ್ತಕ ಪಟ್ಟಿ

ರಕ್ಷಿಸಲಾಗಿದೆ

fHead:pItem; // ಕ್ಷೇತ್ರ - ಪಾಯಿಂಟರ್ಪ್ರಸ್ತುತ ಅಂಶಪಟ್ಟಿ

fSize:ಪದ; // ಕ್ಷೇತ್ರ - ಪಟ್ಟಿ ಅಂಶಗಳ ಸಂಖ್ಯೆ

ಸಾರ್ವಜನಿಕ

// ಆಸ್ತಿ - ಪಟ್ಟಿ ಅಂಶಗಳ ಸಂಖ್ಯೆ (ಓದಲು ಮತ್ತು ಬರೆಯಲು ಪ್ರವೇಶ)

ಆಸ್ತಿಗಾತ್ರ: ಪದ ಓದಿದೆ fSize ಬರೆಯಿರಿ fSize;

// ಆಸ್ತಿ - ಪಟ್ಟಿಯ ಪ್ರಾರಂಭಕ್ಕೆ ಪಾಯಿಂಟರ್ (ಓದಲು ಮತ್ತು ಬರೆಯಲು ಪ್ರವೇಶ)

ಆಸ್ತಿತಲೆ: ಪದ ಓದಿದೆಎಫ್ ಹೆಡ್ ಬರೆಯಿರಿ fHead;

vವಿಳಾಸ ಅಂಶದ ನಂತರಸೇರಿಸು

ವಿಧಾನಸೇರಿಸಿ ನಂತರ (ಸೇರಿಸಿ: pItem; v: tValue);

// ಮೌಲ್ಯದೊಂದಿಗೆ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸಿvವಿಳಾಸ ಅಂಶದ ಮೊದಲುಸೇರಿಸು

ವಿಧಾನಮೊದಲು ಸೇರಿಸು(ಸೇರಿಸು: pItem; v: tValue);

// ಆಡ್ಡರ್ ವಿಳಾಸದೊಂದಿಗೆ ಅಂಶವನ್ನು ಅನುಸರಿಸುವ ಅಂಶವನ್ನು ಹೊರತುಪಡಿಸಿ

ಕಾರ್ಯಅಳಿಸಿ ನಂತರ (ಸೇರಿಸು: pItem): tValue;

// ಪಾಯಿಂಟರ್ ಹೊಂದಿರುವ ಅಂಶವನ್ನು ಹೊರತುಪಡಿಸಿಸೇರಿಸು

ಕಾರ್ಯಅಳಿಸಿ(ಸೇರಿಸು:pItem):tValue;

// ಮೌಲ್ಯದೊಂದಿಗೆ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸಿvಪಟ್ಟಿಯ ಆರಂಭಕ್ಕೆ

ವಿಧಾನ InsertHead(v:tValue);

// ಮೌಲ್ಯದೊಂದಿಗೆ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸಿvಪಟ್ಟಿಯ ಕೊನೆಯವರೆಗೆ

ವಿಧಾನ InsertRear(v:tValue);

// ಪಟ್ಟಿಯ ಪ್ರಾರಂಭದಿಂದ ಒಂದು ಅಂಶವನ್ನು ಹೊರತುಪಡಿಸಿ

ಕಾರ್ಯ DeleteHead:tValue;

// ಪಟ್ಟಿಯ ಅಂತ್ಯದಿಂದ ಒಂದು ಅಂಶವನ್ನು ಹೊರತುಪಡಿಸಿ

ಕಾರ್ಯಹಿಂದಿನ ಅಳಿಸು:tValue;

ವಿಧಾನಸಂಪರ್ಕ ( var CList2: tCircleList); // ಕ್ಲಚ್ ಜೊತೆಗೆ ಪಟ್ಟಿCList2

// ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ಅಂಶಕ್ಕಾಗಿ ಪಟ್ಟಿಯನ್ನು ಹುಡುಕಿvಮತ್ತು ಅವನ ವಿಳಾಸವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತಾನೆ

ಕಾರ್ಯಹುಡುಕಾಟ(v: tValue): pItem;

ಕಾರ್ಯಖಾಲಿ: ಬೂಲಿಯನ್; // ಹಿಂತಿರುಗಿನಿಜ,ಒಂದು ವೇಳೆ ಪಟ್ಟಿ ಖಾಲಿ

ವಿಧಾನಸ್ಪಷ್ಟ; // ಪಟ್ಟಿಯನ್ನು ತೆರವುಗೊಳಿಸುವುದು

ನಿರ್ಮಾಣಕಾರರಚಿಸಿ; // ಕನ್ಸ್ಟ್ರಕ್ಟರ್ - ಖಾಲಿ ಪಟ್ಟಿಯನ್ನು ರಚಿಸುವುದು

ವಿಧ್ವಂಸಕನಾಶಮಾಡು; ಅತಿಕ್ರಮಿಸಿ; // ವಿಧ್ವಂಸಕ - ಅಳಿಸುವಿಕೆ ಪಟ್ಟಿ

ಅಂತ್ಯ; // ವರ್ಗtCircleList

tCircleList ವರ್ಗವನ್ನು tList ವರ್ಗದ ವಂಶಸ್ಥರು ಎಂದು ಘೋಷಿಸಲಾಗಿಲ್ಲ, ಏಕೆಂದರೆ ಅದರ ಎಲ್ಲಾ ವಿಧಾನಗಳ ಅನುಷ್ಠಾನವು ಚಕ್ರೇತರ ಪಟ್ಟಿಗೆ ಅದೇ ಹೆಸರಿನ ವಿಧಾನಗಳ ಅನುಷ್ಠಾನದಿಂದ ಭಿನ್ನವಾಗಿರುತ್ತದೆ. ವ್ಯತ್ಯಾಸಗಳು ಮುಖ್ಯವಾಗಿ ಈ ಕೆಳಗಿನಂತಿವೆ:

- InsertAfter ಮತ್ತು InsertBefor ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ, ಖಾಲಿ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸುವುದು ಮತ್ತು ಆವರ್ತಕ ಪಟ್ಟಿಯ ಪ್ರಾರಂಭ ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ಸೇರ್ಪಡೆ ವಿಭಿನ್ನವಾಗಿ ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ;

- ಒಂದು ಅಂಶವನ್ನು ಒಳಗೊಂಡಿರುವ ಆವರ್ತಕ ಪಟ್ಟಿಗೆ ಅಳಿಸುವಿಕೆಯ ನಂತರ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಅನ್ವಯಿಸುವುದರಿಂದ ಈ ಅಂಶದ ಹೊರಗಿಡುವಿಕೆಗೆ ಕಾರಣವಾಗಬಾರದು;

- ಅಳಿಸುವಿಕೆಯ ನಂತರ ಮತ್ತು ಅಳಿಸುವ ವಿಧಾನಗಳು ಈ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಮಯದಲ್ಲಿ ಅದನ್ನು ತೆಗೆದುಹಾಕಿದರೆ ಆವರ್ತಕ ಪಟ್ಟಿಯ ಕೊನೆಯ ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಮರುಸ್ಥಾಪಿಸಬೇಕು;

- ಹುಡುಕಾಟ ಮತ್ತು ತೆರವುಗೊಳಿಸಿ ವಿಧಾನಗಳಲ್ಲಿ, ಆಕ್ಸಿಲರಿ ಪಾಯಿಂಟರ್ ಬ್ರೌಸಿಂಗ್ ಪ್ರಾರಂಭವಾದ ಅಂಶವನ್ನು ತಲುಪಿದಾಗ ಆವರ್ತಕ ಪಟ್ಟಿಯನ್ನು ಬ್ರೌಸಿಂಗ್ ಪೂರ್ಣಗೊಳಿಸುವುದರ ಸಂಕೇತವಾಗಿದೆ.

ಮತ್ತು ಕೇವಲ ರಚಿಸಿ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಮತ್ತು ಡಿಸ್ಟ್ರಾಯ್ ಡಿಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು tList ವರ್ಗದಲ್ಲಿ ಅದೇ ಹೆಸರಿನ ವಿಧಾನಗಳ ರೀತಿಯಲ್ಲಿಯೇ ಅಳವಡಿಸಲಾಗಿದೆ.

ನಿಸ್ಸಂಶಯವಾಗಿ, ಪ್ರಸ್ತುತ ಅಂಶದ ಬಲ ಮತ್ತು ಎಡಕ್ಕೆ ಸೇರ್ಪಡೆ ಮತ್ತು ಹೊರಗಿಡುವ ಕಾರ್ಯಾಚರಣೆಗಳು (InsertHead, InsertRear, DeleteHead, DeleteRear) ಆವರ್ತಕವಲ್ಲದ ಪಟ್ಟಿಗೆ ಅದೇ ಹೆಸರಿನ ಕಾರ್ಯಾಚರಣೆಗಳಂತೆಯೇ ಅದೇ ಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತವೆ. ವ್ಯತ್ಯಾಸವೆಂದರೆ ಹೊಸ ಕಾರ್ಯಾಚರಣೆಗಳು ಪಾಯಿಂಟರ್‌ನ ಮೌಲ್ಯವನ್ನು ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿಯ ಕೊನೆಯ ಅಂಶಕ್ಕೆ ಬದಲಾಯಿಸಿದರೆ ಪಟ್ಟಿಯು ಎಡ ಅಥವಾ ಬಲಕ್ಕೆ ವಿಸ್ತರಿಸಿದರೆ ಅಥವಾ ಎಡ ಅಥವಾ ಬಲಕ್ಕೆ ಕಿರಿದಾಗುತ್ತದೆ.

ಕೊನೆಯ ನವೀಕರಣ: 10/25/2016

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

ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಪಟ್ಟಿಯು ಒಂದು ಹೆಡ್ ಎಲಿಮೆಂಟ್, ಹೆಡ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ, ನಾವು ಅಂತಹ ಪಟ್ಟಿಯನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಮುಚ್ಚಬಹುದು:

ಹೆಡ್.ಮುಂದೆ = ತಲೆ;

ಅನುಷ್ಠಾನಕ್ಕಾಗಿ, ಒಂದೇ ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿಯಲ್ಲಿ ಬಳಸಲಾದ ಅಂಶ ವರ್ಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ:

ಸಾರ್ವಜನಿಕ ವರ್ಗ ನೋಡ್ (ಸಾರ್ವಜನಿಕ ನೋಡ್(ಟಿ ಡೇಟಾ) (ಡೇಟಾ = ಡೇಟಾ;) ಸಾರ್ವಜನಿಕ ಟಿ ಡೇಟಾ (ಪಡೆಯಿರಿ; ಹೊಂದಿಸಿ;) ಸಾರ್ವಜನಿಕ ನೋಡ್ ಮುಂದೆ (ಪಡೆಯಿರಿ; ಹೊಂದಿಸಿ;))

ಈಗ ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿ ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸೋಣ:

System.Collections ಅನ್ನು ಬಳಸುವುದು; System.Collections.Generic ಅನ್ನು ಬಳಸುವುದು; ನೇಮ್‌ಸ್ಪೇಸ್ SimpleAlgorithmsApp (ಸಾರ್ವಜನಿಕ ವರ್ಗದ ಸುತ್ತೋಲೆ ಲಿಂಕ್ಡ್‌ಲಿಸ್ಟ್ :ಅಸಂಖ್ಯಾತ // ರಿಂಗ್ ಲಿಂಕ್ಡ್ ಪಟ್ಟಿ ( ನೋಡ್ ತಲೆ; // ತಲೆ/ಮೊದಲ ಅಂಶ ನೋಡ್ ಬಾಲ; // ಕೊನೆಯ/ಟೈಲ್ ಅಂಶ ಇಂಟ್ ಎಣಿಕೆ; //ಪಟ್ಟಿಯಲ್ಲಿರುವ ಅಂಶಗಳ ಸಂಖ್ಯೆ // ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸುವುದು ಸಾರ್ವಜನಿಕ ನಿರರ್ಥಕ ಸೇರಿಸಿ(ಟಿ ಡೇಟಾ) ( ನೋಡ್ ನೋಡ್ = ಹೊಸ ನೋಡ್ (ಡೇಟಾ); // ಪಟ್ಟಿಯು ಖಾಲಿಯಾಗಿದ್ದರೆ (ತಲೆ == ಶೂನ್ಯ) (ತಲೆ = ನೋಡ್; ಬಾಲ = ನೋಡ್; ಬಾಲ.ಮುಂದೆ = ತಲೆ; ) ಬೇರೆ (ನೋಡ್.ಮುಂದೆ = ತಲೆ; ಬಾಲ.ಮುಂದೆ = ನೋಡ್; ಬಾಲ = ನೋಡ್; ) ಎಣಿಕೆ++ ; ) ಸಾರ್ವಜನಿಕ bool ತೆಗೆದುಹಾಕಿ(T ಡೇಟಾ) ( ನೋಡ್ ಪ್ರಸ್ತುತ = ತಲೆ; ನೋಡ್ ಹಿಂದಿನ = ಶೂನ್ಯ; ಒಂದು ವೇಳೆ (ಇಸ್ ಖಾಲಿ) ತಪ್ಪಾಗಿ ಹಿಂತಿರುಗಿ; ಮಾಡಿ (ಒಂದು ವೇಳೆ (current.Data.Equals(data)) ( // ನೋಡ್ ಮಧ್ಯದಲ್ಲಿ ಅಥವಾ ಕೊನೆಯಲ್ಲಿ ಇದ್ದರೆ (ಹಿಂದಿನ != ಶೂನ್ಯ) ( // ಪ್ರಸ್ತುತ ನೋಡ್ ಅನ್ನು ತೆಗೆದುಹಾಕಿ, ಈಗ ಹಿಂದಿನದು ಪ್ರಸ್ತುತವಲ್ಲ, ಆದರೆ ಪ್ರಸ್ತುತಕ್ಕೆ.ಮುಂದಿನ ಹಿಂದಿನದು .ಮುಂದಿನದು = ಪ್ರಸ್ತುತ / ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದೇ ಒಂದು ಅಂಶವಿದ್ದರೆ (ಎಣಿಕೆ= =1) (ತಲೆ = ಬಾಲ = ಶೂನ್ಯ; ) ಬೇರೆ (ತಲೆ = ಪ್ರಸ್ತುತ.ಮುಂದೆ; ಬಾಲ.ಮುಂದೆ = ಪ್ರಸ್ತುತ.ಮುಂದೆ; ) ಎಣಿಕೆ--; ನಿಜವನ್ನು ಹಿಂತಿರುಗಿ; ) ಹಿಂದಿನ = ಪ್ರಸ್ತುತ; ಪ್ರಸ್ತುತ = ಪ್ರಸ್ತುತ. ಮುಂದೆ; ) ಆದರೆ (ಪ್ರಸ್ತುತ != ತಲೆ); ಸುಳ್ಳು ಹಿಂತಿರುಗಿ; ) ಪಬ್ಲಿಕ್ ಇಂಟ್ ಕೌಂಟ್ (ಪಡೆಯಿರಿ (ರಿಟರ್ನ್ ಎಣಿಕೆ;)) ಸಾರ್ವಜನಿಕ ಬೂಲ್ ಐಎಸ್‌ಇಂಪ್ಟಿ (ಪಡೆಯಿರಿ (ರಿಟರ್ನ್ ಎಣಿಕೆ == 0;)) ಸಾರ್ವಜನಿಕ ಶೂನ್ಯವನ್ನು ತೆರವುಗೊಳಿಸಿ () (ತಲೆ = ಶೂನ್ಯ; ಬಾಲ = ಶೂನ್ಯ; ಎಣಿಕೆ = 0;) ಸಾರ್ವಜನಿಕ ಬೂಲ್ (ಟಿ) ಒಳಗೊಂಡಿದೆ ಡೇಟಾ) (ನೋಡ್ ಪ್ರಸ್ತುತ = ತಲೆ; ಒಂದು ವೇಳೆ (ಪ್ರಸ್ತುತ == ಶೂನ್ಯ) ತಪ್ಪು ಹಿಂತಿರುಗಿ; (ಪ್ರಸ್ತುತ. ಡೇಟಾ. ಸಮಾನ (ಡೇಟಾ)) ನಿಜವನ್ನು ಹಿಂತಿರುಗಿಸಿದರೆ; ಪ್ರಸ್ತುತ = ಪ್ರಸ್ತುತ.ಮುಂದೆ; ) ಹಾಗೆಯೇ (ಪ್ರಸ್ತುತ != ತಲೆ); ಸುಳ್ಳು ಹಿಂತಿರುಗಿ; ) IEnumerable.GetEnumerator() ( ಹಿಂತಿರುಗಿ ((IEnumerable)this).GetEnumerator(); ) IEnumerator ಅಸಂಖ್ಯಾತ .GetEnumerator() ( ನೋಡ್ ಪ್ರಸ್ತುತ = ತಲೆ; (ಪ್ರಸ್ತುತ != ಶೂನ್ಯ) (ಇಳುವರಿ ರಿಟರ್ನ್ ಕರೆಂಟ್.ಡೇಟಾ; ಪ್ರಸ್ತುತ = ಪ್ರಸ್ತುತ.ಮುಂದೆ; ) ) ಮಾಡುವಾಗ (ಪ್ರಸ್ತುತ != ತಲೆ); )))

ಸೇರ್ಪಡೆಯು ಮೂಲಭೂತವಾಗಿ ಪಾಯಿಂಟರ್ ಅನ್ನು ಕೊನೆಯ ಬಾಲ ಅಂಶಕ್ಕೆ ಮರುಹೊಂದಿಸಲು ಮತ್ತು ಬಾಲ ಮತ್ತು ತಲೆಯ ನಡುವೆ ಹೊಸ ಅಂಶವನ್ನು ಇರಿಸಲು ಸಮನಾಗಿರುತ್ತದೆ:

ಸಾರ್ವಜನಿಕ ಅನೂರ್ಜಿತ ಸೇರ್ಪಡೆ (ಟಿ ಡೇಟಾ) ( ನೋಡ್ ನೋಡ್ = ಹೊಸ ನೋಡ್ (ಡೇಟಾ); // ಪಟ್ಟಿಯು ಖಾಲಿಯಾಗಿದ್ದರೆ (ತಲೆ == ಶೂನ್ಯ) (ತಲೆ = ನೋಡ್; ಬಾಲ = ನೋಡ್; ಬಾಲ.ಮುಂದೆ = ತಲೆ; ) ಬೇರೆ (ನೋಡ್.ಮುಂದೆ = ತಲೆ; ಬಾಲ.ಮುಂದೆ = ನೋಡ್; ಬಾಲ = ನೋಡ್; ) ಎಣಿಕೆ++ ; )

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

ಪಬ್ಲಿಕ್ ಬೂಲ್ ರಿಮೂವ್(ಟಿ ಡೇಟಾ) ( ನೋಡ್ ಪ್ರಸ್ತುತ = ತಲೆ; ನೋಡ್ ಹಿಂದಿನ = ಶೂನ್ಯ; ಒಂದು ವೇಳೆ (ಇಸ್ ಖಾಲಿ) ತಪ್ಪಾಗಿ ಹಿಂತಿರುಗಿ; ಮಾಡಿ (ಒಂದು ವೇಳೆ (current.Data.Equals(data)) ( // ನೋಡ್ ಮಧ್ಯದಲ್ಲಿ ಅಥವಾ ಕೊನೆಯಲ್ಲಿ ಇದ್ದರೆ (ಹಿಂದಿನ != ಶೂನ್ಯ) ( // ಪ್ರಸ್ತುತ ನೋಡ್ ಅನ್ನು ತೆಗೆದುಹಾಕಿ, ಈಗ ಹಿಂದಿನದು ಪ್ರಸ್ತುತವಲ್ಲ, ಆದರೆ ಪ್ರಸ್ತುತಕ್ಕೆ.ಮುಂದಿನ ಹಿಂದಿನದು .ಮುಂದಿನದು = ಪ್ರಸ್ತುತ / ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದೇ ಒಂದು ಅಂಶವಿದ್ದರೆ (ಎಣಿಕೆ= =1) (ತಲೆ = ಬಾಲ = ಶೂನ್ಯ; ) ಬೇರೆ (ತಲೆ = ಪ್ರಸ್ತುತ.ಮುಂದೆ; ಬಾಲ.ಮುಂದೆ = ಪ್ರಸ್ತುತ.ಮುಂದೆ; ) ಎಣಿಕೆ--; ನಿಜವನ್ನು ಹಿಂತಿರುಗಿ; ) ಹಿಂದಿನ = ಪ್ರಸ್ತುತ; ಪ್ರಸ್ತುತ = ಪ್ರಸ್ತುತ. ಮುಂದೆ; ) ಆದರೆ (ಪ್ರಸ್ತುತ != ತಲೆ); ಸುಳ್ಳು ಹಿಂತಿರುಗಿ; )

ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿಯನ್ನು ಬಳಸುವುದು:

ಸುತ್ತೋಲೆ ಲಿಂಕ್ಡ್ಲಿಸ್ಟ್ ಸರ್ಕ್ಯುಲರ್ಲಿಸ್ಟ್ = ಹೊಸ ಸರ್ಕ್ಯುಲರ್ಲಿಂಕ್ಡ್ಲಿಸ್ಟ್ (); ಸರ್ಕ್ಯುಲರ್ಲಿಸ್ಟ್.ಆಡ್ ("ಟಾಮ್"); ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿ. ಸೇರಿಸಿ ("ಬಾಬ್"); ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿ. ಸೇರಿಸಿ ("ಆಲಿಸ್"); ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿ. ಸೇರಿಸಿ ("ಜ್ಯಾಕ್"); foreach (ವೃತ್ತಪಟ್ಟಿಯಲ್ಲಿ var ಐಟಂ) ( Console.WriteLine(ಐಟಂ); ) circularList.Remove("Bob"); Console.WriteLine("\nಅಳಿಸುವಿಕೆಯ ನಂತರ:\n"); foreach (ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿಯಲ್ಲಿರುವ var ಐಟಂ) ( Console.WriteLine(ಐಟಂ); )

ಕನ್ಸೋಲ್ ಔಟ್‌ಪುಟ್:

ಟಾಮ್ ಬಾಬ್ ಆಲಿಸ್ ಜ್ಯಾಕ್ ತೆಗೆದುಹಾಕಿದ ನಂತರ: ಟಾಮ್ ಆಲಿಸ್ ಜ್ಯಾಕ್

ಉಪನ್ಯಾಸ ಪಠ್ಯ.

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

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

ವೃತ್ತಾಕಾರದ (ರಿಂಗ್) ಪಟ್ಟಿಒಂದು ಡೇಟಾ ರಚನೆಯು ಅಂಶಗಳ ಅನುಕ್ರಮವಾಗಿದೆ, ಅದರ ಕೊನೆಯ ಅಂಶವು ಪಟ್ಟಿಯ ಮೊದಲ ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ ಮತ್ತು ಮೊದಲನೆಯದು (ದ್ವಿಮುಖ ಪಟ್ಟಿಯ ಸಂದರ್ಭದಲ್ಲಿ) ಕೊನೆಯದಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ.

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

ವೃತ್ತಾಕಾರದ ಪಟ್ಟಿಗಳು, ರೇಖೀಯ ಪದಗಳಿಗಿಂತ, ಏಕಮುಖ ಅಥವಾ ದ್ವಿಮುಖವಾಗಿರಬಹುದು.

ವೃತ್ತಾಕಾರದ ಏಕಮುಖ ಪಟ್ಟಿರೇಖೀಯ ಏಕಮುಖ ಪಟ್ಟಿಯನ್ನು ಹೋಲುತ್ತದೆ, ಆದರೆ ಅದರ ಕೊನೆಯ ಅಂಶವು ಅದನ್ನು ಮೊದಲ ಅಂಶಕ್ಕೆ ಲಿಂಕ್ ಮಾಡುವ ಪಾಯಿಂಟರ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ (ಚಿತ್ರ 1).

ಅಂತಹ ಪಟ್ಟಿಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಹಾದುಹೋಗಲು, ಅನಿಯಂತ್ರಿತ ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೊಂದಲು ಸಾಕು, ಮತ್ತು ರೇಖೀಯ ಏಕಮುಖ ಪಟ್ಟಿಯಲ್ಲಿರುವಂತೆ ಮೊದಲನೆಯದಕ್ಕೆ ಅಲ್ಲ. ಇಲ್ಲಿ "ಮೊದಲ" ಅಂಶದ ಪರಿಕಲ್ಪನೆಯು ಸಾಕಷ್ಟು ಅನಿಯಂತ್ರಿತವಾಗಿದೆ ಮತ್ತು ಯಾವಾಗಲೂ ಅಗತ್ಯವಿಲ್ಲ. ಅದರ ಮೇಲೆ ವಿಶೇಷ ಪಾಯಿಂಟರ್ ಅನ್ನು ಇರಿಸುವ ಮೂಲಕ ಕೆಲವು ಅಂಶವನ್ನು "ಮೊದಲ" ಎಂದು ಹೈಲೈಟ್ ಮಾಡಲು ಕೆಲವೊಮ್ಮೆ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಪಟ್ಟಿಯನ್ನು ವೀಕ್ಷಿಸುವಾಗ "ಲೂಪಿಂಗ್" ಅನ್ನು ತಡೆಯಲು ಇದು ಅಗತ್ಯವಿದೆ.

ಅಕ್ಕಿ. 1. ವೃತ್ತಾಕಾರದ ಏಕಮುಖ ಪಟ್ಟಿ

ವೃತ್ತಾಕಾರದ ಏಕಮುಖ ಪಟ್ಟಿಯೊಂದಿಗೆ ನಡೆಸಲಾದ ಮೂಲ ಕಾರ್ಯಾಚರಣೆಗಳು:

· ಪಟ್ಟಿಯನ್ನು ರಚಿಸುವುದು;

· ಪಟ್ಟಿಯನ್ನು ಮುದ್ರಿಸಿ (ವೀಕ್ಷಿಸಿ);

· ಒಂದು ಅಂಶವನ್ನು ಪಟ್ಟಿಗೆ ಸೇರಿಸುವುದು;

· ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ಅಂಶವನ್ನು ಹುಡುಕಿ;

· ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು;

· ಪಟ್ಟಿಯನ್ನು ಅಳಿಸಲಾಗುತ್ತಿದೆ.

ಈ ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ವಿವರಿಸಲು, ರೇಖಾತ್ಮಕ ಏಕಮುಖ ಪಟ್ಟಿಗಾಗಿ ನಾವು ಅದೇ ಘೋಷಣೆಗಳನ್ನು ಬಳಸುತ್ತೇವೆ.

ಆವರ್ತಕ ಏಕಮುಖ ಪಟ್ಟಿಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಪಟ್ಟಿ ಮಾಡಲಾದ ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಗಳ ಕಾರ್ಯಗಳನ್ನು ನಾವು ಪ್ರಸ್ತುತಪಡಿಸೋಣ.

//ವೃತ್ತಾಕಾರದ ಏಕಮುಖ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಿ

ಅನೂರ್ಜಿತ Make_Circle_Single_List(int n,

Circle_Single_List** Head, Circle_Single_List* ಲೂಪ್)(

(*ಹೆಡ್) = ಹೊಸ ಸರ್ಕಲ್_ಸಿಂಗಲ್_ಲಿಸ್ಟ್();

ಕೌಟ್<< "Введите значение ";

ಸಿನ್ >> (*ಹೆಡ್)->ಡೇಟಾ;

(*ತಲೆ)->

ಮಾಡಿ_ಸರ್ಕಲ್_ಸಿಂಗಲ್_ಲಿಸ್ಟ್(n-1,&(*ಹೆಡ್)->ಮುಂದೆ),ಲೂಪ್);

//ವೃತ್ತಾಕಾರದ ಏಕ ದಿಕ್ಕಿನ ಪಟ್ಟಿಯನ್ನು ಮುದ್ರಿಸಿ

ಅನೂರ್ಜಿತ Print_Circle_Single_List(Circle_Single_List* Head) (

Circle_Single_List* ptr=Head;

// ಸಹಾಯಕ ಪಾಯಿಂಟರ್

ಕೌಟ್<< ptr->ಡೇಟಾ<< "\t";

ptr=ptr->ಮುಂದೆ;

) ಸಂದರ್ಭದಲ್ಲಿ (ptr!=ಹೆಡ್);

ಕೌಟ್<< "\n";

/* ನೀಡಿರುವ ಸಂಖ್ಯೆಯ ನಂತರ ಒಂದು ಅಂಶವನ್ನು ವೃತ್ತಾಕಾರದ ಏಕಮುಖ ಪಟ್ಟಿಗೆ ಸೇರಿಸಿ*/

Circle_Single_List* Insert_Item_Circle_Single_List(Circle_Single_List* Head,

ಇಂಟ್ ಸಂಖ್ಯೆ, ಇಂಟ್ ಡೇಟಾ ಐಟಂ)(

//ಮೊದಲ ಅಂಶದ ಮೇಲೆ ನಿಂತುಕೊಳ್ಳಿ

Circle_Single_List *NewItem = new(Circle_Single_List);

//ಹೊಸ ಅಂಶವನ್ನು ರಚಿಸಲಾಗಿದೆ

ಹೊಸ ಐಟಂ-> ಡೇಟಾ = ಡೇಟಾ ಐಟಂ;

ಹೊಸ ಐಟಂ->ಮುಂದೆ = ಹೊಸ ಐಟಂ;

ಬೇರೆ (//ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿಲ್ಲ

ಗಾಗಿ (int i = 1; i< Number; i++)

ಪ್ರಸ್ತುತ = ಪ್ರಸ್ತುತ->ಮುಂದೆ;

ಹೊಸ ಐಟಂ->ಮುಂದೆ = ಪ್ರಸ್ತುತ->ಮುಂದೆ;

ಪ್ರಸ್ತುತ->ಮುಂದೆ = ಹೊಸ ಐಟಂ;

/* ವೃತ್ತಾಕಾರದ ಏಕಮುಖ ಪಟ್ಟಿಯಿಂದ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕುವುದು*/

Circle_Single_List* Delete_Item_Circle_Single_List

(Circle_Single_List* Head, int Number)(

ಒಂದು ವೇಳೆ (ತಲೆ != NULL)(

Circle_Single_List *ಪ್ರಸ್ತುತ = ತಲೆ;

ಒಂದು ವೇಳೆ (ತಲೆ->ಮುಂದೆ != ತಲೆ)(

ಗಾಗಿ (int i = 1; i< Number; i++)

ಪ್ರಸ್ತುತ = ಪ್ರಸ್ತುತ->ಮುಂದೆ;

ಹಾಗೆಯೇ (ptr->ಮುಂದೆ != ಪ್ರಸ್ತುತ)

ptr = ptr->ಮುಂದೆ;

// ಅಂಶವನ್ನು ನೇರವಾಗಿ ತೆಗೆದುಹಾಕುವುದು

ptr->ಮುಂದೆ = ಪ್ರಸ್ತುತ->ಮುಂದೆ;

ವೇಳೆ (ಹೆಡ್ = ಕರೆಂಟ್) ಹೆಡ್ = ಕರೆಂಟ್->ಮುಂದೆ;

ಅಳಿಸಿ (ಪ್ರಸ್ತುತ);

ಅಳಿಸಿ (ಪ್ರಸ್ತುತ);

//ವೃತ್ತಾಕಾರದ ಏಕಮುಖ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ಅಂಶವನ್ನು ಹುಡುಕಿ

bool Find_Item_Circle_Single_List(Circle_Single_List* Head,

Circle_Single_List *ptr = ಹೆಡ್;

// ಸಹಾಯಕ ಪಾಯಿಂಟರ್

(ಡೇಟಾಐಟಂ == ptr->ಡೇಟಾ) ನಿಜವನ್ನು ಹಿಂತಿರುಗಿಸಿದರೆ;

else ptr = ptr->ಮುಂದೆ;

ಹಾಗೆಯೇ (ptr != ತಲೆ);

//ವೃತ್ತಾಕಾರದ ಏಕ ದಿಕ್ಕಿನ ಪಟ್ಟಿಯ ಖಾಲಿತನವನ್ನು ಪರಿಶೀಲಿಸಿ

bool Empty_Circle_Single_List(Circle_Single_List* Head)(

//ವೃತ್ತಾಕಾರದ ಏಕಮುಖ ಪಟ್ಟಿಯನ್ನು ತೆಗೆದುಹಾಕಲಾಗುತ್ತಿದೆ

ಅನೂರ್ಜಿತ Delete_Circle_Single_List(Circle_Single_List* Head)(

ಒಂದು ವೇಳೆ (ತಲೆ != NULL)(

ಹೆಡ್ = Delete_Item_Circle_Single_List(ಹೆಡ್, 1);

Delete_Circle_Single_List(Head);

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

ಚಿತ್ರ.2. ಸುತ್ತೋಲೆ ದ್ವಿಗುಣ ಪಟ್ಟಿ

ವೃತ್ತಾಕಾರದ ದ್ವಿಮುಖ ಪಟ್ಟಿಯೊಂದಿಗೆ ನಡೆಸಲಾದ ಮೂಲ ಕಾರ್ಯಾಚರಣೆಗಳು:

· ಪಟ್ಟಿಯನ್ನು ರಚಿಸುವುದು;

· ಪಟ್ಟಿಯನ್ನು ಮುದ್ರಿಸಿ (ವೀಕ್ಷಿಸಿ);

· ಒಂದು ಅಂಶವನ್ನು ಪಟ್ಟಿಗೆ ಸೇರಿಸುವುದು;

· ಪಟ್ಟಿಯಿಂದ ಒಂದು ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕುವುದು;

· ಪಟ್ಟಿಯಲ್ಲಿರುವ ಅಂಶವನ್ನು ಹುಡುಕಿ

· ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು;

· ಪಟ್ಟಿಯನ್ನು ಅಳಿಸಲಾಗುತ್ತಿದೆ.

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

ಸೈಕ್ಲಿಕ್ ಬೈಡೈರೆಕ್ಷನಲ್ ಪಟ್ಟಿಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಪಟ್ಟಿ ಮಾಡಲಾದ ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಗಳ ಕಾರ್ಯಗಳನ್ನು ನಾವು ಪ್ರಸ್ತುತಪಡಿಸೋಣ.

//ವೃತ್ತಾಕಾರದ ದ್ವಿಗುಣ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಿ

Circle_Double_List* Make_Circle_Double_List(int n,

ಸರ್ಕಲ್_ಡಬಲ್_ಲಿಸ್ಟ್** ಹೆಡ್, ಸರ್ಕಲ್_ಡಬಲ್_ಲಿಸ್ಟ್* ಲೂಪ್)(

Circle_Double_List* ptr;//ಆಕ್ಸಿಲಿಯರಿ ಪಾಯಿಂಟರ್

(*ಹೆಡ್) = ಹೊಸ ಸರ್ಕಲ್_ಡಬಲ್_ಲಿಸ್ಟ್();

//ಹೊಸ ಅಂಶಕ್ಕಾಗಿ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಿ

ವೇಳೆ (ಲೂಪ್ == NULL) ಲೂಪ್ = (*ಹೆಡ್);

ಕೌಟ್<< "Введите значение ";

ಸಿನ್ >> (*ಹೆಡ್)->ಡೇಟಾ;

//ಮಾಹಿತಿ ಕ್ಷೇತ್ರದ ಮೌಲ್ಯವನ್ನು ನಮೂದಿಸಿ

(*ಹೆಡ್)->ಮುಂದೆ=NULL;//ವಿಳಾಸ ಕ್ಷೇತ್ರವನ್ನು ಶೂನ್ಯಗೊಳಿಸಲಾಗುತ್ತಿದೆ

ptr = Make_Circle_Double_List(n-1,&(*Head)->ಮುಂದೆ),Loop);

ವೇಳೆ ((*ಹೆಡ್)->ಮುಂದೆ != NULL)

(*ಹೆಡ್)->ಮುಂದೆ->ಪೂರ್ವ = (*ಹೆಡ್);

ವೇಳೆ ((*ಹೆಡ್)->ಪೂರ್ವ == ಶೂನ್ಯ)

(*ಹೆಡ್)->ಪೂರ್ವ = ptr;

ಒಂದು ವೇಳೆ (ptr == NULL)

ಬೇರೆ ಹಿಂತಿರುಗಿ ptr;

//ವೃತ್ತಾಕಾರದ ದ್ವಿಗುಣ ಪಟ್ಟಿಯನ್ನು ಮುದ್ರಿಸಿ

ಅನೂರ್ಜಿತ Print_Circle_Double_List(Circle_Double_List* Head) (

Circle_Double_List* ptr=Head;

// ಸಹಾಯಕ ಪಾಯಿಂಟರ್

ಕೌಟ್<< ptr->ಡೇಟಾ<< "\t";

ptr=ptr->ಮುಂದೆ;

) ಸಂದರ್ಭದಲ್ಲಿ (ptr!=ಹೆಡ್);

ಕೌಟ್<< "\n";

/* ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ನಂತರ ಒಂದು ಅಂಶವನ್ನು ವೃತ್ತಾಕಾರದ ದ್ವಿಮುಖ ಪಟ್ಟಿಗೆ ಸೇರಿಸಿ*/

Circle_Double_List* Insert_Item_Circle_Double_List

(Circle_Double_List* Head, int Number, int DataItem)(

//ಮೊದಲ ಅಂಶದ ಮೇಲೆ ನಿಂತುಕೊಳ್ಳಿ

Circle_Double_List *NewItem = ಹೊಸದು(Circle_Double_List);

//ಹೊಸ ಅಂಶವನ್ನು ರಚಿಸಲಾಗಿದೆ

ಹೊಸ ಐಟಂ-> ಡೇಟಾ = ಡೇಟಾ ಐಟಂ;

ಒಂದು ವೇಳೆ (ಹೆಡ್ == NULL) (//ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿದೆ

ಹೊಸ ಐಟಂ->ಮುಂದೆ = ಹೊಸ ಐಟಂ;

ಹೊಸ ಐಟಂ->ಪೂರ್ವ = ಹೊಸ ಐಟಂ;

ಬೇರೆ (//ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿಲ್ಲ

ಗಾಗಿ (int i = 1; i< Number; i++)

ಪ್ರಸ್ತುತ = ಪ್ರಸ್ತುತ->ಮುಂದೆ;

ಹೊಸ ಐಟಂ->ಮುಂದೆ = ಪ್ರಸ್ತುತ->ಮುಂದೆ;

ಪ್ರಸ್ತುತ->ಮುಂದೆ = ಹೊಸ ಐಟಂ;

ಹೊಸ ಐಟಂ->ಪೂರ್ವ = ಪ್ರಸ್ತುತ;

ಹೊಸ ಐಟಂ->ಮುಂದೆ->ಪೂರ್ವ = ಹೊಸ ಐಟಂ;

/* ವೃತ್ತಾಕಾರದ ದ್ವಿಮುಖ ಪಟ್ಟಿಯಿಂದ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕುವುದು*/

Circle_Double_List* Delete_Item_Circle_Double_List(Circle_Double_List* Head,

ಒಂದು ವೇಳೆ (ತಲೆ != NULL)(

Circle_Double_List *ಪ್ರಸ್ತುತ = ತಲೆ;

ಒಂದು ವೇಳೆ (ತಲೆ->ಮುಂದೆ != ತಲೆ)(

ಗಾಗಿ (int i = 1; i< Number; i++)

ಪ್ರಸ್ತುತ = ಪ್ರಸ್ತುತ->ಮುಂದೆ;

Circle_Double_List *ptr = ಪ್ರಸ್ತುತ->ಮುಂದೆ;

ಪ್ರಸ್ತುತ->ಪೂರ್ವ->ಮುಂದೆ = ಪ್ರಸ್ತುತ->ಮುಂದೆ;

ಪ್ರಸ್ತುತ->ಮುಂದೆ->ಪೂರ್ವ = ಪ್ರಸ್ತುತ->ಪೂರ್ವ;

ಒಂದು ವೇಳೆ (ಹೆಡ್ = ಕರೆಂಟ್) //ಮೊದಲನೆಯದನ್ನು ಅಳಿಸಿ

ತಲೆ = ಪ್ರಸ್ತುತ->ಮುಂದೆ;

ಅಳಿಸಿ (ಪ್ರಸ್ತುತ);

ಅಳಿಸಿ (ಪ್ರಸ್ತುತ);

//ವೃತ್ತಾಕಾರದ ದ್ವಿಮುಖ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ಅಂಶವನ್ನು ಹುಡುಕಿ

bool Find_Item_Circle_Double_List(Circle_Double_List* Head,

Circle_Double_List *ptr = ಹೆಡ್;

// ಸಹಾಯಕ ಪಾಯಿಂಟರ್

ವೇಳೆ (ಡೇಟಾಐಟಂ == ptr->ಡೇಟಾ)

else ptr = ptr->ಮುಂದೆ;

ಹಾಗೆಯೇ (ptr != ತಲೆ);

//ವೃತ್ತಾಕಾರದ ದ್ವಿಗುಣ ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ

bool Empty_Circle_Double_List(Circle_Double_List* Head)(

ಹಿಂತಿರುಗಿ (ತಲೆ != NULL? ತಪ್ಪು: ನಿಜ);

//ವೃತ್ತಾಕಾರದ ದ್ವಿಗುಣ ಪಟ್ಟಿಯನ್ನು ತೆಗೆದುಹಾಕಲಾಗುತ್ತಿದೆ

ಅನೂರ್ಜಿತ Delete_Circle_Double_List(Circle_Double_List* Head)(

ಒಂದು ವೇಳೆ (ತಲೆ != NULL)(

ಹೆಡ್ = Delete_Item_Circle_Double_List(ಹೆಡ್, 1);

Delete_Circle_Double_List(ಹೆಡ್);