ما هو الفرز؟

يشير الفرز إلى عملية ترتيب البيانات بترتيب معين، عادةً بترتيب تصاعدي أو تنازلي، بناءً على علاقة خطية بين عناصر البيانات.

لماذا نحتاج إلى الفرز؟

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

خوارزميات الفرز

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

فرز الفقاعة

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

خوارزمية

الخطوة 1: البدء
الخطوة 2: أنا = 0
الخطوة 3: إذا كنت الخطوة 4: ي = 0
الخطوة 5: إذا كان j الخطوة 6: إذا كانت المصفوفة [j] > المصفوفة [j 1]، فانتقل إلى الخطوة 7؛ وإلا انتقل إلى الخطوة 8
الخطوة 7: تبديل المصفوفة [j] والمصفوفة [j 1]
الخطوة 8: زيادة ي؛ انتقل إلى الخطوة 5
الخطوة 9: زيادة ط؛ انتقل إلى الخطوة 3
الخطوة 10: النهاية

شفرة

def bubble_sort(arr):
    print("Array Before Sorting: ", end='')
    print(arr)
    for i in range(len(arr)):
        for j in range(len(arr)-i-1):
            if arr[j] > arr[j 1]:
                arr[j], arr[j 1] = arr[j 1], arr[j]

    print("Array After Sorting: ", end='')
    print(arr)

# Main
bubble_sort([7, 4, 1, 3, 4, 7, 87, 9, 6, 4, 2, 2, 3, 5, 6])

تعقيد الوقت

أفضل حالة: O(n)
متوسط ​​الحالة : O(n^2)
أسوأ حالة: O(n^2)

فرز التحديد

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

خوارزمية

الخطوة 1: البدء
الخطوة 2: أنا = 0
الخطوة 3: إذا كنت الخطوة 4: الحد الأدنى_قيمة = أنا؛ ي = ط 1
الخطوة 5: إذا كان j الخطوة 6: إذا كانت المصفوفة[minimum_value] > المصفوفة[j]، فانتقل إلى الخطوة 7؛ وإلا انتقل إلى الخطوة 8
الخطوة 7: الحد الأدنى_قيمة = ي
الخطوة 8: زيادة ي؛ انتقل إلى الخطوة 5
الخطوة 9: مبادلة المصفوفة [minimum_value] والمصفوفة [i]
الخطوة 10: زيادة ط؛ انتقل إلى الخطوة 3
الخطوة 11: النهاية

شفرة

def selection_sort(arr):
    print("Array Before Sorting: ", end='')
    print(arr)
    for i in range(len(arr) - 1):
        min_val = i
        for j in range(i   1, len(arr)):
            if arr[j] 




  
  
  تعقيد الوقت


أفضل حالة: O(n^2)

متوسط ​​الحالة : O(n^2)

أسوأ حالة: O(n^2) 


  
  
  فرز الإدراج


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


  
  
  خوارزمية


الخطوة 1: البدء

الخطوة 2: أنا = 1

الخطوة 3: إذا كنت 
الخطوة 4: المفتاح = arr[i]

الخطوة 5: ي = ط - 1

الخطوة 6: إذا كان j >= 0 وarr[j] > مفتاحًا، فانتقل إلى الخطوة 7؛ وإلا انتقل إلى الخطوة 10

الخطوة 7: arr[j 1] = arr[j]

الخطوة 8: إنقاص j بمقدار 1

الخطوة 9: انتقل إلى الخطوة 6

الخطوة 10: arr[j 1] = مفتاح

الخطوة 11: قم بزيادة i بمقدار 1؛ انتقل إلى الخطوة 3

الخطوة 12: النهاية


  
  
  شفرة




def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1

        while j >= 0 and arr[j] > key:
            arr[j   1] = arr[j]
            j -= 1

        arr[j   1] = key

