Python algoritmaları

Python işlevleri ve meth

Algoritmalar, sorunları çözmek için kullanılan iyi tanımlanmış talimatlardır. Bir binanın ikinci katında yaşadığınızı ve postalarınızı kontrol etmek için kendinize talimatlar vermeniz gerektiğini hayal edin. Algoritmanız şuna benzer:

Talimatlarımızda çok iyi tanımlanmamız gerektiğine dikkat edin. Kapıyı açmadan daireden çıkamıyoruz. Bir talimatın atlanması, geliştiricilerin bir sorunu çözmesini engelleyebilir.

Python'da birkaç farklı algoritma türü vardır. Bazıları sorunları diğerlerinden daha hızlı çözmeye yardımcı olabilir. Bunu Big-O notasyonunu kullanarak ölçüyoruz.

Bu makalede, verimliliklerini veya Big-O notasyonunu ölçerken farklı türde sıralama algoritmalarına dalıyoruz.




Python Sıralama Algoritmaları

Sıralama algoritmaları, diğer birçok algoritmanın üzerine inşa edebileceği yapı taşı algoritmalarıdır. Sıralama algoritmaları, bir listedeki öğe(ler)i arama, listeden öğe(ler)i seçme ve dağıtımlar gibi sorunları çözmek için kullanılır. Sıralama ile bu sorunları çözmek çok daha hızlıdır. 

Yalnızca gündelik, aktif giyim ve iş açısından değil aynı zamanda renkli olan bir gömme dolabınız olduğunu hayal edin. koordineli. Dolabınız olan listede mavi spor şortunuzu düzensiz veya sıralanmamış bir dolaba kıyasla bulmak ne kadar hızlı olurdu? 

Python'un Yerleşik Sıralama Algoritması

Python, listeler için kullanılabilecek yerleşik bir sıralama algoritmasına sahiptir, sorted().

list = [5, 45, 22 , 3, 9, 0, 12, 6, 1] print(sıralı(list)) # prints [0, 1, 3, 5, 6 , 9, 12, 22, 45]

Kabarcık Sıralaması

Kabarcık sıralama, Big-O notasyonu. Big-O hakkında daha sonra daha fazlasını öğreneceğiz. Şimdilik, listeyi birden çok kez gözden geçirelim, öğeleri tek tek karşılaştıralım ve buna göre değiştirelim. Aşağıdaki örneği ele alalım.

Katılımcıların %81'i, bir eğitim kampına katıldıktan sonra teknik iş beklentileri konusunda daha emin hissettiklerini belirtti. Bugün bir eğitim kampı ile eşleşin.

Ortalama bir eğitim kampı mezunu, bir eğitim kampına başlamaktan ilk işini bulmaya kadar, kariyer geçişinde altı aydan daha az zaman harcadı.

Her seferinde nasıl yaptığımıza dikkat edin. Listede yineleme yapmak için listenin yinelememiz gereken bölümü küçülür çünkü sağdaki (turuncu renkte) öğeler zaten sıralanmıştır. Aşağıda, yukarıdaki kabarcık sıralama görselleştirmemizde neler olduğuna dair bir açıklama bulunmaktadır. 

# initial listeleyin, karşılaştırın 29 & 10 [29, 10, 15, 32, 10] # 29 > 10, yani takas ediyoruz & 29 & 15 [10, 29, 15, 32, 10] # 29 > 15, bu yüzden takas ediyoruz & 29 & 32 [10, 15, 29, 32, 10] # 29 < 32, bu yüzden 32 & 10 [10, 15, 29, 32, 10] # 32 > 10, bu yüzden takas ediyoruz [10, 15, 29, 10, 32] # İlk elemandan tekrar başlayın, 10 & 15 [10, 15, 29, 10, 32] # 10 <; 15, bu nedenle 15 & 29 [10, 15, 29, 10, 32] # 15 <; 29, bu yüzden 29 & 10 [10, 15, 29, 10, 32] # 29 > 15, bu yüzden takas ediyoruz & 29 & 32 [10, 15, 10, 29, 32] # Tekrar başlayın, ilk öğeden 10 & 15 [10, 15, 10, 29, 32] # 10 <; 15, bu nedenle 15 & 10 [10, 15, 10, 29, 32] # 15 > 10, yani takas ediyoruz [10, 10, 15, 29, 32] # İlk elemandan tekrar başlayın, liste şimdi sıralandı [10, 10, 15, 29, 32]

Kabarcık sıralama kodu aşağıdaki örnek koda benzer bir şey ister:

