هياكل البيانات في التطبيقات الصناعية

ما هي هياكل البيانات ولماذا تهمّ المهندس؟

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

هيكل البيانات (Data Structure) هو نفس الفكرة بالضبط — طريقة تنظيم البيانات في الذاكرة بحيث يمكن الوصول إليها ومعالجتها بأسرع وأكفأ طريقة ممكنة. اختيار الهيكل المناسب يعني الفرق بين نظام مراقبة يستجيب بمللي ثانية ونظام يتجمّد عند كل إنذار.

المصفوفة (Array): التخزين المتتالي

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

الاستخدام الصناعي: تخزين قراءات الحساسات الأخيرة (buffer) لحساب المتوسط المتحرك.

# مخزن مؤقت لآخر 10 قراءات حرارة
temp_buffer = [0.0] * 10  # مصفوفة بحجم ثابت
write_index = 0

def add_reading(value):
    global write_index
    temp_buffer[write_index % 10] = value
    write_index += 1

def moving_average():
    count = min(write_index, 10)
    return sum(temp_buffer[:count]) / count if count > 0 else 0

# إضافة قراءات
for temp in [78.5, 79.1, 80.3, 77.8, 81.2]:
    add_reading(temp)

print(f"المتوسط المتحرك: {moving_average():.1f}°C")

القائمة المترابطة (Linked List): مرونة الإضافة والحذف

القائمة المترابطة سلسلة من العُقد، كل عقدة تحتوي بيانات ومؤشراً للعقدة التالية. لا تحتاج ذاكرة متتالية — كل عقدة يمكن أن تكون في أي مكان.

الاستخدام الصناعي: سجل أحداث (event log) يتغيّر حجمه باستمرار — إضافة وحذف سريعان بدون إعادة ترتيب.

class EventNode:
    def __init__(self, timestamp, event_type, message):
        self.timestamp = timestamp
        self.event_type = event_type
        self.message = message
        self.next = None

class EventLog:
    def __init__(self):
        self.head = None
        self.count = 0

    def add_event(self, timestamp, event_type, message):
        new_node = EventNode(timestamp, event_type, message)
        new_node.next = self.head
        self.head = new_node  # الحدث الأحدث في البداية
        self.count += 1

    def get_recent(self, n=5):
        events = []
        current = self.head
        while current and len(events) < n:
            events.append(f"[{current.timestamp}] {current.event_type}: {current.message}")
            current = current.next
        return events

# استخدام
log = EventLog()
log.add_event("14:30:05", "ALARM", "ارتفاع حرارة CNC-01")
log.add_event("14:30:12", "ACTION", "تم تخفيض السرعة")
log.add_event("14:31:00", "INFO", "الحرارة عادت طبيعية")

مقارنة المصفوفة والقائمة المترابطة:

جدول التجزئة (Hash Map): البحث الفوري

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

الاستخدام الصناعي: ربط معرّف الآلة بحالتها الحالية — عندما يصل إنذار من آلة معينة، تجد بياناتها فوراً.

# حالة كل آلة في المصنع
machine_status = {
    "CNC-01": {"temp": 78.5, "status": "running", "alarms": 0},
    "CNC-02": {"temp": 91.2, "status": "warning", "alarms": 3},
    "PUMP-05": {"temp": 65.0, "status": "idle", "alarms": 0},
    "COMP-03": {"temp": 82.1, "status": "running", "alarms": 1},
}

# الوصول الفوري لحالة آلة
machine = "CNC-02"
info = machine_status[machine]  # O(1) - فوري
print(f"{machine}: حرارة {info['temp']}°C - {info['status']}")

# تحديث حالة
machine_status["CNC-02"]["alarms"] += 1

# البحث عن كل الآلات في حالة تحذير
warnings = {k: v for k, v in machine_status.items() if v["status"] == "warning"}

الطابور (Queue): أولاً يدخل أولاً يخرج

الطابور يعمل بنظام FIFO (First In, First Out) — تماماً مثل طابور الإنتاج في المصنع: أول طلب يدخل هو أول طلب يُعالج.

الاستخدام الصناعي: طابور الإنذارات — يضمن معالجة الإنذارات بترتيب ورودها حتى لا يضيع أي تنبيه.

