Isang Panimula sa Algorithm ng Pagsasama-sama ng Pagsasama-sama

Ang merge sort ay isang pag-uuri ng algorithm batay sa diskarteng 'hatiin at lupigin'. Isa ito sa pinaka mahusay na pag-uuri ng mga algorithm.

hindi kasama ang serbisyo ng windows 10 blue screen system

Sa artikulong ito, malalaman mo ang tungkol sa pagtatrabaho ng merge sort algorithm, ang algorithm ng pagsasama-sama, ang oras at pagkakumplikado ng espasyo, at ang pagpapatupad nito sa iba't ibang mga wika sa pagprograma tulad ng C ++, Python, at JavaScript.

---

---

Paano Gumagana ang Pagsasama-sama ng Pagsasaayos ng Algorithm?

Ang pagsasama-sama ay gumagana sa prinsipyo ng paghati at pagsakop. Ang pag-uuri ng pag-uuri ay paulit-ulit na pinuputol ang isang array sa dalawang pantay na mga subarray hanggang sa ang bawat subarray ay binubuo ng isang solong elemento. Sa wakas, ang lahat ng mga subarray na iyon ay pinagsama tulad ng ang resulta ng array ay pinagsunod-sunod.

Ang konseptong ito ay maaaring ipaliwanag nang mas mahusay sa tulong ng isang halimbawa. Isaalang-alang ang isang hindi nasusunog na array na may mga sumusunod na elemento: {16, 12, 15, 13, 19, 17, 11, 18}.

Dito, hinahati ng merge sort algorithm ang array sa dalawang halves, tinawag ang sarili para sa dalawang halves, at pagkatapos ay pinagsasama ang dalawang pinagsunod-sunod na halves.

Pagsamahin ang Pagsunud-sunurin sa Algorithm

Nasa ibaba ang algorithm ng uri ng pagsasama:

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)

Kaugnay: Ano ang Recursion at Paano Mo Ito Ginagamit?

---

---

Pagiging kumplikado ng Oras at Puwang ng Algorithm ng Pagsasama-sama ng Pagsasama-sama

Ang merge sort algorithm ay maaaring ipahayag sa anyo ng sumusunod na kaugnay ng pag-ulit:

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

---

---

Matapos malutas ang kaugnay na pag-ulit na ito gamit ang teorama ng master o pamamaraan ng pag-ulit ng puno, makakakuha ka ng solusyon bilang O (n logn). Kaya, ang pagiging kumplikado ng oras ng pagsasama-sama ng algorithm ay O (n logn) .

Ang pagiging kumplikado ng oras na pinakamahusay na kaso ng pagsasama-sama: O (n logn)

Ang pagiging kumplikado ng average-case na oras ng pagsasama-sama ng uri: O (n logn)

Ang pinakapangit na pagkakumplikado ng oras ng pagsasama-sama: O (n logn)

Kaugnay: Ano ang Big-O Notation?

Ang pagiging kumplikado ng auxiliary space ng merge sort algorithm ay O (n) bilang n kinakailangang puwang ng pandiwang pantulong sa pagpapatupad ng uri ng pagsasama.

C ++ Pagpapatupad ng Algorithm ng Pagsunud-sunurin

Nasa ibaba ang pagpapatupad ng C ++ ng merge sort algorithm:

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

Output:

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

Pagpapatupad ng JavaScript ng Algorithm ng Pagsasama-sama ng Pagsasama-sama

Nasa ibaba ang pagpapatupad ng JavaScript ng merge sort algorithm:

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

Output:

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

Kaugnay: Dynamic na Programming: Mga Halimbawa, Karaniwang Mga problema, at Solusyon

Pagpapatupad ng Python ng Algorithm ng Pagsunud-sunurin

Nasa ibaba ang pagpapatupad ng Python ng merge sort algorithm:

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


Output:

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

Maunawaan ang Iba Pang Mga Pagsasaayos ng Algorithm

Ang pag-uuri ay isa sa mga pinaka ginagamit na algorithm sa pagprograma. Maaari mong pag-uri-uriin ang mga elemento sa iba't ibang mga wika sa pag-program gamit ang iba't ibang mga pag-uuri ng mga algorithm tulad ng mabilis na pag-uuri, pag-uuri ng bubble, pagsasama-sama ng pagsasama, pag-uuri ng pagpasok, atbp.

Ang pag-uuri ng bubble ay ang pinakamahusay na pagpipilian kung nais mong malaman ang tungkol sa pinakasimpleng pag-uuri ng algorithm.

Magbahagi Magbahagi Mag-tweet Email Isang Panimula sa Algorithm ng Bubble Sort

Ang algorithm ng Bubble Sort: isang mahusay na pagpapakilala sa pag-uuri ng mga arrays.

Basahin Susunod Mga Kaugnay na Paksa

• Programming
• JavaScript
• Sawa
• Mga Tutorial sa Coding

Tungkol sa May-akda Yuvraj Chandra(60 Mga Artikulo Na-publish)

Si Yuvraj ay isang undergraduate na mag-aaral sa Computer Science sa University of Delhi, India. Masigasig siya sa Full Stack Web Development. Kapag hindi siya nagsusulat, sinisiyasat niya ang lalim ng iba't ibang mga teknolohiya.

Higit pa Mula kay Yuvraj Chandra

Mag-subscribe sa aming newsletter

Sumali sa aming newsletter para sa mga tip sa tech, pagsusuri, libreng ebook, at eksklusibong deal!

Mag-click dito upang mag-subscribe