12 research outputs found
Dynamic algorithms in D.E. Knuth's model: a probabilistic analysis
AbstractBy dynamic algorithms we mean algorithms that operate on dynamically varying data structures (dictionaries, priority queues, linear lists) subject to insertions I, deletions D, positive (negative) queries Q+ (Q−). Let us remember that dictionaries are implementable by unsorted or sorted lists, binary search trees, priority queues by sorted lists, binary search trees, binary tournaments, pagodas, binomial queues and linear lists by sorted or unsorted lists, etc. At this point the following question is very natural in computer science: for a given data structure, which representation is the most efficient? In comparing the space or time costs of two data organizations A and B for the same operations, we cannot merely compare the costs of individual operations for data of given sizes: A may be better than B on some data, and vice versa on others. A reasonable way to measure the efficiency of a data organization is to consider sequences of operations on the structure. Françon (1978, 1979) Knuth (1977) discovered that the number of possibilities for the ith insertion or negative query is equal to i, but that for deletions and positive queries this number depends on the size of the data structure. Answering the questions raised by Françon and Knuth is the main object of this paper more precisely, we show •how to obtain limiting processes;•how to compute explicitly the average costs;•how to obtain variance estimates;•that the costs coverage as n → ∞ to random variables, either Gaussian or depending on Brownian excursion functionals (the limiting distributions are, therefore, completely described).To our knowledge such a complete analysis has never been done before dynamic algorithms in Knuth's model
Sorting Algorithms in MOQA
AbstractA high-level overview of the MOQA language is presented. The representation of its data structure, a labeled series-parallel partial order, is shown along with some of the functions allowed upon this data structure. The combination of MOQA's data structure and its functions capture the required calculus to statically obtain the average-case time of algorithms written in this language. The implementation of these concepts is discussed and algorithms written in this implementation are presented. A detailed analysis of one of these implemented algorithms, quicksort, critically compares its average-case time in MOQA against the average-case time of standard quicksort. While the asymptotic average of quicksort in MOQA remains unchanged, extra constant costs are incurred by the MOQA method. It is shown that these costs result from molding the algorithm around the MOQA data structure and functions versus the general approach of choosing the data structure and functions that best match the algorithm. This limitation is balanced against an approach that aims to obtain the average-case time of algorithms statically
Data linkage algebra, data linkage dynamics, and priority rewriting
We introduce an algebra of data linkages. Data linkages are intended for
modelling the states of computations in which dynamic data structures are
involved. We present a simple model of computation in which states of
computations are modelled as data linkages and state changes take place by
means of certain actions. We describe the state changes and replies that result
from performing those actions by means of a term rewriting system with rule
priorities. The model in question is an upgrade of molecular dynamics. The
upgrading is mainly concerned with the features to deal with values and the
features to reclaim garbage.Comment: 48 pages, typos corrected, phrasing improved, definition of services
replaced; presentation improved; presentation improved and appendix adde
Data structures
We discuss data structures and their methods of analysis. In particular, we treat the unweighted and weighted dictionary problem, self-organizing data structures, persistent data structures, the union-find-split problem, priority queues, the nearest common ancestor problem, the selection and merging problem, and dynamization techniques. The methods of analysis are worst, average and amortized case
Data structures
We discuss data structures and their methods of analysis. In particular, we treat the unweighted and weighted dictionary problem, self-organizing data structures, persistent data structures, the union-find-split problem, priority queues, the nearest common ancestor problem, the selection and merging problem, and dynamization techniques. The methods of analysis are worst, average and amortized case