Yhdistämislajittelu on samanlainen kuin pikalajittelualgoritmi, koska se toimii hajota ja hallitse -konseptin parissa. Se on yksi suosituimmista ja tehokkaimmista lajittelualgoritmeista. Se on paras esimerkki hajota ja hallitse -kategorian algoritmeista.
Se jakaa annetun luettelon kahteen puolikkaaseen, kutsuu itseään kahdeksi puolikkaaksi ja yhdistää sitten kaksi lajiteltua puoliskoa. Me määrittelemme yhdistää() toiminto, jota käytetään yhdistämään kaksi puoliskoa.
Alilistat jaetaan uudestaan ja uudestaan puoliksi, kunnes saamme kukin ainoan elementin. Sitten yhdistämme yhden elementtiluettelon parin kahdeksi elementtiluetteloksi lajittelemalla ne samalla prosessilla. Lajiteltu kaksi elementtiparia yhdistetään neljään elementtiluetteloon ja niin edelleen, kunnes saadaan lajiteltu luettelo.
Yhdistä lajittelukonsepti
Katsotaanpa seuraavaa Yhdistämisen lajittelukaaviota.
Olemme jakaneet annetun listan kahteen osaan. Listaa ei voitu jakaa yhtä suuriin osiin, sillä ei ole mitään väliä.
Yhdistelmälajittelu voidaan toteuttaa käyttämällä kahta tapaa - ylhäältä alas -lähestymistapaa ja alhaalta ylös -lähestymistapaa. Käytämme ylhäältä alas -lähestymistapaa yllä olevassa esimerkissä, joka on yleisimmin käytetty yhdistämislajittelu.
Alhaalta ylös -lähestymistapa tarjoaa enemmän optimointia, jonka määrittelemme myöhemmin.
Algoritmin tärkein osa on se, miten yhdistämme kaksi lajiteltua alilistaa. Yhdistetään kaksi lajiteltua yhdistämisluetteloa.
- A: [ 2 , 4, 7, 8]
- B: [ 1 , 3, 11]
- lajiteltu: tyhjä
Ensin tarkastelemme molempien luetteloiden ensimmäistä elementtiä. Huomaamme, että B:n ensimmäinen elementti on pienempi, joten lisäämme tämän lajiteltuun luetteloomme ja siirrymme eteenpäin B-luettelossa.
- A: [ 2 , 4, 7, 8]
- B : [1, 3 , yksitoista]
- Lajiteltu: 1
Nyt tarkastellaan seuraavaa elementtiparia 2 ja 3. 2 on pienempi, joten lisäämme sen lajiteltuun luetteloomme ja siirrymme eteenpäin luetteloon.
- A: [ 2 , 4, 7, 8]
- B : [1, 3 , yksitoista]
- Lajiteltu: 1
Jatka tätä prosessia ja päädymme lajiteltuun luetteloon {1, 2, 3, 4, 7, 8, 11}. Erikoistapauksia voi olla kaksi.
poisto binäärihakupuusta
Entä jos molemmissa alilistoissa on samat elementit - Tässä tapauksessa voimme siirtää jompaakumpaa alilistaa ja lisätä elementin lajiteltuun luetteloon. Teknisesti voimme siirtyä eteenpäin molemmissa aliluetteloissa ja lisätä elementit lajiteltuun luetteloon.
Meillä ei ole enää elementtiä yhdessä aliluettelossa. Kun alaluettelo loppuu, lisää vain toisen elementti peräkkäin.
Meidän tulee muistaa, että voimme lajitella elementin mihin tahansa järjestykseen. Lajittelemme annetun listan nousevaan järjestykseen, mutta voimme helposti lajitella laskevaan järjestykseen.
Toteutus
Yhdistämislajittelualgoritmi toteutetaan käyttämällä ylhäältä alas -lähestymistapaa. Se voi näyttää hieman vaikealta, joten tarkennamme jokaisen vaiheen yksityiskohdat. Tässä toteutamme tämän algoritmin kahdentyyppisissä kokoelmissa - kokonaislukuelementtien luettelossa (jota käytetään yleensä lajittelun käyttöönotossa) ja mukautetussa objektissa (käytännöllisempi ja realistisempi skenaario).
Lajittelutaulukko
Algoritmin pääkonsepti on jakaa (ali)lista puoliksi ja lajitella ne rekursiivisesti. Jatkamme prosessia, kunnes päädymme luetteloihin, joissa on vain yksi elementti. Ymmärretään seuraava jakofunktio -
def merge_sort(array, left_index, right_index): if left_index >= right_index: return middle = (left_index + right_index)//2 merge_sort(array, left_index, middle) merge_sort(array, middle + 1, right_index) merge(array, left_index, right_index, middle)
Päätavoitteemme on jakaa luettelo alaosiin ennen lajittelua. Meidän on saatava kokonaislukuarvo, jotta käytämme //-operaattoria indekseillemme.
Valitse useista taulukoista sql
Ymmärretään yllä oleva menettely seuraavien vaiheiden avulla.
- Ensimmäinen askel on luoda kopiot luetteloista. Ensimmäinen luettelo sisältää luettelot alkaen [vasen_indeksi,...,keskellä] ja toinen alkaen [keski+1,?,oikea_indeksi] .
- Selaamme luettelon molemmat kopiot osoittimen avulla, valitsemme kahdesta arvosta pienemmän arvon ja lisäämme ne lajiteltuun luetteloon. Kun lisäämme elementin luetteloon, siirrymme eteenpäin järjestetyssä luettelossa riippumatta.
- Lisää toisen kopion loput elementit lajiteltuun taulukkoon.
Toteutetaan yhdistämislajittelu Python-ohjelmassa.
Python ohjelma
# Here, we are declaring the function to divide the lists in to the two sub lists # Here, we are passing the list1, left index, right index as the parameters def merge_sort(list1, left_index, right_index): if left_index >= right_index: # here, we are checking the if condition return middle = (left_index + right_index)//2 # Here, we are finding the middle of the given two numbers merge_sort(list1, left_index, middle) # Here, we are calling the merge sort function till the middle number we got merge_sort(list1, middle + 1, right_index) # Here, we are calling the merge sort function till the end of the list i.e., right index merge(list1, left_index, right_index, middle) # Here, we are calling the merge function to merge the divided list using the merge # sort function above # Here, we are defining a function for merge the list after dividing def merge(list1, left_index, right_index, middle): # Here, we are creating subparts of a lists left_sublist = list1[left_index:middle + 1] right_sublist = list1[middle+1:right_index+1] # Here, we are initializing the values for variables that we use to keep # track of where we are in each list1 left_sublist_index = 0 right_sublist_index = 0 sorted_index = left_index # Here, we are traversing the both copies until we get run out one element while left_sublist_index <len(left_sublist) 1 and right_sublist_index < len(right_sublist): # here, we are declaring a while loop if our left_sublist has the smaller element, put it in sorted part then move forward (by increasing pointer) left_sublist[left_sublist_index] checking condition, is true will enter block list1[sorted_index]="left_sublist[left_sublist_index]" left_sublist_index="left_sublist_index" + otherwise add into right sublist else: moving sorted_index="sorted_index" go through remaining elements them len(left_sublist): len(right_sublist):# list1="[44," 65, 2, 3, 58, 14, 57, 23, 10, 1, 7, 74, 48] print('the given list before performing merge sort is: ', list1) this input unsorted array by user merge_sort(list1, 0, len(list1) -1) after is:', printing amd functions pre> <p> <strong>Output:</strong> </p> <pre> The given list before performing the merge sort is: [44, 65, 2, 3, 58, 14, 57, 23, 10, 1, 7, 74, 48] The given list after performing the merge sort is: [1, 2, 3, 7, 10, 14, 23, 44, 48, 57, 58, 65, 74] </pre> <h2>Sorting Custom Objects</h2> <p>We can also sort the custom objects by using the <a href="/python-tutorial-python-programming-language">Python</a> class. This algorithm is almost similar to the above but we need to make it more versatile and pass the comparison function.</p> <p>We will create a custom class, Car and add a few fields to it. We make few changes in the below algorithm to make it more versatile. We can do this by using the lambda functions.</p> <p>Let's understand the following example.</p> <h3>Python Program</h3> <pre> class Car: # here, we are declaring a class named car def __init__(self, make, model, year): self.make = make # Here, we are using the self to declare the make variables locally self.model = model # Here, we are using the self to declare the model variables locally self.year = year # Here, we are using the self to declare the year variables locally def __str__(self): return str.format('Make: {}, Model: {}, Year: {}', self.make, self.model, self.year) # Here, we are returning the format of the strings given def merge(list1, l, r, m, comp_fun): # Here, we are defining a function for merge the list using the compound function left_copy = list1[l:m + 1] # here, we are coping the left part of the list r_sublist = list1[m+1:r+1] # here, we are coping the right part of the list left_copy_index = 0 # here, we are coping the left part indexes of the list r_sublist_index = 0 # here, we are coping the right part indexes of the list sorted_index = l while left_copy_index <len(left_copy) 1 and r_sublist_index < len(r_sublist): # here, we are declaring a while loop using the comp_fun instead of simple comparison operator if comp_fun(left_copy[left_copy_index], r_sublist[r_sublist_index]): checking condition, it is true then will enter block list1[sorted_index]="left_copy[left_copy_index]" left_copy_index="left_copy_index" + else: condition false else sorted_index="sorted_index" len(left_copy): <len(r_sublist): def merge_sort(list1, l, r, comp_fun): merge sort function to given list l>= r: # Here, we are checking the if condition, if it is true then we will enter the block return m = (l + r)//2 # here, we are finding the middle element of the list merge_sort(list1, l, m, comp_fun) # Here, we are calling the merge sort function till the middle number we got merge_sort(list1, m + 1, r, comp_fun) # Here, we are calling the merge sort function from the middle number we got merge(list1, l, r, m, comp_fun) # Here, we are calling the merge function to merge the divided list using the merge # sort function above car1 = Car('Renault', '33 Duster', 2001) car2 = Car('Maruti', 'Maruti Suzuki Dzire', 2015) car3 = Car('Tata motor', 'Jaguar', 2004) car4 = Car('Cadillac', 'Seville Sedan', 1995) list1 = [car1, car2, car3, car4] merge_sort(list1, 0, len(list1) -1, lambda carA, carB: carA.year <carb.year) print('cars sorted by year:') for car in list1: # here, we are declaring the loop to iterate through list1 print(car) printing all data of and list print() merge_sort(list1, 0, len(list1) -1, lambda cara, carb: cara.make < carb.make) make:') pre> <p> <strong>Output:</strong> </p> <pre> Cars sorted by year: Make: Cadillac, Model: Seville Sedan, Year: 1995 Make: Renault, Model: 33 Duster, Year: 2001 Make: Tata motor, Model: Jaguar, Year: 2004 Make: Maruti, Model: Maruti Suzuki Dzire, Year: 2015 Cars sorted by make: Make: Cadillac, Model: Seville Sedan, Year: 1995 Make: Maruti, Model: Maruti Suzuki Dzire, Year: 2015 Make: Renualt, Model: 33 Duster, Year: 2001 Make: Tata motor, Model: Jaguar, Year: 2004 </pre> <h2>Optimization</h2> <p>We can improve the performance of the merge sort algorithm. First let's understand the difference between the top-down and bottom-up merge sort. The bottom-up approach sorts the elements of adjacent lists iteratively where the top-down approach breaks down the lists into the two halves.</p> <p>The given list is [10, 4, 2, 12, 1, 3], instead of breaking it down into [10], [4], [2], [12], [1], [3] - we divide into the sub lists which may already sorted: [10, 4], [2], [1, 12], [3] and now are ready to sort them.</p> <p>Merge sort is inefficient algorithm in both time and space for the smaller sub lists. So, insertion sort is more efficient algorithm than the merge sort for the smaller sub lists.</p> <h2>Conclusion</h2> <p>Merge sort is popular and efficient algorithm. It is more efficient algorithm for the large lists. It does not depend on the any unfortunate decisions that lead to bad runtimes.</p> <p>There is one major demerit in the merge sort. It uses the additional memory that is used to store the temporary copies of lists before merging them. However Merge sort is widely used in the software. Its performance is fast and produces the excellent result.</p> <p>We have discussed the merge sort concept in brief and implement it both on simple integer list and on custom objects via a lambda function used for comparison.</p> <hr></carb.year)></len(left_copy)></pre></len(left_sublist)> Mukautettujen objektien lajittelu
Voimme myös lajitella mukautetut objektit käyttämällä Python luokkaa. Tämä algoritmi on melkein samanlainen kuin yllä oleva, mutta meidän on tehtävä siitä monipuolisempi ja läpäistävä vertailutoiminto.
Luomme mukautetun luokan, Auton, ja lisäämme siihen muutaman kentän. Teemme muutamia muutoksia alla olevaan algoritmiin tehdäksemme siitä monipuolisemman. Voimme tehdä tämän käyttämällä lambda-toimintoja.
Ymmärretään seuraava esimerkki.
Python ohjelma
class Car: # here, we are declaring a class named car def __init__(self, make, model, year): self.make = make # Here, we are using the self to declare the make variables locally self.model = model # Here, we are using the self to declare the model variables locally self.year = year # Here, we are using the self to declare the year variables locally def __str__(self): return str.format('Make: {}, Model: {}, Year: {}', self.make, self.model, self.year) # Here, we are returning the format of the strings given def merge(list1, l, r, m, comp_fun): # Here, we are defining a function for merge the list using the compound function left_copy = list1[l:m + 1] # here, we are coping the left part of the list r_sublist = list1[m+1:r+1] # here, we are coping the right part of the list left_copy_index = 0 # here, we are coping the left part indexes of the list r_sublist_index = 0 # here, we are coping the right part indexes of the list sorted_index = l while left_copy_index <len(left_copy) 1 and r_sublist_index < len(r_sublist): # here, we are declaring a while loop using the comp_fun instead of simple comparison operator if comp_fun(left_copy[left_copy_index], r_sublist[r_sublist_index]): checking condition, it is true then will enter block list1[sorted_index]="left_copy[left_copy_index]" left_copy_index="left_copy_index" + else: condition false else sorted_index="sorted_index" len(left_copy): <len(r_sublist): def merge_sort(list1, l, r, comp_fun): merge sort function to given list l>= r: # Here, we are checking the if condition, if it is true then we will enter the block return m = (l + r)//2 # here, we are finding the middle element of the list merge_sort(list1, l, m, comp_fun) # Here, we are calling the merge sort function till the middle number we got merge_sort(list1, m + 1, r, comp_fun) # Here, we are calling the merge sort function from the middle number we got merge(list1, l, r, m, comp_fun) # Here, we are calling the merge function to merge the divided list using the merge # sort function above car1 = Car('Renault', '33 Duster', 2001) car2 = Car('Maruti', 'Maruti Suzuki Dzire', 2015) car3 = Car('Tata motor', 'Jaguar', 2004) car4 = Car('Cadillac', 'Seville Sedan', 1995) list1 = [car1, car2, car3, car4] merge_sort(list1, 0, len(list1) -1, lambda carA, carB: carA.year <carb.year) print(\'cars sorted by year:\') for car in list1: # here, we are declaring the loop to iterate through list1 print(car) printing all data of and list print() merge_sort(list1, 0, len(list1) -1, lambda cara, carb: cara.make < carb.make) make:\') pre> <p> <strong>Output:</strong> </p> <pre> Cars sorted by year: Make: Cadillac, Model: Seville Sedan, Year: 1995 Make: Renault, Model: 33 Duster, Year: 2001 Make: Tata motor, Model: Jaguar, Year: 2004 Make: Maruti, Model: Maruti Suzuki Dzire, Year: 2015 Cars sorted by make: Make: Cadillac, Model: Seville Sedan, Year: 1995 Make: Maruti, Model: Maruti Suzuki Dzire, Year: 2015 Make: Renualt, Model: 33 Duster, Year: 2001 Make: Tata motor, Model: Jaguar, Year: 2004 </pre> <h2>Optimization</h2> <p>We can improve the performance of the merge sort algorithm. First let's understand the difference between the top-down and bottom-up merge sort. The bottom-up approach sorts the elements of adjacent lists iteratively where the top-down approach breaks down the lists into the two halves.</p> <p>The given list is [10, 4, 2, 12, 1, 3], instead of breaking it down into [10], [4], [2], [12], [1], [3] - we divide into the sub lists which may already sorted: [10, 4], [2], [1, 12], [3] and now are ready to sort them.</p> <p>Merge sort is inefficient algorithm in both time and space for the smaller sub lists. So, insertion sort is more efficient algorithm than the merge sort for the smaller sub lists.</p> <h2>Conclusion</h2> <p>Merge sort is popular and efficient algorithm. It is more efficient algorithm for the large lists. It does not depend on the any unfortunate decisions that lead to bad runtimes.</p> <p>There is one major demerit in the merge sort. It uses the additional memory that is used to store the temporary copies of lists before merging them. However Merge sort is widely used in the software. Its performance is fast and produces the excellent result.</p> <p>We have discussed the merge sort concept in brief and implement it both on simple integer list and on custom objects via a lambda function used for comparison.</p> <hr></carb.year)></len(left_copy)> Optimointi
Voimme parantaa yhdistämislajittelualgoritmin suorituskykyä. Ymmärrämme ensin eron ylhäältä alas ja alhaalta ylös yhdistämisen välillä. Alhaalta ylös -lähestymistapa lajittelee vierekkäisten luetteloiden elementit iteratiivisesti, jolloin ylhäältä alas -lähestymistapa jakaa luettelot kahteen puolikkaaseen.
Annettu luettelo on [10, 4, 2, 12, 1, 3], sen sijaan, että se jaotettaisiin [10], [4], [2], [12], [1], [3] - jaamme aliluetteloihin, jotka ovat jo lajiteltuja: [10, 4], [2], [1, 12], [3] ja ovat nyt valmiita lajittelemaan ne.
Yhdistämislajittelu on tehoton algoritmi sekä ajallisesti että tilassa pienille alilistoille. Joten lisäyslajittelu on tehokkaampi algoritmi kuin yhdistäminen pienempien aliluetteloiden kohdalla.
Johtopäätös
Yhdistämislajittelu on suosittu ja tehokas algoritmi. Se on tehokkaampi algoritmi suurille listoille. Se ei riipu valitettavista päätöksistä, jotka johtavat huonoihin ajoaikoihin.
Yhdistämisessä on yksi suuri huono puoli. Se käyttää lisämuistia, jota käytetään luetteloiden väliaikaisten kopioiden tallentamiseen ennen niiden yhdistämistä. Yhdistä lajittelua käytetään kuitenkin laajasti ohjelmistossa. Sen suorituskyky on nopea ja tuottaa erinomaisen tuloksen.
Olemme käsitelleet yhdistämislajittelukonseptia lyhyesti ja toteuttaneet sen sekä yksinkertaisessa kokonaislukuluettelossa että mukautetuissa objekteissa vertailuun käytetyn lambda-funktion kautta.