كان البحث في موقعنا كالبحث عن إبرة في كومة قش: كيف أنقذتنا ‘خوارزمية البحث الثنائي’ من جحيم تجربة المستخدم البطيئة؟

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

لكن مع نمو قاعدة البيانات، بدأت غيوم سوداء تتجمع في سماء المشروع. بدأت توصلنا رسائل من المستخدمين: “البحث بطيء جدًا!”، “بحاول ألاقي منتج معين وبستنى دقيقة كاملة!”، “يا عمي الموقع معلّق!”. في البداية، تجاهلنا الأمر وقلنا “ضغط سيرفرات عادي”. لكن لما صارت الشكوى هي القاعدة مش الاستثناء، عرفنا إنه في مشكلة حقيقية لازم نحلها، وإلا المشروع كله راح يوقع على راسنا.

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

المشكلة: لما البحث الخطي (Linear Search) بطل يِجَمِّل

لما بنينا ميزة البحث أول مرة، استخدمنا الطريقة البديهية والأسهل: البحث الخطي (Linear Search). الفكرة بسيطة جدًا: لو عندك قائمة من 1000 منتج وبدك تبحث عن منتج معين، الخوارزمية بتمشي عليهم واحد واحد، من الأول للآخر، لحد ما تلاقيه. زي لما تكون بتدور على كتاب معين في رف كتب عشوائي، فبتضطر تقرأ عنوان كل كتاب على الرف لحد ما توصل للكتاب اللي بدك إياه.

في البداية، لما كان عنا كم مية منتج، كانت العملية سريعة وما حدا حاسس فيها. لكن لما وصل العدد لـ 50,000 منتج، صارت العملية أشبه بكابوس. لو كان المنتج اللي ببحث عنه المستخدم هو آخر واحد في القائمة، كان السيرفر بيحتاج يمر على 49,999 منتج قبله! وهذا يعني وقت انتظار طويل وتجربة مستخدم سيئة جدًا.

ماذا يقول الكود؟

للتوضيح، هاي هي فكرة البحث الخطي بكود بايثون بسيط:

def linear_search(data, target):
    # المرور على كل عنصر في القائمة
    for i in range(len(data)):
        # إذا وجدنا العنصر المطلوب، نرجع موقعه
        if data[i] == target:
            return i
    # إذا انتهت القائمة ولم نجده، نرجع -1
    return -1

# مثال:
products = ["لابتوب", "ماوس", "شاشة", "كيبورد", "سماعات"]
position = linear_search(products, "كيبورد")
# سيقوم الكود بالمرور على "لابتوب" ثم "ماوس" ثم "شاشة" ثم يجد "كيبورد" في الموقع 3

هذه الخوارزمية لها تعقيد زمني يُعرف بـ O(n)، ويعني ببساطة أن الوقت اللازم للبحث يزداد بشكل طردي ومباشر مع ازدياد حجم البيانات (n). كلما زادت البيانات، زاد الوقت. وهذا بالضبط ما كان يدمر أداء موقعنا.

وميض الأمل: العودة إلى الأساسيات مع البحث الثنائي (Binary Search)

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

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

وهون مربط الفرس. البحث الثنائي يتطلب شرطًا واحدًا وأساسيًا: يجب أن تكون البيانات مرتبة (Sorted). بدون ترتيب، هاي الخوارزمية ما بتسوى قرش.

كيف يعمل البحث الثنائي خطوة بخطوة؟

لنفترض أن لدينا قائمة أرقام مرتبة ونبحث عن الرقم 72:

[2, 5, 8, 12, 16, 23, 38, 56, 72, 91]

1. الخطوة الأولى: نجد العنصر الأوسط. القائمة فيها 10 عناصر. العنصر الأوسط هو العنصر الخامس تقريبًا، وهو 16.
2. الخطوة الثانية: نقارن هدفنا (72) بالعنصر الأوسط (16). بما أن 72 أكبر من 16، نحن نتجاهل النصف الأول من القائمة بالكامل ونركز على النصف الثاني. قائمتنا الجديدة للبحث هي: [23, 38, 56, 72, 91].
3. الخطوة الثالثة: نكرر العملية. العنصر الأوسط في القائمة الجديدة هو 56.
4. الخطوة الرابعة: نقارن 72 بـ 56. بما أن 72 أكبر، نتجاهل النصف الأول من القائمة الجديدة. قائمتنا الآن هي: [72, 91].
5. الخطوة الخامسة: العنصر الأوسط هو 72. نقارن 72 بـ 72. تطابق! خلص، لقيناها! 🎉

