Presentation is loading. Please wait.

Presentation is loading. Please wait.

Section 8.8 Heapsort.  Merge sort time is O(n log n) but still requires, temporarily, n extra storage locations  Heapsort does not require any additional.

Published byLorena Ray Modified over 9 years ago

Similar presentations

Presentation on theme: "Section 8.8 Heapsort.  Merge sort time is O(n log n) but still requires, temporarily, n extra storage locations  Heapsort does not require any additional."— Presentation transcript:

1 Section 8.8 Heapsort

2  Merge sort time is O(n log n) but still requires, temporarily, n extra storage locations  Heapsort does not require any additional storage  As its name implies, heapsort uses a heap to store the array

3 First Version of a Heapsort Algorithm  When used as a priority queue, a heap maintains a smallest value at the top  The following algorithm  places an array's data into a heap,  then removes each heap item (O(n log n)) and moves it back into the array  This version of the algorithm requires n extra storage locations Heapsort Algorithm: First Version 1. Insert each value from the array to be sorted into a priority queue (heap). 2. Set i to 0 3. while the priority queue is not empty 4. Remove an item from the queue and insert it back into the array at position i 5. Increment i

4 Revising the Heapsort Algorithm  In heaps we've used so far, each parent node value was less than the values of its children  We can build a heap so that each parent node value is larger than its children  Then,  move the top item to the bottom of the heap  reheap, ignoring the item moved to the bottom

5 Trace of Heapsort 89 76 74 37 32 39 66 20 26 18 28 29 6 6 Go to End

6 Trace of Heapsort (cont.) 89 76 74 37 32 39 66 20 26 18 28 29 6 6

7 Trace of Heapsort (cont.) 89 76 74 37 32 39 66 20 26 18 28 29 6 6

8 Trace of Heapsort (cont.) 6 6 76 74 37 32 39 66 20 26 18 28 29 89

9 Trace of Heapsort (cont.) 76 6 6 74 37 32 39 66 20 26 18 28 29 89

10 Trace of Heapsort (cont.) 76 37 74 6 6 32 39 66 20 26 18 28 29 89

11 Trace of Heapsort (cont.) 76 37 74 26 32 39 66 20 6 6 18 28 29 89

12 Trace of Heapsort (cont.) 76 37 74 26 32 39 66 20 6 6 18 28 29 89

13 Trace of Heapsort (cont.) 76 37 74 26 32 39 66 20 6 6 18 28 29 89

14 Trace of Heapsort (cont.) 76 37 74 26 32 39 66 20 6 6 18 28 29 89

15 Trace of Heapsort (cont.) 29 37 74 26 32 39 66 20 6 6 18 28 76 89

16 Trace of Heapsort (cont.) 74 37 29 26 32 39 66 20 6 6 18 28 76 89

17 Trace of Heapsort (cont.) 74 37 66 26 32 39 29 20 6 6 18 28 76 89

18 Trace of Heapsort (cont.) 74 37 66 26 32 39 29 20 6 6 18 28 76 89

19 Trace of Heapsort (cont.) 74 37 66 26 32 39 29 20 6 6 18 28 76 89

20 Trace of Heapsort (cont.) 74 37 66 26 32 39 29 20 6 6 18 28 76 89

21 Trace of Heapsort (cont.) 28 37 66 26 32 39 29 20 6 6 18 74 76 89

22 Trace of Heapsort (cont.) 66 37 28 26 32 39 29 20 6 6 18 74 76 89

23 Trace of Heapsort (cont.) 66 37 39 26 32 28 29 20 6 6 18 74 76 89

24 Trace of Heapsort (cont.) 66 37 39 26 32 28 29 20 6 6 18 74 76 89

25 Trace of Heapsort (cont.) 66 37 39 26 32 28 29 20 6 6 18 74 76 89

26 Trace of Heapsort (cont.) 66 37 39 26 32 28 29 20 6 6 18 74 76 89

27 Trace of Heapsort (cont.) 18 37 39 26 32 28 29 20 6 6 66 74 76 89

28 Trace of Heapsort (cont.) 39 37 18 26 32 28 29 20 6 6 66 74 76 89

