Measure Of Presortedness Research Articles

On the adaptiveness of Quicksort

Quicksort was first introduced in 1961 by Hoare. Many variants have been developed, the best of which are among the fastest generic-sorting algorithms available, as testified by the choice of Quicksort as the default sorting algorithm in most programming libraries. Some sorting algorithms are adaptive, i.e., they have a complexity analysis that is better for inputs, which are nearly sorted, according to some specified measure of presortedness. Quicksort is not among these, as it uses Ω( n log n ) comparisons even for sorted inputs. However, in this paper, we demonstrate empirically that the actual running time of Quicksort is adaptive with respect to the presortedness measure Inv. Differences close to a factor of two are observed between instances with low and high Inv value. We then show that for the randomized version of Quicksort, the number of element swaps performed is provably adaptive with respect to the measure Inv. More precisely, we prove that randomized Quicksort performs expected O ( n (1 + log(1 + Inv/ n ))) element swaps, where Inv denotes the number of inversions in the input sequence. This result provides a theoretical explanation for the observed behavior and gives new insights on the behavior of Quicksort. We also give some empirical results on the adaptive behavior of Heapsort and Mergesort.

On the Adaptiveness of Quicksort

Quicksort was first introduced in 1961 by Hoare. Many variants have been developed, the best of which are among the fastest generic sorting algorithms available, as testified by the choice of Quicksort as the default sorting algorithm in most programming libraries. Some sorting algorithms are adaptive, i.e. they have a complexity analysis which is better for inputs which are nearly sorted, according to some specified measure of presortedness. Quicksort is not among these, as it uses Omega(n log n) comparisons even when the input is already sorted. However, in this paper we demonstrate empirically that the actual running time of Quicksort <em>is</em> adaptive with respect to the presortedness measure Inv. Differences close to a factor of two are observed between instances with low and high Inv value. We then show that for the randomized version of Quicksort, the number of element <em>swaps</em> performed is <em>provably</em> adaptive with respect to the measure Inv. More precisely, we prove that randomized Quicksort performs expected O(n (1 + log (1 + Inv/n))) element swaps, where Inv denotes the number of inversions in the input sequence. This result provides a theoretical explanation for the observed behavior, and gives new insights on the behavior of the Quicksort algorithm. We also give some empirical results on the adaptive behavior of Heapsort and Mergesort.

Exploiting few inversions when sorting: Sequential and parallel algorithms

We consider the problem of taking advantage of existing order within the input sequence when sorting. The measure of presortedness used is the number of inversions. Let X be a sequence of length n and let Inv(X) be the (unknown) number of inversions in X. Our main results are: • • X can be sorted in-place, i.e. using only O( log n) bits of extra space, in time O(n log( Inv(X) n )) , which is optimal with respect to the number of inversions. • • Given p processors on an EREW PRAM, X can be sorted in time O( n log( Inv(X) n ) p + log n) , which is optimal with respect to the number of inversions.

A framework for adaptive sorting

A sorting algorithm is adaptive if it sorts sequences that are close to sorted faster than random sequences, where the distance is determined by some measure of presortedness. Over the years several measures of presortedness have been proposed in the literature, but it has been far from clear how they relate to each other. We show that there exists a natural partial order on the set of measures, which makes it possible to say that some measures are superior to others. We insert all known measures of presortedness into the partial order, and thereby provide a powerful tool for evaluating both measures and adaptive sorting algorithms. We further present a new measure and show that it is a maximal element in the partial order formed by all known measures, and thus that any sorting algorithm that optimally adapts to the new measure also optimally adapts to all other known measures of presortedness. We have not succeeded in developing an optimal algorithm for the new measure; however, we present one that is optimal in terms of comparisons.

Sublinear merging and natural mergesort

The complexity of merging two sorted sequences into one is linear in the worst case as well as in the average case. There are, however, instances for which a sublinear number of comparisons is sufficient. We consider the problem of measuring and exploiting such instance easiness. The merging algorithm presented, Adaptmerge, is shown to adapt optimally to different kinds of measures of instance easiness. In the sorting problem the concept of instance easiness has received a lot of attention, and it is interpreted by a measure of presortedness. We apply Adaptmerge in the already adaptive sorting algorithm Natural Mergesort. The resulting algorithm, Adaptive Mergesort, optimally adapts to several, known and new, measures of presortedness. We also prove some interesting results concerning the relation between measures of presortedness proposed in the literature.

Right invariant metrics and measures of presortedness

Right invariant metrics (ri-metrics) have several applications in the theory of rank correlation methods. For example, ranking models based on ri-metrics generalize Mallow's ranking models. We explore the relationship between right invariant metrics and measures of presortedness (mops). The latter have been used to evaluate the behavior of sorting algorithms on nearly-sorted inputs. We give necessary and sufficient conditions for a measure of presortedness to be extended to a ri-metric; we characterize those ri-metrics that can be used as mops; and we show that those mops that are extendible to ri-metrics can be constructed from sets of sorting operations. Our results provide a paradigm for the construction of mops and ri-metrics.

An optimal parallel adaptive sorting algorithm

We consider the problem of designing optimal parallel algorithms for sorting presorted sequences. To evaluate the existing order in an input sequence, we use the number of the maximal ascending consecutive subsequences, Runs. in the sequence as a measure of presortedness. An adaptive parallel sorting algorithm is presented, which sorts a sequence X of length n inO(log n·log Runs( X)) time by using O( n logn ) processors in the EREW PRAM model of computation. It is the first adaptive parallel sorting algorithm that is cost optimal with respect to Runs.

A note on adaptive parallel sorting

We present a cost optimal parallel algorithm for sorting presorted sequences. The measure of presortedness we consider is Rem, i.e., the smallest number of elements whose removal leaves a sorted sequence. The algorithm sorts a sequence X of length n, with Rem( X) = r, in O(log n) time, provided O(( n + r log r)/log n) processors are available, in the EREW PRAM model. This is the first PRAM sorting algorithm which is cost optimal with respect to Rem.

A new measure of presortedness

A new measure of presortedness is presented which we call Par . We prove that it is distinct from other common measures of presortedness and we design sorting algorithms that sort a sequence X in O (| X | log Par ( X )) comparisons. Moreover, we prove that this is Par -optimal in a comparison-based model of computation.

Encroaching lists as a measure of presortedness

Encroaching lists are a generalization of monotone sequences in permutations. Since ordered permutations contain fewer encroaching lists than random ones, the number of such listsm provides a measure of presortedness with advantages over others in the literature. Experimental and analytic results are presented to cast light on the properties of encroaching lists. Also, we describe a new sorting algorithm,melsort, with complexityO(nlogm). Thus it is linear for well ordered sets and reduces to mergesort andO(nlogn) in the worst case.

Measures of Presortedness and Optimal Sorting Algorithms

The concept of presortedness and its use in sorting are studied. Natural ways to measure presortedness are given and some general properties necessary for a measure are proposed. A concept of a sorting algorithm optimal with respect to a measure of presortedness is defined, and examples of such algorithms are given. A new insertion sort algorithm is shown to be optimal with respect to three natural measures. The problem of finding an optimal algorithm for an arbitrary measure is studied, and partial results are proven.