شرح هياكل البيانات والخوارزميات بالعربي، دليل مبسّط

إذا كنت طالب علوم حاسب أو تقنية معلومات، فمادة هياكل البيانات والخوارزميات (Data Structures & Algorithms) من أهم المواد اللي راح تدرسها في مسيرتك الجامعية. هذه المادة هي الأساس اللي تُبنى عليه كل مواد البرمجة المتقدمة، ومن أكثر المواضيع اللي تُسأل عنها في المقابلات الوظيفية.

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

في هذا الدليل، راح نشرح لك أهم هياكل البيانات والخوارزميات بأسلوب واضح ومباشر، مع أمثلة من الحياة الواقعية وأكواد مبسطة تساعدك تفهم الفكرة من أول مرة.

ليش هياكل البيانات والخوارزميات مهمة؟

قبل ما ندخل في التفاصيل، خلنا نفهم ليش هذه المادة مهمة أصلا.

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

نفس الفكرة بالضبط تنطبق على البرمجة: هياكل البيانات هي طريقة تنظيم وتخزين البيانات في الذاكرة، والخوارزميات هي الخطوات المنظمة لمعالجة هذه البيانات (مثل البحث والترتيب والإضافة والحذف).

اختيار هيكل البيانات المناسب ممكن يكون الفرق بين برنامج ينفّذ عملية في ثانية وبرنامج يحتاج ساعة لنفس العملية. وهذا بالضبط ما يريد الدكتور إنك تتعلمه.

---

أولا: هياكل البيانات (Data Structures)

1. المصفوفات (Arrays)

التشبيه: تخيل صف من الخزائن المرقمة في المدرسة. كل خزانة لها رقم ثابت (index)، وتقدر تروح مباشرة لأي خزانة إذا تعرف رقمها.

المصفوفة هي أبسط هيكل بيانات: مجموعة عناصر من نفس النوع مخزّنة بشكل متتالي في الذاكرة. كل عنصر له موقع (index) يبدأ من الصفر.

مميزاتها:

• الوصول لأي عنصر فوري (بالـ index)، يعني O(1)
• بسيطة وسهلة الاستخدام

عيوبها:

• حجمها ثابت بعد الإنشاء (في أغلب اللغات)
• إدراج أو حذف عنصر من النص مكلّف لأنك تحتاج تزحلق بقية العناصر

// إنشاء مصفوفة بحجم 5
int[] grades = {85, 92, 78, 95, 88};

// الوصول لعنصر: سريع جدا O(1)
System.out.println(grades[0]); // 85
System.out.println(grades[3]); // 95

// المرور على كل العناصر: O(n)
for (int i = 0; i < grades.length; i++) {
    System.out.println("الدرجة " + (i+1) + ": " + grades[i]);
}

متى تستخدمها؟ عندما تعرف حجم البيانات مسبقا وتحتاج وصول سريع للعناصر بالموقع.

---

2. القوائم المتصلة (Linked Lists)

التشبيه: تخيل قطار. كل عربة (عقدة/Node) فيها حمولة (البيانات) ورابط يوصلها بالعربة اللي بعدها. ما تقدر تروح للعربة رقم 5 مباشرة، لازم تمر بالعربات اللي قبلها وحدة وحدة.

القائمة المتصلة هي سلسلة من العقد (Nodes)، كل عقدة تحتوي على:

1. البيانات (القيمة المخزنة)
2. مؤشر (Pointer) يشير للعقدة التالية

[بيانات|التالي] → [بيانات|التالي] → [بيانات|null]
     Head                                    Tail