29 Trace of Heapsort (cont.) 39 37 29 26 32 28 18 20 6 6 66 74 76 89

30 Trace of Heapsort (cont.) 39 37 29 26 32 28 18 20 6 6 66 74 76 89

31 Trace of Heapsort (cont.) 39 37 29 26 32 28 18 20 6 6 66 74 76 89

32 Trace of Heapsort (cont.) 39 37 29 26 32 28 18 20 6 6 66 74 76 89

33 Trace of Heapsort (cont.) 6 6 37 29 26 32 28 18 20 39 66 74 76 89

34 Trace of Heapsort (cont.) 37 6 6 29 26 32 28 18 20 39 66 74 76 89

35 Trace of Heapsort (cont.) 37 32 29 26 6 6 28 18 20 39 66 74 76 89

36 Trace of Heapsort (cont.) 37 32 29 26 6 6 28 18 20 39 66 74 76 89

37 Trace of Heapsort (cont.) 37 32 29 26 6 6 28 18 20 39 66 74 76 89

38 Trace of Heapsort (cont.) 37 32 29 26 6 6 28 18 20 39 66 74 76 89

39 Trace of Heapsort (cont.) 20 32 29 26 6 6 28 18 37 39 66 74 76 89

40 Trace of Heapsort (cont.) 32 20 29 26 6 6 28 18 37 39 66 74 76 89

41 Trace of Heapsort (cont.) 32 26 29 20 6 6 28 18 37 39 66 74 76 89

42 Trace of Heapsort (cont.) 32 26 29 20 6 6 28 18 37 39 66 74 76 89

43 Trace of Heapsort (cont.) 32 26 29 20 6 6 28 18 37 39 66 74 76 89

44 Trace of Heapsort (cont.) 32 26 29 20 6 6 28 18 37 39 66 74 76 89

45 Trace of Heapsort (cont.) 18 26 29 20 6 6 28 32 37 39 66 74 76 89

46 Trace of Heapsort (cont.) 29 26 18 20 6 6 28 32 37 39 66 74 76 89

47 Trace of Heapsort (cont.) 29 26 28 20 6 6 18 32 37 39 66 74 76 89

48 Trace of Heapsort (cont.) 29 26 28 20 6 6 18 32 37 39 66 74 76 89

49 Trace of Heapsort (cont.) 29 26 28 20 6 6 18 32 37 39 66 74 76 89

50 Trace of Heapsort (cont.) 29 26 28 20 6 6 18 32 37 39 66 74 76 89

51 Trace of Heapsort (cont.) 18 26 28 20 6 6 29 32 37 39 66 74 76 89

52 Trace of Heapsort (cont.) 28 26 18 20 6 6 29 32 37 39 66 74 76 89

53 Trace of Heapsort (cont.) 28 26 18 20 6 6 29 32 37 39 66 74 76 89

54 Trace of Heapsort (cont.) 28 26 18 20 6 6 29 32 37 39 66 74 76 89

55 Trace of Heapsort (cont.) 28 26 18 20 6 6 29 32 37 39 66 74 76 89

56 Trace of Heapsort (cont.) 6 6 26 18 20 28 29 32 37 39 66 74 76 89

57 Trace of Heapsort (cont.) 26 6 6 18 20 28 29 32 37 39 66 74 76 89

58 Trace of Heapsort (cont.) 26 20 18 6 6 28 29 32 37 39 66 74 76 89

59 Trace of Heapsort (cont.) 26 20 18 6 6 28 29 32 37 39 66 74 76 89

60 Trace of Heapsort (cont.) 26 20 18 6 6 28 29 32 37 39 66 74 76 89

61 Trace of Heapsort (cont.) 26 20 18 6 6 28 29 32 37 39 66 74 76 89

62 Trace of Heapsort (cont.) 6 6 20 18 26 28 29 32 37 39 66 74 76 89

63 Trace of Heapsort (cont.) 20 6 6 18 26 28 29 32 37 39 66 74 76 89

64 Trace of Heapsort (cont.) 20 6 6 18 26 28 29 32 37 39 66 74 76 89

