# Heaps by T1u2o2L

VIEWS: 14 PAGES: 38

• pg 1
```									    Heaps

 Chapter 10 has several
programming projects, including a
project that uses heaps.
 This presentation shows you what
a heap is, and demonstrates two of
the important heap algorithms.
 This chapter also takes a look at
B-trees
Data Structures
and Other Objects
Using Java
Heaps

A heap is a
certain kind of
complete
binary tree.
Heaps
Root

A heap is a
certain kind of
complete
binary tree.

When a complete
binary tree is built,
its first node must be
the root.
Heaps
Left child
Complete                of the
binary tree.            root

The second node is
always the left child
of the root.
Heaps

Right child
Complete                                     of the
binary tree.                                   root

The third node is
always the right child
of the root.
Heaps

Complete
binary tree.

The next nodes
always fill the next
level from left-to-right.
Heaps

Complete
binary tree.

The next nodes
always fill the next
level from left-to-right.
Heaps

Complete
binary tree.

The next nodes
always fill the next
level from left-to-right.
Heaps

Complete
binary tree.

The next nodes
always fill the next
level from left-to-right.
Heaps

Complete
binary tree.
Heaps
45
A heap is a
certain kind             35                  23
of complete
binary tree.        27        21        22        4

19
Each node in a heap
contains a key that
can be compared to
other nodes' keys.
Heaps
45
A heap is a
certain kind             35                  23
of complete
binary tree.        27        21        22        4

19
The "heap property"
requires that each
node's key is >= the
keys of its children
Adding a Node to a Heap
45
¶ Put the new node in the
next available spot.
35                   23
 Push the new node
upward, swapping with
its parent until the new      27         21        22        4
node reaches an
acceptable location.     19         42
Adding a Node to a Heap
45
¶ Put the new node in the
next available spot.
35                   23
 Push the new node
upward, swapping with
its parent until the new      42         21        22        4
node reaches an
acceptable location.     19         27
Adding a Node to a Heap
45
¶ Put the new node in the
next available spot.
42                   23
 Push the new node
upward, swapping with
its parent until the new      35         21        22        4
node reaches an
acceptable location.     19         27
Adding a Node to a Heap
45
 The parent has a key
that is >= new node, or
42                   23
 The node reaches the
root.
 The process of pushing
35         21        22        4
the new node upward
is called               19         27
reheapification
upward.
Removing the Top of a Heap
45
¶   Move the last node onto
the root.
42                   23

35         21        22        4

19         27
Removing the Top of a Heap
27
¶   Move the last node onto
the root.
42                  23

35        21        22        4

19
Removing the Top of a Heap
27
¶ Move the last node onto
the root.
42                  23
 Push the out-of-place
node downward,
swapping with its larger      35        21        22        4
child until the new node
reaches an acceptable    19
location.
Removing the Top of a Heap
42
¶ Move the last node onto
the root.
27                  23
 Push the out-of-place
node downward,
swapping with its larger      35        21        22        4
child until the new node
reaches an acceptable    19
location.
Removing the Top of a Heap
42
¶ Move the last node onto
the root.
35                  23
 Push the out-of-place
node downward,
swapping with its larger      27        21        22        4
child until the new node
reaches an acceptable    19
location.
Removing the Top of a Heap
42
 The children all have
keys <= the out-of-place
35                  23
node, or
 The node reaches the
leaf.                         27        21        22        4
 The process of pushing
the new node             19
downward is called
reheapification
downward.
Implementing a Heap
42
   We will store the
data from the            35             23
nodes in a
partially-filled    27        21
array.

An array of data
Implementing a Heap
42
   Data from the root
goes in the               35             23
first
location             27        21
of the
array.
42

An array of data
Implementing a Heap
42
   Data from the next
row goes in the              35             23
next two array
locations.              27        21

42    35     23

An array of data
Implementing a Heap
42
   Data from the next
row goes in the               35             23
next two array
locations.               27        21

42    35     23   27    21

An array of data
Implementing a Heap
42
   Data from the next
row goes in the               35              23
next two array
locations.               27        21

42    35     23   27    21

An array of data
We don't care what's in
this part of the array.
Implementation
42
   The links between the tree's
nodes are not actually stored as
35           23
pointers, or in any other way.
   The only way we "know" that
"the array is a tree" is from the 27    21
way we manipulate the data.

42     35    23     27     21

An array of data
Implementation
42
   If you know the index of a
node, then it is easy to figure
35             23
out the indexes of that node's
parent and children. Formulas
are given in the book.              27          21

42     35      23      27         21

[0]    [1]     [2]     [3]        [4]
Summary

 A heap is a complete binary tree, where the entry
at each node is greater than or equal to the entries
in its children.
 To add an entry to a heap, place the new entry at
the next available spot, and perform a
reheapification upward.
 To remove the biggest entry, move the last node
onto the root, and perform a reheapification
downward.
Depth of a binary search tree

   The first tree has a large depth that would not have
to be if it was like the more balanced second tree
Count 1                6                              5
Count 1
4               100                3               100
1                6         150      1           4       6     150

2        5                          2   4       6

4                                       Count 2
3           Count 2
B-trees

 Problem  of Unbalanced Trees
 Solutions
 Allinvolve trees whose depth remains small
 Could balance trees periodically
 AVL trees
 Red-Black Trees

 We’ll   look at B-trees
B-Tree Rules

 Depends  on a positive constant integer
called MINIMUM
 Rule 1: The root may have as few as one
element (or none if no children) ; every
other node has at least MINIMUM elements
 Rule 2: The maximum number of elements
in a node is twice the value of MINIMUM

 Rule  3: The elements of each B-tree node
are stored in a partially filled array, sorted
from the smallest element (at index 0) to the
largest element (at the final position of the
array)
 Rule 4: The number of subtrees below node
depends on how many elements are in a
node: always one more
Subtrees below a B-tree node

 Rule   5: For any non-leaf node
 An element at index i is greater than all the
elements in subtree number i of the node
 An element at index i is less than all the
elements in subtree number i+1 of the node
A B-tree is balanced
 Rule 6: Every leaf in a B-tree has the same
depth
Sample B-tree

6

2 and 4                     9

1        3       5        7 and 8        10
Every child of the root node is also the root node of a
smaller B-tree
Non-leaf node with two elements

93 and 107

Subtree 0     Subtree 1   Subtree 2
Searching for a number

Subset [0]                   dataCount =1
childCount=2
6
Subset[1]

2 and 4               9

1       3     5       7 and 8      10

```
To top