Program w Pythonie do sortowania przez scalanie

Jako wieloparadygmatyczny język programowania ze strukturalnym, zorientowanym obiektowo podejściem do projektowania oraz prostą i przejrzystą składnią i gramatyką, Python szybko staje się językiem wybieranym przez programistów pracujących nad projektami o różnej złożoności i skali.

Python udostępnia modułową bibliotekę gotowych algorytmów, która umożliwia użytkownikom wykonywanie różnych operacji, które mogą pomóc im w realizacji ich zadań samodzielnie lub służyć jako krok na drodze do osiągnięcia większego, bardziej złożonego celu. Jednym z bardziej popularnych tego typu algorytmów jest ten, który umożliwia funkcję sortowania przez scalanie.

Co to jest sortowanie przez scalanie?

Jest to technika sortowania ogólnego przeznaczenia, która umożliwia użytkownikom pobranie losowego zbioru danych dowolnego typu i z dowolnego źródła oraz podzielenie go na powtarzające się etapy, aż w końcu zostanie on rozbity na poszczególne komponenty – technika rekurencyjna, powszechnie nazywana „ metodą dziel i zwyciężaj.

Algorytm następnie łączy poszczególne komponenty – ponownie w powtarzających się etapach – ale sortuje je w z góry ustaloną, logiczną sekwencję na każdym etapie, używając podstawowego porównania i zamiany, aż cała seria danych zostanie odtworzona w pożądanej sekwencji logicznej .

Sprawdź nasze inne kursy data science na upGrad.

Technika dziel i rządź

Weźmy na przykład losowy zestaw danych składający się z liter alfabetu: N, H, V, B, Q, D, Z, R.

Krok 1 : Oryginalny zestaw danych jest najpierw dzielony na dwie grupy w następujący sposób:

N, H, V, B Q, D, Z, R

Krok 2 : Obie wynikowe tablice są dalej dzielone w następujący sposób:

N, H V, B Q, DZ, R

Krok 3 : Na koniec wszystkie cztery tablice są dalej wypluwane, aż cała seria danych zostanie podzielona na poszczególne komponenty:

N H V B Q D Z R

Następnie proces odwraca się, a poszczególne punkty danych zaczynają się teraz łączyć etapami. Ale w trakcie tego procesu scalania każdy element w każdej podtablicy jest oceniany i zamieniany, tak aby uporządkowały się w logicznej kolejności (kolejność alfabetyczna), jak następuje:

Krok 4 : Poszczególne elementy łączą się w pary, zamieniając miejscami w razie potrzeby, aby utworzyć prawidłową sekwencję:

H, NB , V D, Q R, Z

Krok 5 : Rekurencyjny proces łączenia i sortowania trwa do następnej iteracji:

B, H, N, V ​​D, Q, R, Z

Krok 6 : Cała seria danych jest ostatecznie odtwarzana w logicznej kolejności alfabetycznej:

B, D, H, N, Q, R, V, Z

Zapoznaj się z naszymi popularnymi kursami Data Science

Implementacje sortowania przez scalanie

Istnieją dwa podejścia do implementacji sortowania przez scalanie w Pythonie. Podejście odgórne i podejście oddolne.

Podejście odgórne:

Częściej stosowanym podejściem odgórnym jest podejście opisane powyżej. Zajmuje to więcej czasu i zużywa więcej pamięci, dlatego jest nieefektywne podczas pracy z mniejszymi zbiorami danych. Jest jednak znacznie bardziej niezawodny, szczególnie w przypadku dużych zbiorów danych.

Przeczytaj nasze popularne artykuły dotyczące nauki o danych

Wprowadź kod:

def merge_sort (inp_arr):

rozmiar = długość (tablica_wejściowa)

jeśli rozmiar > 1:

środek = rozmiar // 2

lewy_tablica = wejściowy_tablica(:środkowy)

tablica_prawa = tablica_wejściowa(środek:)

merge_sort(lewy_arr)

scalaj _sort(prawy_tablica)

ja = 0

j = 0

k = 0

(Gdzie i i j to iteratory do przechodzenia odpowiednio przez lewą i prawą połowę serii danych, a k to iterator całej serii danych).

lewy_rozmiar = dł.(lewy_arr)

prawy_rozmiar = dł.(prawy_arr)

podczas gdy i < rozmiar_lewy i j < rozmiar prawy:

jeśli lewy_arr(i) < prawy_arr (j):

inp_arr(k) – lewy_arr(i)

ja >= 1

w przeciwnym razie:

tablica_wejściowa(k) = tablica_prawa (j)

j += 1

k += 1

podczas gdy i < rozmiar_lewy:

tablica_wejściowa (k) = tablica_lewa_(i)

ja += 1

k += 1

podczas gdy j < prawy_rozmiar:

tablica_wejściowa (k) = tablica_prawa(j)

j += 1

k += 1

tablica_wejściowa = (N, H, V, B, Q, D, Z, R)

print(:Tablica wejściowa:\n”)

print(inp_arr)

merge_sort (tablica_wejściowa)

print("Posortowana tablica:\n")

drukuj (tablica_wejściowa)

Wyjście:

Tablica wejściowa: N, H, V, B, Q, D, Z, R

Tablica wyjściowa: B, D, H, N, Q, R, V, Z

Podejście oddolne:

Podejście oddolne jest szybsze, zużywa mniej pamięci i działa wydajniej z mniejszymi zbiorami danych, ale może napotkać problemy podczas pracy z dużymi zbiorami danych. Dlatego jest rzadziej używany.