# Main
arr = [7, 4, 1, 3, 4, 7, 87, 9, 6, 4, 2, 2, 3, 5, 6]
print("Array Before Sorting:", arr)
insertion_sort(arr)
print("Array After Sorting:", arr)





  
  
  تعقيد الوقت


أفضل حالة: O(n)

متوسط ​​الحالة : O(n^2)

أسوأ حالة: O(n^2) 


  
  
  دمج الفرز


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


  
  
  خوارزمية


  خوارزمية فرز الدمج  
 

الخطوة 1: البدء

الخطوة 2: إذا كان الطول (المصفوفة) 
الخطوة 3: mid_point = الطول (المصفوفة) // 2

الخطوة 4: left_half = المصفوفة [:mid_point] 

الخطوة 5: right_half = المصفوفة[mid_point:]

الخطوة 6:sorted_left = merge_sort(left_half)

الخطوة 7:sorted_right = merge_sort(right_half)

الخطوة 8: إرجاع الدمج (sorted_left,sorted_right)

الخطوة 9: النهاية

  وظيفة الدمج  
 

الخطوة 1: البدء

الخطوة 2:sorted_merge = []

الخطوة 3: ل = 0، ص = 0

الخطوة 4: إذا كان l 
الخطوة 5: إذا كان اليسار[l] 
الخطوة 6: أضف اليسار [l] إلىsorted_merge؛ زيادة ل بمقدار 1

الخطوة 7: أضف اليمين [r] إلىsorted_merge؛ زيادة ص بمقدار 1

الخطوة 8: انتقل إلى الخطوة 4

الخطوة 9: إذا كان l 
الخطوة 10: أضف اليسار [l] إلىsorted_merge؛ زيادة ل بمقدار 1 

الخطوة 11: انتقل إلى الخطوة 9

الخطوة 12: إذا كان r 
الخطوة 13: أضف اليمين [r] إلىsorted_merge؛ زيادة ص بمقدار 1

الخطوة 14: انتقل إلى الخطوة 12

الخطوة 15: إرجاعsorted_merge

الخطوة 16: النهاية


  
  
  شفرة




def merge(left, right):
    sorted_merge = []
    l = r = 0
    while l 




  
  
  تعقيد الوقت


أفضل حالة: O(n log n)

متوسط ​​الحالة : O(n log n)

أسوأ حالة: O(n log n) 


  
  
  فرز سريع


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


  
  
  خوارزمية


 الفرز السريع 
 

الخطوة 1: البدء

الخطوة 2: إذا كان منخفضًا 
الخطوة 3: Pivot_index = Partition(arr, low, High)

الخطوة 4: الفرز السريع(arr, low,ivot_index - 1)

الخطوة 5: الفرز السريع (arr، Pivot_index 1، High)

الخطوة 6: إنهاء 

  وظيفة التقسيم  
 

الخطوة 1: البدء

الخطوة 2: المحور = arr[عالٍ]

الخطوة 3: اليسار = منخفض، اليمين = مرتفع - 1

الخطوة 4: إذا كان اليسار 
الخطوة 5: إذا كان arr[يسار] > المحوري وarr[يمين] 
الخطوة 6: إذا arr[left] 
الخطوة 7: إذا كان arr[right] >= محوريًا، فقم بإنقاص اليمين

الخطوة 8: انتقل إلى الخطوة 4

الخطوة 9: قم بتبديل arr[left] وarr[high]

الخطوة 10: العودة إلى اليسار

الخطوة 11: النهاية 


  
  
  شفرة




def partition(arr, low, high):
    pivot = arr[high]
    left = low
    right = high - 1
    while left  pivot and arr[right] = pivot:
            right -= 1
    arr[left], arr[high] = arr[high], arr[left]
    return left

def quicksort(arr, low, high):
    if low 




  
  
  تعقيد الوقت


أفضل حالة: O(n log n)

متوسط ​​الحالة : O(n log n)

أسوأ حالة: O(n^2)