Home-theater-designers
La combinació d'ordenació és un algorisme d'ordenació basat en la tècnica de 'dividir i conquerir'. És un dels algorismes d’ordenació més eficients.
com saber si està bloquejat a Snapchat
En aquest article, aprendreu sobre el funcionament de l'algorisme de classificació de combinació, l'algorisme de la classificació de combinació, la seva complexitat temporal i espacial i la seva implementació en diversos llenguatges de programació com C ++, Python i JavaScript.
Com funciona l'algorisme de classificació de combinació?
La classificació Merge funciona segons el principi de dividir i conquerir. La combinació d'ordenacions descompon repetidament una matriu en dos subarrays iguals fins que cada subarraia consta d'un sol element. Finalment, tots aquests subarrays es combinen de manera que s’ordena la matriu resultant.
Aquest concepte es pot explicar de manera més eficient amb l'ajut d'un exemple. Penseu en una matriu sense classificar amb els elements següents: {16, 12, 15, 13, 19, 17, 11, 18}.
Aquí, l'algorisme d'ordenació de combinació divideix la matriu en dues meitats, es fa dir per les dues meitats i, a continuació, combina les dues meitats ordenades.
Fusiona l'algorisme d'ordenació
A continuació es mostra l'algorisme del tipus de combinació:
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)Relacionat: Què és la recursivitat i com s’utilitza?
Complexitat temporal i espacial de l'algorisme de classificació Merge
L'algorisme de classificació Merge es pot expressar en la forma de la relació de recurrència següent:
T (n) = 2T (n / 2) + O (n)
Després de resoldre aquesta relació de recurrència mitjançant el mètode del teorema del mestre o arbre de recurrència, obtindreu la solució com O (n logn). Per tant, la complexitat temporal de l'algorisme d'ordenació de combinació és O (n registre) .
La complexitat temporal en el millor dels casos del tipus de combinació: O (n registre)
La complexitat del temps mitjà de majúscules i minúscules de l'ordenació de combinació: O (n registre)
La complexitat temporal en el pitjor dels casos del tipus de combinació: O (n registre)
Relacionat: Què és la notació Big-O?
La complexitat de l’espai auxiliar de l'algorisme d'ordenació de combinació és O (n) com n es requereix espai auxiliar a la implementació de la classificació per combinació.
Implementació de C ++ de l'algorisme de classificació Merge
A continuació es mostra la implementació de C ++ de l’algorisme d’ordenació de combinació:
// 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;
} Sortida:
Unsorted array:
16 12 15 13 19 17 11 18
Sorted array:
11 12 13 15 16 17 18 19Implementació de JavaScript de l'algorisme d'ordenació de combinació
A continuació es mostra la implementació de JavaScript de l’algorisme d’ordenació de combinació:
// 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); Sortida:
Unsorted array:
16 12 15 13 19 17 11 18
Sorted array:
11 12 13 15 16 17 18 19Relacionat: Programació dinàmica: exemples, problemes comuns i solucions
Implementació de Python de l'algorisme de classificació Merge
A continuació es mostra la implementació de Python de l'algorisme d'ordenació de combinació:
# 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)
Sortida:
Unsorted array:
16 12 15 13 19 17 11 18
Sorted array:
11 12 13 15 16 17 18 19Comprendre altres algorismes d'ordenació
L’ordenació és un dels algorismes més utilitzats en programació. Podeu ordenar els elements en diferents llenguatges de programació mitjançant diversos algoritmes d’ordenació, com ara l’ordenació ràpida, l’ordenació de bombolles, l’ordenació de combinació, la inserció, etc.
La classificació per bombolles és la millor opció si voleu conèixer l’algoritme d’ordenació més senzill.
Compartir Compartir Tweet Correu electrònic Una introducció a l'algorisme de classificació de bombollesL’algorisme Bubble Sort: una excel·lent introducció a l’ordenació de matrius.
Llegiu a continuació Temes relacionats- Programació
- JavaScript
- Python
- Tutorials de codificació
Yuvraj és estudiant universitari en ciències de la computació a la Universitat de Delhi, Índia. És un apassionat del desenvolupament web Full Stack. Quan no escriu, explora la profunditat de les diferents tecnologies.
Més de Yuvraj ChandraSubscriu-te al nostre butlletí
Uniu-vos al nostre butlletí per obtenir consells tècnics, ressenyes, llibres electrònics gratuïts i ofertes exclusives.
Feu clic aquí per subscriure-us