Pengantar Algoritma Pengurutan Gabung

Merge sort adalah algoritma pengurutan berdasarkan teknik 'membagi dan menaklukkan'. Ini adalah salah satu algoritma pengurutan yang paling efisien.

apakah game ps4 bisa dimainkan di ps5

Dalam artikel ini, Anda akan belajar tentang cara kerja algoritma merge sort, algoritma merge sort, kompleksitas ruang dan waktu, dan implementasinya dalam berbagai bahasa pemrograman seperti C++, Python, dan JavaScript.

Bagaimana Cara Kerja Algoritma Merge Sort?

Merge sort bekerja berdasarkan prinsip membagi dan menaklukkan. Merge sort berulang kali memecah array menjadi dua subarray yang sama hingga setiap subarray terdiri dari satu elemen. Akhirnya, semua subarray tersebut digabungkan sedemikian rupa sehingga array yang dihasilkan diurutkan.

Konsep ini dapat dijelaskan lebih efisien dengan bantuan sebuah contoh. Pertimbangkan array yang tidak disortir dengan elemen berikut: {16, 12, 15, 13, 19, 17, 11, 18}.

Di sini, algoritma merge sort membagi array menjadi dua bagian, memanggil dirinya sendiri untuk dua bagian, dan kemudian menggabungkan dua bagian yang diurutkan.

Gabungkan Algoritma Sortir

Di bawah ini adalah algoritma dari merge sort:

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)

Terkait: Apa itu Rekursi dan Bagaimana Anda Menggunakannya?

Kompleksitas Waktu dan Ruang dari Algoritma Pengurutan Gabung

Algoritma Merge sort dapat dinyatakan dalam bentuk relasi perulangan berikut:

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

Setelah menyelesaikan relasi perulangan ini menggunakan teorema master atau metode pohon perulangan, Anda akan mendapatkan solusinya sebagai O(n logn). Jadi, kompleksitas waktu dari algoritma merge sort adalah O (n log masuk) .

Kompleksitas waktu kasus terbaik dari jenis gabungan: O (n log masuk)

Kompleksitas waktu kasus rata-rata dari jenis gabungan: O (n log masuk)

Kompleksitas waktu kasus terburuk dari jenis gabungan: O (n log masuk)

Terkait: Apa itu Notasi Big-O?

Kompleksitas ruang tambahan dari algoritma merge sort adalah Pada) sebagai n ruang tambahan diperlukan dalam implementasi merge sort.

Implementasi C++ dari Algoritma Merge Sort

Di bawah ini adalah implementasi C++ dari algoritma merge sort:

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

Keluaran:

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

Implementasi JavaScript dari Algoritma Merge Sort

Di bawah ini adalah implementasi JavaScript dari algoritma merge sort:

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

Keluaran:

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

Terkait: Pemrograman Dinamis: Contoh, Masalah Umum, dan Solusi

Implementasi Python dari Algoritma Merge Sort

Di bawah ini adalah implementasi Python dari algoritma merge sort:

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

Keluaran:

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

Memahami Algoritma Penyortiran Lainnya

Sorting adalah salah satu algoritma yang paling banyak digunakan dalam pemrograman. Anda dapat mengurutkan elemen dalam bahasa pemrograman yang berbeda menggunakan berbagai algoritme pengurutan seperti pengurutan cepat, pengurutan gelembung, pengurutan gabungan, pengurutan penyisipan, dll.

Bubble sort adalah pilihan terbaik jika Anda ingin belajar tentang algoritma pengurutan yang paling sederhana.

Membagikan Membagikan Menciak Surel Pengantar Algoritma Bubble Sort

Algoritma Bubble Sort: pengenalan yang sangat baik untuk mengurutkan array.

Baca Selanjutnya Topik-topik yang berkaitan

Pemrograman
JavaScript
Python
Tutorial Pengkodean

Tentang Penulis Yuvraj Chandra(60 Artikel Diterbitkan)

Yuvraj adalah mahasiswa sarjana Ilmu Komputer di University of Delhi, India. Dia bersemangat tentang Pengembangan Web Full Stack. Ketika dia tidak menulis, dia menjelajahi kedalaman teknologi yang berbeda.

Berlangganan newsletter kami

Bergabunglah dengan buletin kami untuk kiat teknologi, ulasan, ebook gratis, dan penawaran eksklusif!

Klik di sini untuk berlangganan