The average complexity of deterministic and randomized parallel comparison sorting algorithms

N. Alon; Y. Azar

doi:10.1109/SFCS.1987.54

The average complexity of deterministic and randomized parallel comparison sorting algorithms

N. Alon, Y. Azar

School of Computer Science

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution › peer-review

Abstract

In practice, the average time of (deterministic or randomized) sorting algorithms seems to be more relevant than the worst case time of deterministic algorithms. Still, the many known complexity bounds for parallel comparison sorting include no nontrivial lower bounds for the average time required to sort by comparisons n elements with p processors (via deterministic or randomized algorithms). We show that for p ≥ n this time is Θ (log n/log(1 + p/n)), (it is easy to show that for p ≤ n the time is Θ (n log n/p) = Θ (log n/(p/n)). Therefore even the average case behaviour of randomized algorithms is not more efficient than the worst case behaviour of deterministic ones.

Original language	American English
Title of host publication	28th Annual Symposium on Foundations of Computer Science (sfcs 1987)
Publisher	IEEE
Pages	489-498
Number of pages	10
ISBN (Print)	0-8186-0807-2
DOIs	https://doi.org/10.1109/SFCS.1987.54
State	Published - 14 Oct 1987
Event	28th Annual Symposium on Foundations of Computer Science (sfcs 1987) - Los Angeles, CA, USA Duration: 12 Oct 1987 → 14 Oct 1987

Conference

Conference	28th Annual Symposium on Foundations of Computer Science (sfcs 1987)
Period	12/10/87 → 14/10/87

Keywords

Sorting
Phase change random access memory
Computer science
Parallel algorithms
Read-write memory
Decision trees

Access to Document

10.1109/SFCS.1987.54

https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=4568305

Cite this

@inproceedings{a3c642161dbf4789a9f70cfe43398ce7,

title = "The average complexity of deterministic and randomized parallel comparison sorting algorithms",

abstract = "In practice, the average time of (deterministic or randomized) sorting algorithms seems to be more relevant than the worst case time of deterministic algorithms. Still, the many known complexity bounds for parallel comparison sorting include no nontrivial lower bounds for the average time required to sort by comparisons n elements with p processors (via deterministic or randomized algorithms). We show that for p ≥ n this time is Θ (log n/log(1 + p/n)), (it is easy to show that for p ≤ n the time is Θ (n log n/p) = Θ (log n/(p/n)). Therefore even the average case behaviour of randomized algorithms is not more efficient than the worst case behaviour of deterministic ones.",

keywords = "Sorting, Phase change random access memory, Computer science, Parallel algorithms, Read-write memory, Decision trees",

author = "N. Alon and Y. Azar",

year = "1987",

month = oct,

day = "14",

doi = "10.1109/SFCS.1987.54",

language = "American English",

isbn = "0-8186-0807-2",

pages = "489--498",

booktitle = "28th Annual Symposium on Foundations of Computer Science (sfcs 1987)",

publisher = "IEEE",

note = "28th Annual Symposium on Foundations of Computer Science (sfcs 1987) ; Conference date: 12-10-1987 Through 14-10-1987",

}

TY - GEN

T1 - The average complexity of deterministic and randomized parallel comparison sorting algorithms

AU - Alon, N.

AU - Azar, Y.

PY - 1987/10/14

Y1 - 1987/10/14

N2 - In practice, the average time of (deterministic or randomized) sorting algorithms seems to be more relevant than the worst case time of deterministic algorithms. Still, the many known complexity bounds for parallel comparison sorting include no nontrivial lower bounds for the average time required to sort by comparisons n elements with p processors (via deterministic or randomized algorithms). We show that for p ≥ n this time is Θ (log n/log(1 + p/n)), (it is easy to show that for p ≤ n the time is Θ (n log n/p) = Θ (log n/(p/n)). Therefore even the average case behaviour of randomized algorithms is not more efficient than the worst case behaviour of deterministic ones.

AB - In practice, the average time of (deterministic or randomized) sorting algorithms seems to be more relevant than the worst case time of deterministic algorithms. Still, the many known complexity bounds for parallel comparison sorting include no nontrivial lower bounds for the average time required to sort by comparisons n elements with p processors (via deterministic or randomized algorithms). We show that for p ≥ n this time is Θ (log n/log(1 + p/n)), (it is easy to show that for p ≤ n the time is Θ (n log n/p) = Θ (log n/(p/n)). Therefore even the average case behaviour of randomized algorithms is not more efficient than the worst case behaviour of deterministic ones.

KW - Sorting

KW - Phase change random access memory

KW - Computer science

KW - Parallel algorithms

KW - Read-write memory

KW - Decision trees

UR - https://ieeexplore.ieee.org/document/4568305/

U2 - 10.1109/SFCS.1987.54

DO - 10.1109/SFCS.1987.54

M3 - Conference contribution

SN - 0-8186-0807-2

SP - 489

EP - 498

BT - 28th Annual Symposium on Foundations of Computer Science (sfcs 1987)

PB - IEEE

T2 - 28th Annual Symposium on Foundations of Computer Science (sfcs 1987)

Y2 - 12 October 1987 through 14 October 1987

ER -

The average complexity of deterministic and randomized parallel comparison sorting algorithms

Abstract

Conference

Keywords

Access to Document

Other files and links

Fingerprint

Cite this