SlideServe
Télécharger Obtenir Pro
Menu
Accueil Pro
Préférences
ApparenceLight Aide et commentaires
© SlideServe · v2026

Understanding Heapsort: An Efficient In-Place Sorting Algorithm

alida avatar
alida
25 diapositives · 430 Views · Sep 11, 2014

This chapter delves into Heapsort, a sophisticated sorting algorithm that operates in O(n log n) time complexity. It begins by explaining the significance of sorting algorithms in various applications and proceeds to discuss binary heaps, max-heaps, and the properties that govern them. Key procedures such as Max-Heapify, Build-Max-Heap, and the Heapsort algorithm itself are explained step-by-step. The chapter emphasizes the practical aspects of implementing Heapsort, as well as its essential role in priority queues, making it a fundamental topic in algorithm studies.

Understanding Heapsort: An Efficient In-Place Sorting Algorithm - slide 1
01 / 25Understanding Heapsort: An Efficient In-Place Sorting Algorithm
1 / 17

Télécharger la présentation

Understanding Heapsort: An Efficient In-Place Sorting Algorithm
Une image / un lien ci-dessous est fourni (tel quel) pour télécharger la présentation

Politique de téléchargement : le contenu du site vous est fourni TEL QUEL pour votre information et votre usage personnel ; il ne peut être vendu, concédé sous licence ni partagé sur d’autres sites sans l’accord de son auteur.Le contenu vous est fourni TEL QUEL, pour votre information et votre usage personnel uniquement. Téléchargez la présentation en cliquant sur ce lien. Lors du téléchargement, si vous ne parvenez pas à télécharger une présentation, l’éditeur a peut-être supprimé le fichier de son serveur.Pendant le téléchargement, si vous ne parvenez pas à obtenir une présentation, le fichier a peut-être été supprimé par l’éditeur.

F I N

Plus de contenu associé

Transcription de la présentation

  1. Chapter 6 Heapsort Lee, Hsiu-Hui Ack: This presentation is based on the lecture slides from Hsu, Lih-Hsing, as well as various materials from the web.

  2. Why sorting 1. Sometimes the need to sort information is inherent in the application. 2. Algorithms often use sorting as a key subroutine. 3. There is a wide variety of sorting algorithms, and they use rich set of techniques. 4. Sorting problem has a nontrivial lower bound 5. Many engineering issues come to fore when implementing sorting algorithms. Hsiu-Hui Lee

  3. Sorting algorithm • Insertion sort : • In place: only a constant number of elements of the input array are even sorted outside the array. • Merge sort : • not in place. • Heap sort : (chapter 6) • Sorts n numbers in place in O(n lgn) Hsiu-Hui Lee

  4. Sorting algorithm • Quick sort : (chapter 7) • worst time complexity O(n2) • Average time complexity O(n lg n) • Decision tree model : (chapter 8) • Lower bound O (n lg n) • Counting sort • Radix sort • Order statistics Hsiu-Hui Lee

  5. 6.1 Heaps (Binary heap) • Thebinary heap data structure is an array object that can be viewed as a complete tree. Parent(i) return  Left(i) return 2i  Right(i) return2i+1 Hsiu-Hui Lee

  6. Heap property • Max-heap : A[Parent(i)] A[i] • Min-heap : A[Parent(i)]≤ A[i] • The height of a node in a tree: the number of edges on the longest simple downward path from the node to a leaf. • The height of a tree: the height of the root • Theheight of a heap: O(lg n). Hsiu-Hui Lee

  7. Basic procedures on heap • Max-Heapify • Build-Max-Heap • Heapsort • Max-Heap-Insert • Heap-Extract-Max • Heap-Increase-Key • Heap-Maximum Hsiu-Hui Lee

  8. 6.2 Maintaining the heap property Max-Heapify(A, i) • To maintain the max-heap property. • Assume that the binary trees rooted at Left(i) and Right(i) are heaps, but that A[i] may be smaller than its children, thus violating the heap property. Hsiu-Hui Lee

  9. Max-Heapify(A,i) 1 l Left(i) 2 r  Right(i) 3 if l ≤ heap-size[A] and A[l] > A[i] 4 then largest  l 5 else largest  i 6 if r ≤ heap-size[A] and A[r] > A[largest] 7 then largest  r 8 if largest  i 9 then exchange A[i]  A[largest] 10 Max-Heapify(A, largest) Alternatively O(h) (h: height) Hsiu-Hui Lee

  10. Max-Heapify(A,2)heap-size[A] = 10 Max-Heapify(A,2) -> Max-Heapify(A,4) ->Max-Heapify(A,9) Hsiu-Hui Lee

  11. 6.3 Building a Heap Build-Max-Heap(A) • To produce a max-heap from an unordered input array. Build-Max-Heap(A) 1 heap-size[A]  length[A] 2 fori  length[A]/2 downto 1 3 do Max-Heapify(A, i) Hsiu-Hui Lee

  12. Build-Max-Heap(A)heap-size[A] = 10 i=5 Max-Heapify(A, i) i=4 Max-Heapify(A, i) Hsiu-Hui Lee

  13. i=3 Max-Heapify(A, i) i=2 Max-Heapify(A, i) Hsiu-Hui Lee

  14. i=1 Max-Heapify(A, i) Hsiu-Hui Lee

  15. Hsiu-Hui Lee

  16. 6.4 Heapsort algorithm Heapsort(A) • To sort an array in place. Heapsort(A) 1 Build-Max-Heap(A) 2 fori length[A] down to 2 3 do exchange A[1]A[i] 4 heap-size[A]  heap-size[A]-1 5 Max-Heapify(A,1) Hsiu-Hui Lee

  17. Operation of Heapsort Hsiu-Hui Lee

  18. Analysis: O(n lg n) Hsiu-Hui Lee

  19. 6.5 Priority Queues • A priority queue is a data structure that maintain a set S of elements, each with an associated value call a key. • A max-priority queue support the following operations: Insert(S, x) O(lg n) inserts the element x into the set S. Maximum(S) O(1) returns the element of S with the largest key. Hsiu-Hui Lee

  20. Extract-Max(S) O(lg n) removes and returns the element of S with the largest key. Increase-Key(S,x,k) O(lg n) increases the value of element x’s key to the new value k, where k x’s current key value Hsiu-Hui Lee

  21. Heap-Maximum Heap-Maximum(A) 1 returnA[1] Hsiu-Hui Lee

  22. Heap_Extract-Max Heap_Extract-Max(A) 1 if heap-size[A] < 1 2 then error “heap underflow” 3 max  A[1] 4 A[1] A[heap-size[A]] 5 heap-size[A]  heap-size[A] - 1 6 Max-Heapify(A, 1) 7 return max Hsiu-Hui Lee

  23. Heap-Increase-Key Heap-Increase-Key (A, i, key) 1 if key < A[i] • then error “new key is smaller than current key” 3 A[i]  key 4 whilei > 1 and A[Parent(i)] < A[i] 5 do exchange A[i]  A[Parent(i)] 6 i  Parent(i) Hsiu-Hui Lee

  24. Heap-Increase-Key(A,i,15) Hsiu-Hui Lee

  25. Heap_Insert Heap_Insert(A, key) 1 heap-size[A] heap-size[A] + 1 2 A[heap-size[A]] -∞ 3 Heap-Increase-Key(A, heap-size[A], key) Hsiu-Hui Lee