scholarly journals Sort Integers into a Linked List

2020 ◽  
Vol 13 (1) ◽  
pp. 51
Author(s):  
Yijie Han ◽  
Hemasree Koganti ◽  
Nikita Goyal
Keyword(s):  
Constant Time ◽  
Linked List ◽  
Pram Model ◽  
Crcw Pram

We show that n integers in {0, 1, …, m-1} can be sorted into a linked list in constant time using nlogm processors on the Priority CRCW PRAM model, and they can be sorted into a linked list in O(loglogm/logt) time using nt processors on the Priority CRCW PRAM model.

scholarly journals Parallel Merging and Sorting on Linked List

2021 ◽  
Vol 10 (2) ◽  
Author(s):  
Yijie Han ◽  
Sreevalli Tata
Keyword(s):  
Constant Time ◽  
Real Numbers ◽  
Linked List ◽  
Pram Model ◽  
Linked Lists

We study linked list sorting and merging on the PRAM model. In this paper we show that n real numbers can be sorted into a linked list in constant time with n2+e processors or in ) time with n2 processors. We also show that two sorted linked lists of n integers in {0, 1, …, m}  can be merged into one sorted linked list in O(log(c)n(loglogm)1/2) time using n/(log(c)n(loglogm)1/2)  processors, where c is an arbitrarily large constant.

SUB-LOGARITHMIC ALGORITHMS FOR THE LARGEST EMPTY RECTANGLE PROBLEM

1993 ◽  
Vol 03 (01) ◽  
pp. 79-85
Author(s):  
STEPHAN OLARIU ◽  
WENHUI SHEN ◽  
LARRY WILSON
Keyword(s):  
Parallel Algorithms ◽  
Erew Pram ◽  
Pram Model ◽  
The Common ◽  
Crcw Pram ◽  
Natural Way

We show that the Largest Empty Rectangle problem can be solved by reducing it, in a natural way, to the All Nearest Smaller Values problem. We provide two classes of algorithms: the first one assumes that the input points are available sorted by x (resp. y) coordinate. Our algorithm corresponding to this case runs in O(log log n) time using [Formula: see text] processors in the Common-CRCW-PRAM model. For unsorted input, we present algorithms that run in [Formula: see text] time using [Formula: see text] processors in the Common-CRCW-PRAM, or in O( log n) time using [Formula: see text] processors in the EREW-PRAM model. No sub-logarithmic time parallel algorithms have been previously reported for this problem.

A SIMPLE PARALLEL ALGORITHM FOR THE SINGLE FUNCTION COARSEST PARTITION PROBLEM

1994 ◽  
Vol 04 (04) ◽  
pp. 437-445 ◽  
Author(s):  
CLIVE N. GALLEY ◽  
COSTAS S. ILIOPOULOS
Keyword(s):  
Parallel Algorithm ◽  
Parallel Computation ◽  
Simple Algorithm ◽  
Partition Problem ◽  
Pram Model ◽  
Single Function ◽  
Crcw Pram

This paper shows a simple algorithm for solving the single function coarsest partition problem on the CRCW PRAM model of parallel computation using O(n) processors in O( log n) time with O(n1+ε) space.

scholarly journals SEQUENTIAL AND PARALLEL ALGORITHMS FOR THE k CLOSEST PAIRS PROBLEM

1995 ◽  
Vol 05 (03) ◽  
pp. 273-288 ◽  
Author(s):  
HANS-PETER LENHOF ◽  
MICHIEL SMID
Keyword(s):  
Decision Tree ◽  
Parallel Algorithms ◽  
Dimensional Space ◽  
Decision Tree Model ◽  
Sequential Algorithm ◽  
Tree Model ◽  
Parallel Time ◽  
Parallel Version ◽  
Pram Model ◽  
Crcw Pram

Let S be a set of n points in D-dimensional space, where D is a constant, and let k be an integer between 1 and [Formula: see text]. A new and simpler proof is given of Salowe’s theorem, i.e., a sequential algorithm is given that computes the k closest pairs in the set S in O(n log n+k) time, using O(n+k) space. The algorithm fits in the algebraic decision tree model and is, therefore, optimal. Salowe’s algorithm seems difficult to parallelize. A parallel version of our algorithm is given for the CRCW-PRAM model. This version runs in O((log n)2 log log n) expected parallel time and has an O(n log n log log n+k) time-processor product. Finally, actual running times are given of an implementation of our sequential algorithm.

PARALLEL VERTEX COLOURING OF INTERVAL GRAPHS

1999 ◽  
Vol 10 (01) ◽  
pp. 19-31 ◽  
Author(s):  
G. SAJITH ◽  
SANJEEV SAXENA
Keyword(s):  
Chromatic Number ◽  
Interval Graph ◽  
Interval Graphs ◽  
Chromatic Numbers ◽  
Erew Pram ◽  
Pram Model ◽  
Interval Representation ◽  
Left And Right ◽  
Crcw Pram ◽  
Vertex Colouring

Evidence is given to suggest that minimally vertex colouring an interval graph may not be in NC 1. This is done by showing that 3-colouring a linked list is NC 1-reducible to minimally colouring an interval graph. However, it is shown that an interval graph with a known interval representation and an O(1) chromatic number can be minimally coloured in NC 1. For the CRCW PRAM model, an o( log n) time, polynomial processors algorithm is obtained for minimally colouring an interval graph with o( log n) chromatic number and a known interval representation. In particular, when the chromatic number is O(( log n)1-ε), 0<ε<1, the algorithm runs in O( log n/ log log n) time. Also, an O( log n) time, O(n) cost, EREW PRAM algorithm is found for interval graphs of arbitrary chromatic numbers. The following lower bound result is also obtained: even when the left and right endpoints of the interval are separately sorted, minimally colouring an interval graph needs Ω( log n/ log log n) time, on a CRCW PRAM, with a polynomial number of processors.

