Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
19 views

Detailed Merge Sort Algorithm

Merge sort is a divide and conquer algorithm that recursively divides an array into halves and then merges the sorted halves. It has a time complexity of O(n log n) and requires O(n) auxiliary space but provides a stable sort. Heap sort uses a binary heap to sort in place with O(1) auxiliary space but is not stable and less suitable for linked lists.

Uploaded by

Resonous Com
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
19 views

Detailed Merge Sort Algorithm

Merge sort is a divide and conquer algorithm that recursively divides an array into halves and then merges the sorted halves. It has a time complexity of O(n log n) and requires O(n) auxiliary space but provides a stable sort. Heap sort uses a binary heap to sort in place with O(1) auxiliary space but is not stable and less suitable for linked lists.

Uploaded by

Resonous Com
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

Merge Sort: Detailed Explanation

Overview

Merge Sort is a classic divide-and-conquer algorithm used for sorting an array or list. It
recursively divides the input array into two halves until each sub-array has only one element, and
then merges these sub-arrays back together in a sorted manner.

Key Concepts

1 Divide-and-Conquer:

◦ Divide: Split the array into two halves.


◦ Conquer: Recursively sort each half.
◦ Combine: Merge the two sorted halves to produce the final sorted array.
2 Stable Sorting:

◦ Merge Sort preserves the relative order of equal elements, making it a stable sort.
3 Time Complexity:

◦ Merge Sort has a consistent time complexity of O ( n log ⁡ n ) O(nlogn) for all
cases (best, average, and worst).
4 Space Complexity:

◦ It requires additional space proportional to the size of the input array, with O ( n )
O(n) auxiliary space.
Steps in Merge Sort

1 Divide:

◦ If the array has more than one element, split it into two sub-arrays: the left half and the
right half.
◦ This division is continued recursively until each sub-array contains a single element.
2 Conquer:

◦ Recursively sort the left and right halves. Since an array with one element is already
sorted, this step naturally completes once the division step reaches individual
elements.
3 Combine:

◦ Merge the sorted sub-arrays.


◦ The merging process involves comparing the smallest elements of the two sub-arrays
and repeatedly adding the smaller element to the result array.
Detailed Merging Process

• Initialization:
◦ Use two pointers to track positions in the left and right sub-arrays.
• Comparison:

◦ Compare the elements pointed to by these pointers.


◦ Append the smaller element to the result array.
◦ Move the pointer forward in the sub-array from which the element was taken.
• Completion:

◦ When one sub-array is exhausted, append the remaining elements of the other sub-
array to the result array.
Example of Merge Sort

Given an array: [38, 27, 43, 3, 9, 82, 10]

1 Divide:

◦ Split into [38, 27, 43, 3] and [9, 82, 10]


◦ Further split to [38, 27], [43, 3], [9, 82], [10]
◦ Finally split to [38], [27], [43], [3], [9], [82], [10]
2 Conquer:

◦ Single elements are trivially sorted.


3 Combine:

◦ Merge [38] and [27] to get [27, 38]


◦ Merge [43] and [3] to get [3, 43]
◦ Merge [27, 38] and [3, 43] to get [3, 27, 38, 43]
◦ Similarly, merge [9], [82], and [10] to get [9, 10, 82]
◦ Finally, merge [3, 27, 38, 43] and [9, 10, 82] to get [3, 9, 10,
27, 38, 43, 82]
Differentiation: Merge Sort vs. Heap Sort

1. Algorithm Type

• Merge Sort: Divide-and-conquer algorithm.


• Heap Sort: Comparison-based algorithm using a binary heap.
2. Stability

• Merge Sort: Stable sort; maintains relative order of equal elements.


• Heap Sort: Not stable; equal elements may not retain their original order.
3. Time Complexity

• Merge Sort: Consistent O ( n log ⁡ n ) O(nlogn) for best, average, and worst cases.
• Heap Sort: O ( n log ⁡ n ) O(nlogn) for best and average cases, and worst case O ( n
log ⁡ n ) O(nlogn).
4. Space Complexity

• Merge Sort: Requires additional O ( n ) O(n) space for merging.


• Heap Sort: In-place sorting with O ( 1 ) O(1) auxiliary space.
5. Recursion

• Merge Sort: Uses recursion to divide the array.


• Heap Sort: Iterative approach, primarily focusing on heap operations.
6. Performance on Linked Lists

• Merge Sort: Well-suited for linked lists as merging can be done in-place with O ( 1 )
O(1) space.
• Heap Sort: Not suitable for linked lists; operations are efficient on arrays.
7. Use Cases

• Merge Sort: Preferred when stable sort is required or for sorting linked lists.
• Heap Sort: Used when in-place sorting is necessary and additional space is a constraint.
8. Merging vs. Heapifying

• Merge Sort: Merging is the primary operation, combining sorted subarrays.


• Heap Sort: Heapifying is the primary operation, maintaining the heap structure.
Summary

• Merge Sort is efficient for stable sorting, especially with linked lists or when predictable
performance is required.
• Heap Sort is useful for memory-constrained environments requiring in-place sorting but may
not be stable.
Both sorting algorithms have their strengths and are suited for different scenarios, providing
flexibility and efficiency depending on the application requirements.

You might also like