0% found this document useful (0 votes)
36 views52 pages

Lecture 5-Merge Sort

The document describes the merge sort algorithm. It works by recursively dividing an array into halves, sorting each half using merge sort, and then merging the sorted halves back together into a fully sorted array. To merge, it keeps track of the smallest element in each half and inserts them into an auxiliary array until both halves are exhausted. This divide and conquer approach results in a running time of O(n log n) for merge sort.

Uploaded by

q.u.in.tosun.a
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
36 views52 pages

Lecture 5-Merge Sort

The document describes the merge sort algorithm. It works by recursively dividing an array into halves, sorting each half using merge sort, and then merging the sorted halves back together into a fully sorted array. To merge, it keeps track of the smallest element in each half and inserts them into an auxiliary array until both halves are exhausted. This divide and conquer approach results in a running time of O(n log n) for merge sort.

Uploaded by

q.u.in.tosun.a
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 52

MERGE SORT

Introduction
⚫ Many useful algorithms are recursive in structure: to
solve a given problem, they call themselves recursively
one or more times to deal with closely related
subproblems.
⚫ These algorithms typically follow a
divide-and-conquer approach: they break the
problem into several subproblems that are similar to
the original problem but smaller in size, solve the
subproblems recursively, and then combine these
solutions to create a solution to the original problem.
Divide and conquer approach
Mergesort
⚫Mergesort (divide-and-conquer)
⚫ Divide array into two halves.

A L G O R I T H M S

A L G O R I T H M S divide
Mergesort
⚫Mergesort (divide-and-conquer)
⚫ Divide array into two halves.
⚫ Recursively sort each half.

A L G O R I T H M S

A L G O R I T H M S divide

A G L O R H I M S T sort
Mergesort
⚫Mergesort (divide-and-conquer)
⚫ Divide array into two halves.
⚫ Recursively sort each half.
⚫ Merge two halves to make sorted whole.

A L G O R I T H M S

A L G O R I T H M S divide

A G L O R H I M S T sort

A G H I L M O R S T merge
Merging
⚫Merge.
⚫ Keep track of smallest element in each sorted half.
⚫ Insert smallest of two elements into auxiliary array.
⚫ Repeat until done.
smallest smallest

A G L O R H I M S T

A auxiliary array
Merging
⚫Merge.
⚫ Keep track of smallest element in each sorted half.
⚫ Insert smallest of two elements into auxiliary array.
⚫ Repeat until done.

smallest smallest

A G L O R H I M S T

A G auxiliary array
Merging
⚫Merge.
⚫ Keep track of smallest element in each sorted half.
⚫ Insert smallest of two elements into auxiliary array.
⚫ Repeat until done.
smallest smallest

A G L O R H I M S T

A G H auxiliary array
Merging
⚫Merge.
⚫ Keep track of smallest element in each sorted half.
⚫ Insert smallest of two elements into auxiliary array.
⚫ Repeat until done.
smallest smallest

A G L O R H I M S T

A G H I auxiliary array
Merging
⚫Merge.
⚫ Keep track of smallest element in each sorted half.
⚫ Insert smallest of two elements into auxiliary array.
⚫ Repeat until done.
smallest smallest

A G L O R H I M S T

A G H I L auxiliary array
Merging
⚫Merge.
⚫ Keep track of smallest element in each sorted half.
⚫ Insert smallest of two elements into auxiliary array.
⚫ Repeat until done.
smallest smallest

A G L O R H I M S T

A G H I L M auxiliary array
Merging
⚫Merge.
⚫ Keep track of smallest element in each sorted half.
⚫ Insert smallest of two elements into auxiliary array.
⚫ Repeat until done.
smallest smallest

A G L O R H I M S T

A G H I L M O auxiliary array
Merging
⚫Merge.
⚫ Keep track of smallest element in each sorted half.
⚫ Insert smallest of two elements into auxiliary array.
⚫ Repeat until done.
smallest smallest

A G L O R H I M S T

A G H I L M O R auxiliary array
Merging
⚫Merge.
⚫ Keep track of smallest element in each sorted half.
⚫ Insert smallest of two elements into auxiliary array.
⚫ Repeat until done. first half
exhausted smallest

A G L O R H I M S T

A G H I L M O R S auxiliary array
Merging
⚫Merge.
⚫ Keep track of smallest element in each sorted half.
⚫ Insert smallest of two elements into auxiliary array.
⚫ Repeat until done. first half
exhausted smallest

A G L O R H I M S T

A G H I L M O R S T auxiliary array
Divide and Conquer
⚫ Divide the problem into a number of subproblems
that are smaller instances of the
same problem.
⚫ Conquer the subproblems by solving them
recursively. If the subproblem sizes are small enough,
however, just solve the subproblems in a
straightforward manner.
⚫ Combine the solutions to the subproblems into the
solution for the original problem.
Merge sort
⚫ Divide: Divide the n-element sequence to be
sorted into two subsequences of n/2 elements
each.

⚫ Conquer: Sort the two subsequences recursively


using merge sort.

⚫ Combine: Merge the two sorted subsequences to


