In this paper so-called discrete loops are introduced which narrow the gap between general loops (e.g. while- or repeat-loops) and for-loops. Alt- hough discrete loops can be used for applications that would otherwise require general loops, discrete loops are known to complete in any case. Furthermore it is possible to determine the number of iterations of a discrete loop, while this is trivial to do for for-loops and extremely difficult for general loops. Thus discrete loops form an ideal frame-work for determining the worst case timing behavior of a program and they are especially useful in implementing real-time systems and proving such systems correct.

The purpose of this paper is to introduce frameworks based on data-flow equations which provide for estimating the worst-case execution time (WCET) of (real-time) programs. These frameworks allow several different WCET analysis techniques, which range from nave approaches to exact analysis, provided exact knowledge on the program behaviour is available. However, data-flow frameworks can also be used for symbolic analysis based on information derived automatically from the source code of the program. As a byproduct we show that slightly modified elimination methods can be employed for solving WCET data-flow equations, while iteration algorithms cannot be used for this purpose.

Two in-place variants of the classical mergesort algorithm are analysed in detail. The first, straightforward variant performs at most N log 2 N + O(N ) comparisons and 3N log 2 N + O(N ) moves to sort N elements. The second, more advanced variant requires at most N log 2 N + O(N ) comparisons and "N log 2 N moves, for any fixed " ? 0 and any N ? N ("). In theory, the second one is superior to advanced versions of heapsort. In practice, due to the overhead in the index manipulation, our fastest in-place mergesort behaves still about 50 per cent slower than the bottom-up heapsort. However, our implementations are practical compared to mergesort algorithms based on in-place merging. Key words: sorting, mergesort, in-place algorithms CR Classification: F.2.2 1.

Heaps constitute a well-known data structure allowing the implementation of an e#cient O(n log n) sorting algorithm as well as the design of fast priority queues. Although heaps have been known for long, their combinatorial properties are still partially worked out: exact summation formulae have been stated, but most of the asymptotic behaviors are still unknown. In this paper, we present a number of general (not restricting to special subsequences) asymptotic results that give insight on the di#culties encountered in the asymptotic study of the number of heaps of a given size and of the cost of heap construction. In particular we exhibit the influence of arithmetic functions in the apparently chaotic behavior of these quantities. It is also shown that the distribution function of the cost of heap construction using Floyd's algorithm and other variants is asymptotically normal. 1

. A variant of Heapsort---named Ultimate Heapsort---is presented that sorts n elements in-place in \Theta(n log 2 (n+ 1)) worst-case time by performing at most n log 2 n + \Theta(n) key comparisons and n log 2 n + \Theta(n) element moves. The secret behind Ultimate Heapsort is that it occasionally transforms the heap it operates with to a two-layer heap which keeps small elements at the leaves. Basically, Ultimate Heapsort is like Bottom-Up Heapsort but, due to the two-layer heap property, an element taken from a leaf has to be moved towards the root only O(1) levels, on an average. Let a[1::n] be an array of n elements each consisting of a key and some information associated with this key. This array is a (maximum) heap if, for all i 2 f2; : : : ; ng, the key of element a[bi=2c] is larger than or equal to that of element a[i]. That is, a heap is a pointer-free representation of a left complete binary tree, where the elements stored are partially ordered according to their keys. Ele...

. Dutton #1993# presents a further HEAPSORT variant called WEAK-HEAPSORT, which also contains a new data structure for priority queues. The sorting algorithm and the underlying data structure are analyzed showing that WEAK-HEAPSORT is the best HEAPSORT variant and that it has a lot of nice properties. It is shown that the worst case number of comparisons is ndlog ne# 2 dlog ne + n #dlog ne#nlog n +0:1nand weak heaps can be generated with n # 1 comparisons. A double-ended priority queue based on weakheaps can be generated in n + dn=2e#2 comparisons. Moreover, examples for the worst and the best case of WEAK-HEAPSORT are presented, the number of Weak-Heaps on f1;:::;ng is determined, and experiments on the average case are reported. 1

Three pointer-based parallel join algorithms are presented and analyzed for environments in which secondary storage is made transparent to the programmer through memory mapping. Buhr, Goel, and Wai [11] have shown that data structures such as B-Trees, R-Trees and graph data structures can be implemented as efficiently and effectively in this environment as in a traditional environment using explicit I/O. Here we show how higher-order algorithms, in particular parallel join algorithms, behave in a memory mapped environment. A quantitative analytical model has been developed to conduct performance analysis of the parallel join algorithms. The model has been validated by experiments. 1 Introduction Programmers working with complex and possibly large persistent data structures are faced with the problem that there are two, mostly incompatible, views of structured data, namely data in primary and secondary storage. In primary storage, pointers are used to construct complex relationships a...

In this paper we have observed and shown that ternary systems are more promising than the more traditional binary systems used in computers. In particular, ternary number system, heaps on ternary trees, and quicksort with 3 partitions do indicate some theoretical advantages over the more established binary systems. The magic Napierian e plays the crucial role to establish the results. The experimental data, supporting the analysis, have also been presented. Keywords: Analysis of algorithms; Performance evaluation; Quicksort; Heaps; Divide and conquer technique 1 Introduction With the invention of computers, 2-parametric algebra, number system and graphs among other systems started to flourish with accelerated speed. Boolean algebra got its important applications in computer technology, binary number system has occupied the core of computer arithmetic, and binary trees have become inseparable in Revised version of ref. no. CAM 2974. y Corresponding Author. mathematical analysis...

This is the rst installment of the Algorithmics Column dedicated to Analysis of Algorithms (AofA) that sometimes goes under the name Average-Case Analysis of Algorithms or Mathematical Analysis of Algorithms. The area of analysis of algorithms (at least, the way we understand it here) was born on July 27, 1963, when D. E. Knuth wrote his \Notes on Open Addressing". Since 1963 the eld has been undergoing substantial changes. We report here how it evolved since then. For a long time this area of research did not have a real \home". But in 1993 the rst seminar entirely devoted to analysis of algorithms took place in Dagstuhl, Germany. Since then seven seminars were organized, and in this column we briey summarize the rst three meetings held in Schloss Dagstuhl (thus \Dagstuhl Period") and discuss various scienti c activities that took place, describing some research problems, solutions, and open problems discussed during these meetings. In addition, we describe three special issues dedicated to these meetings.

Abstract. We present an algorithm for asymptotically efficient multiway blockwise in-place merging. Given an array A containing sorted subsequences A1,..., Ak of respective lengths n1,..., nk, where ∑k ni = n, we assume i=1 that extra k·s elements (so called buffer elements) are positioned at the very end of array A, and that the lengths n1,..., nk are positive integer multiples of some parameter s (i.e., multiples of a given block of length s). The number of input sequences k is a fixed constant parameter, not dependent on the lengths of input sequences. Then our algorithm merges the subsequences A1,..., Ak into a single sorted sequence, performing Θ(log k·n) + O((n/s) 2) + O(s· log s) element comparisons and 3·n + O(s·log s) element moves. 1 Then, for s = ⌈n 2/3 /(log n) 1/3 ⌉, this gives an algorithm performing Θ(log k·n) + O((n·log n) 2/3) comparisons and 3·n + O((n·log n) 2/3) moves. That is, our algorithm runs in linear time, with an asymptotically optimal number of comparisons and with the number of moves independent on the number of input sequences. Moreover, our algorithm is “almost in-place”, it requires only k extra blocks of size s = o(n). 1