Quick Sort Vs Merge Sort [duplicate]

Quick sort lends itself to parallel computing basically as well as merge sort. Quick sort is top down where as merge sort is bottom up, which I was about to say is irrelevant to parallelization, but now that I think about it I actually think Quick sort is a little better for parallelization. I'm thinking the top down approach is better for work stealing in the fork join framework which comes into play on hyper modern CPUs like Intel Alder Lake and the latest smartphone chips which have asymmetric cores.

I'm also not sure merge sort is better for cache locality either. For one thing disk to RAM is the same thing in principle as RAM to cache so you would expect to see the same phenomenon in both places. Furthermore again the fundamental difference between quick sort and merge sort is that one is top down where as the other is bottom up which makes no difference in terms of overall locality of reference or even being able to fit all of something somewhere. Merge sort can be broken up into small pieces at the beginning where as quick sort can do it at the end. Why does the timing of that matter?

As I understand it Quick Sort is faster because it has (slightly) better locality of reference by virtue of the fact that it can be executed within a single array where as an efficient implementation of Merge Sort will alternate back and forth between two arrays. This of course also saves memory and a memory allocation/de-allocation.

Stephan Eggermont Over a year ago

Okay upon further thought I retract the portion of my statement on parallelization in which I said that Quick Sort is a little computationally superior to Merge Sort in the context of work stealing. You can implement the fork join framework in an equally effective manner for both. However I am confident that employing fork join on Quick Sort is a little simpler.

Georg Schölly · Accepted Answer · 2009-03-25 07:47:09Z

64

For Merge sort worst case is O(n*log(n)), for Quick sort: O(n²). For other cases (avg, best) both have O(n*log(n)). However Quick sort is space constant where Merge sort depends on the structure you're sorting.

See this comparison.

You can also see it visually.

edited Mar 25, 2009 at 7:47

Georg Schölly

127k54 gold badges225 silver badges277 bronze badges

answered Mar 25, 2009 at 7:32

Marcin Gil

70k8 gold badges63 silver badges62 bronze badges

4 Comments

That is wrong. An acceptable implementation of quicksort sorts smallest subrange first.

extraneon Over a year ago

Very good comparison article indeed. Both explanation and simple implementations.

@Stephan Eggermont: You're right -- quicksort uses at least O(log n) and at most O(n) extra space, since every split (recursion) requires constant space to store the pivot location and there must be at least log2(n) of them. I must have got confused and put the extra factor of n in by mistake.

