Birleştirme sıralaması, böl ve yönet kavramı üzerinde çalıştığı için hızlı sıralama algoritmasına benzer. En popüler ve etkili sıralama algoritmalarından biridir. Algoritmaların böl ve yönet kategorisine en iyi örnektir.

Verilen listeyi iki yarıya böler, kendisini iki yarı için çağırır ve daha sonra sıralanan iki yarıyı birleştirir. biz tanımlarız birleştirmek() İki yarımı birleştirmek için kullanılan fonksiyon.

Alt listeler, her biri tek bir öğeyi elde edene kadar tekrar tekrar yarıya bölünür. Daha sonra bir öğe listesi çiftini iki öğe listesi halinde birleştirip bunları işlem sırasında sıralarız. Sıralanan iki öğe çifti, dört öğe listesiyle birleştirilir ve sıralanmış listeyi elde edene kadar bu böyle devam eder.

Birleştirme Sıralama Konsepti

Aşağıdaki Birleştirme sıralama diyagramını görelim.

Verilen listeyi ikiye böldük. Liste eşit parçalara bölünemezdi, hiçbir önemi yoktu.

Birleştirme sıralaması iki şekilde uygulanabilir: yukarıdan aşağıya yaklaşım ve aşağıdan yukarıya yaklaşım. Yukarıdaki örnekte en sık kullanılan Birleştirme sıralaması olan yukarıdan aşağıya yaklaşımı kullanıyoruz.

Aşağıdan yukarıya yaklaşım daha sonra tanımlayacağımız optimizasyonu sağlar.

Algoritmanın ana kısmı iki sıralı alt listeyi nasıl birleştireceğimizdir. İki sıralı birleştirme listesini birleştirelim.

• A : [ 2 , 4, 7, 8]
• B : [ 1 , 3, 11]
• sıralanmış: boş

Öncelikle her iki listenin de ilk elemanını gözlemliyoruz. B'nin ilk elemanının daha küçük olduğunu görüyoruz, bu yüzden bunu sıralı listemize ekliyoruz ve B listesinde ilerliyoruz.

• A : [ 2 , 4, 7, 8]
• B : [1, 3 , onbir]
• Sıralanmış : 1

Şimdi bir sonraki eleman çifti 2 ve 3'e bakıyoruz. 2 daha küçük olduğundan onu sıralı listemize ekleyip listeye ilerliyoruz.

• A : [ 2 , 4, 7, 8]
• B : [1, 3 , onbir]
• Sıralanmış : 1

Bu işleme devam edersek {1, 2, 3, 4, 7, 8, 11} şeklinde sıralanmış bir liste elde ederiz. İki özel durum olabilir.

Java'yı karaktere dönüştürmek

Ya her iki alt listede de aynı öğeler varsa - Bu durumda, bir alt listeyi taşıyabilir ve öğeyi sıralanan listeye ekleyebiliriz. Teknik olarak hem alt listede ilerleyebilir hem de elemanları sıralanmış listeye ekleyebiliriz.

Bir alt listede hiçbir öğemiz kalmadı. Bir alt listede listemiz bittiğinde, basitçe ikincinin elemanını arka arkaya ekleyin.

Öğeyi herhangi bir sıraya göre sıralayabileceğimizi unutmamalıyız. Verilen listeyi artan sırada sıralıyoruz ancak kolaylıkla azalan düzende de sıralayabiliriz.

Uygulama

Birleştirme sıralama algoritması yukarıdan aşağıya yaklaşımı kullanılarak uygulanır. Biraz zor görünebilir, bu nedenle her adımın ayrıntılarını detaylandıracağız. Burada bu algoritmayı iki tür koleksiyona uygulayacağız: tamsayı öğe listesi (genellikle sıralamayı tanıtmak için kullanılır) ve özel bir nesne (daha pratik ve gerçekçi bir senaryo).

Sıralama Dizisi

Algoritmanın ana konsepti (alt)listeyi ikiye bölerek yinelemeli olarak sıralamaktır. Tek elemanlı listeler elde edene kadar işleme devam ediyoruz. Bölme için aşağıdaki fonksiyonu anlayalım -

 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) 

Sıralama gerçekleşmeden önce listeyi alt bölümlere ayırmak öncelikli odak noktamızdır. İndekslerimiz için // operatörünü kullanabilmemiz için tamsayı değerini almamız gerekiyor.