from collections import deque

class AlarmQueue:
    def __init__(self, max_size=100):
        self.queue = deque(maxlen=max_size)

    def push_alarm(self, machine_id, severity, message):
        alarm = {
            "machine": machine_id,
            "severity": severity,  # "low", "medium", "high", "critical"
            "message": message,
            "acknowledged": False
        }
        self.queue.append(alarm)

    def process_next(self):
        if self.queue:
            alarm = self.queue.popleft()  # أقدم إنذار أولاً
            print(f"معالجة: [{alarm['severity']}] {alarm['machine']}: {alarm['message']}")
            return alarm
        return None

    def pending_count(self):
        return len(self.queue)

# استخدام
alarms = AlarmQueue()
alarms.push_alarm("CNC-01", "high", "حرارة مرتفعة")
alarms.push_alarm("PUMP-05", "critical", "ضغط منخفض جداً")
alarms.push_alarm("CONV-02", "low", "حزام بحاجة صيانة")

print(f"إنذارات معلّقة: {alarms.pending_count()}")
while alarms.pending_count() > 0:
    alarms.process_next()

المكدّس (Stack): آخر ما يدخل أولاً يخرج

المكدّس يعمل بنظام LIFO (Last In, First Out) — مثل كومة صحون: آخر صحن وضعته هو أول صحن تأخذه.

الاستخدام الصناعي: تراجع عن العمليات (Undo) في واجهات التحكم، أو تتبّع حالات الآلة.

class MachineStateStack:
    """تتبّع تاريخ حالات الآلة للتراجع عند الحاجة"""
    def __init__(self):
        self.stack = []

    def save_state(self, state_dict):
        self.stack.append(state_dict.copy())

    def undo(self):
        if self.stack:
            return self.stack.pop()  # آخر حالة محفوظة
        return None

    def peek(self):
        """رؤية آخر حالة بدون حذف"""
        return self.stack[-1] if self.stack else None

# استخدام: المشغّل يغيّر إعدادات CNC
history = MachineStateStack()

# الحالة الأولى
history.save_state({"speed": 1200, "feed": 0.15, "depth": 2.0})

# المشغّل غيّر السرعة
history.save_state({"speed": 1500, "feed": 0.15, "depth": 2.0})

# المشغّل غيّر العمق — نتائج سيئة!
history.save_state({"speed": 1500, "feed": 0.15, "depth": 3.5})

# التراجع عن آخر تغيير
previous = history.undo()
print(f"التراجع إلى: سرعة={previous['speed']}, عمق={previous['depth']}")

الشجرة (Tree): التنظيم الهرمي

الشجرة هيكل هرمي — كل عقدة لها أب (ما عدا الجذر) وقد يكون لها أبناء. مثالية لتمثيل العلاقات الهرمية.

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

class FactoryNode:
    def __init__(self, name, node_type):
        self.name = name
        self.node_type = node_type  # "factory", "department", "line", "machine"
        self.children = []

    def add_child(self, child):
        self.children.append(child)
        return child

    def display(self, indent=0):
        prefix = "  " * indent + ("|- " if indent > 0 else "")
        print(f"{prefix}[{self.node_type}] {self.name}")
        for child in self.children:
            child.display(indent + 1)

# بناء هيكل المصنع
factory = FactoryNode("مصنع دكتور ماشين", "factory")

dept_mech = factory.add_child(FactoryNode("قسم التشغيل الميكانيكي", "department"))
line_cnc = dept_mech.add_child(FactoryNode("خط CNC", "line"))
line_cnc.add_child(FactoryNode("CNC-01 (مخرطة)", "machine"))
line_cnc.add_child(FactoryNode("CNC-02 (فريزة)", "machine"))

dept_assembly = factory.add_child(FactoryNode("قسم التجميع", "department"))
line_a = dept_assembly.add_child(FactoryNode("خط التجميع A", "line"))
line_a.add_child(FactoryNode("محطة لحام روبوتية", "machine"))
line_a.add_child(FactoryNode("محطة فحص بصري", "machine"))

factory.display()

متى تستخدم كل هيكل؟

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