تصحيح أخطاء فرز الدمج

تبدو محاولتك لتنفيذ فرز الدمج على قائمة مرتبطة صحيحة بشكل عام، لكن هناك بعض الأخطاء في الشيفرة التي يتعين تصحيحها. لنقم بتحليل الشيفرة وتحديد الأخطاء:

1. في وظيفة merge:

   • يجب استخدام listnode * بدلاً من struct listnode * لنوع المعلمة الثانية.
   • في الشرط else if (node_2 = NULL)، يجب استخدام == بدلاً من = للمقارنة بين node_2 و NULL.
   • بداخل الدالة، تحتاج إلى التأكد من تحرير الذاكرة المُخصصة للعقد التي تم دمجها، وهذا يعني أنه يجب عليك استدعاء free على العقد بعد الدمج.

2. في دالة main:

   • يجب تضمين واستخدام std::cout بدلاً من cout.
   • قد تحتاج أيضًا إلى استدعاء free لتحرير الذاكرة المخصصة لكل عقد بعد انتهاء البرنامج.

لحل هذه المشاكل، يجب تعديل الشيفرة على النحو التالي:

cppCopy code
#include 
#include 

using namespace std;

struct listnode { 
    struct listnode *next; 
    int key; 
};

void separate(struct listnode *node, struct listnode **front, struct listnode **back);

struct listnode *merge(struct listnode *node_1, struct listnode *node_2);

void mergeSort(struct listnode **node) {
    struct listnode *head = *node; 
    struct listnode *node_1; 
    struct listnode *node_2;

    if ((head == NULL) || (head->next == NULL)) { 
        return; 
    }

    separate(head, &node_1, &node_2); 
    mergeSort(&node_1); 
    mergeSort(&node_2); 
    *node = merge(node_1, node_2);
}

struct listnode *merge(struct listnode *node_1, struct listnode *node_2) {
    struct listnode *return_result = NULL;
    if (node_1 == NULL) { 
        return node_2; 
    } else if (node_2 == NULL) { 
        return node_1; 
    }

    if (node_1->key <= node_2->key) {
        return_result = node_1; 
        return_result->next = merge(node_1->next, node_2); 
    } else { 
        return_result = node_2; 
        return_result->next = merge(node_1, node_2->next); 
    }

    return return_result;
}

void separate(struct listnode *node, struct listnode **front, struct listnode **back) {
    struct listnode *fast; 
    struct listnode *slow;

    if (node == NULL || node->next == NULL) { 
        *front = node; 
        *back = NULL; 
    } else {
        slow = node; 
        fast = node->next;

        while (fast != NULL) {
            fast = fast->next;
            if (fast != NULL) { 
                slow = slow->next; 
                fast = fast->next; 
            }
        }

        *front = node; 
        *back = slow->next; 
        slow->next = NULL;
    }
}

void push(struct listnode **head, int data) {
    struct listnode *added_node = (struct listnode *)malloc(sizeof(struct listnode));
    added_node->key = data;
    added_node->next = (*head);
    (*head) = added_node;
}

void printList(struct listnode *node) {
    while (node != NULL) {
        cout << node->key << " ";
        node = node->next;
    }
}

int main() {
    struct listnode *node1 = NULL;

    push(&node1, 3); 
    push(&node1, 30); 
    push(&node1, 23); 
    push(&node1, 1); 
    push(&node1, 0); 
    push(&node1, 9);

    mergeSort(&node1);

    cout << endl;
    printList(node1);

    // Freeing memory
    struct listnode *temp;
    while (node1 != NULL) {
        temp = node1;
        node1 = node1->next;
        free(temp);
    }

    return 0;
}

بعد التعديلات، ينبغي أن يعمل الشيفرة بشكل صحيح ويعطيك الناتج المتوقع. لا تنسى دائمًا تحرير الذاكرة المخصصة بعد الانتهاء من استخدام القوائم المرتبطة لتجنب تسريب الذاكرة.

بالطبع، إليك إكمال المقال:

بعد إجراء التعديلات اللازمة على الشيفرة، يمكننا الآن فحص عملية فرز الدمج لقائمة مرتبطة. تعتبر عملية فرز الدمج من الخوارزميات الشهيرة والفعالة لفرز البيانات، وتعتمد على مبدأ الانقسام والفتح (Divide and Conquer) لتقسيم القائمة إلى أقسام صغيرة قبل دمجها بشكل متسلسل.

تتضمن الخطوات الرئيسية لفرز الدمج على القوائم المرتبطة:

1. تقسيم القائمة: نقوم بتقسيم القائمة إلى نصفين، وذلك بواسطة العثور على العقد الوسيط في القائمة. هذا يتم عادةً بواسطة استخدام مؤشرين؛ أحدهما يتقدم بسرعة مزدوجة مقارنة بالآخر، مما يسمح بالعثور على المكان الوسيط للتقسيم.

2. فرز الأقسام الفرعية: بعد التقسيم، نقوم بتطبيق عملية الفرز الدمج على كل نصف بشكل منفصل. هذه العملية تُكرَّر بشكل متكرر حتى يتم فرز القوائم الفرعية إلى عقد فردي.

3. دمج القوائم الفرعية: بمجرد فرز القوائم الفرعية إلى عقد فردي، نقوم بدمجها معًا بشكل متسلسل لإنشاء قائمة نهائية مرتبة.

4. إعادة القائمة المرتبة: بعد الدمج النهائي، يتم إعادة هيكلة القائمة المرتبة بشكل صحيح، ويتم إعادة تعيين المؤشرات والروابط بين العقد لتمثيل القائمة المرتبة بالكامل.

بتنفيذ هذه الخطوات بشكل صحيح، يمكن لفرز الدمج أن يقدم أداءً فعّالًا في ترتيب البيانات، ويُعتبر من الخوارزميات الأساسية في مجالات مثل علم الحوسبة والذكاء الاصطناعي وعلم البيانات.

باستخدام الشيفرة المحدثة والتصحيحات التي قمنا بها، يجب أن تعمل عملية فرز الدمج الآن بشكل صحيح على القائمة المرتبطة الخاصة بك. يمكنك الآن استخدام هذه الشيفرة كنقطة انطلاق لتطبيقاتك الحقيقية واختبارها مع مجموعات بيانات أكبر وأكثر تعقيدًا.

في النهاية، يجب دائمًا أن نتذكر أهمية فحص الشيفرة بشكل دقيق وتصحيح أي أخطاء قد تظهر، حيث أن البرمجة الجيدة تتطلب الدقة والاهتمام بالتفاصيل لضمان أداء البرنامج بكفاءة وصحة.

بهذا، يتم إكمال المقال حول فرز الدمج لقوائم مرتبطة، مع التركيز على تصحيح الأخطاء في الشيفرة المقدمة. إذا كان لديك أي أسئلة إضافية أو استفسارات، فلا تتردد في طرحها.