A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2018; you can also visit the original URL.
The file type is `application/pdf`

.

## Filters

##
###
An in-place sorting with O(nlog n) comparisons and O(n) moves

2005
*
Journal of the ACM
*

We present the first

doi:10.1145/1082036.1082037
fatcat:n36ky7vl6jfsdacyh3zc6dmcma
*in*-*place*algorithm for*sorting**an*array of size*n*that performs,*in*the worst case, at most*O*(*n*log*n*) element*comparisons**and**O*(*n*) element transports. ... This solves a long-standing open problem, stated explicitly, for example,*in*Munro*and*Raman [1992], of whether there exists a*sorting*algorithm that matches the asymptotic lower bounds on all computational ... The corresponding heap tree is thus of constant height, which results*in**an*algorithm*sorting**with**O*(*n*)*moves*,*O*(1) storage,*and**O*(*n*1+ε )*comparisons*. ...##
###
An In-Place Sorting with O(n log n) Comparisons and O(n) Moves
[article]

2003
*
arXiv
*
pre-print

We present the first

arXiv:cs/0305005v1
fatcat:zc5qqdgpyre4bohnzxjlb4xqqi
*in*-*place*algorithm for*sorting**an*array of size*n*that performs,*in*the worst case, at most*O*(*n*log*n*) element*comparisons**and**O*(*n*) element transports. ... .,*in*[J.I. Munro*and*V. Raman,*Sorting**with*minimum data movement, J. ... Our algorithm operates*in*-*place*,*with*at most 2n·log*n*+*o*(*n·log**n*) element*comparisons**and*(13+ε)·*n*element*moves**in*the worst case, for each*n*≥ 1. ...##
###
A deciding algorithm for linear isomorphism of types with complexity O(nlog 2(n))
[chapter]

1997
*
Lecture Notes in Computer Science
*

We describe

doi:10.1007/bfb0026989
fatcat:rooxkruyfbdariuve5xkjhoyme
*an*algorithm deciding if two types are linearly isomorphic*with*complexity*O*(*nlog*2 (*n*)). ... It is known, that ordinary isomorphisms (associativity*and*commutativity of \times", isomorphisms for \times" unit*and*currying) provide a complete axiomatisation of isomorphism of types*in*multiplicative ... Acknowledgements We would like to thank Michael Rittri*and*Roberto Di Cosmo for many stimulating discussions of the matter,*and*Glynn Winskel*and*U e Engberg for helpful attention to our work while at ...##
###
Algorithms for Moving Objects Databases

2003
*
Computer journal
*

*In*earlier work we have proposed

*an*approach based on abstract data types. Hence,

*moving*point or

*moving*region are viewed as data types

*with*suitable operations. ... Algorithms are meant to be used

*in*a database context; we also address filtering techniques

*and*practical issues such as large object management or numeric robustness

*in*the context of

*an*ongoing prototype ...

*In*any case the size of a is

*O*(M). For the second argument b

*and*for the result of

*an*operation, we use

*with*the same meaning

*N*

*and*R, respectively. ...

##
###
Sorting Short Keys in Circuits of Size o(n log n)
[article]

2020
*
arXiv
*
pre-print

We consider the classical problem of

arXiv:2010.09884v2
fatcat:ji2762hgevbpxijglqczbp5sxu
*sorting**an*input array containing*n*elements, where each element is described*with*a k-bit*comparison*-key*and*a w-bit payload. ... Specifically, we prove that there is a circuit*with*(k + w) ·*O*(*n*k) ·(log^**n*- log^* (w + k)) boolean gates capable of*sorting*any input array containing*n*elements, each described*with*a k-bit key*and*... This work is*in*part supported by*an*NSF CAREER Award under the award number CNS-1601879, a Packard Fellowship,*an*ONR YIP award,*and*a DARPA Brandeis award. ...##
###
Matrix Sort - A Parallelizable Sorting Algorithm

2016
*
International Journal of Computer Applications
*

It has a time complexity of

doi:10.5120/ijca2016910341
fatcat:bin4yjmxyzaivm2zbeecvvkf4a
*O*(*n*√*nlog*√*n*)*and*hence takes lesser time than existing*O*(*n*2 ) algorithms. ...*In*this paper, a new*sorting*algorithm called Matrix*sort*is introduced. This algorithm aims to*sort*the elements of a matrix without disturbing the matrix structure. ... Consider such*an*input matrix*with**n*elements organized*in*√*n*rows*and*√*n*columns. For such*an*input, the top-down operation ends only*in*the √*n*th iteration, for*an*input matrix*with**n*elements. ...##
###
Heap Sorting Based on Array Sorting

2017
*
Journal of Computer and Communications
*

A kind of heap

doi:10.4236/jcc.2017.512006
fatcat:7cpqc5iyxbapzdypoh7pi2x4cy
*sorting*method based on array*sorting*was proposed. Some advantages*and*disadvantages of it were discussed. It was compared*with*the traditional method of direct application. ...*In*the method, the ordered keywords*in*the array are put into the heap one by one after building*an*empty heap. This method needs relatively less space*and*is fit for ordered sequence. ... The lower bound of time complexity is*O*(*nlog*(2,*n*)*and*the worst case is*O*(*n*^2). ...##
###
Multiway In-Place Merging
[chapter]

2009
*
Lecture Notes in Computer Science
*

Then, for s =

doi:10.1007/978-3-642-03409-1_13
fatcat:3xgd5bnukjeubj3goudoar3bnu
*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. ... We conjecture that, using the algorithm described here as a subroutine, it is possible to devise*an*asymptotically efficient multiway*in*-*place*merging algorithm. ...##
###
A Heapify Based Parallel Sorting Algorithm

2008
*
Journal of Computer Science
*

Quick

doi:10.3844/jcssp.2008.897.902
fatcat:72zsdm5tyrbipfm3ykwce7ieci
*sort*is a*sorting*algorithm whose worst case running time is (*n*2 ) on*an*input array of*n*numbers. It is the best practical for*sorting*because it has the advantage of*sorting**in**place*. ... Problem statement: Behavior of quick*sort*is complex, we proposed*in*-*place*2m threads parallel heap*sort*algorithm which had advantage*in**sorting**in**place**and*had better performance than classical sequential ...*In*[10] , is proposed ultimate heap*sort*that is a variant of heap*sort*that*sorts**n*elements*in*(*nlog*2 (*n*+1)) time*in*the worst case by performing at most*nlog*2*n*+θ(*n*) key*comparisons**and**nlog*2*n*...##
###
Exploiting few inversions when sorting: Sequential and parallel algorithms

1996
*
Theoretical Computer Science
*

X can be

doi:10.1016/0304-3975(95)00256-1
fatcat:b32pw364yvgzhasajak577nvai
*sorted**in*-*place*, i.e. using only*O*(logn) bits of extra space,*in*time*O*(*n*log (Znv(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 0*n*log(z~wM> ( flog*n*, P 1 which is optimal*with*respect to the number of inversions. ... Introduction It is well known that Sl(*nlog**n*) time is necessary to*sort**n*elements*in*both the worst case*and*the average case*in*a*comparison*-based model of computation [21] . ...##
###
Efficient Algorithms for Two Generalized 2-Median Problems on Trees
[chapter]

2001
*
Lecture Notes in Computer Science
*

For this problem, Tamir [14] had

doi:10.1007/3-540-45678-3_65
fatcat:rxfrb2otfjf6plxigoyt7v2ujq
*an**O*(pn 2 )-time algorithm, while Gavish*and*Sridhar [6] had*an**O*(*nlog**n*)-time algorithm for the case of p=2. ... We solve both generalizations*in**O*(*nlog**n*) time, improving the previous ones from*O*(*n*2 ). We also study cases when linear time algorithms exist for the 2-median problem*and*the two generalizations. ... Gavish*and*Sridhar had*an**O*(*nlog**n*)-time algorithm, which runs Step 1*and*3*in**O*(*n*) time but needs*O*(*nlog**n*) time for Step 2. ...##
###
Computing with Noisy Information

1994
*
SIAM journal on computing (Print)
*

Each leaf is labeled

doi:10.1137/s0097539791195877
fatcat:qgqcx6bp75cohevdyibuvoq44m
*with*a permutation representing the*sorted*order for the input (for*sorting**and*merging) or*an*index*in*[1,*N*] (for selection*and*searching). A simple example is*in*order here. ...*In*the noisy*comparison*tree model, tight bounds are given on the number of noisy*comparisons*for searching,*sorting*, selection*and*merging. ... We thank Noga Alon*and*Yossi Azar for helpful discussions,*and*for directing us to some of the references. ...##
###
Association of Moving Objects Across Visual Sensor Networks

2012
*
Journal of Multimedia
*

normally distributed,

doi:10.4304/jmm.7.1.2-8
fatcat:4cc7sala7ffixohi3ccvothajm
*with*zero mean*and*variance σ 2 , we have: AIC(p; α) = K(*n*,σ) + R p /σ 2 + αp, (4) where K(*n*,σ) =*nlog*(2πσ 2 ) is a constant depending on the marginals of thexs. ... On lattice complexity, the computation process of this algorithm requires two matrixes*with*lattice size M×*N**and*a matrix*with*size M×*N*×8, the algorithm*in*the lattice complexity is*O*(M×*N*) ; It can be ... Service ontology mapping mechanism is analyzed*in*detail*and*semantic model is built*with*the study of the correlation across the geometry modeling service. ...##
###
Selection from read-only memory and sorting with minimum data movement

1996
*
Theoretical Computer Science
*

These include

doi:10.1016/0304-3975(95)00225-1
fatcat:cmbezgl5cfbdrgjljr6hdmrv4m
*an**O*(*n*"E) worst case algorithm*and**an**O*(*n*log log*n*) average case algorithm, both using a constant number of extra storage cells or indices. ... Here, we consider the scenario*in*which the data resides*in**an*array of read-only memory*and*hence the elements cannot be*moved*within the array. ...*An*array of*n*items can be*sorted*using*O*(n2 )*comparisons*, 0( 1) indices,*and*13n/2J data*moves**in*the worst case. Proof. We*place*elements of a non-trivial cycle as follows. ...##
###
Scalable parallel formulations of the barnes-hut method for n-body simulations

1994
*
Supercomputing, Proceedings
*

Coupled

doi:10.1145/602843.602846
fatcat:qguwievrqnfo3dqxxbck7leury
*with*parallel processing, these techniques hold the promise of large scale*n*-body simulations. ... We present*an*experimental evaluation of our schemes on a 256 processor nCUBE2*and*a 256 processor CM5. ... This work is also sponsored*in*part by MSI. Access to computing facilities was provided by Cray Research*and*by the Pittsburgh Supercomputing C enter. ...
« Previous

*Showing results 1 — 15 out of 526 results*