65 Trace of Heapsort (cont.) 20 6 6 18 26 28 29 32 37 39 66 74 76 89

66 Trace of Heapsort (cont.) 20 6 6 18 26 28 29 32 37 39 66 74 76 89

67 Trace of Heapsort (cont.) 18 6 6 20 26 28 29 32 37 39 66 74 76 89

68 Trace of Heapsort (cont.) 18 6 6 20 26 28 29 32 37 39 66 74 76 89

69 Trace of Heapsort (cont.) 18 6 6 20 26 28 29 32 37 39 66 74 76 89

70 Trace of Heapsort (cont.) 18 6 6 20 26 28 29 32 37 39 66 74 76 89

71 Trace of Heapsort (cont.) 6 6 18 20 26 28 29 32 37 39 66 74 76 89

72 Trace of Heapsort (cont.) 6 6 18 20 26 28 29 32 37 39 66 74 76 89

73 Revising the Heapsort Algorithm  If we implement the heap as an array  each element removed will be placed at the end of the array, and  the heap part of the array decreases by one element Goto Initial Heap

74 Algorithm for In-Place Heapsort 1. Build a heap by rearranging the elements in an unsorted array 2. while the heap is not empty 3. Remove the first item from the heap by swapping it with the last item in the heap and restoring the heap property

75 Algorithm to Build a Heap  Start with an array table of length table.length  Consider the first item to be a heap of one item  Next, consider the general case where the items in array table from 0 through n-1 form a heap and the items from n through table.length – 1 are not in the heap

76 Algorithm to Build a Heap (cont.) Refinement of Step 1 for In-Place Heapsort 1.1 while n is less than table.length 1.2 Increment n by 1. This inserts a new item into the heap 1.3 Restore the heap property

77 Analysis of Heapsort  Because a heap is a complete binary tree, has log n levels  Building a heap of size n requires finding the correct location for an item in a heap with log n levels  Each insert (or remove) is O(log n)  With n items, building a heap is O(n log n)  No extra storage is needed

78 Code for Heapsort  Listing 8.7 ( HeapSort.java, pages 449 -451)

79 Section 8.9 Quicksort

80  Developed in 1962  Quicksort selects a specific value called a pivot and rearranges the array into two parts (called partioning)  all the elements in the left subarray are less than or equal to the pivot  all the elements in the right subarray are larger than the pivot  The pivot is placed between the two subarrays  The process is repeated until the array is sorted

81 Trace of Quicksort 44 75 23 43 55 12 64 77 33

82 Trace of Quicksort (cont.) 44 75 23 43 55 12 64 77 33 Arbitrarily select the first element as the pivot

83 Trace of Quicksort (cont.) 55 75 23 43 44 12 64 77 33 Swap the pivot with the element in the middle

84 Trace of Quicksort (cont.) 55 75 23 43 44 12 64 77 33 Partition the elements so that all values less than or equal to the pivot are to the left, and all values greater than the pivot are to the right

85 Trace of Quicksort (cont.) 12 33 23 43 44 55 64 77 75 Partition the elements so that all values less than or equal to the pivot are to the left, and all values greater than the pivot are to the right

86 Quicksort Example(cont.) 12 33 23 43 44 55 64 77 75 44 is now in its correct position

87 Trace of Quicksort (cont.) 12 33 23 43 44 55 64 77 75 Now apply quicksort recursively to the two subarrays

88 Trace of Quicksort (cont.) 12 33 23 43 44 55 64 77 75 Pivot value = 12

89 Trace of Quicksort (cont.) 12 33 23 43 44 55 64 77 75 Pivot value = 12

90 Trace of Quicksort (cont.) 12 33 23 43 44 55 64 77 75 Pivot value = 33

91 Trace of Quicksort (cont.) 12 23 33 43 44 55 64 77 75 Pivot value = 33

92 Trace of Quicksort (cont.) 12 23 33 43 44 55 64 77 75 Pivot value = 33

93 Trace of Quicksort (cont.) 12 23 33 43 44 55 64 77 75 Pivot value = 33 Left and right subarrays have single values; they are sorted