produce the sorted answer
⚫ The recursion “bottoms out” when the sequence to be
sorted has length 1, in which case there is no work to
be done, since every sequence of length l is already in
sorted order
⚫ The key operation of the merge sort algorithm is the
merging of two sorted sequences in the “combine”
step.
⚫ We merge by calling an auxiliary procedure
MERGE(A,p,q,r), where A is an array and p, q, and r are
indices into the array such that p<= q < r.
⚫ Assumes sub arrays A[p..q] and A[q+1…r] are in sorted
order
⚫ It merges them to form a single sorted subarray
A[p…r]
Merge sort indices
Merge sort
⚫ We need a base case.
⚫ The base case is a subarray containing fewer than two
elements, that is, when p >=r, since a subarray with no
elements or just one element is already sorted.
⚫ So we'll divide-conquer-combine only when p < r.
⚫ Let's see an example. Let's start with array holding
[14, 7, 3, 12, 9, 11, 6, 2],
⚫ so that the first subarray is actually the full
array, array[0..7]
⚫ (p=0 and r=7).
⚫ This subarray has at least two elements, and so it's not
a base case.

Steps
⚫ Divide by finding the number q of the position
midway between p and r. : add p and r, divide by 2, and
round down.
⚫ Conquer by recursively sorting the subarrays in each
of the two subproblems created by the divide step.
That is, recursively sort the subarray array[p..q] and
recursively sort the subarray array[q+1..r].
⚫ Combine by merging the two sorted subarrays back
into the single sorted subarray array[p..r].
⚫ You can check for the base case easily. Finding the
midpoint q in the divide step is also really easy.
⚫ You have to make two recursive calls in the conquer
step.
⚫ It's the combine step, where you have to merge
two sorted subarrays, where the real work
happens.
Steps
Merge (A,p,q,r)
In the two subarrays , the smallest is on the
top .
Take the smallest for these and put it into the
result array. Repeat until both the subarrays
are empty.
Copy to A[p…r].
Recursively ..
Merging
Merging the final two sorted
sequences
⚫ Compare the top most element of both the sorted
sequences
⚫ So order (n) comparisons are required.
⚫ i.e. n-1 comparisons ,since we require that every
element (except the last) be compared.
Recurrence Analysis
Analysis
⚫ How much time in the division step? Constant time
Theta(1)

⚫ The conquer step, where we recursively sort two


subarrays of approximately n/2 elements each, takes
some amount of time, but we'll account for that time
when we consider the subproblems.

⚫ Merger step takes Theta(n ) time -how?


Divide and merge steps alone
⚫ ..take Theta(n)….
⚫ …because
⚫ Theta(1) can be included in Theta(n) .

⚫ To make things more concrete, let's say that the divide


and combine steps together take cn time for some
constant c.
⚫ Lets see how…
⚫ Now we have to figure out the running time of two
recursive calls on n/2 elements.
⚫ Each of these two recursive calls takes twice of the
running time of mergeSort on an (n/4)-element
subarray….
⚫ And so on…
Recursion Tree for Merge Sort
Each of the size n/2 problems has a cost
For the original problem, we of cn/2 plus two subproblems, each
have a cost of cn, plus two costing T(n/4).
subproblems each of size (n/2)
and running time T(n/2).

cn

cn
Cost of divide
and merge.
cn/2 cn/2

T(n/2) T(n/2)
T(n/4 T(n/4 T(n/4 T(n/4
Cost of sorting ) ) ) )
subproblems.

Comp 122
Running time at each level of
merge –recursive merge sort calls
⚫ 2 x n/2 +4xn/4+8 xn/8…
⚫ 2 units of time and n/2 merge sort calls
⚫ Then..
⚫ 4 units of time and n/4 such merge sort calls
⚫ 8 units of time and n/8…
⚫ As the subproblems get smaller, the number of
subproblems doubles at each "level" of the recursion,
but the merging time halves.
⚫ The doubling and halving cancel each other out, and
so the total merging time is cn at each level of
recursion.
⚫ Eventually, we get down to subproblems of size 1
⚫ We have to spend Θ(1) time to sort subarrays of size 1,
because we have to test whether p <r, and this test
takes time.
⚫ How many subarrays of size 1 are there?
⚫ Since we started with n elements, there must be n of
them.
⚫ Since each base case takes Θ(1) time, let's say that
altogether, the base cases take cn time:
How many levels ?
⚫ he total time for mergeSort is the sum of the merging
times for all the levels.
⚫ If there are l levels in the tree, then the total merging
time is l.cn
⚫ So what is l ?
⚫ We start with subproblems of size n and repeatedly
halve until we get down to subproblems of size 1.
⚫ The answer is l = lg n + 1
⚫ For example, if n=8, then lg n + 1 = 4, and sure
enough, the tree has four levels:
⚫ n = 8, 4, 2, 1
⚫ . The total time for mergeSort, then, is cn.(lg n +1)
Running time
⚫ When we use big-Θ notation to describe this running
time, we can discard the low-order term 1
⚫ and the constant coefficient c, giving us a running
time Θ(n lg n)

⚫ It is a tight bound ‘theta’ ,because the best ,worst and


average cases are the same
Not ‘in place’
⚫ During merging, it makes a copy of the entire array
being sorted, with one half in lowHalf and the other
half in highHalf.
⚫ Because it copies more than a constant number of
elements at some time, we say that merge sort does
not work in place
⚫ How many merge sort calls made so far ? n -1 recursive
calls. i.e order n –why?
⚫ Each of the blocks (big ) make a mergesort call i.e 7
here

You might also like