Wprowadź kod:

def merge(lewy, prawy):

wynik = [] x, y = 0, 0

dla k w zakresie (0, dł. (po lewej) + dł. (po prawej)):

if i == len(left): # if na koniec pierwszej połowy,

result.append(right[j]) # dodaj wszystkie wartości drugiej połowy

j += 1

elif j == len(po prawej): # jeśli pod koniec drugiej połowy,

result.append(left[x]) # dodaj wszystkie wartości pierwszej połowy

ja += 1

elif prawo[j] < lewo[i]:

wynik.dołącz(prawo[j])

j += 1

w przeciwnym razie:

wynik.dołącz(lewo[i])

ja += 1

zwróć wynik

def mergesort(ar_list):

długość = len(ar_list)

rozmiar = 1

podczas gdy rozmiar < długość:

size+=size # inicjuje się na 2 zgodnie z opisem

dla pozycji w zakresie (0, długość, rozmiar):

początek = poz

mid = poz + int(rozmiar / 2)

koniec = pozycja + rozmiar

lewa = ar_list[ początek : środek ] prawa = ar_lista [ środek : koniec ]

ar_list[początek:koniec] = scalanie(lewa, prawa)

zwróć listę_ar

ar_list = [N, H, V, B, Q, D, Z, R] print(mergesort(ar_list))

Wyjście:

Tablica wejściowa: N, H, V, B, Q, D, Z, R

Tablica wyjściowa: B, D, H, N, Q, R, V, Z

Implementacja sortowania przez scalanie zastosowana do bardziej złożonych, rzeczywistych zestawów danych

Zastosujmy podejście odgórne do czterech przypadkowych pojazdów terenowych w Indiach:

Wprowadź kod:

samochód klasy :

def __init__(ja, marka, model, cena):

marka własna = marka

model.własny = model

cena własna = cena

def __str__(ja):

return str.format("Marka: {}, Model: {}, Cena: {}", self.brand,

własny.model, własna.cena)

def merge(list1, i, j, k, comp_fun):

lewa_kopia = lista1[i:k + 1]

r_podlista = lista1[k+1:r+1]

left_copy_index = 0

j_sublist_index = 0

sorted_index = i

podczas gdy left_copy_index < len (left_copy) ij_sublist_index <

len(j_podlista):

if comp_fun(left_copy[left_copy_index], j_sublist[j_sublist_index]):

lista1[indeks_posortowanej] = lewa_kopia[indeks_lewej_kopii]

lewy_indeks_kopii = lewy_indeks_kopii + 1

inaczej :

lista1[sortowany_indeks] = j_podlista[j_indeks_podlisty]

j_sublist_index = j_sublist_index + 1

sortowany_indeks = sortowany_indeks + 1

while left_copy_index < len(lewa_kopia):

lista1[indeks_posortowanej] = lewa_kopia[indeks_lewej_kopii]

lewy_indeks_kopii = lewy_indeks_kopii + 1

sortowany_indeks = sortowany_indeks + 1

while j_sublist_index < len(j_sublist):

lista1[sortowany_indeks] = j_podlista[j_indeks_podlisty]

j_sublist_index = j_sublist_index + 1

sortowany_indeks = sortowany_indeks + 1

def merge_sort(list1, i, j, comp_fun):

jeśli i >= j:

powrót

k = (ja + j)//2

merge_sort(list1, i, k, comp_fun)

merge_sort(list1, k + 1, j, comp_fun)

scalanie (lista1, i, j, k, komp_zabawa)

samochód1 = Samochód("Jeep", "Wrangler", 0,58)

samochód2 = Samochód("Ford", "Endeavour", 0,35)

samochód3 = Samochód(„Jaguar Land Rover”, „Range Rover Sport”, 1,76)

samochód4 = Samochód("Mercedes Benz", "Klasa G", 2,42)

lista1 = [samochód1, samochód2, samochód3, samochód4]

merge_sort(list1, 0, len(list1) -1, lambda carA, carB: carA.brand < carB.brand)

print ("Samochody posortowane według marki:")

dla samochodu zlisty 1:

druk (samochód)

drukuj ()

merge_sort(list1, 0, len(list1) -1, lambda carA, carB: carA.cena< carB.cena)

print ("Samochody posortowane według ceny:")

dla samochodu zlisty 1:

druk (samochód)

Wyjście:

Samochody posortowane według marki:

Forda Endeavoura

Jaguar Land Rover Range Rover Sport

Jeepa Wranglera

Mercedes-Benz klasy G

Samochody posortowane według ceny:

Forda Endeavoura

Jeepa Wranglera

Range Rovera Jaguara Land Rovera

Mercedes-Benz klasy G

Możesz nauczyć się zarówno teoretycznych, jak i praktycznych aspektów Pythona dzięki profesjonalnemu certyfikatowi upGrad w zakresie analizy danych i analizy biznesowej z University of Maryland. Ten kurs pomoże Ci nauczyć się Pythona od podstaw. Nawet jeśli jesteś nowy w programowaniu i kodowaniu, upGrad zaoferuje ci dwutygodniowy kurs przygotowawczy, dzięki któremu możesz poznać podstawy programowania. poznasz różne narzędzia, takie jak Python, SQL, podczas pracy nad wieloma projektami branżowymi.

Zaplanuj swoją karierę programisty już teraz!

Złóż wniosek o profesjonalny program certyfikatów w zakresie nauki o danych i analityki biznesowej