S obzirom na skup elemenata koji pronalaze koja bi permutacija ovih elemenata rezultirala najgorim slučajem spajanja.
Sorta asimptotički spajanja uvijek zahtijeva O (n log n) vrijeme, ali slučajevi koji zahtijevaju više usporedbi uglavnom traju više vremena u praksi. U osnovi moramo pronaći permutaciju ulaznih elemenata koji bi doveli do maksimalnog broja usporedbi kada se sortiraju pomoću tipičnog algoritma sortiranja spajanja.
Primjer:
Consider the below set of elements
{1 2 3 4 5 6 7 8 9 10 11 12
13 14 15 16}
Below permutation of the set causes 153
comparisons.
{1 9 5 13 3 11 7 15 2 10 6
14 4 12 8 16}
And an already sorted permutation causes
30 comparisons.
Sada kako dobiti najgori unos za unos za spajanje za ulazni skup?
java povezani popis
Pustimo nam da pokušamo izgraditi niz odozdo prema gore
Neka je sortirani niz {12345678}.
Da bi se stvorio najgori slučaj spajanja sortiranje, operacija spajanja koja je rezultirala gore sortiranim nizom trebala bi rezultirati maksimalnim usporedbama. Da bi se to učinilo, lijeva i desna pod-nijansa uključena u rad spajanja trebala bi pohraniti alternativne elemente sortiranog niza. tj. lijevi pod-array treba biti {1357}, a desni pod-array bi trebao biti {2468}. Sada će se svaki element niza usporediti na najzapalju i to će rezultirati maksimalnim usporedbama. Istu logiku primjenjujemo i za lijevo i desno. Za niz {1357} Najgori slučaj bit će kada su njegovi lijevi i desni pod-array {15} i {37}, a za niz {2468} najgori slučaj će se dogoditi za {24} i {68}.
pretvoriti niz u datum
Kompletan algoritam -
GenereWorstcase (arr [])
- Napravite dva pomoćna nizova lijevo i desno i u njih pohranite elemente alternativnih nizova.
- Poziv GenerateWorstCase za lijevi podraza: GenerationWorstcase (lijevo)
- Nazovite GenerateWorstcase za desni podreda: GeneratisWorstCase (desno)
- Kopirajte sve elemente lijevog i desnog podruka natrag u originalni niz.
Ispod je provedba ideje
C++// C++ program to generate Worst Case // of Merge Sort #include
// C program to generate Worst Case of Merge Sort #include
// Java program to generate Worst Case of Merge Sort import java.util.Arrays; class GFG { // Function to join left and right subarray static void join(int arr[] int left[] int right[] int l int m int r) { int i; for (i = 0; i <= m - l; i++) arr[i] = left[i]; for (int j = 0; j < r - m; j++) arr[i + j] = right[j]; } // Function to store alternate elements in left // and right subarray static void split(int arr[] int left[] int right[] int l int m int r) { for (int i = 0; i <= m - l; i++) left[i] = arr[i * 2]; for (int i = 0; i < r - m; i++) right[i] = arr[i * 2 + 1]; } // Function to generate Worst Case of Merge Sort static void generateWorstCase(int arr[] int l int r) { if (l < r) { int m = l + (r - l) / 2; // create two auxiliary arrays int[] left = new int[m - l + 1]; int[] right = new int[r - m]; // Store alternate array elements in left // and right subarray split(arr left right l m r); // Recurse first and second halves generateWorstCase(left l m); generateWorstCase(right m + 1 r); // join left and right subarray join(arr left right l m r); } } // driver program public static void main (String[] args) { // sorted array int arr[] = { 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 }; int n = arr.length; System.out.println('Sorted array is'); System.out.println(Arrays.toString(arr)); // generate Worst Case of Merge Sort generateWorstCase(arr 0 n - 1); System.out.println('nInput array that will result in n'+ 'worst case of merge sort is n'); System.out.println(Arrays.toString(arr)); } } // Contributed by Pramod Kumar
# Python program to generate Worst Case of Merge Sort # Function to join left and right subarray def join(arr left right l m r): i = 0; for i in range(m-l+1): arr[i] = left[i]; i+=1; for j in range(r-m): arr[i + j] = right[j]; # Function to store alternate elements in left # and right subarray def split(arr left right l m r): for i in range(m-l+1): left[i] = arr[i * 2]; for i in range(r-m): right[i] = arr[i * 2 + 1]; # Function to generate Worst Case of Merge Sort def generateWorstCase(arr l r): if (l < r): m = l + (r - l) // 2; # create two auxiliary arrays left = [0 for i in range(m - l + 1)]; right = [0 for i in range(r-m)]; # Store alternate array elements in left # and right subarray split(arr left right l m r); # Recurse first and second halves generateWorstCase(left l m); generateWorstCase(right m + 1 r); # join left and right subarray join(arr left right l m r); # driver program if __name__ == '__main__': # sorted array arr = [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]; n = len(arr); print('Sorted array is'); print(arr); # generate Worst Case of Merge Sort generateWorstCase(arr 0 n - 1); print('nInput array that will result in n' + 'worst case of merge sort is '); print(arr); # This code contributed by shikhasingrajput
// C# program to generate Worst Case of // Merge Sort using System; class GFG { // Function to join left and right subarray static void join(int []arr int []left int []right int l int m int r) { int i; for (i = 0; i <= m - l; i++) arr[i] = left[i]; for (int j = 0; j < r - m; j++) arr[i + j] = right[j]; } // Function to store alternate elements in // left and right subarray static void split(int []arr int []left int []right int l int m int r) { for (int i = 0; i <= m - l; i++) left[i] = arr[i * 2]; for (int i = 0; i < r - m; i++) right[i] = arr[i * 2 + 1]; } // Function to generate Worst Case of // Merge Sort static void generateWorstCase(int []arr int l int r) { if (l < r) { int m = l + (r - l) / 2; // create two auxiliary arrays int[] left = new int[m - l + 1]; int[] right = new int[r - m]; // Store alternate array elements // in left and right subarray split(arr left right l m r); // Recurse first and second halves generateWorstCase(left l m); generateWorstCase(right m + 1 r); // join left and right subarray join(arr left right l m r); } } // driver program public static void Main () { // sorted array int []arr = { 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 }; int n = arr.Length; Console.Write('Sorted array isn'); for(int i = 0; i < n; i++) Console.Write(arr[i] + ' '); // generate Worst Case of Merge Sort generateWorstCase(arr 0 n - 1); Console.Write('nInput array that will ' + 'result in n worst case of' + ' merge sort is n'); for(int i = 0; i < n; i++) Console.Write(arr[i] + ' '); } } // This code is contributed by Smitha
<script> // javascript program to generate Worst Case // of Merge Sort // Function to print an array function printArray(Asize) { for(let i = 0; i < size; i++) { document.write(A[i] + ' '); } } // Function to join left and right subarray function join(arrleftrightlmr) { let i; for(i = 0; i <= m - l; i++) arr[i] = left[i]; for(let j = 0; j < r - m; j++) { arr[i + j] = right[j]; } } // Function to store alternate elements in // left and right subarray function split(arrleftrightlmr) { for(let i = 0; i <= m - l; i++) left[i] = arr[i * 2]; for(let i = 0; i < r - m; i++) right[i] = arr[i * 2 + 1]; } // Function to generate Worst Case // of Merge Sort function generateWorstCase(arrlr) { if (l < r) { let m = l + parseInt((r - l) / 2 10); // Create two auxiliary arrays let left = new Array(m - l + 1); let right = new Array(r - m); left.fill(0); right.fill(0); // Store alternate array elements // in left and right subarray split(arr left right l m r); // Recurse first and second halves generateWorstCase(left l m); generateWorstCase(right m + 1 r); // Join left and right subarray join(arr left right l m r); } } let arr = [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ]; let n = arr.length; document.write('Sorted array is' + ''); printArray(arr n); // Generate Worst Case of Merge Sort generateWorstCase(arr 0 n - 1); document.write('' + 'Input array that will result ' + 'in worst case of merge sort is' + ''); printArray(arr n); // This code is contributed by vaibhavrabadiya117. </script>
Izlaz:
Sorted array is
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Input array that will result in worst
case of merge sort is
1 9 5 13 3 11 7 15 2 10 6 14 4 12 8 16
Vremenska složenost: O (n logn)
Pomoćni prostor: O (n)
Reference - Prelijevanje snopa