94 Trace of Quicksort (cont.) 12 23 33 43 44 55 64 77 75 Pivot value = 33 Left and right subarrays have single values; they are sorted

95 Trace of Quicksort (cont.) 12 23 33 43 44 55 64 77 75 Pivot value = 55

96 Trace of Quicksort (cont.) Pivot value = 64 12 23 33 43 44 55 64 77 75

97 Trace of Quicksort (cont.) 12 23 33 43 44 55 64 77 75 Pivot value = 77

98 Trace of Quicksort (cont.) 12 23 33 43 44 55 64 75 77 Pivot value = 77

99 Trace of Quicksort (cont.) 12 23 33 43 44 55 64 75 77 Pivot value = 77

100 Trace of Quicksort (cont.) 12 23 33 43 44 55 64 75 77 Left subarray has single value; it is sorted

101 Trace of Quicksort (cont.) 12 23 33 43 44 55 64 75 77

102 Algorithm for Quicksort  We describe how to do the partitioning later  The indexes first and last are the end points of the array being sorted  The index of the pivot after partitioning is pivIndex Algorithm for Quicksort 1. if first < last then 2. Partition the elements in the subarray first... last so that the pivot value is in its correct place (subscript pivIndex ) 3. Recursively apply quicksort to the subarray first... pivIndex - 1 4. Recursively apply quicksort to the subarray pivIndex + 1... last

103 Analysis of Quicksort  If the pivot value is a random value selected from the current subarray,  then statistically half of the items in the subarray will be less than the pivot and half will be greater  If both subarrays have the same number of elements (best case), there will be log n levels of recursion  At each recursion level, the partitioning process involves moving every element to its correct position—n moves  Quicksort is O(n log n), just like merge sort

104 Analysis of Quicksort (cont.)  The array split may not be the best case, i.e. 50-50  An exact analysis is difficult (and beyond the scope of this class), but, the running time will be bound by a constant x n log n

105 Analysis of Quicksort (cont.)  A quicksort will give very poor behavior if, each time the array is partitioned, a subarray is empty.  In that case, the sort will be O(n 2 )  Under these circumstances, the overhead of recursive calls and the extra run-time stack storage required by these calls makes this version of quicksort a poor performer relative to the quadratic sorts  We’ll discuss a solution later

106 Code for Quicksort  Listing 8.8 ( QuickSort.java, pages 453 - 454)

107 Algorithm for Partitioning 44 75 23 43 55 12 64 77 33 If the array is randomly ordered, it does not matter which element is the pivot. For simplicity we pick the element with subscript first

108 Trace of Partitioning (cont.) 44 75 23 43 55 12 64 77 33 If the array is randomly ordered, it does not matter which element is the pivot. For simplicity we pick the element with subscript first

109 Trace of Partitioning (cont.) 44 75 23 43 55 12 64 77 33 For visualization purposes, items less than or equal to the pivot will be colored blue; items greater than the pivot will be colored light purple

110 Trace of Partitioning (cont.) 44 75 23 43 55 12 64 77 33 For visualization purposes, items less than or equal to the pivot will be colored light green; items greater than the pivot will be colored light red

111 Trace of Partitioning (cont.) Search for the first value at the left end of the array that is greater than the pivot value 44 75 23 43 55 12 64 77 33

112 Trace of Partitioning (cont.) Search for the first value at the left end of the array that is greater than the pivot value up 44 75 23 43 55 12 64 77 33

113 Trace of Partitioning (cont.) Then search for the first value at the right end of the array that is less than or equal to the pivot value updown 44 75 23 43 55 12 64 77 33

114 Trace of Partitioning (cont.) Exchange these values updown 44 75 23 43 55 12 64 77 33

115 Trace of Partitioning (cont.) Exchange these values 44 33 23 43 55 12 64 77 75

116 Trace of Partitioning (cont.) Repeat 44 33 23 43 55 12 64 77 75

117 Trace of Partitioning (cont.) Find first value at left end greater than pivot up 44 33 23 43 55 12 64 77 75

118 Trace of Partitioning (cont.) Find first value at right end less than or equal to pivot updown 44 33 23 43 55 12 64 77 75

119 Trace of Partitioning (cont.) Exchange 44 33 23 43 12 55 64 77 75