// تعريف عقدة في القائمة المتصلة
class Node {
    int data;       // البيانات
    Node next;      // مؤشر للعقدة التالية

    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

بعد تعريف العقدة، ننشئ قائمة متصلة ونمر على عناصرها:

// إنشاء قائمة متصلة بسيطة
Node head = new Node(10);
head.next = new Node(20);
head.next.next = new Node(30);

// المرور على القائمة وطباعة العناصر
Node current = head;
while (current != null) {
    System.out.print(current.data + " → ");
    current = current.next;
}
// الخرج: 10 → 20 → 30 →

مميزاتها:

• الإضافة والحذف من البداية سريعة جدا، O(1)
• حجمها ديناميكي (تكبر وتصغر حسب الحاجة)

عيوبها:

• الوصول لعنصر معين يحتاج المرور من البداية، O(n)
• تستهلك ذاكرة أكثر بسبب المؤشرات

متى تستخدمها؟ عندما تحتاج إدراج وحذف متكرر ولا تحتاج وصول عشوائي سريع.

---

3. المكدسات (Stacks)

التشبيه: تخيل كومة صحون. آخر صحن تحطه فوق هو أول صحن تشيله. ما تقدر تشيل صحن من النص بدون ما تشيل اللي فوقه أولا.

المكدس يعمل بمبدأ LIFO، Last In, First Out (آخر داخل أول خارج). يعني آخر عنصر تضيفه هو أول عنصر تحذفه.

العمليات الأساسية:

• Push: إضافة عنصر في الأعلى
• Pop: حذف العنصر من الأعلى
• Peek/Top: قراءة العنصر في الأعلى بدون حذفه
• isEmpty: التحقق هل المكدس فاضي

import java.util.Stack;

Stack<String> stack = new Stack<>();

// إضافة عناصر (Push)
stack.push("صفحة 1");
stack.push("صفحة 2");
stack.push("صفحة 3");

// قراءة العنصر العلوي بدون حذف (Peek)
System.out.println("العنصر العلوي: " + stack.peek());
// الخرج: صفحة 3

// حذف العنصر العلوي (Pop)
System.out.println("تم حذف: " + stack.pop()); // صفحة 3
System.out.println("تم حذف: " + stack.pop()); // صفحة 2

// التحقق من الحجم
System.out.println("العناصر المتبقية: " + stack.size()); // 1

أين يُستخدم المكدس في الحياة الحقيقية؟

• زر التراجع (Undo) في أي برنامج، كل عملية تنحط في المكدس، ولما تضغط Ctrl+Z يشيل آخر عملية
• تاريخ المتصفح، زر الرجوع يشيل آخر صفحة زرتها
• استدعاء الدوال في البرمجة (Call Stack)

---

4. الطوابير (Queues)

التشبيه: تخيل طابور الكاشير في السوبرماركت. أول شخص يوصل هو أول شخص يُخدم. ما أحد يقطع الطابور (نظريا).

الطابور يعمل بمبدأ FIFO، First In, First Out (أول داخل أول خارج). يعني أول عنصر تضيفه هو أول عنصر يطلع.

العمليات الأساسية:

• Enqueue: إضافة عنصر في النهاية (آخر الطابور)
• Dequeue: حذف عنصر من البداية (أول الطابور)
• Front/Peek: قراءة العنصر الأول بدون حذفه
• isEmpty: التحقق هل الطابور فاضي

import java.util.LinkedList;
import java.util.Queue;

Queue<String> queue = new LinkedList<>();

// إضافة عناصر (Enqueue)
queue.add("طالب 1");
queue.add("طالب 2");
queue.add("طالب 3");

// قراءة العنصر الأول بدون حذف (Peek)
System.out.println("الأول في الطابور: " + queue.peek());
// الخرج: طالب 1

// حذف العنصر الأول (Dequeue)
System.out.println("تمت خدمة: " + queue.poll()); // طالب 1
System.out.println("تمت خدمة: " + queue.poll()); // طالب 2

// التحقق من الحجم
System.out.println("المنتظرون: " + queue.size()); // 1

أين يُستخدم الطابور في الحياة الحقيقية؟

• طابعة مشتركة، أوامر الطباعة تُنفذ بالترتيب اللي وصلت فيه
• معالجة الطلبات في الخوادم (Servers)، أول طلب يوصل أول طلب يُعالج
• BFS (البحث بالعرض أولا) في الرسوم البيانية

---

5. الأشجار (Trees)

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

الشجرة هيكل بيانات هرمي يتكون من عقد (Nodes) مرتبطة بعلاقات أب-ابن. أشهر نوع هو شجرة البحث الثنائية (Binary Search Tree، BST) حيث كل عقدة لها ابن أيسر (أصغر منها) وابن أيمن (أكبر منها) كحد أقصى.

المصطلحات الأساسية:

• الجذر (Root): العقدة العليا في الشجرة
• الورقة (Leaf): عقدة ما لها أبناء
• الارتفاع (Height): عدد المستويات من الجذر لأبعد ورقة
• الابن الأيسر/الأيمن: الفروع المتصلة بالعقدة

        50           ← الجذر (Root)
       /  \
     30    70        ← المستوى الأول
    /  \   /  \
  20   40 60   80    ← أوراق (Leaves)

// تعريف عقدة في شجرة ثنائية
class TreeNode {
    int data;
    TreeNode left;   // الابن الأيسر
    TreeNode right;  // الابن الأيمن

