Data Structures and Algorithm Analysis Priority Queues (Heaps) - PowerPoint PPT Presentation

1 / 30
About This Presentation
Title:

Data Structures and Algorithm Analysis Priority Queues (Heaps)

Description:

Data Structures and Algorithm Analysis Priority Queues (Heaps) Lecturer: Jing Liu Email: neouma_at_mail.xidian.edu.cn Homepage: http://see.xidian.edu.cn/faculty/liujing – PowerPoint PPT presentation

Number of Views:148
Avg rating:3.0/5.0
Slides: 31
Provided by: educ5398
Category:

less

Transcript and Presenter's Notes

Title: Data Structures and Algorithm Analysis Priority Queues (Heaps)


1
Data Structures and Algorithm AnalysisPriority
Queues (Heaps)
  • Lecturer Jing Liu
  • Email neouma_at_mail.xidian.edu.cn
  • Homepage http//see.xidian.edu.cn/faculty/liujing

2
General Idea
  • Example Suppose there are a sequence of jobs are
    sent to a printer. Although jobs sent to a
    printer are generally placed on a queue, this
    might not always be the best thing to do.
  • For instance, if, when the printer becomes
    available, there are several 1-page jobs and one
    100-page job, it might be reasonable to make the
    long job go last, even if it is not the last job
    submitted.
  • This particular application seems to require a
    special kind of queue, known as a priority queue.

3
Model
  • A priority queue is a data structure that allows
    at least the following two operations
  • (1) Insert is the equivalent of Enqueue
  • (2) DeleteMin finds, returns, and removes the
    minimum element in the priority queue.

Insert(H)
DeleteMin(H)
Priority Queue H
4
Simple Implementations
  • There are several obvious ways to implement a
    priority queue. We could use a simple linked
    list, performing insertions at the front and
    traversing the list to delete the minimum.
  • Alternatively, we could insist that the list be
    kept always sorted.
  • Another way of implementing priority queues would
    be to use a binary search tree. Recall that the
    only element we ever delete is the minimum.
    Repeatedly removing a node that is in the left
    subtree would seem to hurt the balance of the
    tree by making the right subtree heavy.

5
Binary Heap
  • The implementation we will use is known as a
    binary heap.
  • Like binary search trees, binary heaps have two
    properties, namely, a structure property and a
    heap order property.

6
Structure Property
  • Structure property A heap is a binary tree that
    is completely filled, with the possible exception
    of the bottom level, which is filled from left to
    right. Such a tree is known as a complete binary
    tree.

A
B
C
F
D
E
G
H
I
J
7
Structure Property
  • An important observation is that because a
    complete binary tree is so regular, it can be
    represented in an array and no pointers are
    necessary.
  • For any element in array position i, the left
    child is in position 2i, the right child is in
    the cell after that left child (2i1), and the
    parent is in position ?i/2?.

8
Structure Property
A
B
C
F
D
E
G
H
I
J
I
A
C
B
E
D
G
F
H
J
0
1
2
3
4
5
6
7
8
10
11
12
13
9
9
Structure Property
  • Thus, not only are pointers not required, but the
    operations required to traverse the tree are
    extremely simple and likely to be very fast on
    most computers.
  • The only problem with this implementation is that
    an estimate of the maximum heap size is required
    in advance.
  • A heap data structure will then consist of an
    array (of whatever type the key is) and an
    integer representing the maximum and current heap
    sizes.
  • Figure 6.4 shows a typical priority queue
    declaration.

10
Structure Property
Struct HeapStruct int Capacity
int Size elementType Elements
Initialize(int MaxElements) Line 3
Hmalloc(sizeof(struct HeapStruct)) Line
6 H-gtElements
malloc((MaxElements1)sizeof(ElementType))
11
Heap Order Property
  • The property that allows operations to be
    performed quickly is the heap order property.
  • Since we want to be able to find the minimum
    quickly, it makes sense that the smallest element
    should be at the root.
  • If we consider that any subtree should also be a
    heap, then any node should be smaller than all of
    its descendants.

12
Heap Order Property
  • Applying this logic, we arrive at the heap order
    property In a heap, for every node X, the key in
    the parent of X is smaller than (or equal to) the
    key in X, with the exception of the root (which
    is has no parent).
  • Analogously, we can declare a (max) heap, which
    enables us to efficiently find and remove the
    maximum element, by changing the heap order
    property. Thus, a priority queue can be used to
    find either a minimum or a maximum, but this
    needs to be decided ahead of time.

13
Basic Heap Operations
  • It is easy (both conceptually and practically) to
    perform the two required operations, namely
    Insert and DeleteMin.
  • All the work involves ensuring that the heap
    order property is maintained.

14
Basic Heap Operations
  • Insert To insert an element X into the heap, we
    create a hole in the next available location,
    since otherwise the tree will not be complete.
  • If X can be placed in the hole without violating
    heap order, then we do so and are done.
  • Otherwise we slide the element that is in the
    holes parent node into the hole, thus bubbling
    the hole up towards the root.
  • We continue this process until X can be placed in
    the hole.

15
Basic Heap Operations
13
Example
21
16
Insert 14
24
31
19
68
26
65
32
Original Tree
16
Basic Heap Operations
13
13
21
16
21
16
24
31
19
24
31
19
68
68
26
26
65
65
32
32
17
Basic Heap Operations
13
13
21
16
21
16
24
19
24
19
31
68
68
26
26
65
32
65
32
31
18
Basic Heap Operations
13
13
21
16
16
24
19
24
19
21
68
68
26
26
65
32
65
32
31
31
19
Basic Heap Operations
13
13
16
16
14
24
19
24
19
21
21
68
68
26
26
65
32
65
32
31
31
20
Basic Heap Operations
  • DeleteMin DeleteMins are handled in a similar
    manner as insertions. Finding the minimum is
    easy the hard part is removing it.
  • When the minimum is removed, a hole is created at
    the root. Since the heap now becomes one smaller,
    it follows that the last element X in the heap
    must move some where in the heap.

21
Basic Heap Operations
  • If X can be placed in the hole, then we are done.
    This is unlikely, so we slide the smaller of the
    holes children into the hole, thus pushing the
    hole down one level.
  • We repeat this step until X can be placed in the
    hole. Thus, our action is to place X in its
    correct spot along a path from the root
    containing minimum children.

22
Basic Heap Operations
13
Example
Delete the minimum key
16
14
21
19
19
68
26
65
31
32
Original Tree
23
Basic Heap Operations
13
16
14
16
14
19
19
21
21
19
19
68
68
26
26
65
32
31
65
31
32
24
Basic Heap Operations
14
16
14
16
19
19
21
21
19
19
68
68
26
26
65
32
31
65
31
32
25
Basic Heap Operations
14
14
16
16
19
19
19
21
21
19
68
68
26
26
65
32
31
65
31
32
26
Basic Heap Operations
14
14
16
19
16
19
19
21
21
19
68
26
68
26
65
32
31
65
31
32
27
Basic Heap Operations
14
14
16
19
16
19
19
21
26
21
19
68
26
68
65
32
31
31
65
32
28
d-Heap
  • Binary heaps are so simple that they are almost
    always used when priority queues are needed.
  • A simple generalization is a d-heap, which is
    exactly like a binary heap except that all nodes
    have d children (thus, a binary heap is a 2-heap).

29
d-Heap
1
5
3
2
10
7
6
9
4
15
17
13
8
11
9
An example of 3-heap
30
Homework
  • 6.2a
  • 6.3
  • 6.13
Write a Comment
User Comments (0)
About PowerShow.com