Heaps

(ヒープ)

Data Structures and Algorithms

5th lecture, October 31, 2019

http://www.sw.it.aoyama.ac.jp/2019/DA/lecture5.html

Martin J. Dürst

AGU

© 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, ...
Operations:

 

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

 

 

 

Heap

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:

 

Heap

A heap is (full definition):

The root always has the highest priority

We need the following operations for implementing a heap:

 

Invariant

 

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:

C:\Algorithms>irb
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.

 

Summary

 

Homework

  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)

 

Glossary

priority queue
順位キュー、優先順位キュー、優先順位付き待ち行列
complete binary tree
完全二分木
heap
ヒープ
internal node
内部節
restoration
修復
invariant
不変条件
sort
整列、ソート
decreasing (order)
降順
increasing (order)
昇順
join
合併
binomial queue/heap
2項キュー、2 項ヒープ
distribution
分布
layer violation
階層侵害