En introduksjon til sammenslåingssorteringsalgoritmen

Merge sort er en sorteringsalgoritme basert på 'dele og erobre' teknikken. Det er en av de mest effektive sorteringsalgoritmene.

grunner til at sosiale medier er dårlige

I denne artikkelen lærer du om hvordan sammenslåingssorteringsalgoritmen fungerer, algoritmen for sammenslåingssorteringen, tid og romkompleksitet og implementering på forskjellige programmeringsspråk som C ++, Python og JavaScript.

---

---

Hvordan fungerer flette -sorteringsalgoritmen?

Merge sort fungerer etter prinsippet om å dele og erobre. Merge sort bryter flere ganger ned en matrise i to like underarrayer til hvert delarray består av et enkelt element. Til slutt blir alle disse delarrangementene slått sammen slik at den resulterende matrisen blir sortert.

Dette konseptet kan forklares mer effektivt ved hjelp av et eksempel. Vurder en usortert matrise med følgende elementer: {16, 12, 15, 13, 19, 17, 11, 18}.

Her deler sammenslåingssorteringsalgoritmen matrisen i to halvdeler, kaller seg for de to halvdelene og slår deretter sammen de to sorterte halvdelene.

Slå sammen sorteringsalgoritme

Nedenfor er algoritmen for sammenslåingssorteringen:

MergeSort(arr[], leftIndex, rightIndex)
if leftIndex >= rightIndex
return
else
Find the middle index that divides the array into two halves:
middleIndex = leftIndex + (rightIndex-leftIndex)/2
Call mergeSort() for the first half:
Call mergeSort(arr, leftIndex, middleIndex)
Call mergeSort() for the second half:
Call mergeSort(arr, middleIndex+1, rightIndex)
Merge the two halves sorted in step 2 and 3:
Call merge(arr, leftIndex, middleIndex, rightIndex)

Relatert: Hva er rekursjon og hvordan bruker du det?

---

---

Tid og rom Kompleksitet av sammenslåingssorteringsalgoritmen

Merge -sorteringsalgoritmen kan uttrykkes i form av følgende gjentakelsesrelasjon:

T (n) = 2T (n / 2) + O (n)

---

---

Etter å ha løst denne gjentakelsesrelasjonen ved hjelp av masterens teorem eller metoden for gjentakelsestre, får du løsningen som O (n logn). Dermed er tidskompleksiteten til sammenslåingssorteringsalgoritmen O(n logn) .

Tidskompleksiteten i sammenslåingstypen i beste tilfelle: O(n logn)

Kompleksiteten for sammenslåingstiden i gjennomsnittlig sak: O(n logn)

Tidskompleksiteten i sammenslåingstiden i verste fall: O(n logn)

I slekt: Hva er Big-O Notation?

Den ekstra romkompleksiteten av sammenslåingssorteringsalgoritmen er På) som n ekstra plass er nødvendig i sammenslåingssorteringsimplementeringen.

C ++ Implementering av sammenslåingssorteringsalgoritmen

Nedenfor er C ++ - implementeringen av sammenslåingssorteringsalgoritmen:

