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

##
###
Average-case analysis of algorithms using Kolmogorov complexity

2000
*
Journal of Computer Science and Technology
*

We prove bounds on

doi:10.1007/bf02950402
fatcat:cvy26nh7vvcqplghhzg55mupum
*the**average*-*case*number*of*stacks (queues) required for*sorting*sequential or*parallel*Queuesort or Stacksort. ... Analyzing*the**average*-*case**complexity**of*algorithms is a very practical but very difficult problem in computer science. ...*Average**Case**of*Bubble*Sort*: An Example Generally speaking,*the*difficulty*of*analyzing*the**average*-*case**complexity*comes from*the*fact that one has to analyze*the*time*complexity*for all inputs*of*each ...##
###
A survey of randomness and parallelism in comparison problems
[chapter]

1998
*
Lecture Notes in Computer Science
*

A survey

doi:10.1007/3-540-64359-1_703
fatcat:igwdbljwqrhpvejxczrsioofne
*of*results for*the*problems*of*selection, merging and*sorting*in*the*Randomized*Parallel*Comparison Tree RPCT model is given. ...*The*results indicate that while randomization helps" in*the**case**of*selection, it does not provide any advantage for*the**cases**of*merging and*sorting*, in this model. ...*parallel**complexity**of*either merging or*sorting*, in*the*PCT model. ...##
###
Average-Case Complexity of Shellsort (Preliminary Version)
[chapter]

1999
*
Lecture Notes in Computer Science
*

*The*proof method is an incompressibility argument based on Kolmogorov

*complexity*. Using similar techniques,

*the*

*average*-

*case*

*complexity*

*of*several other

*sorting*algorithms is analyzed. ... We prove a general lower bound on

*the*

*average*-

*case*

*complexity*

*of*Shellsort:

*the*

*average*number

*of*data-movements (and com-paris~ns) made by a p-pass Shellsort for any incremental sequence is fl(pn HIP) ... This requires that (approximately) m :S efo = O(yri,).This yields an

*average*

*complexity*

*of*

*Parallel*-Stack-

*Sort*

*of*: On

*the*

*average*,

*the*number

*of*

*parallel*stacks required to

