Uvod u algoritam sortiranja spoja

Merge sort je algoritam za sortiranje koji se temelji na tehnici 'podijeli pa vladaj'. To je jedan od najučinkovitijih algoritama za sortiranje.

učiti matematiku od osnovnih do naprednih

U ovom ćete članku naučiti o radu algoritma sortiranja spajanjem, algoritmu sortiranja spajanja, njegovoj složenosti u vremenu i prostoru te njegovoj implementaciji u različite programske jezike poput C ++, Python i JavaScript.

---

---

Kako funkcionira algoritam za sortiranje spajanja?

Spajanje sortiranjem radi na principu zavadi pa vladaj. Razvrstavanje pri spajanju opetovano razbija niz u dva jednaka niza sve dok se svaki podniz ne sastoji od jednog elementa. Konačno, svi ti podpolovi se spajaju tako da se rezultirajući niz sortira.

Ovaj se koncept može učinkovitije objasniti uz pomoć primjera. Razmotrimo nerazvrstani niz sa sljedećim elementima: {16, 12, 15, 13, 19, 17, 11, 18}.

Ovdje algoritam sortiranja spajanjem dijeli niz na dvije polovice, poziva se za dvije polovice, a zatim spaja dvije razvrstane polovice.

Algoritam spajanja sortiranja

Dolje je algoritam sortiranja spajanja:

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)

Povezano: Što je rekurzija i kako je koristite?

---

---

Vremenska i prostorna složenost algoritma sortiranja spajanja

Algoritam sortiranja spoji može se izraziti u obliku sljedeće relacije ponavljanja:

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

---

---

Nakon rješavanja ove relacije ponavljanja pomoću master teorema ili metode stabla ponavljanja, rješenje ćete dobiti kao O (n logn). Dakle, vremenska složenost algoritma sortiranja spajanjem iznosi O (n prijava) .

Najbolja vremenska složenost vrste spajanja: O (n prijava)

Prosječna složenost vremena spajanja vrste spajanja: O (n prijava)

Najgora vremenska složenost vrste spajanja: O (n prijava)

Povezano: Što je oznaka Big-O?

Složenost pomoćnog prostora algoritma sortiranja spajanjem je Na) kao n pomoćni prostor potreban je u implementaciji sortiranja stapanjem.

C ++ Implementacija algoritma za sortiranje spajanja

Ispod je C ++ implementacija algoritma sortiranja spajanjem:

// 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;
}

Izlaz:

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

JavaScript implementacija algoritma sortiranja spajanja

U nastavku je JavaScript implementacija algoritma sortiranja spajanjem:

// 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);

Izlaz:

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

Povezano: Dinamičko programiranje: primjeri, uobičajeni problemi i rješenja

Python implementacija algoritma za sortiranje spajanja

Ispod je Python implementacija algoritma sortiranja spajanjem:

# 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)


Izlaz:

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

Razumijevanje drugih algoritama za sortiranje

Sortiranje je jedan od najčešće korištenih algoritama u programiranju. Elemente možete sortirati u različitim programskim jezicima pomoću različitih algoritama za sortiranje, poput brzog sortiranja, sortiranja po mjehurićima, spajanja spoja, sortiranja umetanja itd.

Sortiranje mjehurićima najbolji je izbor ako želite naučiti o najjednostavnijem algoritmu sortiranja.

Udio Udio Cvrkut E -pošta Uvod u algoritam sortiranja mjehurića

Algoritam sortiranja mjehurića: izvrstan uvod u sortiranje nizova.

Pročitajte Dalje Povezane teme

• Programiranje
• JavaScript
• Piton
• Vodiči za kodiranje

O autoru Yuvraj Chandra(Objavljeno 60 članaka)

Yuvraj je student preddiplomskog studija Računarstva na Sveučilištu u Delhiju u Indiji. Oduševljen je Full Stack web razvojem. Kad ne piše, istražuje dubinu različitih tehnologija.

Više od Yuvraja Chandre

Pretplatite se na naše obavijesti

Pridružite se našem biltenu za tehničke savjete, recenzije, besplatne e -knjige i ekskluzivne ponude!

Kliknite ovdje za pretplatu