لاحظ أننا احتجنا 3 مقارنات فقط لنجد الرقم في قائمة من 10 عناصر. البحث الخطي كان سيحتاج 9 مقارنات!

لنرى الكود يتكلم

هذا هو تطبيق البحث الثنائي بلغة بايثون:

def binary_search(data, target):
    low = 0
    high = len(data) - 1

    # نستمر في البحث طالما أن هناك جزء من القائمة لم نفحصه
    while low  target:
            high = mid - 1
        # إذا كان هدفنا أكبر، تجاهل النصف الأيسر
        else:
            low = mid + 1

    # إذا خرجنا من الحلقة، فهذا يعني أن العنصر غير موجود
    return -1

# مثال:
# ملاحظة: القائمة يجب أن تكون مرتبة!
sorted_products_ids = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]
position = binary_search(sorted_products_ids, 72)
# سيجد الكود العنصر في خطوات قليلة جدًا

النتائج على أرض الواقع: من ثوانٍ إلى أجزاء من الثانية

بعد أن فهمنا الحل، قمنا بتعديل نظامنا. أولاً، تأكدنا من أن قائمة المنتجات (أو على الأقل مُعرّفاتها – IDs) مخزنة دائمًا بشكل مرتب في قاعدة البيانات أو في الذاكرة المؤقتة (Cache). ثم، استبدلنا كود البحث الخطي الساذج بكود البحث الثنائي الفعال.

النتيجة؟ كانت مذهلة! عمليات البحث التي كانت تستغرق 3-5 ثوانٍ، أصبحت الآن تستغرق 10-20 ميلي ثانية. كانت الصفحة تفتح قبل ما ترمش عينك. انخفض الضغط على السيرفر بشكل هائل، والأهم من كل هذا، عادت الابتسامة لوجوه مستخدمينا (ورسائل الشكوى تحولت إلى رسائل شكر!).

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

نصائح من أبو عمر

من وحي هذه التجربة وغيرها، أحب أشارككم بعض النصائح العملية:

• 
  

  نصيحة 1: اعرف بياناتك

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

• 
  

  نصيحة 2: الترتيب هو المفتاح

  أكرر مرة أخرى: لا بحث ثنائي بدون ترتيب. تأكد من أن هيكل البيانات الذي تستخدمه يدعم الترتيب بكفاءة. في حالتنا، كنا نرتب مُعرّفات المنتجات عند إضافتها، مما حافظ على القائمة مرتبة دائمًا وجاهزة للبحث السريع.

• 
  

  نصيحة 3: ليس الحل السحري لكل شيء

  البحث الثنائي عظيم للبحث عن قيمة مطابقة تمامًا في قائمة مرتبة. لكنه لن يساعدك في البحث النصي المتقدم (Full-text search) أو البحث عن “كلمات قريبة من” أو “منتجات تشبه”. لكل مشكلة أدواتها. لفهم اللغة الطبيعية والبحث المتقدم، هناك أدوات أقوى مثل Elasticsearch أو Algolia.

• 
  

  نصيحة 4: فكر في تجربة المستخدم دائمًا

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

الخلاصة: الدرس المستفاد 💡

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

فيا جماعة الخير، نصيحتي الأخيرة لكم: قبل أن تركضوا وراء أحدث إطار عمل (Framework) أو ألمع مكتبة برمجية، استثمروا وقتًا في إتقان الأساسيات. لأن فهم الفرق بين O(n) و O(log n) قد يكون هو الفاصل بين مشروع فاشل يلفظ أنفاسه الأخيرة، ومشروع ناجح يحبه المستخدمون. ودمتم مبدعين!