Why some heaps support constant-amortized-time decrease-key operations, and others do not

John Iacono, Özgür Özkan

    Research output: Chapter in Book/Report/Conference proceedingConference contribution

    Abstract

    A lower bound is presented which shows that a class of heap algorithms in the pointer model with only heap pointers must spend Ω(log log n/log log log n) amortized time on the Decrease-Key operation (given O(logn) amortized-time Extract-Min). Intuitively, this bound shows the key to having O(1)-time Decrease-Key is the ability to sort O(logn) items in O(logn) time; Fibonacci heaps [M. .L. Fredman and R. E. Tarjan. J. ACM 34(3):596-615 (1987)] do this through the use of bucket sort. Our lower bound also holds no matter how much data is augmented; this is in contrast to the lower bound of Fredman [J. ACM 46(4):473-501 (1999)] who showed a tradeoff between the number of augmented bits and the amortized cost of Decrease-Key. A new heap data structure, the sort heap, is presented. This heap is a simplification of the heap of Elmasry [SODA 2009: 471-476] and shares with it a O(loglogn) amortized-time Decrease-Key, but with a straightforward implementation such that our lower bound holds. Thus a natural model is presented for a pointer-based heap such that the amortized runtime of a self-adjusting structure and amortized lower asymptotic bounds for Decrease-Key differ by but a O(logloglogn) factor.

    Original languageEnglish (US)
    Title of host publicationAutomata, Languages, and Programming - 41st International Colloquium, ICALP 2014, Proceedings
    PublisherSpringer Verlag
    Pages637-649
    Number of pages13
    Volume8572 LNCS
    EditionPART 1
    ISBN (Print)9783662439470
    DOIs
    StatePublished - 2014
    Event41st International Colloquium on Automata, Languages, and Programming, ICALP 2014 - Copenhagen, Denmark
    Duration: Jul 8 2014Jul 11 2014

    Publication series

    NameLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
    NumberPART 1
    Volume8572 LNCS
    ISSN (Print)03029743
    ISSN (Electronic)16113349

    Other

    Other41st International Colloquium on Automata, Languages, and Programming, ICALP 2014
    CountryDenmark
    CityCopenhagen
    Period7/8/147/11/14

    Fingerprint

    Heap
    Time Constant
    Decrease
    Data structures
    Sort
    Lower bound
    Costs
    Simplification
    Data Structures
    Trade-offs
    Model

    ASJC Scopus subject areas

    • Computer Science(all)
    • Theoretical Computer Science

    Cite this

    Iacono, J., & Özkan, Ö. (2014). Why some heaps support constant-amortized-time decrease-key operations, and others do not. In Automata, Languages, and Programming - 41st International Colloquium, ICALP 2014, Proceedings (PART 1 ed., Vol. 8572 LNCS, pp. 637-649). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 8572 LNCS, No. PART 1). Springer Verlag. https://doi.org/10.1007/978-3-662-43948-7_53

    Why some heaps support constant-amortized-time decrease-key operations, and others do not. / Iacono, John; Özkan, Özgür.

    Automata, Languages, and Programming - 41st International Colloquium, ICALP 2014, Proceedings. Vol. 8572 LNCS PART 1. ed. Springer Verlag, 2014. p. 637-649 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 8572 LNCS, No. PART 1).

    Research output: Chapter in Book/Report/Conference proceedingConference contribution

    Iacono, J & Özkan, Ö 2014, Why some heaps support constant-amortized-time decrease-key operations, and others do not. in Automata, Languages, and Programming - 41st International Colloquium, ICALP 2014, Proceedings. PART 1 edn, vol. 8572 LNCS, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), no. PART 1, vol. 8572 LNCS, Springer Verlag, pp. 637-649, 41st International Colloquium on Automata, Languages, and Programming, ICALP 2014, Copenhagen, Denmark, 7/8/14. https://doi.org/10.1007/978-3-662-43948-7_53
    Iacono J, Özkan Ö. Why some heaps support constant-amortized-time decrease-key operations, and others do not. In Automata, Languages, and Programming - 41st International Colloquium, ICALP 2014, Proceedings. PART 1 ed. Vol. 8572 LNCS. Springer Verlag. 2014. p. 637-649. (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); PART 1). https://doi.org/10.1007/978-3-662-43948-7_53
    Iacono, John ; Özkan, Özgür. / Why some heaps support constant-amortized-time decrease-key operations, and others do not. Automata, Languages, and Programming - 41st International Colloquium, ICALP 2014, Proceedings. Vol. 8572 LNCS PART 1. ed. Springer Verlag, 2014. pp. 637-649 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); PART 1).
    @inproceedings{98ce112826a44a309a833826e64df60e,
    title = "Why some heaps support constant-amortized-time decrease-key operations, and others do not",
    abstract = "A lower bound is presented which shows that a class of heap algorithms in the pointer model with only heap pointers must spend Ω(log log n/log log log n) amortized time on the Decrease-Key operation (given O(logn) amortized-time Extract-Min). Intuitively, this bound shows the key to having O(1)-time Decrease-Key is the ability to sort O(logn) items in O(logn) time; Fibonacci heaps [M. .L. Fredman and R. E. Tarjan. J. ACM 34(3):596-615 (1987)] do this through the use of bucket sort. Our lower bound also holds no matter how much data is augmented; this is in contrast to the lower bound of Fredman [J. ACM 46(4):473-501 (1999)] who showed a tradeoff between the number of augmented bits and the amortized cost of Decrease-Key. A new heap data structure, the sort heap, is presented. This heap is a simplification of the heap of Elmasry [SODA 2009: 471-476] and shares with it a O(loglogn) amortized-time Decrease-Key, but with a straightforward implementation such that our lower bound holds. Thus a natural model is presented for a pointer-based heap such that the amortized runtime of a self-adjusting structure and amortized lower asymptotic bounds for Decrease-Key differ by but a O(logloglogn) factor.",
    author = "John Iacono and {\"O}zg{\"u}r {\"O}zkan",
    year = "2014",
    doi = "10.1007/978-3-662-43948-7_53",
    language = "English (US)",
    isbn = "9783662439470",
    volume = "8572 LNCS",
    series = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",
    publisher = "Springer Verlag",
    number = "PART 1",
    pages = "637--649",
    booktitle = "Automata, Languages, and Programming - 41st International Colloquium, ICALP 2014, Proceedings",
    edition = "PART 1",

    }

    TY - GEN

    T1 - Why some heaps support constant-amortized-time decrease-key operations, and others do not

    AU - Iacono, John

    AU - Özkan, Özgür

    PY - 2014

    Y1 - 2014

    N2 - A lower bound is presented which shows that a class of heap algorithms in the pointer model with only heap pointers must spend Ω(log log n/log log log n) amortized time on the Decrease-Key operation (given O(logn) amortized-time Extract-Min). Intuitively, this bound shows the key to having O(1)-time Decrease-Key is the ability to sort O(logn) items in O(logn) time; Fibonacci heaps [M. .L. Fredman and R. E. Tarjan. J. ACM 34(3):596-615 (1987)] do this through the use of bucket sort. Our lower bound also holds no matter how much data is augmented; this is in contrast to the lower bound of Fredman [J. ACM 46(4):473-501 (1999)] who showed a tradeoff between the number of augmented bits and the amortized cost of Decrease-Key. A new heap data structure, the sort heap, is presented. This heap is a simplification of the heap of Elmasry [SODA 2009: 471-476] and shares with it a O(loglogn) amortized-time Decrease-Key, but with a straightforward implementation such that our lower bound holds. Thus a natural model is presented for a pointer-based heap such that the amortized runtime of a self-adjusting structure and amortized lower asymptotic bounds for Decrease-Key differ by but a O(logloglogn) factor.

    AB - A lower bound is presented which shows that a class of heap algorithms in the pointer model with only heap pointers must spend Ω(log log n/log log log n) amortized time on the Decrease-Key operation (given O(logn) amortized-time Extract-Min). Intuitively, this bound shows the key to having O(1)-time Decrease-Key is the ability to sort O(logn) items in O(logn) time; Fibonacci heaps [M. .L. Fredman and R. E. Tarjan. J. ACM 34(3):596-615 (1987)] do this through the use of bucket sort. Our lower bound also holds no matter how much data is augmented; this is in contrast to the lower bound of Fredman [J. ACM 46(4):473-501 (1999)] who showed a tradeoff between the number of augmented bits and the amortized cost of Decrease-Key. A new heap data structure, the sort heap, is presented. This heap is a simplification of the heap of Elmasry [SODA 2009: 471-476] and shares with it a O(loglogn) amortized-time Decrease-Key, but with a straightforward implementation such that our lower bound holds. Thus a natural model is presented for a pointer-based heap such that the amortized runtime of a self-adjusting structure and amortized lower asymptotic bounds for Decrease-Key differ by but a O(logloglogn) factor.

    UR - http://www.scopus.com/inward/record.url?scp=84904174074&partnerID=8YFLogxK

    UR - http://www.scopus.com/inward/citedby.url?scp=84904174074&partnerID=8YFLogxK

    U2 - 10.1007/978-3-662-43948-7_53

    DO - 10.1007/978-3-662-43948-7_53

    M3 - Conference contribution

    AN - SCOPUS:84904174074

    SN - 9783662439470

    VL - 8572 LNCS

    T3 - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

    SP - 637

    EP - 649

    BT - Automata, Languages, and Programming - 41st International Colloquium, ICALP 2014, Proceedings

    PB - Springer Verlag

    ER -