120 Trace of Partitioning (cont.) Repeat 44 33 23 43 12 55 64 77 75

121 Trace of Partitioning (cont.) Find first element at left end greater than pivot up 44 33 23 43 12 55 64 77 75

122 Trace of Partitioning (cont.) Find first element at right end less than or equal to pivot up down 44 33 23 43 12 55 64 77 75

123 Trace of Partitioning (cont.) Since down has "passed" up, do not exchange up down 44 33 23 43 12 55 64 77 75

124 Trace of Partitioning (cont.) Exchange the pivot value with the value at down up down 44 33 23 43 12 55 64 77 75

125 Trace of Partitioning (cont.) Exchange the pivot value with the value at down down 12 33 23 43 44 55 64 77 75

126 Trace of Partitioning (cont.) The pivot value is in the correct position; return the value of down and assign it to the pivot index pivIndex down 12 33 23 43 44 55 64 77 75

127 Algorithm for Partitioning

128 Code for partition

129 Code for partition (cont.)  Listing 8.9 ( QuickSort1, page 457)

130 Revised Partition Algorithm  Quicksort is O(n 2 ) when each split yields one empty subarray, which is the case when the array is presorted  A better solution is to pick the pivot value in a way that is less likely to lead to a bad split  Use three references: first, middle, last  Select the median of the these items as the pivot

131 Trace of Revised Partitioning 44 75 23 43 55 12 64 77 33

132 Trace of Revised Partitioning (cont.) 44 75 23 43 55 12 64 77 33 middle first last

133 Trace of Revised Partitioning (cont.) 44 75 23 43 55 12 64 77 33 Sort these values middle first last

134 Trace of Revised Partitioning (cont.) 33 75 23 43 44 12 64 77 55 Sort these values middle first last

135 Trace of Revised Partitioning (cont.) 33 75 23 43 44 12 64 77 55 Exchange middle with first middle first last

136 Trace of Revised Partitioning (cont.) 44 75 23 43 33 12 64 77 55 Exchange middle with first middle first last

137 Trace of Revised Partitioning (cont.) 44 75 23 43 33 12 64 77 55 Run the partition algorithm using the first element as the pivot

138 Algorithm for Revised partition Method 1. Sort table[first], table[middle], and table[last] 2. Move the median value to table[first] (the pivot value) by exchanging table[first] and table[middle]. 3. Initialize up to first and down to last 4. do 5. Increment up until up selects the first element greater than the pivot value or up has reached last 6. Decrement down until down selects the first element less than or equal to the pivot value or down has reached first 7. if up < down then 8. Exchange table[up] and table[down] 9. while up is to the left of down 10. Exchange table[first] and table[down] 11. Return the value of down to pivIndex

139 Code for Revised partition Method  Listing 8.10 ( QuickSort2, page 459)

140 Summary Comparison of Sort Algorithms

141 Sort Review

Download ppt "Section 8.8 Heapsort.  Merge sort time is O(n log n) but still requires, temporarily, n extra storage locations  Heapsort does not require any additional."

Similar presentations

Introduction to Algorithms Quicksort

Introduction to Algorithms Quicksort
ITEC200 Week10 Sorting. www.ics.mq.edu.au/p pdp 2 Learning Objectives – Week10 Sorting (Chapter10) By working through this chapter, students should: Learn.

ITEC200 Week10 Sorting. pdp 2 Learning Objectives – Week10 Sorting (Chapter10) By working through this chapter, students should: Learn.
Heaps1 Part-D2 Heaps 2 65 79. Heaps2 Recall Priority Queue ADT (§ 7.1.3) A priority queue stores a collection of entries Each entry is a pair (key, value)

Heaps1 Part-D2 Heaps Heaps2 Recall Priority Queue ADT (§ 7.1.3) A priority queue stores a collection of entries Each entry is a pair (key, value)
Transform and Conquer Chapter 6. Transform and Conquer Solve problem by transforming into: a more convenient instance of the same problem (instance simplification)

