In the past 20 years there has been treftlendous progress in developing and analyzing parallel algorithftls. Researchers have developed efficient parallel algorithms to solve most problems for which efficient sequential solutions are known. Although some ofthese algorithms are efficient only in a theoretical framework, many are quite efficient in practice or have key ideas that have been used in efficient implementations. This research on parallel algorithms has not only improved our general understanding ofparallelism but in several cases has led to improvements in sequential algorithms. Unf:ortunately there has been less success in developing good languages f:or prograftlftling parallel algorithftls, particularly languages that are well suited for teaching and prototyping algorithms. There has been a large gap between languages

We show that a unit-cost RAM with a word length of w bits can sort n integers in the range 0 : : 2 w \Gamma1 in O(n log log n) time, for arbitrary w log n, a significant improvement over the bound of O(n p log n) achieved by the fusion trees of Fredman and Willard. Provided that w (log n) 2+ffl for some fixed ffl ? 0, the sorting can even be accomplished in linear expected time with a randomized algorithm. Both of our algorithms parallelize without loss on a unit-cost PRAM with a word length of w bits. The first one yields an algorithm that uses O(logn) time and O(n log log n) operations on a deterministic CRCW PRAM. The second one yields an algorithm that uses O(log n) expected time and O(n) expected operations on a randomized EREW PRAM, provided that w (log n) 2+ffl for some fixed ffl ? 0. Our deterministic and randomized sequential and parallel algorithms generalize to the lexicographic sorting problem of sorting multiple-precision integers represented in several words. ...

We show that n integers in the range 1 : : n can be sorted stably on an EREW PRAM using O(t) time and O(n( p log n log log n + (log n) 2 =t)) operations, for arbitrary given t log n log log n, and on a CREW PRAM using O(t) time and O(n( p log n + log n=2 t=logn )) operations, for arbitrary given t log n. In addition, we are able to sort n arbitrary integers on a randomized CREW PRAM within the same resource bounds with high probability. In each case our algorithm is a factor of almost \Theta( p log n) closer to optimality than all previous algorithms for the stated problem in the stated model, and our third result matches the operation count of the best previous sequential algorithm. We also show that n integers in the range 1 : : m can be sorted in O((log n) 2 ) time with O(n) operations on an EREW PRAM using a nonstandard word length of O(log n log log n log m) bits, thereby greatly improving the upper bound on the word length necessary to sort integers with a linear t...

An optimal O(log log n) time parallel algorithm for string matching on CRCWPRAM is presented. It improves previous results of [G] and [V].

We classify functions in recursive graph theory in terms of how many queries to K (or # ## or # ### ) are required to compute them. We show that (1) binary search is optimal (in terms of the number of queries to K) for finding the chromatic number of a recursive graph and that no set of Turing degree less than 0 # will su#ce, (2) determining if a recursive graph has a finite chromatic number is # 2 -complete, and (3) binary search is optimal (in terms of the number of queries to # ### ) for finding the recursive chromatic number of a recursive graph and that no set of Turing degree less than 0 ### will su#ce. We also explore how much help queries to a weaker set may provide. Some of our results have analogues in terms of asking p questions at a time, but some do not. In particular, (p + 1)-ary search is not always optimal for finding the chromatic number of a recursive graph. Most of our results are also true for highly recursive graphs, though there are some interesting di#erenc...

We explore two ways of incorporating parallelism into priority queues. The first is to speed up the execution of individual priority operations so that they can be performed one operation per time step, unlike sequential implementations which require O(log N ) time steps per operation for an N element heap. We give an optimal parallel implementation that uses a linear array of O(log N ) processors. Second, we consider parallel operations on the priority queue. We show that using a d-dimensional array (constant d) of P processors we can insert or delete the smallest P elements from a heap in time O(P 1=d log 1\Gamma1=d P ), where the number of elements in the heap is assumed to be polynomial in P . We also show a matching lower bound, based on communication complexity arguments, for a range of deterministic implementations. Finally, using randomization, we show that the time can be reduced to the optimal O(P 1=d ) time with high probability. 1 Introduction Much of the theoret...

The problem of sorting n elements using p processors in a parallel comparison model is considered. Lower and upper bounds which imply that for p ³ n, the time complexity of this problem is Q( log(1 + p / n) logn ___________ ) are presented. This complements [AKS-83] in settling the problem since the AKS sorting network established that for pn the time complexity is Q( p nlogn ______ ). To prove the lower bounds we show that to achieve k logn parallel time, we need W(n 1 + 1/k ) processors. 1. Introduction Apparently, there is no problem in Computer Science which received more attention than sorting. [Kn-73], for instance, found that existing computers devote approximately a quarter of their time to sorting. The advent of parallel computers stimulated intensive research of the sorting with respect to various models of parallel computation. Extensive lists of references which recorded this activity are given in [Ak-85], [BHe-86] and [Th-83]. Most of the fastest serial and paral...

In this paper various algorithms for sorting on processor networks are considered. We focus on meshes, but the results can be generalized easily to other decomposable architectures. We consider the k-k sorting problem in which every PU initially holds k packets. We present well-known randomized and deterministic splitter-based sorting algorithms. We come with a new deterministic sorting algorithm which performs much better than previous ones. The number of routing steps is reduced by a refined deterministic splitter selection. Hereby deterministic sorting might become competitive with randomized sorting in practice. 1 Introduction 1.1 Problem and Machine Meshes. One of the most thoroughly investigated interconnection schemes for parallel computation is the n \Theta n mesh, in which n 2 processing units, PUs, are connected by a twodimensional grid of communication links. Its immediate generalizations are d-dimensional n \Theta \Delta \Delta \Delta \Theta n meshes. While meshes have ...

Problems involving strings arise in many areas of computer science and have numerous practical applications. We consider several problems from a theoretical perspective and provide efficient algorithms and lower bounds for these problems in sequential and parallel models of computation. In the sequential setting, we present new algorithms for the string matching problem improving the previous bounds on the number of comparisons performed by such algorithms. In parallel computation, we present tight algorithms and lower bounds for the string matching problem, for finding the periods of a string, for detecting squares and for finding initial palindromes.

The unbounded search problem was posed by Bentley and Yao. It is the problem of finding a key in a linearly ordered unbounded table, with the proviso that the number of comparisons is to be minimized. We show that Bentley and Yao's lower bound is essentially optimal, and we prove some new upper bounds for the unbounded search problem. We show how to solve this problem in parallel as well. 1. Introduction As posed in [BY76], unbounded search is the problem of searching for a key in a sorted table of unbounded size. The following two-player game is equivalent to the unbounded search problem: Player A chooses an arbitrary positive integer, n. Player B is allowed to ask whether an integer x is less than n. In general the number of questions that B has to ask in order to determine n is a function of n. In this paper, we present lower and upper bounds on the size of this function. The following theorem from [BY76] is instrumental in providing lower bounds on the number of questions needed i...