Aşağıdaki adımları takip ederek yukarıdaki prosedürü anlayalım.

• İlk adım listelerin kopyalarını oluşturmaktır. İlk liste aşağıdaki listeleri içerir: [left_index,...,orta] ve ikincisi [orta+1,?,right_index] .
• İşaretçiyi kullanarak listenin her iki kopyasını da dolaşıyoruz, iki değerden küçük olanı seçip sıralanan listeye ekliyoruz. Elemanı listeye ekledikten sonra sıralanan listede ne olursa olsun ilerliyoruz.
• Diğer kopyadaki kalan öğeleri sıralanan diziye ekleyin.

Python programında birleştirme sıralamasını uygulayalım.

Python Programı

 # 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 &gt;= 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&apos;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(&apos;Make: {}, Model: {}, Year: {}&apos;, 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(&apos;Renault&apos;, &apos;33 Duster&apos;, 2001) car2 = Car(&apos;Maruti&apos;, &apos;Maruti Suzuki Dzire&apos;, 2015) car3 = Car(&apos;Tata motor&apos;, &apos;Jaguar&apos;, 2004) car4 = Car(&apos;Cadillac&apos;, &apos;Seville Sedan&apos;, 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&apos;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)>

Özel Nesneleri Sıralama

Özel nesneleri aşağıdakileri kullanarak da sıralayabiliriz: Python sınıf. Bu algoritma hemen hemen yukarıdakine benzer ancak onu daha çok yönlü hale getirmemiz ve karşılaştırma fonksiyonunu geçirmemiz gerekiyor.

Özel bir sınıf olan Car'ı oluşturacağız ve ona birkaç alan ekleyeceğiz. Daha çok yönlü hale getirmek için aşağıdaki algoritmada birkaç değişiklik yapıyoruz. Bunu lambda fonksiyonlarını kullanarak yapabiliriz.

Aşağıdaki örneği anlayalım.

Python Programı

 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(&apos;Make: {}, Model: {}, Year: {}&apos;, 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(&apos;Renault&apos;, &apos;33 Duster&apos;, 2001) car2 = Car(&apos;Maruti&apos;, &apos;Maruti Suzuki Dzire&apos;, 2015) car3 = Car(&apos;Tata motor&apos;, &apos;Jaguar&apos;, 2004) car4 = Car(&apos;Cadillac&apos;, &apos;Seville Sedan&apos;, 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&apos;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)>

Optimizasyon

Birleştirme sıralama algoritmasının performansını artırabiliriz. Öncelikle yukarıdan aşağıya ve aşağıdan yukarıya birleştirme sıralaması arasındaki farkı anlayalım. Aşağıdan yukarıya yaklaşım, bitişik listelerin öğelerini yinelemeli olarak sıralarken, yukarıdan aşağıya yaklaşım, listeleri iki yarıya böler.

Verilen liste [10, 4, 2, 12, 1, 3]'tür, onu [10], [4], [2], [12], [1], [3]'e bölmek yerine - bölüyoruz zaten sıralanmış olan alt listelere: [10, 4], [2], [1, 12], [3] ve şimdi bunları sıralamaya hazırsınız.

Birleştirme sıralaması, daha küçük alt listeler için hem zaman hem de alan açısından verimsiz bir algoritmadır. Bu nedenle ekleme sıralaması, daha küçük alt listeler için birleştirme sıralamasından daha verimli bir algoritmadır.

Çözüm

Birleştirme sıralaması popüler ve etkili bir algoritmadır. Büyük listeler için daha verimli bir algoritmadır. Kötü çalışma sürelerine yol açan talihsiz kararlara bağlı değildir.

Birleştirme sıralamasında önemli bir dezavantaj vardır. Listelerin geçici kopyalarını birleştirmeden önce saklamak için kullanılan ek belleği kullanır. Ancak Birleştirme sıralaması yazılımda yaygın olarak kullanılmaktadır. Performansı hızlıdır ve mükemmel sonuç verir.

Birleştirme sıralaması kavramını kısaca tartıştık ve bunu hem basit tamsayı listesinde hem de karşılaştırma için kullanılan bir lambda işlevi aracılığıyla özel nesnelerde uyguladık.

css'de bir görüntüyü ortalamak