توثيق الخوارزميات الشامل

تنفيذ الخوارزمية بلغة JavaScript:

function bubbleSort(arr) {
    const n = arr.length;
    
    // تنفيذ فرز الفقاعة
    for (let i = 0; i < n - 1; i++) {
        // علم للتحقق من حدوث تبديل
        let swapped = false;
        
        for (let j = 0; j < n - i - 1; j++) {
            // قارن العناصر المتجاورة
            if (arr[j] > arr[j + 1]) {
                // تبديل العناصر
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
                swapped = true;
            }
        }
        
        // إذا لم يحدث تبديل في تكرار كامل، فالمصفوفة مرتبة
        if (!swapped) break;
    }
    
    return arr;
}

// مثال للاستخدام
const array = [64, 34, 25, 12, 22, 11, 90];
console.log("المصفوفة قبل الفرز:", array);
bubbleSort(array);
console.log("المصفوفة بعد الفرز:", array);

تنفيذ الخوارزمية بلغة Python:

def selection_sort(arr):
    n = len(arr)
    
    # مرر خلال جميع عناصر المصفوفة
    for i in range(n):
        # ابحث عن الحد الأدنى في المصفوفة غير المرتبة
        min_idx = i
        for j in range(i + 1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
                
        # بدل العنصر الأصغر مع العنصر الأول
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    
    return arr

# مثال للاستخدام
arr = [64, 25, 12, 22, 11]
print("المصفوفة قبل الفرز:", arr)
selection_sort(arr)
print("المصفوفة بعد الفرز:", arr)

تنفيذ الخوارزمية بلغة C++:

#include <iostream>
#include <vector>
using namespace std;

// دالة للتقسيم
int partition(vector<int> &arr, int low, int high) {
    int pivot = arr[high];  // نختار آخر عنصر كمحور
    int i = (low - 1);  // مؤشر العنصر الأصغر
    
    for (int j = low; j <= high - 1; j++) {
        // إذا كان العنصر الحالي أصغر من أو يساوي المحور
        if (arr[j] <= pivot) {
            i++;  // زيادة مؤشر العنصر الأصغر
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return (i + 1);
}

// دالة الفرز السريع
void quickSort(vector<int> &arr, int low, int high) {
    if (low < high) {
        // احصل على موضع التقسيم
        int pi = partition(arr, low, high);
        
        // فرز العناصر قبل وبعد التقسيم
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

// دالة للطباعة
void printArray(const vector<int> &arr) {
    for (int i : arr)
        cout << i << " ";
    cout << endl;
}

int main() {
    vector<int> arr = {10, 7, 8, 9, 1, 5};
    
    cout << "المصفوفة قبل الفرز: ";
    printArray(arr);
    
    quickSort(arr, 0, arr.size() - 1);
    
    cout << "المصفوفة بعد الفرز: ";
    printArray(arr);
    
    return 0;
}

تنفيذ الخوارزمية بلغة Java:

public class MergeSort {
    // دالة دمج مصفوفتين مرتبتين
    void merge(int arr[], int l, int m, int r) {
        // حساب أحجام المصفوفتين الفرعيتين
        int n1 = m - l + 1;
        int n2 = r - m;
 
        // إنشاء مصفوفات مؤقتة
        int L[] = new int[n1];
        int R[] = new int[n2];
 
        // نسخ البيانات إلى المصفوفات المؤقتة
        for (int i = 0; i < n1; ++i)
            L[i] = arr[l + i];
        for (int j = 0; j < n2; ++j)
            R[j] = arr[m + 1 + j];
 
        // دمج المصفوفات المؤقتة
        int i = 0, j = 0;
        int k = l;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }
 
        // نسخ العناصر المتبقية من L[]، إن وجدت
        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }
 
        // نسخ العناصر المتبقية من R[]، إن وجدت
        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
 
    // الدالة الرئيسية التي تقسم المصفوفة وتفرزها
    void sort(int arr[], int l, int r) {
        if (l < r) {
            // إيجاد نقطة المنتصف
            int m = l + (r - l) / 2;
 
            // فرز النصف الأول والثاني
            sort(arr, l, m);
            sort(arr, m + 1, r);
 
            // دمج النصفين المرتبين
            merge(arr, l, m, r);
        }
    }
 
    // دالة للطباعة
    static void printArray(int arr[]) {
        for (int i : arr)
            System.out.print(i + " ");
        System.out.println();
    }
 
    // دالة الاختبار الرئيسية
    public static void main(String args[]) {
        int arr[] = { 12, 11, 13, 5, 6, 7 };
 
        System.out.println("المصفوفة قبل الفرز:");
        printArray(arr);
 
        MergeSort ob = new MergeSort();
        ob.sort(arr, 0, arr.length - 1);
 
        System.out.println("المصفوفة بعد الفرز:");
        printArray(arr);
    }
}

تنفيذ الخوارزمية بلغة Python:

def linear_search(arr, x):
    """
    تنفيذ خوارزمية البحث الخطي
    
    المعطيات:
    arr -- المصفوفة للبحث فيها
    x -- القيمة المطلوب البحث عنها
    
    إرجاع:
    موقع العنصر إذا وجد، وإلا -1
    """
    for i in range(len(arr)):
        if arr[i] == x:
            return i
    return -1

# مثال للاستخدام
arr = [2, 3, 4, 10, 40]
x = 10

# استدعاء دالة البحث
result = linear_search(arr, x)

if result != -1:
    print(f"العنصر موجود في الموقع {result}")
else:
    print("العنصر غير موجود في المصفوفة")

تنفيذ الخوارزمية بلغة JavaScript:

function binarySearch(arr, x) {
    let start = 0;
    let end = arr.length - 1;
    
    while (start <= end) {
        // حساب نقطة المنتصف
        let mid = Math.floor((start + end) / 2);
        
        // إذا وجد العنصر في المنتصف
        if (arr[mid] === x) {
            return mid;
        }
        
        // إذا كان العنصر أكبر من قيمة المنتصف، 
        // ابحث في النصف الأيمن
        if (arr[mid] < x) {
            start = mid + 1;
        } 
        // وإلا، ابحث في النصف الأيسر
        else {
            end = mid - 1;
        }
    }
    
    // العنصر غير موجود
    return -1;
}

// مثال للاستخدام
const sortedArray = [2, 3, 4, 10, 40, 50, 70];
const target = 10;
const result = binarySearch(sortedArray, target);

if (result !== -1) {
    console.log(`العنصر موجود في الموقع ${result}`);
} else {
    console.log("العنصر غير موجود في المصفوفة");
}

مثال لاستخدام المصفوفات بلغة JavaScript:

// إنشاء مصفوفة
let fruits = ['تفاح', 'موز', 'برتقال', 'فراولة'];

// الوصول إلى عنصر باستخدام الفهرس
console.log(fruits[0]);  // تفاح

// تعديل عنصر
fruits[1] = 'كيوي';
console.log(fruits);  // ['تفاح', 'كيوي', 'برتقال', 'فراولة']

// إضافة عنصر في النهاية
fruits.push('مانجو');
console.log(fruits);  // ['تفاح', 'كيوي', 'برتقال', 'فراولة', 'مانجو']

// حذف آخر عنصر
let lastFruit = fruits.pop();
console.log(lastFruit);  // مانجو
console.log(fruits);  // ['تفاح', 'كيوي', 'برتقال', 'فراولة']

// إضافة عنصر في البداية
fruits.unshift('عنب');
console.log(fruits);  // ['عنب', 'تفاح', 'كيوي', 'برتقال', 'فراولة']

// حذف أول عنصر
let firstFruit = fruits.shift();
console.log(firstFruit);  // عنب
console.log(fruits);  // ['تفاح', 'كيوي', 'برتقال', 'فراولة']

// الحصول على طول المصفوفة
console.log(fruits.length);  // 4

// البحث عن عنصر
let orangeIndex = fruits.indexOf('برتقال');
console.log(orangeIndex);  // 2

تنفيذ قائمة متصلة بسيطة بلغة JavaScript:

// تعريف فئة العقدة
class Node {
    constructor(data) {
        this.data = data;  // القيمة المخزنة في العقدة
        this.next = null;  // مؤشر للعقدة التالية
    }
}

// تعريف فئة القائمة المتصلة البسيطة
class LinkedList {
    constructor() {
        this.head = null;  // رأس القائمة
        this.size = 0;     // حجم القائمة
    }
    
    // إضافة عنصر في نهاية القائمة
    append(data) {
        // إنشاء عقدة جديدة
        const newNode = new Node(data);
        
        // إذا كانت القائمة فارغة، اجعل العقدة الجديدة هي الرأس
        if (!this.head) {
            this.head = newNode;
        } else {
            // تصفح القائمة حتى آخر عقدة
            let current = this.head;
            while (current.next) {
                current = current.next;
            }
            
            // اجعل مؤشر آخر عقدة يشير إلى العقدة الجديدة
            current.next = newNode;
        }
        
        this.size++;
    }
    
    // إضافة عنصر في بداية القائمة
    prepend(data) {
        // إنشاء عقدة جديدة
        const newNode = new Node(data);
        
        // اجعل مؤشر العقدة الجديدة يشير إلى الرأس الحالي
        newNode.next = this.head;
        
        // اجعل العقدة الجديدة هي الرأس
        this.head = newNode;
        
        this.size++;
    }
    
    // عرض القائمة
    printList() {
        let current = this.head;
        const elements = [];
        
        while (current) {
            elements.push(current.data);
            current = current.next;
        }
        
        return elements.join(' -> ');
    }
    
    // الحصول على حجم القائمة
    getSize() {
        return this.size;
    }
}

// مثال للاستخدام
const list = new LinkedList();
list.append(10);
list.append(20);
list.append(30);
list.prepend(5);

console.log(list.printList());  // 5 -> 10 -> 20 -> 30
console.log(`حجم القائمة: ${list.getSize()}`);  // حجم القائمة: 4

الطابور (Queue)

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

class Queue {
    constructor() {
        this.items = [];
    }
    
    // إضافة عنصر إلى نهاية الطابور
    enqueue(element) {
        this.items.push(element);
    }
    
    // إزالة وإرجاع العنصر من مقدمة الطابور
    dequeue() {
        if (this.isEmpty()) {
            return "الطابور فارغ";
        }
        return this.items.shift();
    }
    
    // عرض العنصر الموجود في مقدمة الطابور
    front() {
        if (this.isEmpty()) {
            return "الطابور فارغ";
        }
        return this.items[0];
    }
    
    // التحقق إذا كان الطابور فارغًا
    isEmpty() {
        return this.items.length === 0;
    }
    
    // إرجاع حجم الطابور
    size() {
        return this.items.length;
    }
    
    // تفريغ الطابور
    clear() {
        this.items = [];
    }
    
    // عرض الطابور
    print() {
        return this.items.toString();
    }
}

// مثال للاستخدام
const queue = new Queue();
queue.enqueue('أحمد');
queue.enqueue('محمد');
queue.enqueue('علي');

console.log(`الطابور: ${queue.print()}`);  // الطابور: أحمد,محمد,علي
console.log(`العنصر في المقدمة: ${queue.front()}`);  // العنصر في المقدمة: أحمد

console.log(`عنصر تمت إزالته: ${queue.dequeue()}`);  // عنصر تمت إزالته: أحمد
console.log(`الطابور بعد الإزالة: ${queue.print()}`);  // الطابور بعد الإزالة: محمد,علي

تنفيذ شجرة ثنائية للبحث بلغة Python:

class Node:
    def __init__(self, key):
        self.left = None
        self.right = None
        self.val = key

class BinarySearchTree:
    def __init__(self):
        self.root = None
    
    # إدراج عقدة في الشجرة
    def insert(self, root, key):
        # إذا كانت الشجرة فارغة، أرجع عقدة جديدة
        if root is None:
            return Node(key)
        
        # وإلا، تابع اجتياز الشجرة
        if key < root.val:
            root.left = self.insert(root.left, key)
        else:
            root.right = self.insert(root.right, key)
        
        return root
    
    # البحث عن عقدة في الشجرة
    def search(self, root, key):
        # الحالة الأساسية: إذا كان الجذر فارغًا أو يحتوي على المفتاح المطلوب
        if root is None or root.val == key:
            return root
        
        # المفتاح أكبر من قيمة الجذر
        if root.val < key:
            return self.search(root.right, key)
        
        # المفتاح أصغر من قيمة الجذر
        return self.search(root.left, key)
    
    # اجتياز الشجرة بطريقة In-order
    def inorder_traversal(self, root):
        result = []
        if root:
            result = self.inorder_traversal(root.left)
            result.append(root.val)
            result = result + self.inorder_traversal(root.right)
        return result

# مثال للاستخدام
bst = BinarySearchTree()
root = None

# إدراج عناصر في الشجرة
keys = [50, 30, 20, 40, 70, 60, 80]
for key in keys:
    root = bst.insert(root, key)

# اجتياز الشجرة بطريقة In-order
print("اجتياز الشجرة بطريقة In-order:")
print(bst.inorder_traversal(root))  # [20, 30, 40, 50, 60, 70, 80]

# البحث عن قيمة في الشجرة
search_key = 40
result = bst.search(root, search_key)
if result:
    print(f"العنصر {search_key} موجود في الشجرة")
else:
    print(f"العنصر {search_key} غير موجود في الشجرة")

تنفيذ رسم بياني باستخدام قائمة المجاورة بلغة C++:

#include <iostream>
#include <vector>
using namespace std;

// فئة الرسم البياني
class Graph {
private:
    int V;  // عدد الرؤوس
    vector<vector<int>> adj;  // قائمة المجاورة
    
public:
    // المنشئ
    Graph(int vertices) {
        V = vertices;
        adj.resize(V);
    }
    
    // إضافة حافة في الرسم البياني غير الموجه
    void addEdge(int u, int v) {
        adj[u].push_back(v);
        adj[v].push_back(u);  // يُحذف هذا السطر للرسم البياني الموجه
    }
    
    // طباعة قائمة المجاورة
    void printGraph() {
        for (int v = 0; v < V; ++v) {
            cout << "قائمة المجاورة للرأس " << v << ": ";
            for (auto x : adj[v]) {
                cout << "-> " << x;
            }
            cout << endl;
        }
    }
    
    // البحث في العمق (DFS)
    void DFSUtil(int v, vector<bool> &visited) {
        // تأشير الرأس الحالي كـ "تمت زيارته"
        visited[v] = true;
        cout << v << " ";
        
        // تكرار لجميع الرؤوس المجاورة للرأس الحالي
        for (auto x : adj[v]) {
            if (!visited[x]) {
                DFSUtil(x, visited);
            }
        }
    }
    
    // دالة البحث في العمق
    void DFS(int startVertex) {
        // إنشاء مصفوفة للتأشير على الرؤوس المزارة
        vector<bool> visited(V, false);
        
        cout << "نتيجة البحث في العمق بدءًا من الرأس " << startVertex << ": ";
        DFSUtil(startVertex, visited);
        cout << endl;
    }
    
    // البحث في العرض (BFS)
    void BFS(int startVertex) {
        // إنشاء مصفوفة للتأشير على الرؤوس المزارة
        vector<bool> visited(V, false);
        
        // إنشاء طابور للرؤوس
        vector<int> queue;
        
        // تأشير الرأس الابتدائي كـ "تمت زيارته" وإضافته للطابور
        visited[startVertex] = true;
        queue.push_back(startVertex);
        
        cout << "نتيجة البحث في العرض بدءًا من الرأس " << startVertex << ": ";
        
        while (!queue.empty()) {
            // إخراج رأس من الطابور وطباعته
            startVertex = queue.front();
            cout << startVertex << " ";
            queue.erase(queue.begin());
            
            // الحصول على جميع الرؤوس المجاورة للرأس الحالي
            // إذا لم تتم زيارته بعد، تأشيره كـ "تمت زيارته" وإضافته للطابور
            for (auto x : adj[startVertex]) {
                if (!visited[x]) {
                    visited[x] = true;
                    queue.push_back(x);
                }
            }
        }
        cout << endl;
    }
};

// الدالة الرئيسية
int main() {
    // إنشاء رسم بياني بـ 5 رؤوس
    Graph g(5);
    
    // إضافة حواف
    g.addEdge(0, 1);
    g.addEdge(0, 4);
    g.addEdge(1, 2);
    g.addEdge(1, 3);
    g.addEdge(1, 4);
    g.addEdge(2, 3);
    g.addEdge(3, 4);
    
    // طباعة تمثيل الرسم البياني
    cout << "تمثيل الرسم البياني باستخدام قائمة المجاورة:" << endl;
    g.printGraph();
    
    // تنفيذ البحث في العمق والعرض
    g.DFS(0);
    g.BFS(0);
    
    return 0;
}

مثال 2: مسألة الحقيبة (0/1 Knapsack Problem)

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

def knapsack(W, wt, val, n):
    """
    حل مسألة الحقيبة باستخدام البرمجة الديناميكية
    
    المعطيات:
    W -- سعة الحقيبة
    wt -- مصفوفة الأوزان
    val -- مصفوفة القيم
    n -- عدد العناصر
    
    إرجاع:
    أقصى قيمة يمكن وضعها في الحقيبة
    """
    # إنشاء جدول للبرمجة الديناميكية
    dp = [[0 for _ in range(W + 1)] for _ in range(n + 1)]
    
    # بناء الجدول dp[][] بطريقة تصاعدية
    for i in range(1, n + 1):
        for w in range(1, W + 1):
            # إذا كان وزن العنصر الحالي أكبر من سعة الحقيبة الفرعية
            if wt[i-1] > w:
                dp[i][w] = dp[i-1][w]
            # وإلا، نختار الأفضل: تضمين العنصر أو عدم تضمينه
            else:
                dp[i][w] = max(val[i-1] + dp[i-1][w-wt[i-1]], dp[i-1][w])
                
    return dp[n][W]

# مثال للاستخدام
val = [60, 100, 120]  # قيم العناصر
wt = [10, 20, 30]     # أوزان العناصر
W = 50                # سعة الحقيبة
n = len(val)          # عدد العناصر

result = knapsack(W, wt, val, n)
print(f"أقصى قيمة يمكن وضعها في الحقيبة: {result}")  # 220