Sapludināšanas kārtošana ir līdzīga ātrās kārtošanas algoritmam, jo tā darbojas pie sadalīšanas un iekarošanas koncepcijas. Tas ir viens no populārākajiem un efektīvākajiem šķirošanas algoritmiem. Tas ir labākais piemērs algoritmu kategorijas sadali un iekaro.
Tas sadala doto sarakstu abās daļās, izsauc sevi par divām daļām un pēc tam apvieno abas sakārtotās daļas. Mēs definējam sapludināt () funkcija, ko izmanto, lai apvienotu divas puses.
Apakšsaraksti atkal un atkal tiek sadalīti uz pusēm, līdz katrs iegūstam vienīgo vienu elementu. Tad mēs apvienojam viena elementa sarakstu pāri divos elementu sarakstos, tos sakārtojot. Sakārtotie divi elementu pāri tiek sapludināti četros elementu sarakstos un tā tālāk, līdz iegūstam sakārtoto sarakstu.
Sapludināšanas kārtošanas koncepcija
Apskatīsim šādu sapludināšanas kārtošanas diagrammu.
Mēs esam sadalījuši doto sarakstu divās daļās. Sarakstu nevarēja sadalīt vienādās daļās, tam nav nekādas nozīmes.
Sapludināšanas kārtošanu var ieviest, izmantojot divus veidus - lejupējo pieeju un augšupēju pieeju. Iepriekš minētajā piemērā mēs izmantojam pieeju no augšas uz leju, kas visbiežāk tiek izmantota sapludināšanas kārtošana.
Augšupējā pieeja nodrošina lielāku optimizāciju, ko mēs definēsim vēlāk.
Algoritma galvenā daļa ir tā, kā mēs apvienojam divus sakārtotos apakšsarakstus. Apvienosim abus sakārtotos sapludināšanas sarakstus.
- A: [ 2 , 4, 7, 8]
- B : [ 1 , 3, 11]
- sakārtots: tukšs
Pirmkārt, mēs novērojam abu sarakstu pirmo elementu. Mēs atklājam, ka B pirmais elements ir mazāks, tāpēc mēs to pievienojam sakārtotajam sarakstam un virzāmies uz priekšu B sarakstā.
- A: [ 2 , 4, 7, 8]
- B : [1, 3 , vienpadsmit]
- Sašķirots: 1
Tagad mēs skatāmies uz nākamo elementu pāri 2 un 3. 2 ir mazāks, tāpēc mēs to pievienojam savam sakārtotajam sarakstam un virzāmies uz priekšu uz sarakstu.
- A: [ 2 , 4, 7, 8]
- B : [1, 3 , vienpadsmit]
- Sašķirots: 1
Turpiniet šo procesu, un mēs nonākam pie sakārtotā saraksta: {1, 2, 3, 4, 7, 8, 11}. Var būt divi īpaši gadījumi.
string.compare c#
Ko darīt, ja abos apakšsarakstos ir vienādi elementi - Tādā gadījumā mēs varam pārvietot vienu apakšsarakstu un pievienot elementu sakārtotajam sarakstam. Tehniski mēs varam virzīties uz priekšu abos apakšsarakstā un pievienot elementus sakārtotajam sarakstam.
Mums nav palicis neviens elements vienā apakšsarakstā. Kad apakšsarakstā ir beigusies daļa, vienkārši pievienojiet otrā elementu pēc otra.
Jāatceras, ka elementu varam kārtot jebkurā secībā. Mēs kārtojam doto sarakstu augošā secībā, bet varam viegli kārtot dilstošā secībā.
Īstenošana
Sapludināšanas kārtošanas algoritms tiek īstenots, izmantojot pieeju no augšas uz leju. Tas var izskatīties nedaudz sarežģīti, tāpēc mēs precizēsim katru soli. Šeit mēs ieviesīsim šo algoritmu divu veidu kolekcijās - veselu skaitļu elementu sarakstā (parasti izmanto, lai ieviestu kārtošanu) un pielāgotu objektu (praktiskāks un reālistiskāks scenārijs).
Kārtošanas masīvs
Algoritma galvenā koncepcija ir sadalīt (apakš)sarakstu uz pusēm un kārtot tos rekursīvi. Mēs turpinām procesu, līdz tiek izveidoti saraksti, kuros ir tikai viens elements. Sapratīsim šādu dalīšanas funkciju -
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)
Mūsu galvenais uzdevums ir sadalīt sarakstu apakšdaļās pirms šķirošanas. Mums ir jāiegūst vesela skaitļa vērtība, lai mēs saviem indeksiem izmantotu operatoru //.
Izpratīsim iepriekš minēto procedūru, veicot šādas darbības.
- Pirmais solis ir izveidot sarakstu kopijas. Pirmajā sarakstā ir saraksti no [kreisais_indekss,...,vidējais] un otrais no [vidējais+1,?,labais_indekss] .
- Mēs šķērsojam abas saraksta kopijas, izmantojot rādītāju, atlasām abu vērtību mazāko vērtību un pievienojam tās sakārtotajam sarakstam. Kad esam pievienojuši elementu sarakstam, mēs virzāmies uz priekšu sakārtotajā sarakstā neatkarīgi no tā.
- Pievienojiet atlikušos elementus citā kopijā sakārtotajam masīvam.
Ieviesīsim sapludināšanas kārtošanu Python programmā.
Python programma
# 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)> Pielāgotu objektu kārtošana
Mēs varam arī kārtot pielāgotos objektus, izmantojot Python klasē. Šis algoritms ir gandrīz līdzīgs iepriekšminētajam, taču mums tas ir jāpadara daudzpusīgāks un jānokārto salīdzināšanas funkcija.
Mēs izveidosim pielāgotu klasi Auto un pievienosim tai dažus laukus. Mēs veicam dažas izmaiņas tālāk norādītajā algoritmā, lai padarītu to daudzpusīgāku. Mēs to varam izdarīt, izmantojot lambda funkcijas.
Sapratīsim šādu piemēru.
Python programma
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)> Optimizācija
Mēs varam uzlabot sapludināšanas kārtošanas algoritma veiktspēju. Vispirms sapratīsim atšķirību starp sapludināšanas kārtošanu no augšas uz leju un augšupēju. Izmantojot augšupēju pieeju, blakus esošo sarakstu elementi tiek kārtoti iteratīvi, kur lejupējā pieeja sarakstus sadala divās daļās.
Dotais saraksts ir [10, 4, 2, 12, 1, 3], tā vietā, lai to sadalītu [10], [4], [2], [12], [1], [3] - mēs sadalām apakšsarakstos, kas jau var būt sakārtoti: [10, 4], [2], [1, 12], [3] un tagad ir gatavi tos kārtot.
kas ir klasterizācija
Sapludināšanas kārtošana ir neefektīvs algoritms gan laikā, gan telpā mazākiem apakšsarakstiem. Tātad ievietošanas kārtošana ir efektīvāks algoritms nekā sapludināšanas kārtošana mazākiem apakšsarakstiem.
Secinājums
Sapludināšanas kārtošana ir populārs un efektīvs algoritms. Tas ir efektīvāks algoritms lieliem sarakstiem. Tas nav atkarīgs no neveiksmīgiem lēmumiem, kas izraisa sliktu izpildlaiku.
Apvienošanai ir viens būtisks trūkums. Tas izmanto papildu atmiņu, kas tiek izmantota, lai saglabātu sarakstu pagaidu kopijas pirms to sapludināšanas. Tomēr programmatūrā tiek plaši izmantota sapludināšanas kārtošana. Tā darbība ir ātra un nodrošina izcilu rezultātu.
Mēs esam īsi apsprieduši sapludināšanas kārtošanas koncepciju un ieviesām to gan vienkāršā veselu skaitļu sarakstā, gan pielāgotos objektos, izmantojot salīdzināšanai izmantoto lambda funkciju.