Pengenalan Algoritma Gabungan

Merge sort adalah algoritma penyortiran berdasarkan teknik 'divide and winer'. Ini adalah salah satu algoritma penyusun yang paling berkesan.

bagaimana menukar tempat sandaran iTunes

Dalam artikel ini, anda akan belajar mengenai cara kerja algoritma penggabungan, algoritma jenis penggabungan, kerumitan masa dan ruangnya, dan pelaksanaannya dalam pelbagai bahasa pengaturcaraan seperti C ++, Python, dan JavaScript.

---

---

Bagaimana Algoritma Penggabungan Berfungsi?

Penggabungan jenis berfungsi berdasarkan prinsip membahagi dan menakluki. Penggabungan penggabungan berulang kali memecah susunan menjadi dua subarray yang sama sehingga setiap subarray terdiri daripada satu elemen. Akhirnya, semua subarrays digabungkan sehingga susunan yang dihasilkan disusun.

Konsep ini dapat dijelaskan dengan lebih berkesan dengan bantuan contoh. Pertimbangkan susunan yang tidak disusun dengan elemen berikut: {16, 12, 15, 13, 19, 17, 11, 18}.

Di sini, algoritma penggabungan membahagikan susunan menjadi dua bahagian, memanggil dirinya untuk dua bahagian, dan kemudian menggabungkan dua bahagian yang disusun.

Gabungkan Algoritma Susun

Berikut adalah algoritma jenis gabungan:

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)

Berkaitan: Apakah Pengulangan dan Bagaimana Anda Menggunakannya?

---

---

Kerumitan Masa dan Ruang Algoritma Gabungan

Algoritma penggabungan boleh dinyatakan dalam bentuk hubungan berulang berikut:

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

---

---

Setelah menyelesaikan hubungan perulangan ini menggunakan teorema master atau kaedah pokok kambuhan, anda akan mendapat penyelesaiannya sebagai O (n logn). Oleh itu, kerumitan masa algoritma penggabungan adalah O (n logn) .

Kerumitan masa kes terbaik seperti penggabungan: O (n logn)

Kerumitan masa kes-kes gabungan seperti: O (n logn)

Kerumitan masa terburuk jenis penggabungan: O (n logn)

Berkaitan: Apa itu Notasi Big-O?

Kerumitan ruang bantu algoritma penggabungan jenis adalah O (n) sebagai n ruang tambahan diperlukan dalam pelaksanaan penggabungan jenis.

C ++ Pelaksanaan Algoritma Gabungan

Berikut adalah pelaksanaan C ++ algoritma penggabungan jenis:

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

Pengeluaran:

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

Pelaksanaan JavaScript Algoritma Gabungan

Berikut adalah pelaksanaan JavaScript algoritma penggabungan jenis:

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

Pengeluaran:

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

Berkaitan: Pengaturcaraan Dinamik: Contoh, Masalah Umum, dan Penyelesaian

Python Implementation of Merge Sort Algorithm

Berikut adalah pelaksanaan Python algoritma penggabungan jenis:

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


Pengeluaran:

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

Fahami Algoritma Pengisihan Lain

Menyusun adalah salah satu algoritma yang paling banyak digunakan dalam pengaturcaraan. Anda boleh menyusun elemen dalam bahasa pengaturcaraan yang berbeza menggunakan pelbagai algoritma penyortiran seperti penyortiran cepat, penyusun gelembung, penyatuan gabungan, penyisipan jenis, dll.

Pengisihan gelembung adalah pilihan terbaik jika anda ingin mengetahui algoritma penyusun termudah.

Berkongsi Berkongsi Tweet E-mel Pengenalan Algoritma Bubble Sort

Algoritma Bubble Sort: pengenalan yang sangat baik untuk menyusun tatasusunan.

Baca Seterusnya Topik-topik yang berkaitan

• Pengaturcaraan
• JavaScript
• Python
• Tutorial Pengekodan

Mengenai Pengarang Yuvraj Chandra(60 Artikel Diterbitkan)

Yuvraj adalah pelajar sarjana Sains Komputer di University of Delhi, India. Dia meminati Pembangunan Web Stack Penuh. Ketika dia tidak menulis, dia meneroka kedalaman teknologi yang berbeza.

Lagi Dari Yuvraj Chandra

Langgan buletin kami

Sertailah buletin kami untuk mendapatkan petua, ulasan, ebook percuma, dan tawaran eksklusif!

Klik di sini untuk melanggan