    TreeNode(int data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

// إنشاء شجرة بسيطة
TreeNode root = new TreeNode(50);
root.left = new TreeNode(30);
root.right = new TreeNode(70);
root.left.left = new TreeNode(20);
root.left.right = new TreeNode(40);

لماذا شجرة البحث الثنائية مهمة؟ لأن البحث فيها سريع جدا، في كل خطوة تستبعد نصف البيانات. إذا الشجرة متوازنة، عملية البحث تكون O(log n) بدل O(n) في القائمة المتصلة.

أين تُستخدم الأشجار؟

• أنظمة الملفات على جهازك، المجلدات والملفات مرتبة بشكل شجري
• قواعد البيانات، تستخدم أشجار B-Tree و B+ Tree لتسريع البحث
• ضغط البيانات، خوارزمية Huffman تستخدم الأشجار

---

ثانيا: خوارزميات الترتيب (Sorting Algorithms)

الترتيب من أكثر العمليات استخداما في البرمجة. كل مرة تفتح تطبيق وتختار “ترتيب حسب السعر” أو “الأحدث أولا”، فيه خوارزمية ترتيب تشتغل في الخلفية.

1. الترتيب الفقاعي (Bubble Sort)

التشبيه: تخيل صف طلاب واقفين حسب الطول. تمر عليهم من اليسار لليمين، وكل ما تلاقي شخصين الأطول قبل الأقصر، تبدّل مكانهم. تكرر هذه العملية لحد ما يصير الصف مرتب. العناصر الكبيرة “تطفو” للأعلى مثل الفقاعات.

الفكرة: قارن كل عنصرين متجاورين، وإذا كانوا بترتيب خاطئ بدّل مكانهم. كرر لحد ما ما تصير فيه تبديلات.

void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        boolean swapped = false;
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // تبديل العنصرين
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
        // إذا ما صار أي تبديل، المصفوفة مرتبة
        if (!swapped) break;
    }
}

نجرّب الخوارزمية على مصفوفة غير مرتبة:

// مثال
int[] arr = {64, 34, 25, 12, 22};
bubbleSort(arr);
// النتيجة: {12, 22, 25, 34, 64}

التعقيد الزمني: O(n²) في أسوأ حالة، بطيء للبيانات الكبيرة، لكنه أبسط خوارزمية ترتيب للفهم.

---

2. ترتيب الاختيار (Selection Sort)

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

الفكرة: في كل دورة، ابحث عن أصغر عنصر في الجزء غير المرتب وبدّله مع أول عنصر في ذلك الجزء.

void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        // ابحث عن أصغر عنصر في الجزء المتبقي
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        // بدّل أصغر عنصر مع العنصر الحالي
        int temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

نجرّب الخوارزمية على مصفوفة:

// مثال
int[] arr = {64, 25, 12, 22, 11};
selectionSort(arr);
// النتيجة: {11, 12, 22, 25, 64}

التعقيد الزمني: O(n²) دائما، حتى لو المصفوفة مرتبة. لكنه يتميز بأنه يعمل أقل عدد من التبديلات (swaps) مقارنة بـ Bubble Sort.

---

3. ترتيب الإدراج (Insertion Sort)

التشبيه: تخيل إنك تلعب ورق (كوتشينة). كل ما تسحب ورقة جديدة، تدخلها في مكانها الصحيح بين الأوراق اللي في يدك. يعني يدك دائما مرتبة.

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

void insertionSort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; i++) {
        int key = arr[i];  // العنصر اللي نريد إدراجه
        int j = i - 1;

        // زحلق العناصر الأكبر من key لليمين
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        // ضع key في مكانه الصحيح
        arr[j + 1] = key;
    }
}

نجرّب الخوارزمية على مصفوفة غير مرتبة:

// مثال
int[] arr = {12, 11, 13, 5, 6};
insertionSort(arr);
// النتيجة: {5, 6, 11, 12, 13}

التعقيد الزمني: O(n²) في أسوأ حالة، لكنه O(n) إذا كانت المصفوفة شبه مرتبة. وهذا يجعله الأفضل بين الثلاثة للبيانات شبه المرتبة.

---

ثالثا: خوارزميات البحث (Searching Algorithms)

1. البحث الخطي (Linear Search)

التشبيه: تخيل إنك تبحث عن كتاب معين في مكتبة غير مرتبة. ما عندك خيار غير إنك تمر على الكتب وحدة وحدة من البداية لحد ما تلاقيه.

الفكرة: امر على كل عنصر في المصفوفة من البداية للنهاية وقارنه بالقيمة المطلوبة. إذا لقيته رجّع موقعه، وإذا وصلت النهاية بدون ما تلاقيه رجّع -1.

int linearSearch(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;  // لقيناه! رجّع الموقع
        }
    }
    return -1;  // ما لقيناه
}

// مثال
int[] numbers = {15, 23, 8, 42, 16, 4};
int result = linearSearch(numbers, 42);
System.out.println("العنصر 42 في الموقع: " + result); // 3