Transform and Conquer Chapter 6. Transform and Conquer Solve problem by transforming into: a more convenient instance of the same problem (instance simplification)
Algorithms Analysis Lecture 6 Quicksort. Quick Sort 88 14 98 25 62 52 79 30 23 31 Divide and Conquer.

Algorithms Analysis Lecture 6 Quicksort. Quick Sort Divide and Conquer.
Sorting Part 4 CS221 – 3/25/09. Sort Matrix NameWorst Time Complexity Average Time Complexity Best Time Complexity Worst Space (Auxiliary) Selection SortO(n^2)

Sorting Part 4 CS221 – 3/25/09. Sort Matrix NameWorst Time Complexity Average Time Complexity Best Time Complexity Worst Space (Auxiliary) Selection SortO(n^2)
© Copyright 2012 by Pearson Education, Inc. All Rights Reserved. 1 Chapter 17 Sorting.

© Copyright 2012 by Pearson Education, Inc. All Rights Reserved. 1 Chapter 17 Sorting.
Liang, Introduction to Java Programming, Eighth Edition, (c) 2011 Pearson Education, Inc. All rights reserved. 0132130807 1 Chapter 24 Sorting.

Liang, Introduction to Java Programming, Eighth Edition, (c) 2011 Pearson Education, Inc. All rights reserved Chapter 24 Sorting.
© 2004 Goodrich, Tamassia Quick-Sort1 7 4 9 6 2  2 4 6 7 9 4 2  2 47 9  7 9 2  29  9.

© 2004 Goodrich, Tamassia Quick-Sort     29  9.
Sorting Algorithms and Average Case Time Complexity

Sorting Algorithms and Average Case Time Complexity
Sorting Chapter 11. 2 Sorting Consider list x 1, x 2, x 3, … x n We seek to arrange the elements of the list in order –Ascending or descending Some O(n.

Sorting Chapter Sorting Consider list x 1, x 2, x 3, … x n We seek to arrange the elements of the list in order –Ascending or descending Some O(n.
1 Sorting Problem: Given a sequence of elements, find a permutation such that the resulting sequence is sorted in some order. We have already seen: –Insertion.

1 Sorting Problem: Given a sequence of elements, find a permutation such that the resulting sequence is sorted in some order. We have already seen: –Insertion.
Quick-Sort1 7 4 9 6 2  2 4 6 7 9 4 2  2 47 9  7 9 2  29  9.

Quick-Sort     29  9.
CS 206 Introduction to Computer Science II 12 / 09 / 2009 Instructor: Michael Eckmann.

CS 206 Introduction to Computer Science II 12 / 09 / 2009 Instructor: Michael Eckmann.
1 Sorting/Searching CS308 Data Structures. 2 Sorting means... l Sorting rearranges the elements into either ascending or descending order within the array.

1 Sorting/Searching CS308 Data Structures. 2 Sorting means... l Sorting rearranges the elements into either ascending or descending order within the array.
Tirgul 4 Sorting: – Quicksort – Average vs. Randomized – Bucket Sort Heaps – Overview – Heapify – Build-Heap.

Tirgul 4 Sorting: – Quicksort – Average vs. Randomized – Bucket Sort Heaps – Overview – Heapify – Build-Heap.
Spring 2010CS 2251 Sorting Chapter 8. Spring 2010CS 2252 Chapter Objectives To learn how to use the standard sorting methods in the Java API To learn.

Spring 2010CS 2251 Sorting Chapter 8. Spring 2010CS 2252 Chapter Objectives To learn how to use the standard sorting methods in the Java API To learn.
Sorting Chapter 10.

Sorting Chapter 10.
QuickSort QuickSort is often called Partition Sort. It is a recursive method, in which the unsorted array is first rearranged so that there is some record,

QuickSort QuickSort is often called Partition Sort. It is a recursive method, in which the unsorted array is first rearranged so that there is some record,
Sorting CS-212 Dick Steflik. Exchange Sorting Method : make n-1 passes across the data, on each pass compare adjacent items, swapping as necessary (n-1.

Sorting CS-212 Dick Steflik. Exchange Sorting Method : make n-1 passes across the data, on each pass compare adjacent items, swapping as necessary (n-1.

Similar presentations

Ads by Google