// C++ implementation of the
// merge sort algorithm
#include
using namespace std;
// This function merges two subarrays of arr[]
// Left subarray: arr[leftIndex..middleIndex]
// Right subarray: arr[middleIndex+1..rightIndex]
void merge(int arr[], int leftIndex, int middleIndex, int rightIndex)
{
int leftSubarraySize = middleIndex - leftIndex + 1;
int rightSubarraySize = rightIndex - middleIndex;
// Create temporary arrays
int L[leftSubarraySize], R[rightSubarraySize];
// Copying data to temporary arrays L[] and R[]
for (int i = 0; i L[i] = arr[leftIndex + i];
for (int j = 0; j R[j] = arr[middleIndex + 1 + j];
// Merge the temporary arrays back into arr[leftIndex..rightIndex]
// Initial index of Left subarray
int i = 0;
// Initial index of Right subarray
int j = 0;
// Initial index of merged subarray
int k = leftIndex;
while (i {
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
// If there're some remaining elements in L[]
// Copy to arr[]
while (i {
arr[k] = L[i];
i++;
k++;
}
// If there're some remaining elements in R[]
// Copy to arr[]
while (j {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int leftIndex, int rightIndex)
{
if(leftIndex >= rightIndex)
{
return;
}
int middleIndex = leftIndex + (rightIndex - leftIndex)/2;
mergeSort(arr, leftIndex, middleIndex);
mergeSort(arr, middleIndex+1, rightIndex);
merge(arr, leftIndex, middleIndex, rightIndex);
}

// Function to print the elements
// of the array
void printArray(int arr[], int size)
{
for (int i = 0; i {
cout << arr[i] << ' ';
}
cout << endl;
}
// Driver code
int main()
{
int arr[] = { 16, 12, 15, 13, 19, 17, 11, 18 };
int size = sizeof(arr) / sizeof(arr[0]);
cout << 'Unsorted array:' << endl;
printArray(arr, size);
mergeSort(arr, 0, size - 1);
cout << 'Sorted array:' << endl;
printArray(arr, size);
return 0;
}

Produksjon:

Unsorted array:
16 12 15 13 19 17 11 18
Sorted array:
11 12 13 15 16 17 18 19

JavaScript Implementering av Merge Sort Algorithm

Nedenfor er JavaScript -implementeringen av sammenslåingssorteringsalgoritmen:

// JavaScript implementation of the
// merge sort algorithm
// This function merges two subarrays of arr[]
// Left subarray: arr[leftIndex..middleIndex]
// Right subarray: arr[middleIndex+1..rightIndex]
function merge(arr, leftIndex, middleIndex, rightIndex) {
let leftSubarraySize = middleIndex - leftIndex + 1;
let rightSubarraySize = rightIndex - middleIndex;
// Create temporary arrays
var L = new Array(leftSubarraySize);
var R = new Array(rightSubarraySize);
// Copying data to temporary arrays L[] and R[]
for(let i = 0; i L[i] = arr[leftIndex + i];
}
for (let j = 0; j R[j] = arr[middleIndex + 1 + j];
}
// Merge the temporary arrays back into arr[leftIndex..rightIndex]
// Initial index of Left subarray
var i = 0;
// Initial index of Right subarray
var j = 0;
// Initial index of merged subarray
var k = leftIndex;
while (i {
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
// If there're some remaining elements in L[]
// Copy to arr[]
while (i {
arr[k] = L[i];
i++;
k++;
}
// If there're some remaining elements in R[]
// Copy to arr[]
while (j {
arr[k] = R[j];
j++;
k++;
}
}
function mergeSort(arr, leftIndex, rightIndex) {
if(leftIndex >= rightIndex) {
return
}
var middleIndex = leftIndex + parseInt((rightIndex - leftIndex)/2);
mergeSort(arr, leftIndex, middleIndex);
mergeSort(arr, middleIndex+1, rightIndex);
merge(arr, leftIndex, middleIndex, rightIndex);
}
// Function to print the elements
// of the array
function printArray(arr, size) {
for(let i = 0; i document.write(arr[i] + ' ');
}
document.write('
');
}
// Driver code:
var arr = [ 16, 12, 15, 13, 19, 17, 11, 18 ];
var size = arr.length;
document.write('Unsorted array:
');
printArray(arr, size);
mergeSort(arr, 0, size - 1);
document.write('Sorted array:
');
printArray(arr, size);

Produksjon:

Unsorted array:
16 12 15 13 19 17 11 18
Sorted array:
11 12 13 15 16 17 18 19

Relatert: Dynamisk programmering: eksempler, vanlige problemer og løsninger

Python -implementering av sammenslåingssorteringsalgoritmen

Nedenfor er Python -implementeringen av sammenslåingssorteringsalgoritmen:

# Python implementation of the
# merge sort algorithm
def mergeSort(arr):
if len(arr) > 1:
# Finding the middle index of the array
middleIndex = len(arr)//2
# Left half of the array
L = arr[:middleIndex]
# Right half of the array
R = arr[middleIndex:]
# Sorting the first half of the array
mergeSort(L)
# Sorting the second half of the array
mergeSort(R)
# Initial index of Left subarray
i = 0
# Initial index of Right subarray
j = 0
# Initial index of merged subarray
k = 0
# Copy data to temp arrays L[] and R[]
while i if L[i] arr[k] = L[i]
i = i + 1
else:
arr[k] = R[j]
j = j + 1
k = k + 1
# Checking if there're some remaining elements
while i arr[k] = L[i]
i = i + 1
k = k + 1
while j arr[k] = R[j]
j = j + 1
k = k + 1
# Function to print the elements
# of the array
def printArray(arr, size):
for i in range(size):
print(arr[i], end=' ')
print()

# Driver code
arr = [ 16, 12, 15, 13, 19, 17, 11, 18 ]
size = len(arr)
print('Unsorted array:')
printArray(arr, size)
mergeSort(arr)
print('Sorted array:')
printArray(arr, size)


Produksjon:

Unsorted array:
16 12 15 13 19 17 11 18
Sorted array:
11 12 13 15 16 17 18 19

Forstå andre sorteringsalgoritmer

Sortering er en av de mest brukte algoritmene innen programmering. Du kan sortere elementer på forskjellige programmeringsspråk ved å bruke forskjellige sorteringsalgoritmer som hurtig sortering, boblesortering, sammenslåingssortering, innsettingssortering, etc.

Boblesortering er det beste valget hvis du vil lære om den enkleste sorteringsalgoritmen.

Dele Dele kvitring E -post En introduksjon til boblesorteringsalgoritmen

Boblesorteringsalgoritmen: en utmerket introduksjon til sorteringsoppstillinger.

Les neste Relaterte temaer

• Programmering
• JavaScript
• Python
• Opplæringsprogrammer for koding

Om forfatteren Yuvraj Chandra(60 artikler publisert)

Yuvraj er en informatikkstudent ved University of Delhi, India. Han brenner for Full Stack webutvikling. Når han ikke skriver, utforsker han dybden i forskjellige teknologier.

Mer fra Yuvraj Chandra

Abonner på vårt nyhetsbrev

Bli med i vårt nyhetsbrev for tekniske tips, anmeldelser, gratis ebøker og eksklusive tilbud!

Klikk her for å abonnere