*sort*a permutation is D ( fo ...

##
###
Average-Case Complexity of Shellsort
[article]

1999
*
arXiv
*
pre-print

Using similar arguments, we analyze

arXiv:cs/9901010v1
fatcat:3hsatxce2jhbvcwmkedlbkd5um
*the**average*-*case**complexity**of*several other*sorting*algorithms. ... We prove a general lower bound on*the**average*-*case**complexity**of*Shellsort:*the**average*number*of*data-movements (and comparisons) made by a p-pass Shellsort for any incremental sequence is Ω (pn^1 + 1 ... Sedgewick for telling us many things about Shellsort and stack/queue*sorts*. ...##
###
Parallel comparison merging of many-ordered lists

1991
*
Theoretical Computer Science
*

.,

doi:10.1016/0304-3975(91)90279-b
fatcat:3l34djesvrb5vezpizdyzios3y
*Parallel*comparison merging*of*many-ordered lists (Note), Theoretical Computer Science 83 (1991) 275-285. ... Berkman for bringing*the*problem considered in this paper to my attention and M. Paterson for helpful remarks. ... Theorem 3.3 for m = n is*the*main result*of*[2] for*the**average**case**complexity**of**sorting*, i.e. that*the**average**case**complexity**of**sorting*n elements requires In order to prove Theorem 3.3 we use*the*...##
###
Analysis of Sorting Algorithms by Kolmogorov Complexity (A Survey)
[article]

2009
*
arXiv
*
pre-print

Recently, many results on

arXiv:0905.4452v1
fatcat:amug6iugczdb3b65kxjrxuemwu
*the*computational*complexity**of**sorting*algorithms were obtained using Kolmogorov*complexity*(*the*incompressibility method). ... Especially,*the*usually hard*average*-*case*analysis is ammenable to this method. ... Hence,*the**average**complexity**of**Parallel*-Stack-*Sort*is O( √ n) · n − 1 n + n · 1 n = O( √ n). 2 Theorem 6 On*average*(uniform distribution),*the*number*of**parallel*stacks required to*sort*a permutation ...##
###
Performance Evaluation of Parallel Sorting Algorithms on IMAN1 Supercomputer

2016
*
International Journal of Advanced Science and Technology
*

Results show that

doi:10.14257/ijast.2016.95.06
fatcat:u7ite3chd5hkbnhmjf4mdw5cye
*the*run time*of**parallel*Quicksort algorithm outperforms both Merge*sort*and Merge-Quicksort algorithms. ... Moreover, on large number*of*processors,*parallel*Quicksort achieves*the*best*parallel*efficiency*of*up to 88%, while Merge*sort*and Merge-Quicksort algorithms achieve up to 49% and 52%*parallel*efficiency ...*The*time*complexity*is O(n 2 ). Figure 5 illustrate*the**complexity**of*Quicksort in*the*best*case*and*average**case*, respectively. ...##
###
Performance Evaluation of Parallel Bubble Sort Algorithm on Supercomputer IMAN1

2019
*
Social Science Research Network
*

*Parallel*

*sorting*algorithms order a set

*of*elements USING MULTIPLE processors in order to enhance

*the*performance

*of*sequential

*sorting*algorithms. ... In this paper,

*the*running time,

*parallel*speedup and

*parallel*efficiency

*OF*

*PARALLEL*bubble

*sort*is evaluated and measured. ... Sequential Bubble

*Sort*Analysis Bubble

*sort*has worst-

*case*and

*average*

*complexity*both О(n 2 ), where n is

*the*number

*of*items being

*sorted*. ...

##
###
A General Framework for Sorting Large Data Sets Using Independent Subarrays of Approximately Equal Length

2022
*
IEEE Access
*

*The*third experiment shows

*the*effectiveness

*of*

*the*proposed

*parallel*framework to

*the*

*parallel*

*sorting*based on

*the*random-access machine model. ...

*The*time

*complexity*analyses

*of*

*the*proposed framework demonstrate an improvement compared to

*the*conventional Merge and Quick

*sorting*algorithms. ... In

*the*worst,

*average*, and best

*cases*

*of*

*the*Merge-

*sort*,

*the*time

*complexity*is O(N log N ), while

*the*time

*complexity*for

*the*worst-

*case*

*of*

*the*Quick-

*sort*is O(N 2 ), and that for

*the*

*average*and best ...

##
###
Page 2947 of Mathematical Reviews Vol. , Issue 95e
[page]

1995
*
Mathematical Reviews
*

We study it from

*the*point*of*view*of**average**case*analysis. As a matter*of*fact,*the**complexity**of*these algorithms varies greatly between*the*worst*case*and*the*best*case*. ... Summary: “*The**parallel**complexity**of*various operations on*sorted*sets is studied. Let X and Y be two*sorted*sets*of*respective sizes n and m,n>m. W.J. Paul, U. Vishkin and H. ...##
###
Effect of Parallelization, Execution Time and Inter-process Communication on Sorting Techniques using Message Passing Interface

2014
*
International Journal of Computer Applications
*

Using MPI,

doi:10.5120/17681-8524
fatcat:xbpf6sxhg5gh5jcsm3z4h3j43q
*parallelization*on five*sorting*techniques which are selection*sort*, bubble*sort*, quick*sort*, insertion*sort*and shell*sort*have been implemented. ... So as*the*number*of*processors increase,*the*amount*of*work done by each processor will be decrease regardless*the*effect*of**the*number*of*physical cores used. ... Shell*Sort*:*Complexity*:*Complexity*is nearly quadratic in nature. [7]*Average**case*: approximately O(n 3/2 ) Method: •*The*original array is divided into sub arrays according to*the*span value. ...##
###
Large-small Sorting for Successive Cancellation List Decoding of Polar Codes

2020
*
IEEE Access
*

To reduce

doi:10.1109/access.2020.2996016
fatcat:rit4tvzjerfploeyl6vqto4rvi
*the*latency*of**the*metric*sorting*, this paper proposes a new*sorting*method derived by analyzing path extension*cases*encountered in SCL decoding. ... Combined with*the*state-*of*-*the*-art*sorting*method,*the*proposed method reduces*the**average*SCL decoding latency for a (1024, 512) polar code by 33.1% when*the*list size is 8. ...*The*proposed method is to adaptively replace*the*large*sorting*with a*parallel*small*sorting*, which is derived by analyzing path extension*cases*. ...##
###
Page 3790 of Mathematical Reviews Vol. , Issue 84i
[page]

1984
*
Mathematical Reviews
*

Author’s summary: “It is shown that a large class

*of*continuous models for*the**average**case*analysis*of*many*sorting*algorithms (including quicksort, Shell’s*sort*, heapsort, insertion*sort*) will display ... Author’s summary: “We give a detailed survey*of**the*small number*of*existing papers on*parallel*methods*of*merging and*sorting*data files in*the*internal storage*of*multiprocessor computers. ...##
###
Noisy sort, a memory-intensive sorting algorithm

1989
*
Linear Algebra and its Applications
*

A table-lookup technique for

doi:10.1016/0024-3795(89)90484-9
fatcat:dvu5alb4rzhnbo6bwgx3n6ewya
*sorting*is developed. It is a highly*parallel*method which develops an approximation to*the**sort*through a single access to an associative memory. ... A postprocessing step is intended to complete*the**sort*.*The*scheme is most effective for special data classes. ...*The*authors thank Dr. Craig Douglas and Dr. Andrew Winkler for stimulating discussions on these topics. ...##
###
Parallel Processing of Sorting and Searching Algorithms Comparative Study

2018
*
Modern Applied Science
*

Each one

doi:10.5539/mas.v12n4p143
fatcat:rbycnsi4jvbavbf2tmxu6w6ipy
*of**the**sort*and search algorithms was tested in worst,*average*and best*case*scenarios. ... Much*of**the*software recently consumes a long period*of*time both to*sort*and search datasets, and thus optimizing these algorithms becomes a priority. ... (Kumari & Chakraborty, 2015) a statistical comparative study*of**sorting*algorithms, viz. Quick*sort*, Heap*sort*and K*sort*with a study*of*time*complexity*for each optimal*average**case**complexity*. ...
« Previous

*Showing results 1 — 15 out of 310,579 results*