บทนำสู่อัลกอริทึมการเรียงลำดับการผสาน

Merge sort เป็นอัลกอริธึมการจัดเรียงตามเทคนิค 'แบ่งและพิชิต' เป็นหนึ่งในอัลกอริธึมการเรียงลำดับที่มีประสิทธิภาพมากที่สุด

xbox one ของฉันจะไม่เชื่อมต่ออินเทอร์เน็ต

ในบทความนี้ คุณจะได้เรียนรู้เกี่ยวกับการทำงานของอัลกอริทึมการจัดเรียงการผสาน อัลกอริธึมของการจัดเรียงการผสาน ความซับซ้อนของเวลาและพื้นที่ และการนำไปใช้ในภาษาการเขียนโปรแกรมต่างๆ เช่น C++, Python และ JavaScript

---

---

อัลกอริทึมการเรียงลำดับการผสานทำงานอย่างไร

Merge sort ทำงานบนหลักการของการแบ่งแยกและพิชิต การเรียงลำดับแบบผสานจะแบ่งอาร์เรย์ออกเป็นสองอาร์เรย์ย่อยที่เท่ากันซ้ำๆ จนกระทั่งแต่ละอาร์เรย์ย่อยประกอบด้วยองค์ประกอบเดียว สุดท้าย อาร์เรย์ย่อยทั้งหมดจะถูกรวมเข้าด้วยกันเพื่อจัดเรียงอาร์เรย์ผลลัพธ์

แนวคิดนี้สามารถอธิบายได้อย่างมีประสิทธิภาพมากขึ้นโดยใช้ตัวอย่าง พิจารณาอาร์เรย์ที่ไม่เรียงลำดับด้วยองค์ประกอบต่อไปนี้: {16, 12, 15, 13, 19, 17, 11, 18}

ในที่นี้ อัลกอริธึมการเรียงลำดับการผสานจะแบ่งอาร์เรย์ออกเป็นสองส่วน เรียกตัวเองว่าสองส่วน แล้วรวมทั้งสองส่วนที่จัดเรียงไว้

ผสานอัลกอริทึมการเรียงลำดับ

ด้านล่างนี้คืออัลกอริทึมของการเรียงลำดับการผสาน:

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)

ที่เกี่ยวข้อง: การเรียกซ้ำคืออะไรและคุณใช้งานอย่างไร

---

---

ความซับซ้อนของเวลาและพื้นที่ของอัลกอริทึมการเรียงลำดับการผสาน

อัลกอริทึมการเรียงลำดับแบบผสานสามารถแสดงในรูปแบบของความสัมพันธ์ที่เกิดซ้ำต่อไปนี้:

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

---

---

หลังจากแก้ไขความสัมพันธ์ที่เกิดซ้ำนี้โดยใช้ทฤษฎีบทของอาจารย์หรือวิธีแผนผังการเกิดซ้ำ คุณจะได้คำตอบเป็น O(n logn) ดังนั้น ความซับซ้อนของเวลาของอัลกอริทึมการเรียงลำดับการผสานคือ O (n เข้าสู่ระบบ) .

ความซับซ้อนของเวลากรณีที่ดีที่สุดของการเรียงลำดับการผสาน: O (n เข้าสู่ระบบ)

ความซับซ้อนของเวลากรณีเฉลี่ยของการเรียงลำดับการผสาน: O (n เข้าสู่ระบบ)

ความซับซ้อนของเวลาในกรณีที่เลวร้ายที่สุดของการเรียงลำดับการผสาน: O (n เข้าสู่ระบบ)

ที่เกี่ยวข้อง: สัญกรณ์ Big-O คืออะไร?

ความซับซ้อนของพื้นที่เสริม ของอัลกอริทึมการเรียงลำดับการผสาน is บน) เช่น NS จำเป็นต้องใช้พื้นที่เสริมในการใช้งานการเรียงลำดับแบบผสาน

การใช้ C++ ของ Merge Sort Algorithm

ด้านล่างนี้คือการใช้ C++ ของอัลกอริทึมการเรียงลำดับการผสาน:

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

เอาท์พุท:

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

การใช้งาน JavaScript ของ Merge Sort Algorithm

ด้านล่างนี้คือการใช้งาน JavaScript ของอัลกอริทึมการเรียงลำดับการผสาน:

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

เอาท์พุท:

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

ที่เกี่ยวข้อง: การเขียนโปรแกรมแบบไดนามิก: ตัวอย่าง ปัญหาทั่วไป และวิธีแก้ไข

การใช้งาน Python ของ Merge Sort Algorithm

ด้านล่างนี้คือการนำ Python ไปใช้อัลกอริธึมการเรียงลำดับการผสาน:

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


เอาท์พุท:

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

ทำความเข้าใจอัลกอริทึมการจัดเรียงอื่นๆ

การเรียงลำดับเป็นหนึ่งในอัลกอริธึมที่ใช้มากที่สุดในการเขียนโปรแกรม คุณสามารถจัดเรียงองค์ประกอบในภาษาการเขียนโปรแกรมต่างๆ ได้โดยใช้อัลกอริธึมการจัดเรียงต่างๆ เช่น การเรียงลำดับอย่างรวดเร็ว การเรียงลำดับแบบฟอง การเรียงลำดับการผสาน การเรียงลำดับการแทรก ฯลฯ

Bubble sort เป็นตัวเลือกที่ดีที่สุดหากคุณต้องการเรียนรู้เกี่ยวกับอัลกอริธึมการเรียงลำดับที่ง่ายที่สุด

แบ่งปัน แบ่งปัน ทวีต อีเมล บทนำสู่ Bubble Sort Algorithm

อัลกอริธึม Bubble Sort: ข้อมูลเบื้องต้นเกี่ยวกับการจัดเรียงอาร์เรย์

อ่านต่อไป หัวข้อที่เกี่ยวข้อง

• การเขียนโปรแกรม
• JavaScript
• Python
• บทเรียนการเข้ารหัส

เกี่ยวกับผู้เขียน ยุวราช จันทรา(60 บทความที่ตีพิมพ์)

Yuvraj เป็นนักศึกษาระดับปริญญาตรีสาขาวิทยาการคอมพิวเตอร์ที่มหาวิทยาลัยเดลี ประเทศอินเดีย เขาหลงใหลเกี่ยวกับ Full Stack Web Development เมื่อไม่ได้เขียน เขากำลังสำรวจความลึกของเทคโนโลยีต่างๆ

เพิ่มเติมจาก Yuvraj Chandra

สมัครรับจดหมายข่าวของเรา

เข้าร่วมจดหมายข่าวของเราสำหรับเคล็ดลับทางเทคนิค บทวิจารณ์ eBook ฟรี และดีลพิเศษ!

คลิกที่นี่เพื่อสมัครสมาชิก