לאחר מערכים, מבנה הנתונים השני הפופולרי ביותר הוא List List. רשימה מקושרת היא מבנה נתונים ליניארי, העשוי משרשרת צמתים שבהם כל צומת מכיל ערך ומצביע לצומת הבא בשרשרת. במאמר זה, בואו נראה כיצד ליישם רשימה מקושרת ב- C.
מהי רשימה מקושרת ב- C?
רשימה מקושרת היא מבנה נתונים ליניארי. לכל רשימה מקושרת יש שני חלקים, קטע הנתונים וקטע הכתובת המכיל את כתובת האלמנט הבא ברשימה, הנקרא צומת.
גודל הרשימה המקושרת אינו קבוע, וניתן להוסיף פריטי נתונים בכל המיקומים ברשימה. החיסרון הוא שכדי להגיע לצומת, עלינו לעבור לכל אורך הדרך מהצומת הראשון לצומת אותו אנו זקוקים. הרשימה המקושרת היא כמו מערך אך בשונה ממערך, היא לא נשמרת ברצף בזיכרון.
Java Addactionlistener (זה)
הסוגים הפופולריים ביותר של רשימה מקושרת הם:
דוגמה לרשימה מקושרת
פורמט: [נתונים, כתובת]
ראש -> [3,1000] -> [43,1001] -> [21,1002]
בדוגמה, המספר 43 נמצא במקום 1000 והכתובת נמצאת בצומת הקודם. כך מיוצגת רשימה מקושרת.
פונקציות בסיסיות של רשימה מקושרת
ישנן פונקציות מרובות שניתן ליישם ברשימה המקושרת ב- C. בואו ננסה להבין אותן בעזרת תוכנית לדוגמא.ראשית, אנו יוצרים רשימה, מציגים אותה, מכניסים בכל מקום, מוחקים מיקום. הקוד הבא יראה לכם כיצד לבצע פעולות ברשימה.
# כלול # כלול ריק ליצור () להציג חלל () ריק insert_begin () ריק insert_end () ריק insert_pos () בטל delete_begin () בטל delete_end () בטל delete_pos () צומת מבנה {int מידע צומת מבנה * הבא} צומת מבנה * התחלה = NULL int main () {int choice while (1) {printf ('n MENU n') printf ('n 1. Create n') printf ('n 2. Display n') printf ('n 3. הכנס ב ההתחלה n ') printf (' n 4. הכנס בסוף n ') printf (' n 5. הכנס למיקום שצוין n ') printf (' n 6. מחק מההתחלה n ') printf (' n 7. מחק מהסוף n ') printf (' n 8. מחק מהמיקום שצוין n ') printf (' n 9. צא n ') printf (' n ----------------- --------------------- n ') printf (' הזן את בחירתך: t ') scanf ('% d ', & choice) מתג (בחירה) {מקרה 1 : ליצור () מקרה הפסקה 2: תצוגה () מקרה הפסקה 3: insert_begin () מקרה הפסקה 4: insert_end () מקרה הפסקה 5: insert_pos () מקרה הפסקה 6: delete_begin () מקרה הפסקה 7: delete_end () מקרה הפסקה 8: delete_pos () break case 9: exit (0) break default: printf ('n Wrong Choice: n') break}} return 0} voi d צור () {struct node * temp, * ptr temp = (struct node *) malloc (sizeof (struct node)) if (temp == NULL) {printf ('nOut of Memory Memory: n') exit (0) } printf ('n הזן את ערך הנתונים של הצומת: t') scanf ('% d', & temp-> info) temp-> next = NULL if (start == NULL) {start = temp} else {ptr = start בעוד (ptr-> הבא! = NULL) {ptr = ptr-> הבא} ptr-> הבא = temp}} חלל תצוגה () {צומת struct * ptr אם (התחל == NULL) {printf ('nList ריק: n ') להחזיר} אחר {ptr = התחל printf (' n רכיבי הרשימה הם: n ') ואילו (ptr! = NULL) {printf ('% dt ', ptr-> info) ptr = ptr-> הבא}}} בטל insert_begin () {struct node * temp temp = (struct node *) malloc (sizeof (struct node)) if (temp == NULL) {printf ('nOut of Memory Memory: n') return} printf ('n הזן את ערך נתונים לצומת: t ') scanf ('% d ', & temp-> info) temp-> הבא = NULL אם (התחל == NULL) {התחל = temp} אחר {temp-> הבא = התחל התחל = temp }} בטל insert_end () {struct node * temp, * ptr temp = (struct node *) malloc (sizeof (struct node)) if (temp == NULL) {printf ('nOut of Memory Memory: n') return} עמ ' rintf ('n הזן את ערך הנתונים עבור הצומת: t') scanf ('% d', & temp-> info) temp-> next = NULL if (start == NULL) {start = temp} אחר {ptr = התחל בזמן (ptr-> הבא! = NULL) {ptr = ptr-> הבא} ptr-> הבא = temp}} ריק insert_pos () {struct node * ptr, * temp int i, pos temp = (struct node *) malloc ( sizeof (צומת מבנה)) אם (temp == NULL) {printf ('לא מתוך שטח הזיכרון: n') חוזר} printf ('n הזן את המיקום של הצומת החדש שיוחדר: t') scanf ('% d' , & pos) printf ('n הזן את ערך הנתונים של הצומת: t') scanf ('% d', & temp-> info) temp-> הבא = NULL אם (pos == 0) {temp-> הבא = התחל התחל = temp} אחר {עבור (i = 0, ptr = startinext אם (ptr == NULL) {printf ('n המיקום לא נמצא: [לטפל בזהירות] n') לחזור}} temp-> הבא = ptr-> ptr הבא -> הבא = temp}} ריק delete_begin () {struct node * ptr if (ptr == NULL) {printf ('nList is Empty: n') return} else {ptr = start start = start-> next printf (' האלמנט שנמחק הוא:% dt ', ptr-> מידע) חינם (ptr)}} בטל delete_end () {struct node * temp, * ptr if (start == NULL) {printf (' nList is Empty: ') יציאה (0) } אחר אם (התחל-> הבא == NULL) {ptr = התחל התחל = NULL printf ('n האלמנט שנמחק הוא:% dt', ptr-> מידע) חינם (ptr)} אחר {ptr = התחל בעוד (ptr- > הבא! = NULL) {temp = ptr ptr = ptr-> הבא} temp-> הבא = NULL printf ('n האלמנט שנמחק הוא:% dt', ptr-> מידע) חינם (ptr)}} בטל delete_pos () {int i, pos struct node * temp, * ptr if (start == NULL) {printf ('n הרשימה ריקה: n') יציאה (0)} אחרת {printf ('n הזן את המיקום של הצומת שיימחק : t ') scanf ('% d ', & pos) if (pos == 0) {ptr = start start = start-> next printf (' n האלמנט שנמחק הוא:% dt ', ptr-> info) חינם (ptr )} אחר {ptr = התחל עבור (i = 0 הבא אם (ptr == NULL) {printf ('n המיקום לא נמצא: n') להחזיר}} temp-> הבא = ptr-> הבא printf ('n האלמנט שנמחק הוא: % dt ', ptr-> מידע) חינם (ptr)}}החלק הראשון של קוד זה הוא יצירת מבנה. מבנה רשימה מקושר נוצר כך שהוא יכול להחזיק את הנתונים והכתובת כפי שאנו זקוקים להם. זה נעשה כדי לתת למהדר מושג כיצד הצומת צריך להיות.
struct node {int info struct node * הבא}במבנה יש לנו משתנה נתונים שנקרא מידע להחזקת נתונים ומשתנה מצביע לכיוון הכתובת. ישנן פעולות שונות שניתן לבצע ברשימה מקושרת, כמו:
- לִיצוֹר()
- לְהַצִיג()
- insert_begin ()
- insert_end ()
- ] insert_pos ()
- delete_begin ()
- delete_end ()
- delete_pos ()
פונקציות אלה נקראות על ידי הפונקציה הראשית המונעת בתפריט. בפונקציה הראשית אנו לוקחים קלט מהמשתמש על סמך הפעולה שהמשתמש רוצה לעשות בתוכנית. לאחר מכן הקלט נשלח למארז המתגים ומבוסס על קלט משתמש.
בהתבסס על איזה קלט ניתן הפונקציה תיקרא. לאחר מכן, יש לנו פונקציות שונות שיש לפתור. בואו נסתכל על כל אחת מהפונקציות הללו.
צור פונקציה
ראשית, יש פונקציית יצירה ליצירת הרשימה המקושרת. זו הדרך הבסיסית שנוצרת הרשימה המקושרת. מאפשר לנו להסתכל על הקוד.
void create () {struct node * temp, * ptr printf ('n הזן את ערך הנתונים של הצומת: t') scanf ('% d', & temp-> info) temp-> הבא = NULL אם (התחל == NULL ) {התחל = temp} אחר {ptr = התחל בעוד (ptr-> הבא! = NULL) {ptr = ptr-> הבא} ptr-> הבא = temp}}תְפוּקָה
ראשית, שתי עצות נוצרות מהסוג צומת, ptr וטמפ . אנו לוקחים את הערך הדרוש להוספת ברשימה המקושרת מהמשתמש ומאחסנים אותו בחלק המידע של המשתנה הטמפ 'ומקצים את הטמפ' של הבא שהוא החלק של הכתובת לאפס. יש מצביע התחלה המחזיק את תחילת הרשימה. ואז אנו בודקים את תחילת הרשימה. אם תחילת הרשימה אפסה, אנו מקצים טמפ 'למצביע ההתחלה. אחרת, אנו עוברים לנקודה האחרונה בה נוספו הנתונים.
לשם כך, אנו מקצים את ptr לערך ההתחלה ולעבור עד ptr-> הבא = null . לאחר מכן אנו מקצים ptr-> הבא כתובת הטמפ ' באופן דומה, ניתן קוד להכניסה בהתחלה, הכנסה בסוף והכנסה במיקום מוגדר.
פונקציית תצוגה
הנה הקוד לתפקוד התצוגה.
הצגת חלל () {struct node * ptr if (start == NULL) {printf ('nList is blank: n') return} else {ptr = start printf ('n רכיבי הרשימה הם: n') ואילו (ptr! = NULL) {printf ('% dt', ptr-> info) ptr = ptr-> הבא}}}תְפוּקָה
בפונקציית התצוגה נבדוק תחילה אם הרשימה ריקה ונחזור אם היא ריקה. בחלק הבא אנו מקצים את ערך ההתחלה ל- ptr. לאחר מכן אנו מפעילים לולאה עד ש- ptr הוא ריק ומדפיס את אלמנט הנתונים עבור כל צומת, עד ש- ptr הוא null, המציין את סוף הרשימה.
מחק פונקציה
הנה קטע הקוד למחיקת צומת מהרשימה המקושרת.
בטל delete_pos () {int i, pos struct node * temp, * ptr if (start == NULL) {printf ('n הרשימה ריקה: n') יציאה (0)} אחרת {printf ('n הזן את המיקום של צומת למחיקה: t ') scanf ('% d ', & pos) if (pos == 0) {ptr = start start = start-> printf הבא (' n האלמנט שנמחק הוא:% dt ', ptr-> מידע ) חינם (ptr)} אחר {ptr = התחל עבור (i = 0 הבא אם (ptr == NULL) {printf ('n המיקום לא נמצא: n') להחזיר}} temp-> הבא = ptr-> הבא printf ('nThe האלמנט שנמחק הוא:% dt ', ptr-> info) חינם (ptr)}}}תְפוּקָה
בתהליך המחיקה, הוא בודק תחילה אם הרשימה ריקה, אם כן היא קיימת. אם הוא אינו ריק הוא מבקש מהמשתמש למחוק את המיקום. ברגע שהמשתמש נכנס למיקום, הוא בודק אם זה המיקום הראשון, אם כן הוא מקצה ptr כדי להתחיל ולהעביר את מצביע ההתחלה למיקום הבא ומוחק את ptr. אם ה המיקום אינו אפס , ואז הוא מפעיל לולאת for מ- 0 עד למצב שהוזן על ידי המשתמש ושמור ב- pos מִשְׁתַנֶה. יש הצהרת if כדי להחליט אם העמדה שנכנסה אינה קיימת. אם ptr שווה לאפס , אז זה לא קיים.
אָנוּ הקצה ptr לטמפ ' בלולאת ה- for ו- ptr ואז עובר לחלק הבא. אחרי זה כשהמצב נמצא. אנו מייצרים את המשתנה הזמני להחזיק את הערך של ptr-> הבא ובכך לדלג על ה- ptr. ואז ptr נמחק. באופן דומה, ניתן לעשות זאת למחיקת האלמנטים הראשונה והאחרונה.
רשימה מקושרת כפליים
זה נקרא הרשימה המקושרת כפליים מכיוון שיש שתיים מצביעים , נקודה אחת לצומת הבא ונקודות אחרות לצומת הקודם. הפעולות המבוצעות בקישור כפול דומות לאלה של רשימה המקושרת יחידה. הנה הקוד לפעולות בסיסיות.
#include #include struct צומת typedef struct צומת * PtrToNode typedef PtrToNode רשימת typedef PtrToNode מיקום struct צומת {int e מיקום הקודם הבא} ריק ריק (sizeof (struct Node)) אם (TmpCell == NULL) printf ('זיכרון מחוץ למרחב') אחר {TmpCell-> e = x TmpCell-> הקודם = p TmpCell-> הבא = p-> הבא p-> הבא = TmpCell}} בטל מחיקה (int x, רשימה l) {מיקום p, p1, p2 p = מצא (x, l) אם (p! = NULL) {p1 = p -> הקודם p2 = p -> p1 הבא - > הבא = p -> הבא אם (p2! = NULL) // אם הצומת אינו הצומת האחרון p2 -> הקודם = p -> הקודם} אחר printf ('אלמנט לא קיים !!! n')} בטל הצג (רשימה l) {printf ('אלמנט הרשימה הם ::') מיקום p = l-> הבא בעוד (p! = NULL) {printf ('% d ->', p-> e) p = p- > הבא}} int main () {int x, pos, ch, i List l, l1 l = (struct Node *) malloc (sizeof (struct Node)) l-> previous = NULL l-> next = NULL List p = l printf ('יישום רשימות קישור כפולות של L IST ADTnn ') לעשות {printf (' nn1. CREATEn 2. DELETEn 3. DISPLAYn 4. QUITnn הזן את הבחירה :: ') scanf ('% d ', & ch) מתג (ch) {case 1: p = l printf (' הזן את האלמנט שיש להכניס :: ') scanf ('% d', & x) printf ('הזן את מיקום האלמנט ::') scanf ('% d', & pos) עבור (i = 1 iהבא} הכנס (x, l, p) מקרה הפסקה 2: p = l printf ('הזן את האלמנט שיימחק ::') scanf ('% d', & x) מחק (x, p) מקרה הפסקה 3: תצוגה (l) לשבור}} תוך (ch<4) } תְפוּקָה
יציקה מסוג מפורש ב- Java
אז, כפי שאתה יכול לראות הרעיון של פעולות הוא די פשוט. לרשימה המקושרת כפליים יש אותן פעולות כמו זו של רשימה מקושרת בשפת תכנות C. ההבדל היחיד הוא שיש משתנה כתובת אחר שעוזר לחצות את הרשימה בצורה טובה יותר ברשימה המקושרת כפליים.
אני מקווה שהבנת כיצד לבצע פעולות בסיסיות ברשימה מקושרת כפולת בסי '.
אם ברצונך ללמוד רשימה מקושרת ב- Java, הנה .
אם אתה נתקל בשאלות כלשהן, אל תהסס לשאול את כל השאלות שלך בקטע התגובות של 'רשימה מקושרת ב- C' והצוות שלנו ישמח לענות.