
	Where results make sense

Topic: Mergesort

Related Topics

Batcher odd even mergesort

In the News (Wed 30 Dec 09)

Northern Trust

Marvin Harrison

Peter Chernin

Gary Locke

Match Play

Penelope Cruz

Mickey Rourke

AR Rahman

Danny Boyle

Hugh Jackman

	Merge sort - Wikipedia, the free encyclopedia
		In computer science, merge sort or mergesort is a sorting algorithm for rearranging lists (or any other data structure that can only be accessed sequentially, e.g.
		Mergesort's most common implementation does not sort in place, meaning memory the size of the input must be allocated for the sorted output to be stored in.
		Mergesort's merge operation is useful in online sorting, where the list to be sorted is received a piece at a time, instead of all at the beginning (see online algorithm).
	en.wikipedia.org /wiki/Mergesort (1112 words)

	5.4 Mergesort (Site not responding. Last check: 2007-10-12)
		Mergesort is also a divide and conquer algorithm and just like quicksort has the three steps.
		Mergesort is based on another simple idea: if you are given a pile of cards to sort, divide the pile in half, sort each half independently, and then merge the two piles.
		Mergesorts are often used to sort singly linked lists because the algorithm does not require random access to the data set on which it is operating.
	www.cs.bris.ac.uk /~mcnamara/ASD/mergesort.html (547 words)

	mergesort (Site not responding. Last check: 2007-10-12)
		Mergesort is a recursive sorting algorithm that runs in O(N log N) worst-case time.
		The main disadvantage of mergesort is that it requires using O(N) additional memory.
		Given a list of size N, mergesort performs sorting by recursively dividing the target list in half until the list is divided into exactly N sub-lists.
	www.middlesex.cc.nj.us /faculty/Steven_Zale/mergesort.html (480 words)

	[No title]
		Unlike all other sorts we have examined so far, mergesort is not an "in-place" sort, since mergesort uses an auxiliary array C of n elements into which the two subarrays of n/2 elements each are merged.
		Compare the space requirements of mergesort and quicksort (in the worst case) for sorting an array of n elements.
		The technique used in mergesort forms the basis for an efficient sorting algorithm in the case of the "external sorting" problem, where the data set to be sorted is too large to fit in main memory.
	www.ececs.uc.edu /~gpurdy/lec15.html (738 words)

	CSC 241- Set7
		Mergesort is a divide and conquer method of sorting.
		Although, mergeSort can be used in sorting arrays, lets consider it in the context of a linked list implementation.
		In Java, parameters can't change, so, you always return the reference to the beginning of the sorted list and store it back in the reference variable that used to refer to the beginning of the list; This is a typical technique for implementing recursive algorithms that manipulate lists.
	gee.cs.oswego.edu /~mohammad/241/s98/lec/set7.html (538 words)

	ActivePerl 5.8 - Online Docs : sort
		On average, mergesort does fewer comparisons than quicksort, so it may be better when complicated comparison routines are used.
		Mergesort also takes advantage of pre-existing order, so it would be favored for using
		The default algorithm is mergesort, which will be stable even if you do not explicitly demand it.
	aspn.activestate.com /ASPN/docs/ActivePerl/lib/sort.html (571 words)

	3 Cache-Effective Mergesort Algorithms
		The L2 cache miss reduction by tiled mergesort with padding is almost the same as that by tiled mergesort, which shows that the padding is not very effective in reducing L2 conflict misses on this machine.
		Capacity misses in the second phase of the tiled mergesort are unavoidable without a complex data structure, because the size of the working set (two subarrays and a destination array) is normally larger than the cache size.
		Figure 5 shows the instruction counts of the five mergesort algorithms and the percentage of total cycles saved by the four improved mergesort algorithms compared to the base mergesort on the simulated Pentium II.
	www.jea.acm.org /ARTICLES/Vol5Nbr3/node3.html (2231 words)

	DSA Lab 8 (Site not responding. Last check: 2007-10-12)
		The objective of this lab is to implement a generic mergesort algorithm.
		If mergesort happened to be called on a list that was already sorted, a simple modification could be made that could test this and reduce the number of comparions to 1 for every merge.
		You should fully understand the symantics of mergesort and you should be able to write the recursive mergesort algorithm if asked on an exam.
	www.cs.rpi.edu /~magdon/courses/csci2300_spring2005/labs/lab8 (813 words)

	MergeSort demo with comparison bounds
		MergeSort is a recursive sorting procedure that uses O(n log n) comparisons in the worst case.
		This is done by examining and comparing the smallest remaining bar in each of the sorted halves.
		For example, to see what MergeSort does when when all the inputs are the same, type in just a single 1 in the text box, then load the input, and click on ``Go''.
	www.cs.toronto.edu /~neto/teaching/238/16/mergesort.html (1321 words)

	Odd-even mergesort
		The odd-even mergesort algorithm was developed by K.E. Batcher [Ba].
		In contrast to mergesort, this algorithm is not data-dependent, i.e.
		By recursive application of the merge algorithm the sorting algorithm odd-even mergesort is formed.
	www.iti.fh-flensburg.de /lang/algorithmen/sortieren/networks/oemen.htm (338 words)

	External Sorting
		Mergesort requires about N lg N comparisons to sort any file of N elements.
		Mergesort requires extra space proportional to N. Mergesort is stable.
		Mergesort is insensitive to the initial order of its input.
	www.cs.utk.edu /~huangj/CS302S04/notes/external-sorting.html (889 words)

	Sorting (Colt 1.2.0 - API Specification)
		The quicksort is a derivative of the JDK 1.2 V1.26 algorithms (which are, in turn, based on Bentley's and McIlroy's fine work).
		The mergesort is a derivative of the JAL algorithms, with optimisations taken from the JDK algorithms.
		Mergesort is stable (by definition), while quicksort is not.
	dsd.lbl.gov /~hoschek/colt/api/cern/colt/matrix/objectalgo/Sorting.html (800 words)

	Example Knowbot Program Applications
		Mergesort is a standard sorting algorithm that is often used to introduce the divide-and-conquer strategy in introducty algorithms courses.
		The real work is performed in the merge phase, beginning with the base case of the recursion where each sublist has 1 element.
		In the mergesort example, each recursive invocation of the mergesort algorithm creates two new KP clones that sort each of the sublists.
	www.cnri.reston.va.us /home/koe/docs/manuals/examples.html (757 words)

	[No title]
		The overall logic of mergesort is to "divide and conquer." A list of random integers will be split into two equal-sized lists (each with the same number of elements, plus or minus one), with each half-list sorted independently of the other.
		Instead of dividing the list once, a recursive mergesort will keep dividing the list in half until the sublists are one or two values in length.
		The merge algorithm is a linear one, so when combined with the Mergesort routine we have a O (N * log N) + O(N), which remains in the category of an O(N * log N) algorithm.
	dimacs.rutgers.edu /~rkrane/clecs/ict/Lesson22/Lesson22.doc (1104 words)

	Mergesort
		MergeSort is a stable algorithm (preserves original order of records with equal keys) that has speed comparable to the best unstable algorithms (shellsort and heapsort).
		Mergesort kind of combines the good features of quicksort and heapsort.
		The problem with Mergesort is that every element will move lg(n) steps (or perhaps a few less because of the exploitability of direct sorting of small sub-lists) regardless.
	www.softpanorama.org /Algorithms/Sorting/mergesort.shtml (427 words)

	Dynamic Memory Adjustment for External Mergesort
		When the input size is unknow or available memory space varies, static memory allocation either wastes memory space or fails to make full use of memory to speed up sorting.
		This paper presents a method for run-time adjustment of in-memory work space for external mergesort and a policy for allocating memory among concurrent, competing sorts.
		When multiple sorts compete for memory resources, we found that sort throughput and response time are improved significantly by our policy for memory allocation combined with limiting the number of sorts processed concurrently.
	research.microsoft.com /research/pubs/view.aspx?pubid=244 (162 words)

	Merge Sort - CS245 Project By Joseph George (Site not responding. Last check: 2007-10-12)
		The mergesort algorithm closely follows the divide-and-conquer paradigm.
		To sort the entire sequence A, Mergesort(A,1,length[A]) is called where length[A]=N. Mergesort works by splitting the list into two halves and then sorting each half recursively.
		Mergesort may be considered to be a tree based algorithm and over here it is executed in a depth first manner.
	www.cse.iitk.ac.in /users/dsrkg/cs210/applets/sorting/mergeSort/mergeSort.html (440 words)

	[No title]
		;; mergesort is the top-level function...it takes a list of numbers ;; to be sorted, splits the list into two equal-sized (plus or minus 1) ;; sublists, calls mergesort on the two sublists recursively, and then ;; calls merge to merge the resulting sorted sublists.
		What you saw with mergesort last week was another illustration of how one uses abstraction to go from a design in some off-the-cuff high-level design language to an actual implementation in Scheme.
		Initially, we started with an English-language description of mergesort, and we designed a working implementation of the sorting algorithm from the top down breaking off a piece of the problem, designing a solution to that little piece, and abstracting away the rest of that problem.
	www.cc.gatech.edu /classes/AY2000/cs1311x/lectureFall2000/lecture11.html (4021 words)

	Mergesort (Site not responding. Last check: 2007-10-12)
		Mergesort is a sorting algorithm that is praised for its efficiency and elegant recursive formulation (Carrano and Prichard 393).
		Merging is more efficient as well as more stable than sorting or bubble sort because the running time is not proportional to the square of the number of elements.
		Actual time measurements on one particular computer showed that mergesort was able to sort half a million numbers 500 times faster than bubblesort.
	www2.hawaii.edu /~lijie/211/mergesort.htm (961 words)

	Scheme Sorting Examples
		Mergesort divides the list in half everytime, calling itself on each half.
		(mergesort '(6 4 5 7 8 9 3 4)) / \ (mergesort '(6 4 5 7)) (mergesort '(8 9 3 4)) / \ / \ (mergesort '(6 4)) (mergesort '(5 7)) (mergesort '(8 9)) (mergesort '(3 4))
		Once we have these, the mergesort itself is fairly short.
	www.tjhsst.edu /~rlatimer/assignments2004/PerlSamples.html (531 words)

	Bottom-Up Mergesort - Panny, Prodinger (ResearchIndex) (Site not responding. Last check: 2007-10-12)
		Abstract: : Though the behaviors of mergesort algorithms are basically known, the periodicity phenomena encountered in their analyses are not easy to deal with.
		In this paper closed-form expressions for the necessary number of comparisons are derived for the bottom-up algorithm, which adequately describe its periodic behavior.
		2: Asymptotic expansions of the mergesort recurrences - Hwang - 1996
	citeseer.ist.psu.edu /panny95bottomup.html (453 words)

	[No title] (Site not responding. Last check: 2007-10-12)
		Logically, (mergesort x) is exactly the same as repeated insertion, so it is fairly easy to reason about.
		But, under the hood, mergesort is implemented fairly efficiently using MBE.
		If you find that the mergesort's perfor- mance is inadequate, which is unlikely, you can work on making it faster.
	www.cs.utexas.edu /users/jared/osets/osets-0.9/sort.lisp (443 words)

	Sorting Algorithms Demo
		Mergesort is supposed to run in O(n log n), but the implementation here runs in O(n * n).
		This is because a temporary scratch array is not used.
		As with most of the examples here, In-Place Mergesort sorts the elements in the array without using additional storage (other than the stack used for the recursive calls, and temporary variables).
	www.cs.ubc.ca /spider/harrison/Java/sorting-demo.html (527 words)

	MergeSort demo with n not a power of 2 (Site not responding. Last check: 2007-10-12)
		If you haven't already, then you should visit the main MergeSort demo page first.
		So MergeSort needs no more than 94 comparisons to sort an array of 21 elements.
		It works in the same way as the applet on the main mergesort demo page.
	www.cs.toronto.edu /~neto/teaching/238/21/mergesort21.html (455 words)

	Speeding Up External Mergesort (Site not responding. Last check: 2007-10-12)
		External mergesort is normally implemented so that each run is stored continuously on disk and blocks of data are read exactly in the order they are needed during merging.
		We investigate two ideas for improving the performance of external mergesort: interleaved layout and a new reading strategy.
		However, permission to reprint/republish this material for advertising or promotional purposes or for creating new collective works for resale or redistribution to servers or lists, or to reuse any copyrighted component of this work in other works must be obtained from the IEEE.
	research.microsoft.com /pubs/view.aspx?pubid=248 (251 words)

	11.4 Mergesort
		Given a sequence of N data elements, we are required to generate an ordered sequence that contains the same elements.
		Here, we present a parallel version of the well-known mergesort algorithm.
		The sequential mergesort algorithm is as follows; its execution is illustrated in Figure 11.4.
	www-unix.mcs.anl.gov /dbpp/text/node127.html (797 words)

	CmSc250: MergeSort
		Hence the complexity of the MergeSort algorithm is O(NlogN).
		Be able to explain how mergesort works and what its complexity is.
		Show that the complexity of mergesort algorithm is O(NlogN) by using recurrence relations
	www.simpson.edu /~sinapova/LN250/L18-MergeSort.htm (371 words)

	[plt-scheme] mergesort stability
		After staring at the MERGESORT implementation for a bit, and drawing a couple of behavioral traces, I realized why MzScheme's implementation is not guaranteed to be stable: because the sorting function doesn't know whether its been passed a reflexive comparator or not.
		There is a crucial bit of code where we actually run the LESS-THAN parameter, and we have to decide what we will do when it returns #f.
		It is a pretty simple change to the MERGESORT implementation, and I believe that it produces a stable sort.
	www.cs.brown.edu /pipermail/plt-scheme/2004-July/006075.html (800 words)

	Mergesort
		The sorting algorithm Mergesort produces a sorted sequence by sorting its two halves and merging them.
		Similar to Quicksort, the Mergesort algorithm is based on a divide and conquer strategy
		Thus, the Mergesort algorithm is optimal, since the lower bound for the sorting problem of
	www.iti.fh-flensburg.de /lang/algorithmen/sortieren/merge/mergen.htm (585 words)

	The Cost Distribution of Queue-Mergesort, Optimal Mergesorts, and Power-of-Two Rules (ResearchIndex)
		Abstract: Queue-mergesort is recently introduced by Golin and Sedgewick as an optimal variant of mergesorts in the worst case.
		We address the corresponding optimality problems and show that if we fix the merging scheme then the optimal mergesort as far as the average number...
		0.3: Asymptotic Expansions of the Mergesort Recurrences - Hwang (1998)
	citeseer.ist.psu.edu /588443.html (397 words)

	CS132 - Introduction To Computing II
		It is suggested that you develop the MergeSort program in a step-by-step manner.
		One possibility is to first design, write and test a method for merging two sorted arrays of integers.
		The following is one possible specification for a mergeSort method.
	www.dickinson.edu /~braught/courses/cs132f01/classes/labs/lab06.html (1316 words)

Try your search on: Qwika (all wikis)