Optimization in Cost of Sorting by CRCW PRAM Model

2020 ◽  
Author(s):  
Sandeep Kumar Gill ◽  
Anju Sharma
Keyword(s):  
Pram Model ◽  
Crcw Pram

A CONSTANT TIME PARALLEL DETECTION OF REPETITIONS

1999 ◽  
Vol 09 (01) ◽  
pp. 81-92 ◽  
Author(s):  
EMMANUEL DELACOURT ◽  
JEAN-FREDERIC MYOUPO ◽  
DAVID SEME
Keyword(s):  
Parallel Computation ◽  
Selective Reduction ◽  
Constant Time ◽  
New Model ◽  
Parallel Detection ◽  
Erew Pram ◽  
Time Solution ◽  
Parallel Prefix ◽  
The One ◽  
Crcw Pram

Recently Akl and al. introduced a new model of parallel computation, called BSR (broadcasting with selective reduction) and showed that it is more powerful than any CRCW PRAM and yet requires no more resources (asymptotically) for implementation than even EREW PRAM [2,3,4]. The model allows constant time solutions to sorting, parallel prefix and other problems. In this paper, we describe constant time solution to the detection of repetitions (with overlapping) problem using the one criterion BSR model. This is the first constant time solution to this problem on any model of computation. If the problem is only to detect the existence of any repetition then n processors suffice, where n is the length of the string. If all repetitions are to be found then [Formula: see text] processors suffice in our algorithm.

Parallel Computations of Levenshtein Distances

1997 ◽  
Author(s):  
A. Apostolico ◽  
M.J. Atallah
Keyword(s):  
Shared Memory ◽  
Search Tree ◽  
Primary Objective ◽  
Sequential Algorithm ◽  
Memory Location ◽  
Pram Model ◽  
Crew Pram ◽  
Algorithmic Design ◽  
Topological Sorting ◽  
Crcw Pram

This chapter discusses parallel solutions for the string editing problem introduced in Chapter 5. The model of computation used is the synchronous, shared - memory machine referred to as PRAM and discussed also earlier in this book. The algorithms of this chapter are based on the CREW and CRCW variants of the PRAM. In the CREW - PRAM model of parallel computation concurrent reads are allowed but no two processors can simultaneously attempt to write in the same memory location (even if they are trying to write the same thing). The CRCW - PRAM differs from the CREW - PRAM in that it allows many processors to attempt simultaneous writes in the same memory location: in any such common-write contest, only one processor succeeds, but it is not known in advance which one. The primary objective of PRAM algorithmic design is to devise algorithms that are both fast and efficient for problems in a particular class called NC. Problems in NC are solvable in O(logo(1) n) parallel time by a PRAM using a polynomial number of processors. In order for an algorithm to be both fast and efficient, the product of its time and processor complexities must fall within a polylog factor of the time complexity of the best sequential algorithm for the problem it solves. This goal has been elusive for many simple problems, such as topological sorting of a directed acyclic graph and finding a breadth-first search tree of a graph, which are trivially in NC. For some other problems in NC, it seems counter-intuitive at first that any fast and efficient algorithm may exist, due to the overwhelming number of simultaneous subproblems that arise at some point of the computation. Such is the case of the string-editing problem. This chapter will show that string editing can be solved in O((log n)2) time and O(n2/ log n) processors on the CREW-PRAM, and in O(log n loglog n) time and O(n2/ loglogn) processors on the CRCW-PRAM. Throughout, it will be convenient to analyze our algorithms using the time and work (i.e., number of operations) complexities.

FAILURE-SENSITIVE ANALYSIS OF PARALLEL ALGORITHMS WITH CONTROLLED MEMORY ACCESS CONCURRENCY

2007 ◽  
Vol 17 (02) ◽  
pp. 153-168 ◽  
Author(s):  
CHRYSSIS GEORGIOU ◽  
ALEXANDER RUSSELL ◽  
ALEXANDER A. SHVARTSMAN
Keyword(s):  
Deterministic Algorithm ◽  
Memory Access ◽  
Work Efficiency ◽  
Sensitive Analysis ◽  
Abstract Problem ◽  
Work Complexity ◽  
Pram Model ◽  
All Solutions ◽  
Processing Steps ◽  
Crcw Pram

The abstract problem of using P failure-prone processors to cooperatively update all locations of an N-element shared array is called Write-All. Solutions to Write-All can be used iteratively to construct efficient simulations of PRAM algorithms on failure-prone PRAMS. Such use of Write-All in simulations is abstracted in terms of the iterative Write-All problem. The efficiency of the algorithmic solutions for Write-All and iterative Write-All is measured in terms of work complexity where all processing steps taken by the processors are counted. This paper considers determinitic solutions for the Write-All and iterative Write-All problems in the fail-stop synchronous CRCW PRAM model where memory access concurrency needs to be controlled. A deterministic algorithm of Kanellakis, Michailidis, and Shvartsman [16] efficiently solves the Write-All problem in this model, while controlling read and write memory access concurrency. However it was not shown how the number of processor failures f affects the work efficiency of the algorithm. The results herein give a new analysis of the algorithm [16] that obtain failure-sensitive work bounds, while retaining the known memory access concurrency bounds. Specifically, the new result expresses the work bound as a function of N, Pandf. Another contribution in this paper is the new failure-sensitive analysis for iterative Write-All with controlled memory access concurrency. This result yields tighter bounds on work (vs. [16]) for simulations of PRAM algorithms on fail-stop PRAMS.

Sign in / Sign up

Export Citation Format

Share Document