Įvadas į sujungimo rūšiavimo algoritmą

Sujungimo rūšiavimas yra rūšiavimo algoritmas, pagrįstas „skaldyk ir valdyk“ technika. Tai vienas iš efektyviausių rūšiavimo algoritmų.

kaip importuoti šepečius į gimdymą

Šiame straipsnyje sužinosite apie sujungimo rūšiavimo algoritmo veikimą, sujungimo rūšiavimo algoritmą, jo laiko ir erdvės sudėtingumą bei jo įgyvendinimą įvairiomis programavimo kalbomis, tokiomis kaip C ++, Python ir JavaScript.

---

---

Kaip veikia sujungimo rūšiavimo algoritmas?

„Merge sort“ veikia skaldymo ir užkariavimo principu. Sujungimo rūšiavimas pakartotinai skaido masyvą į dvi lygias antrines masyvas, kol kiekviena antrinė masė susideda iš vieno elemento. Galiausiai visi šie paketai yra sujungti taip, kad gautas masyvas būtų surūšiuotas.

Šią sąvoką galima efektyviau paaiškinti naudojant pavyzdį. Apsvarstykite nerūšiuotą masyvą su šiais elementais: {16, 12, 15, 13, 19, 17, 11, 18}.

Čia sujungimo rūšiavimo algoritmas padalija masyvą į dvi dalis, vadina save dviem pusėmis ir tada sujungia dvi surūšiuotas puses.

Sujungimo rūšiavimo algoritmas

Žemiau pateikiamas sujungimo rūšiavimo algoritmas:

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)

Susijęs: Kas yra rekursija ir kaip ją naudoti?

---

---

Sujungimo rūšiavimo algoritmo laiko ir erdvės sudėtingumas

Sujungimo rūšiavimo algoritmas gali būti išreikštas tokiu pasikartojimo ryšiu:

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

---

---

Išsprendę šį pasikartojimo ryšį naudodami pagrindinę teoremą arba pasikartojimo medžio metodą, gausite sprendimą kaip O (n logn). Taigi, sujungimo rūšiavimo algoritmo sudėtingumas laiko atžvilgiu yra toks O (n prisijungimas) .

Geriausiu atveju sujungimo rūšies sudėtingumas: O (n prisijungimas)

Vidutinis sujungimo rūšies laiko sudėtingumas: O (n prisijungimas)

Sunkiausias sujungimo rūšies sudėtingumas: O (n prisijungimas)

Susijęs: Kas yra „Big-O“ žymėjimas?

Pagalbinis erdvės sudėtingumas sujungimo rūšiavimo algoritmas yra O (n) kaip n sujungimo rūšiavimo įgyvendinimui reikalinga pagalbinė erdvė.

Sujungimo rūšiavimo algoritmo įgyvendinimas C ++

Žemiau pateikiamas sujungimo rūšiavimo algoritmo C ++ diegimas:

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

Išėjimas:

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

Sujungimo rūšiavimo algoritmo „JavaScript“ diegimas

Žemiau pateikiamas sujungimo rūšiavimo algoritmo „JavaScript“ diegimas:

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

Išėjimas:

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

Susijęs: Dinaminis programavimas: pavyzdžiai, bendros problemos ir sprendimai

„Python“ sujungimo rūšiavimo algoritmo įgyvendinimas

Žemiau pateikiamas sujungimo rūšiavimo algoritmo „Python“ diegimas:

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


Išėjimas:

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

Suprasti kitus rūšiavimo algoritmus

Rūšiavimas yra vienas iš dažniausiai naudojamų programavimo algoritmų. Galite rūšiuoti elementus įvairiomis programavimo kalbomis naudodami įvairius rūšiavimo algoritmus, tokius kaip greitas rūšiavimas, burbuliukų rūšiavimas, sujungimo rūšiavimas, įterpimo rūšiavimas ir kt.

Rūšiuoti burbulus yra geriausias pasirinkimas, jei norite sužinoti apie paprasčiausią rūšiavimo algoritmą.

Dalintis Dalintis „Tweet“ Paštu Įvadas į burbulų rūšiavimo algoritmą

„Bubble Sort“ algoritmas: puikus įvadas į masyvų rūšiavimą.

Skaityti toliau Susijusios temos

• Programavimas
• „JavaScript“
• Python
• Kodavimo pamokos

Apie autorių Yuvraj Chandra(Paskelbti 60 straipsnių)

Yuvraj yra kompiuterių mokslo bakalauro studentas Delyje, Indijoje. Jis aistringas „Full Stack“ žiniatinklio kūrimui. Kai jis nerašo, jis tyrinėja skirtingų technologijų gylį.

Daugiau iš Yuvraj Chandra

Prenumeruokite mūsų naujienlaiškį

Prisijunkite prie mūsų naujienlaiškio, kad gautumėte techninių patarimų, apžvalgų, nemokamų el. Knygų ir išskirtinių pasiūlymų!

Norėdami užsiprenumeruoti, spustelėkite čia