Data Structures and Algorithms

5th lecture, October 31, 2019


Martin J. Dürst


© 2009-19 Martin J. Dürst 青山学院大学

Today's Schedule


Summary of Last Lecture


Last Week's Homework 1

Order the following orders of growth, and explain the reason for your order:

O(n2), O(n!), O(n log log n), O(n log n), O(20n)

Solution: O(n log log n) ⊂ O(n log n) ⊂ O(n2) ⊂ O(20n) ⊂ O(n!)

f(n) g(n) n0 (example solution) c (example solution)
n log log n n log n 2 1
n log n n2 2 1
n2 20n 1 1
20n n! 52 1
20n n! 20 2020/20! (=43099804)


Last Week's Homework 2

Write a simple program that uses the classes in 4ADTs.rb.
Use this program to compare the implementations.
Hint: Use the second part of 2search.rb as an example.


Last Week's Homework 3

Implement the priority queue ADT (Ruby or any other programming language is okay)

A priority queue keeps a priority for each data item.
In the simplest case, the only data is the priority.
The items with the highest priority leave the queue first.
Your implementation can use an array or a linked list or any other data structure.

Example solution: 5prioQ.rb


Priority Queue

Example from IT:
Queue for process management, ...


Simple Implementations

Complexity of Priority Queue Operations
Implementation Ordered array or linked list Unordered array or linked list
insert O(n) O(1)
getNext/findMax O(1) O(n)

Time complexity for each operation differs for different implementations.

But there is always an operation that needs O(n).

Is it possible to improve this?


Ideas for Improving Priority Queue Implementation





Tree Structure





A heap is a binary tree where each parent always has higher priority than its children

The root always has the highest priority





Problem: Balance




Complete Binary Tree

Definition based on tree structure:



A heap is (full definition):

The root always has the highest priority

We need the following operations for implementing a heap:




Implementing a Complete Binary Tree with an Array


Restoring Heap Invariants

If the priority at a given node is too high: Use heapify_up

If the priority at a given node is too low: Use heapify_down

Implementation: 5heap.rb


Implementing a Priority Queue with a Heap


Time Complexity of Heap Operations

Complexity of Operations
Implementation Heap (implemented as an Array)
insert O(log n)
findMax O(1)
getNext O(log n)


Heap Sort


How to use irb

irb: Interactive Ruby, a 'command prompt' for Ruby

Example usage:

irb(main):001:0> load '5heap.rb'
=> true
irb(main):002:0> h = Heap.new
=> #<Heap:0x2833d60 @array=[nil], @size=0>
irb(main):003:0> h.insert 3
=> #<Heap:0x2833d60 @array=[nil, 3], @size=1>
irb(main):004:0> h.insert_many 5, 7
=> #<Heap:0x2833d60 @array=[nil, 7, 3, 5], @size=3>

Alternative to load '5heap.rb': irb -r./5heap


Other Kinds of Heaps


Ideas to Improve Implementation of Priority Queue


Conceptual Layers

Caution: Implementation of heap sort directly uses the array. This is a layer violation.





  1. Cut the sorting cards, and bring them with you to the next lecture
  2. Shuffle the sorting cards, and try to find a fast way to sort them. Play against others (who is fastest?).
  3. Find five different applications of sorting (no need to submit)
  4. Implement joining two (normal) heaps (no need to submit)
  5. Think about the time complexity of creating a heap:
    heapify_down will be called n/2 times and may take up to O(log n) each time.
    Therefore, one guess for the overall time complexity is O(n log n).
    However, this upper bound can be improved by careful analysis.
    (no need to submit)



priority queue
complete binary tree
internal node
decreasing (order)
increasing (order)
binomial queue/heap
2項キュー、2 項ヒープ
layer violation