Merge sort can be implemented with two arrays of size n (regardless of the contents of the array you're sorting) with the algorithm switching back and forth between the two at each level of the recursion.

Brandon Yarbrough · Accepted Answer · 2009-03-25 07:58:43Z

12

While quicksort is often a better choice than merge sort, there are definitely times when merge sort is thereotically a better choice. The most obvious time is when it's extremely important that your algorithm run faster than O(n^2). Quicksort is usually faster than this, but given the theoretical worst possible input, it could run in O(n^2), which is worse than the worst possible merge sort.

Quicksort is also more complicated than mergesort, especially if you want to write a really solid implementation, and so if you're aiming for simplicity and maintainability, merge sort becomes a promising alternative with very little performance loss.

answered Mar 25, 2009 at 7:58

Brandon Yarbrough

38.5k23 gold badges121 silver badges152 bronze badges

4 Comments

Where mergesort shines is when you need either a stable sort (elements that compare equal are not rearranged) or when you are using sequential (rather than random-access) "memory" (e.g. you can mergesort efficiently using tape drives).

@j_random_hacker: your tape drive example is a bit obscure; more common examples might be sorting data as it is received from a network connection, or sorting data structures which don't allow efficient random access like linked lists

You never answered the question.

Quick sort was able to do it in 156 milliseconds whereas Merge sort did the same in 247 milliseconds

An efficient version of Quick Sort is actually a little bit simpler than an efficient version of Merge Sort because efficient versions of Merge Sort alternate back and forth between two arrays of size n to avoid excessive memory allocations and de-allocations which are expensive. So they have to keep track of indices just like Quick Sort and on top of that they have to have logic for alternating between the two arrays. Perhaps you're referring to something like Intro Sort which switches from Quick Sort to Heap Sort if the recursion depth on Quick Sort exceeds log(n).

Saurabh · Accepted Answer · 2020-12-18 08:33:43Z

11

I personally wanted to test the difference between Quick sort and merge sort myself and saw the running times for a sample of 1,000,000 elements.

The Quick sort data, however, was random and quick sort performs well if the data is random where as its not the case with merge sort i.e. merge sort performs the same, irrespective of whether data is sorted or not. But merge sort requires one full extra space and quick sort does not as its an in-place sort

I have written comprehensive working program for them will illustrative pictures too.

edited Dec 18, 2020 at 8:33

Saurabh

7,1485 gold badges48 silver badges58 bronze badges

answered Feb 14, 2010 at 8:41

bragboy

35.7k30 gold badges116 silver badges175 bronze badges

5 Comments

compski Over a year ago

Weird. I also made a Java program to sort a million elements for both quicksort and mergesort. My quicksort executed around the same time as yours but my mergesort executes in like 12 minutes.. any reason why? can you look at my code?

bragboy Over a year ago

@compski: can you point me to your code ?

compski Over a year ago

pastebin.com/sYs4u6Kd

bragboy Over a year ago

@compski: i see a problem in line 14 in your code. instead of using ONE extra array space, you are creating innumerous arrays which will kill the memory. here is the example which uses only ONE extra array (see line 24). tech.bragboy.com/2010/01/merge-sort-in-java.html let me know this answered your problem. if not i can help you more.

You never answered the question.

Peter Leong · Accepted Answer · 2012-07-03 14:11:15Z

8

Quicksort is in place. You just need to swap positions of data during the Partitioning function. Mergesort requires a lot more data copying. You need another temporary storage (typically the same size as your original data array) for the Merge function.

answered Jul 3, 2012 at 14:11

Peter Leong

991 silver badge3 bronze badges

Comments

Community · Accepted Answer · 2017-05-23 10:31:10Z

5

In addition to the others: Merge sort is very efficient for immutable datastructures like linked lists and is therefore a good choice for (purely) functional programming languages.

A poorly implemented quicksort can be a security risk.

edited May 23, 2017 at 10:31

CommunityBot

11 silver badge

answered Feb 14, 2010 at 9:21

Dario

49.4k8 gold badges99 silver badges131 bronze badges

7 Comments

the issue with linked lists is not mutability, but lack of efficient random access, ie you're stuck with on-line algorithms (merge sort, insertion sort)

@Christoph: Quicksort doesn't require random access; linked lists can be quicksorted efficiently. When you look at how quicksort works, it effectively grows several "lists" from defined starting points within an array. (Heapsort OTOH does require O(1) random access.)

@j_random_hacker: without random access, Quicksort suffers from poor choice of pivot

@Christoph: That crossed my mind too, but I think the only pivot-choosing strategy it would affect would be the (admittedly common) median-of-3 variant in which the 3 are taken from the beginning, middle and end. Even doing an O(n) scan to find these 3 elements won't alter the O(n) time complexity of the partitioning step: it should cause an overall slowdown of <2x. And even this could be removed by having the "parent" recursive call determine these 3 values for each partition as it builds them up (for the midpoint element, update a pointer every 2 iters).

@j_random_hacker: any code reference (preferably C or C++)? I'd like to see how well this works out in practice...

|

appbootup · Accepted Answer · 2013-04-03 14:45:26Z

The answer would slightly tilt towards quicksort w.r.t to changes brought with DualPivotQuickSort for primitive values . It is used in JAVA 7 to sort in java.util.Arrays

It is proved that for the Dual-Pivot Quicksort the average number of
comparisons is 2*n*ln(n), the average number of swaps is 0.8*n*ln(n),
whereas classical Quicksort algorithm has 2*n*ln(n) and 1*n*ln(n)
respectively. Full mathematical proof see in attached proof.txt
and proof_add.txt files. Theoretical results are also confirmed
by experimental counting of the operations.

You can find the JAVA7 implmentation here - http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7-b147/java/util/Arrays.java

Further Awesome Reading on DualPivotQuickSort - http://permalink.gmane.org/gmane.comp.java.openjdk.core-libs.devel/2628

Andrew Barber · Accepted Answer · 2012-06-01 08:19:45Z

3

It is not true that quicksort is better. ALso, it depends on what you mean better, memory consumption, or speed.

In terms of memory consumption, in worst case, but quicksort can use n^2 memory (i.e. each partition is 1 to n-1), whereas merge sort uses nlogn.

The above follows in terms of speed.

edited Jun 1, 2012 at 8:19

Andrew Barber

40.3k20 gold badges97 silver badges124 bronze badges

answered Apr 30, 2012 at 6:53

Jason

2153 silver badges1 bronze badge

1 Comment

mlfan Over a year ago

Quicksort, in the worst case will use only O(n) memory. Yes, the time complexity can be O(n^2) in worst case. To understand, look at the max size of recursion stack. That is equal to the maximum number of levels in the DFS tree. Even if each partition is 1,n-1, the number of levels would be n (n, n-1, n-2, n-3 ... 1).

idexi · Accepted Answer · 2012-10-27 19:01:46Z

3

quicksort is named so for a reason ,

highlights : both are stable sorts,(simply an implementation nuisance ) , so lets just move on to complexities

its very confusing with just the big-oh notations being spilled and "abused" , both have average case complexity of 0(nlogn) ,

but merge sort is always 0(nlogn) , whereas quicksort for bad partitions, ie skewed partitions like 1 element-10 element (which can happen due to sorted or reverse sorted list ) can lead to a 0(n^2)..

.. and so we have randomized quicksort , where we pick the pivot randomly and avoid such skewed partitioning , thereby nullifying the whole n^2 scenario anyway even for moderately skewed partitioning like 3-4 , we have a nlog(7/4)n, ideally we want 1-1 partion , thus the whole 2 of O(nlog(2)n).

so it is O(nlogn) , almost always and unlike merge sort the constants hidden under the "big-oh" notation are better for quicksort than for mergesort ..and it doesnt use up extra space like merge sort.

but getting quicksort run perfectly requires tweaking ,rephrase , quicksort provides you opportunities to tweak ....

answered Oct 27, 2012 at 19:01

idexi

1098 bronze badges

2 Comments

idexi Over a year ago

quick sort can be made stable , check this post. I hope that helps