def bubble_sort(list) : # i aralığındaki (0, len(list) - 1) için listedeki her öğe boyunca gezin (geçiş yapın): # Liste 1'deki her öğeyi 1'e karşılaştırın. Her yinelemedeki karşılaştırma # son öğeler değiştikçe kısalır. j için aralık (0, len(list) - 1 - i) içinde sıralanır: # listeyi 0'dan ni-1'e çevir # bulunan öğe sonraki öğeden büyükse, liste[j] > liste[j + 1]: liste[j], liste[j + 1] = liste[j + 1], liste[j] listeyi döndürür yazdır(bubble_sort([2, 3, 7, 1, 9, 5]) )

Sıralama Ekleme

Daha önce poker oynadıysanız, büyük olasılıkla bu sıralama yöntemini kullanmışsınızdır. Yerleştirmeli sıralama ile, elinizde bir kartla başlayacak, sonraki rastgele kartı seçecek, doğru sıraya göre yerleştirecek ve işlemi tekrar edeceksiniz.


Ekleme sıralama algoritması O(n) zamanında, en iyi durumda ve O(n^2) en kötü durumda çalışır.

Upip8gpI1oGSFaGZbPoI2Xe63l7EcnxPimhRpPPaG5hoDs5RUdqZEIfb7YGWhFywKLkwlDVQQJvgx3vZadJATJAOMBwNYRqumzXGTMnfN3W83iUAuFc2 PDsmnyNKm9k4y9 KdVm

Aşağıda, yukarıda ekleme sıralama algoritması görselleştirme bir açıklaması aşağıda verilmiştir. < br>

# İlk öğe olan 10'u sıralı olarak işaretleyin [10, 3, 2, 6] # Sonraki öğeye bakın, 3, 3 < 10 [10, 3, 2, 6] # 3'ü çıkarın ve 10'dan önce taşıyın, ilk öğeyi, 3'ü sıralı olarak işaretleyin [3, 10, 2, 6] # Sonrakine bakın sıralanmamış eleman, 2, 2 < 10, 2 < 3 [3, 10, 2, 6] # 2'yi çıkarın ve 3'ten önce taşıyın, ilk öğeyi 2'yi sıralanmış olarak işaretleyin [2, 3, 10, 6] # Sıralanmamış sonraki öğeye bakın, 6, 6 < 10, 6 > 3 [2, 3, 10, 6] # 6'yı ayıklayın ve 10'dan önce taşıyın [2, 3, 6, 10]

Aşağıda eklemeli sıralama algoritmasının bir kod örneği bulunmaktadır.< br>

def insertionSort(list): # ilk indeks_uzunluğundan sonraki tüm değerler = aralık(1, len (list)) # tüm bu değerler üzerinde bir işlem yapmak için # tüm değerler için indeks_uzunluk değeridir, indeks_uzunluktaki i için: # soldaki öğe daha büyükken bu değerleri sıralamak istiyoruz sort = liste[i] # sağdaki # öğeden daha #, ayrıca i > 0 bc python, list[i-1] > sırala ve ben > 0: # takas listesi[i], liste[i-1] = liste[i-1], liste[i] # listede karşılaştırma yapmaya devam etmek için, # sonraki öğeye bakın i = i - 1 dönüş listesi yazdır (insertionSort([7, 3, 4, 1, 9]))

Birleştirme Sıralaması

Birleştirme sıralama, sıralama için böl ve yönet yaklaşımına sahiptir ve bir yinelemeli olan yukarıdakilerden farklı özyinelemeli sıralama algoritması. Birleştirme sıralamasını anlamak için önce özyinelemeyi anlamalıyız.

Özyinelemeli işlevler, kendilerini çağıran, ancak sonsuz döngüleri önlemek için çalışacak temel bir durumu olan işlevlerdir. Aşağıda temel bir özyinelemeli işlevin kod örneği verilmiştir.

def özyinelemeli(n): # Bu üzerinde çalıştığımız temel durumdur # n==0'a geldiğimizde, n == 0 ise 1 döndürürüz: 1 döndürürüz # burada temel duruma doğru hareket ederiz return n * özyinelemeli(n - 1)

Birleştirme sıralamasında, her şey yolunda olana ve birleştirebilecek duruma gelene kadar çift çift sıralamaya başlarız. Aşağıdaki görselleştirmeyi yapın.


Aşama 1

