Sıralama (Sorting) Algoritmaları

#w1sd0m
def stoogesort(arr, l, h):
    if l >= h:
        return
    # Baştaki veri sondaki veriden büyük ise bunlar yer değiştirir.
    if arr[l]>arr[h]:
        t = arr[l]
        arr[l] = arr[h]
        arr[h] = t

    # Eğer listenin veri sayısı 2'den büyük olduğunda;
    if h-l + 1 > 2:
        t = (int)((h-l + 1)/3)

        # listenin baştan 2/3'ü sıralanır
        stoogesort(arr, l, (h-t))

        # listenin sondan 2/3'ü sıralanır
        stoogesort(arr, l + t, (h))

        # tekrardan listenin baştan 2/3'ü sıralanır ve işlem tamamlanır.
        stoogesort(arr, l, (h-t))

# üretim
arr = [2, 4, 5, 3, 1]
n = len(arr)
stoogesort(arr, 0, n-1)
for i in range(0, n):
    print(arr[i], end = ' ')

#w1sd0m
def bubbleSort(arr):
    n = len(arr)
    # Liste dolaşılır
    for i in range(n):
        swapped = False
        for j in range(0, n-i-1):
            # İlk elemandan başlayarak, her eleman yanındaki eleman ile karşılaştırılır ve sağındaki elemandan büyük ise bunlar yer değiştirir
            if arr[j] > arr[j+1] :
                arr[j], arr[j+1] = arr[j+1], arr[j]
                swapped = True

        # Karşılaştıracak iki eleman kalmazsa işlemi durdur
        if swapped == False:
            break
        
arr = [64, 34, 25, 12, 22, 11, 90]
print("Normal liste: ",arr)
bubbleSort(arr)
print ("Düzenlenmiş liste:")
for i in range(len(arr)):
    print ("%d" %arr[i],end=" ")

#w1sd0m
def cocktailSort(a):
    n = len(a)
    swapped = True
    start = 0
    end = n-1
    while (swapped == True):
        swapped = False

        # Burada, bubble(baloncuk) algoritması işlemi uygulanır
        for i in range(start, end):
            if (a[i] > a[i + 1]):
                a[i], a[i + 1] = a[i + 1], a[i]
                swapped = True

        # Eleman kalmazsa işlem bitirilir
        if (swapped == False):
            break

        # Flagı sıfırlar, işlemi optimize eder
        swapped = False

        # Sondan bir önceki elemandan başlayarak listeyi başa doğru dolaşacaktır
        end = end-1

        # Burada önceki yer değiştirme işlemini tersine uygular
        for i in range(end-1, start-1, -1):
            if (a[i] > a[i + 1]):
                a[i], a[i + 1] = a[i + 1], a[i]
                swapped = True

        # Başlangıç değerini artırır, böylece işlem tamalanıncaya kadar devam eder
        start = start + 1

a = [5, 1, 4, 2, 8, 0, 2]
print("Normal liste: ",a)
cocktailSort(a)
print("Düzenlenmiş liste:")
for i in range(len(a)):
    print("% d" % a[i])

#w1sd0m
def mergeSort(arr):
    if len(arr) > 1:
        # Listenin ortasındaki eleman bulunur
        mid = len(arr)//2
        # Elemanları ayırır
        L = arr[:mid]
        R = arr[mid:]
        # İlk grup sıralanır
        mergeSort(L)
        # İkinci grup sıralanır
        mergeSort(R)
        i = j = k = 0

        # Oluşan elemanları 2 listeye gruplar
        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1

        # Solda eleman kalıp kalmadığını kontrol eder
        while i < len(L):
            arr[k] = L[i]
            i += 1
            k += 1
        # Sağda eleman kalıp kalmadığını kontrol eder
        while j < len(R):
            arr[k] = R[j]
            j += 1
            k += 1

# Tekrar liste haline getirilir
def printList(arr):
    for i in range(len(arr)):
        print(arr[i], end=" ")
    print()

if __name__ == '__main__':
    arr = [12, 11, 13, 5, 6, 7]
    print("Normal liste:", end="\n")
    printList(arr)
    mergeSort(arr)
    print("Düzenlenmiş liste: ", end="\n")
    printList(arr)

#w1sd0m
def partition(start, end, array):
    # Listenin ortasındaki eleman(pivot) belirlenir
    pivot_index = start
    pivot = array[pivot_index]
    # Liste döngüye alınır
    while start < end:
        # Seçilen elemandan büyük bir eleman bulana kadar sayıyı arttırır
        while start < len(array) and array[start] <= pivot:
            start += 1
        # Seçilen elemandan küçük bir eleman bulana kadar sayıyı azaltır
        while array[end] > pivot:
            end -= 1
        # Son değer pivottan büyük ise bunlar yer değiştirir
        if(start < end):
            array[start], array[end] = array[end], array[start]
    # Pivot değeri ile son değer yer değiştirir
    array[end], array[pivot_index] = array[pivot_index], array[end]
    # Dizi tekrar bölünmek üzere döndürülür
    return end
    
def quick_sort(start, end, array):
    if (start < end):
        p = partition(start, end, array)
        quick_sort(start, p - 1, array)
        quick_sort(p + 1, end, array)


array = [ 10, 7, 8, 9, 1, 5 ]
print("Normal liste: ",array)
quick_sort(0, len(array) - 1, array)
print(f'Düzenlenmiş liste: {array}')

#w1sd0m
def shellSort(arr):
    # sıçrama değeri = gap
    gap = len(arr) // 2
    while gap > 0:
        i = 0
        j = gap
        # listeyi dolaşır ve gap değerince kolona böler
        while j < len(arr):
            if arr[i] >arr[j]:
                arr[i],arr[j] = arr[j],arr[i]
            i += 1
            j += 1

            # veriler doğru sıraya sokulur.
            k = i
            while k - gap > -1:
                if arr[k - gap] > arr[k]:
                    arr[k-gap],arr[k] = arr[k],arr[k-gap]
                k -= 1
        gap //= 2

arr2 = [12, 34, 54, 2, 3]
print("İlk liste: ",arr2)

shellSort(arr2)
print("Düzenlenmiş liste: ",arr2)