التعقيد الزمني: O(n)، في أسوأ حالة تمر على كل العناصر.

متى تستخدمه؟ عندما تكون البيانات غير مرتبة أو صغيرة الحجم.

---

2. البحث الثنائي (Binary Search)

التشبيه: تخيل إنك تبحث عن كلمة في القاموس. ما تبدأ من الصفحة الأولى، تفتح القاموس من النص. إذا الكلمة اللي تبحث عنها ترتيبها قبل الصفحة اللي فتحتها، تروح للنص الأول. وإذا بعدها، تروح للنص الثاني. وتكرر نفس العملية لحد ما تلاقيها.

الفكرة: البحث الثنائي يشتغل فقط على بيانات مرتبة. في كل خطوة، قارن العنصر الأوسط مع القيمة المطلوبة:

• إذا تساووا، لقيناه
• إذا المطلوب أصغر، ابحث في النصف الأيسر
• إذا المطلوب أكبر، ابحث في النصف الأيمن

int binarySearch(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;

    while (left <= right) {
        int mid = left + (right - left) / 2;

        if (arr[mid] == target) {
            return mid;           // لقيناه!
        } else if (arr[mid] < target) {
            left = mid + 1;       // ابحث في النصف الأيمن
        } else {
            right = mid - 1;      // ابحث في النصف الأيسر
        }
    }
    return -1;  // ما لقيناه
}

نجرّب الدالة على مصفوفة مرتبة:

// مثال: المصفوفة لازم تكون مرتبة
int[] sorted = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
int result = binarySearch(sorted, 23);
System.out.println("العنصر 23 في الموقع: " + result); // 5

التعقيد الزمني: O(log n)، أسرع بكثير من البحث الخطي. مثلا في مصفوفة فيها مليون عنصر، البحث الخطي يحتاج مليون مقارنة في أسوأ حالة، بينما البحث الثنائي يحتاج حوالي 20 مقارنة فقط.

---

مقارنة شاملة بين البحث الخطي والبحث الثنائي

المعيار	البحث الخطي	البحث الثنائي
التعقيد الزمني	O(n)	O(log n)
الشرط	لا يحتاج ترتيب	يحتاج بيانات مرتبة
عدد المقارنات (مليون عنصر)	حتى 1,000,000	حوالي 20
سهولة التطبيق	بسيط جدا	يحتاج دقة في حساب النصف
الأفضل للاستخدام	بيانات صغيرة أو غير مرتبة	بيانات كبيرة ومرتبة

---

كيف تربط هذه المفاهيم بمشروع تخرجك

هياكل البيانات والخوارزميات ما هي بس مادة تدرسها وتنساها بعد الاختبار. هذه المفاهيم ستحتاجها فعليا في مشروع تخرجك وفي حياتك المهنية، وستحتاج اختيار لغة البرمجة المناسبة لتطبيقها:

• تبني نظام إدارة؟ ستحتاج المصفوفات والقوائم لتخزين البيانات، والأشجار لتنظيم القوائم الهرمية (مثل الأقسام والفروع)
• تبني تطبيق بحث؟ ستحتاج خوارزميات البحث والترتيب لعرض النتائج بسرعة
• تبني تطبيق دردشة؟ ستحتاج الطوابير لإدارة الرسائل بالترتيب
• تبني نظام تراجع (Undo)؟ ستحتاج المكدسات

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

---

نصائح للتفوق في مادة هياكل البيانات والخوارزميات

• ارسم قبل ما تكتب كود. كل هيكل بيانات وكل خوارزمية تصير أوضح بكثير لما ترسمها على ورقة. ارسم المصفوفة، ارسم السهام في القائمة المتصلة، تتبع خطوات الترتيب يدويا. هذه الطريقة أفضل من حفظ الكود
• نفّذ بنفسك. لا تكتفي بقراءة الكود. افتح بيئة التطوير واكتب كل هيكل بيانات من الصفر. حاول تكتب push و pop للمكدس بنفسك بدون ما تنسخ
• قارن واختبر. جرب ترتب نفس المصفوفة بالخوارزميات الثلاث واحسب عدد المقارنات والتبديلات. هذا يعطيك فهم عملي للفرق بينها
• حل مسائل على LeetCode. ابدأ بالمسائل السهلة (Easy) في قسم Arrays و Linked Lists و Stacks. التطبيق العملي هو أسرع طريقة لتثبيت المعلومة
• افهم Big O قبل كل شيء. إذا فهمت كيف تقيس كفاءة الخوارزمية بتحليل التعقيد الزمني (Time Complexity)، بقية المادة تصير أسهل بكثير

الخلاصة

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

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

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