<Şekil sınıfı = "wP-blok resim"> Iz8kE8XQv58nWTQ63VsFF UmZ5rdnyRTQ4Gv8B98b7N4tDs 2ji4m4 JTUuRrsMGDTfndl1uT6pUHZa0Ri4UfUwGGsOLU7RpMouCb3JWQGiqPSUkbYNVpa4CHefrcRxqOVcQ8V5 <TFigür> önce iki St Figür> iki sınıfla karşılaştırın wP-blok-resim "> ClAumSPmBvbVtepF 8XL IPl2Kh GHzpThog0jH40T0ba7 OJRHWDxCsl1p3xNfkByWpgnr20IOhF6q9EyzmBVUeLMKiL33k24PCT0l8G6g0VXiRTj62R9lg5UU ZsdpdaO5YqKL

İkinci olarak, tekrar sağa gitmeden önce ilk iki grubun ilk dizinini karşılaştırarak yol boyunca sıralayarak başlıyoruz.

Adım 3

 O39N9kbi 4KA4OUBQ4M6HejjQOnzglY K3wOg3ReCZrkn1W1gc90ctO7X6Rvz4elLifeTo9EmsNbSB8S4fzjsuJJK 2KAdjGOipd0jvr4TH6xuqnni9xFZbZNH5bAnb43EXRpdo

Son olarak, indeksleri arasında hareket iki grup, biz sağa gitmeden önce değerleri karşılaştırır ve sıralar.

Aşağıda birleştirme sıralamasının bir kod örneğidir.

# bc böl ve yönet yaklaşımında birden fazla adım var # birden fazla fonksiyon tanımına ihtiyacımız var # yardımcı fonksiyon def birleştirme(sol, sağ): elementler = len(sol) + len(right) merged_list = [0] * elementler left_pointer = 0 right_pointer = 0 i = 0 # her iki listede de öğeler varken left_pointer < len(sol) veya right_pointer < len(sağ): # her iki listede de öğe varsa, left_pointer < len(sol) ve right_pointer < len(sağ): sol ise[left_pointer] < right[right_pointer]: merged_list[i] = left[left_pointer] left_pointer += 1 else: merged_list[i] = right[right_pointer] right_pointer += 1 i += 1 # sol listede sadece eleman varsa elif left_pointer < ; len(left): merged_list[i] = left[left_pointer] left_pointer += 1 i += 1 # sadece sağ listede öğeler varsa elif right_pointer < len(right): merged_list[i] = right[right_pointer] right_pointer += 1 i += 1 return merged_list # sort function def merge_sort(list): if len(list) <= 1: listeyi geri döndür: orta = ( len(list)) // 2 left_array = liste[:orta] right_array = liste[orta:] left_array = merge_sort(left_array) right_array = merge_sort(right_array) sonuç = merge(left_array, right_array) dönüş sonucu # yerinde birleştirme sıralama algoritma def merge_in_place(list, start, mid, end): startup_high = mid + 1 # mid ve startup_high zaten sırayla ise, geri dön list[mid] <= list[begin_high]: işaretçiler sınırlar içindeyken geri # start <= mid ve begin_high <= end: # if startup öğesi startup_high elementine göre sıralıysa eğer list[begin] <= list[begin_high]: # artış startup startup += 1 başka: # geçerli değer startup_high değerinin başındadır = list[begin_high] # index is begin_high index = startup_high # iken dizin başlamaya eşit değilken index != startup: # dizindeki öğeyi sol komşusu ile takas edin st[index] = list[index-1] # eksiltme indeks indeksi -= 1 # liste başlangıcındaki değer yeni değer listesidir[begin] = değer # tüm işaretçileri artırma (eksi son) başlangıç ​​+= 1 orta += 1 startup_high + = 1 # yerinde sıralama def merge_sort_in_place(liste, sol, sağ): eğer sol < sağ: orta = (sol + sağ) // 2 merge_sort_in_place(liste, sol, orta) merge_sort_in_place(liste, orta+1, sağ) merge_in_place(liste, sol, orta, sağ) dönüş listesi listesi = [6, 3, 1 , 4, 8, 2, 5, 7] sonuç = merge_sort_in_place(list, 0, len(list)-1) print(result)

Çünkü bölmeli ve sonra birleştirme ile fethetmeliyiz sort, çalışma zamanı karmaşıklığını O(log(n)) * O(n) veya O(n * log(n)) olarak düşünebiliriz. Big O notasyonu hakkında ek bilgi için, Python.Engineering makalelerine, Big-O Notation Time ve Big-O Notation Space.





Python algoritmaları: StackOverflow Questions

Tutorials