
Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
3-way Merge Sort in C++
Merge sort is a popular sorting algorithm that follows the divide-and-conquer strategy. It works by recursively dividing the input array into two halves, sorting each half, and then merging them. With a time complexity of O(n log n).
3-Way Merge Sort
An optimized variation of merge sort is the 3-way merge sort, where the array is divided into three equal parts instead of two. This reduces the number of recursive calls and improves performance in certain scenarios.
3-Way Merge Sort algorithm
Following are the steps (algorithm) to implement the 3-way merge sort:
- Divide the array into three equal parts using two midpoints.
- Recursively sort each of the three parts.
- Create a temporary array to hold the merged result.
- Use three pointers to track the current index in each of the three subarrays.
- At each step, select the smallest of the three elements and add it to the temporary array.
- Once all elements are merged, copy the temporary array back into the original array.
- Repeat the process until the entire array is sorted.
Working of 3-Way Merge Sort with Examples
Let's see some example scenarios to understand 3-Way Merge Sort better:
Scenario 1
Input: arr = [6, 3, 9, 5, 2, 8]
Step 1: Divide into three parts:
- [6, 3], [9, 5], [2, 8]
Step 2: Recursively sort each part:
- [6, 3] → [3, 6]
- [9, 5] → [5, 9]
- [2, 8] → [2, 8] (already sorted)
Step 3: Merge [3, 6], [5, 9], and [2, 8]
- Compare 3, 5, and 2 → choose 2
- Compare 3, 5, and 8 → choose 3
- Compare 6, 5, and 8 → choose 5
- Compare 6, 9, and 8 → choose 6
- Compare 9 and 8 → choose 8
- Remaining → 9
Output: [2, 3, 5, 6, 8, 9]
Explanation: The array is sorted in ascending order.
Scenario 2
Input: arr = [24, -18]
Step 1: Divide as:
- [-18], [24], []
Step 2: Subarrays with one element are already sorted.
Step 3: Merge [-18], [24], and []
- Merge directly → [-18, 24]
Output: [-18, 24]
Explanation: The array is sorted with the smallest number first.
Implementation of 3-Way Merge Sort
Here is the implementation of 3-way merge sort using C++ program:
#include <bits/stdc++.h> using namespace std; void merge(int arr[], int left, int mid1, int mid2, int right) { // Sizes of three subarrays int size1 = mid1 - left + 1; int size2 = mid2 - mid1; int size3 = right - mid2; // Temporary arrays for three parts vector < int > leftArr(size1), midArr(size2), rightArr(size3); // Copy data to temporary arrays for (int i = 0; i < size1; i++) { leftArr[i] = arr[left + i]; } for (int i = 0; i < size2; i++) { midArr[i] = arr[mid1 + 1 + i]; } for (int i = 0; i < size3; i++) { rightArr[i] = arr[mid2 + 1 + i]; } // Merge three sorted subarrays int i = 0, j = 0, k = 0, index = left; while (i < size1 || j < size2 || k < size3) { int minValue = INT_MAX, minIdx = -1; // Find the smallest among the three current elements if (i < size1 && leftArr[i] < minValue) { minValue = leftArr[i]; minIdx = 0; } if (j < size2 && midArr[j] < minValue) { minValue = midArr[j]; minIdx = 1; } if (k < size3 && rightArr[k] < minValue) { minValue = rightArr[k]; minIdx = 2; } // Place the smallest element in the merged array if (minIdx == 0) { arr[index++] = leftArr[i++]; } else if (minIdx == 1) { arr[index++] = midArr[j++]; } else { arr[index++] = rightArr[k++]; } } } void three_way_merge_sort(int arr[], int left, int right) { // Base case: If single element, return if (left >= right) { return; } // Finding two midpoints for 3-way split int mid1 = left + (right - left) / 3; int mid2 = left + 2 * (right - left) / 3; // Recursively sort first third three_way_merge_sort(arr, left, mid1); // Recursively sort second third three_way_merge_sort(arr, mid1 + 1, mid2); // Recursively sort last third three_way_merge_sort(arr, mid2 + 1, right); // Merge the sorted parts merge(arr, left, mid1, mid2, right); } int main() { int arr[] = {6, 3, 9, 5, 2, 8}; int n = sizeof(arr) / sizeof(int); three_way_merge_sort(arr, 0, n - 1); for (int i = 0; i < n; i++) { cout << arr[i] << " "; } return 0; }
Following is the output:
2 3 5 6 8 9
Conclusion
In this article, we learned how 3-way merge sort works. Unlike traditional merge sort, it divides the array into three parts and sorts them recursively before merging.