Scribd
Upload
197 views

C Implementation of Heap Sort

This document describes the heap sort algorithm for sorting an array of integers. It defines a MaxHeap struct to represent a binary heap with functions for max heapifying a subtree, building the initial max heap from an array, and sorting the array using the heap. The key steps are building the max heap from the array in O(n) time, then repeatedly removing the max element from the heap and placing it in the sorted position in the array in O(nLogn) overall time complexity.

Uploaded by

enrik
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
197 views

C Implementation of Heap Sort

This document describes the heap sort algorithm for sorting an array of integers. It defines a MaxHeap struct to represent a binary heap with functions for max heapifying a subtree, building the initial max heap from an array, and sorting the array using the heap. The key steps are building the max heap from the array in O(n) time, then repeatedly removing the max element from the heap and placing it in the sorted position in the array in O(nLogn) overall time complexity.

Uploaded by

enrik
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 3

// C implementation of Heap Sort

#include <stdio.h>
#include <stdlib.h>
// A heap has current size and array of elements
struct MaxHeap
{
int size;
int* array;
};
// A utility function to swap to integers
void swap(int* a, int* b) { int t = *a; *a = *b;

*b = t; }

// The main function to heapify a Max Heap. The function


// assumes that everything under given root (element at
// index idx) is already heapified
void maxHeapify(struct MaxHeap* maxHeap, int idx)
{
int largest = idx; // Initialize largest as root
int left = (idx << 1) + 1; // left = 2*idx + 1
int right = (idx + 1) << 1; // right = 2*idx + 2
// See if left child of root exists and is greater than
// root
if (left < maxHeap->size &&
maxHeap->array[left] > maxHeap->array[largest])
largest = left;
// See if right child of root exists and is greater than
// the largest so far
if (right < maxHeap->size &&
maxHeap->array[right] > maxHeap->array[largest])
largest = right;

// Change root, if needed


if (largest != idx)
{
swap(&maxHeap->array[largest], &maxHeap->array[idx]);
maxHeapify(maxHeap, largest);
}

// A utility function to create a max heap of given capacity


struct MaxHeap* createAndBuildHeap(int *array, int size)
{
int i;
struct MaxHeap* maxHeap =
(struct MaxHeap*) malloc(sizeof(struct MaxHeap));
maxHeap->size = size;
// initialize size of heap
maxHeap->array = array; // Assign address of first element of array
// Start from bottommost and rightmost internal mode and heapify all
// internal modes in bottom up way
for (i = (maxHeap->size - 2) / 2; i >= 0; --i)

maxHeapify(maxHeap, i);
return maxHeap;
}
// The main function to sort
void heapSort(int* array, int
{
// Build a heap from the
struct MaxHeap* maxHeap =

an array of given size


size)
input data.
createAndBuildHeap(array, size);

// Repeat following steps while heap size is greater than 1.


// The last element in max heap will be the minimum element
while (maxHeap->size > 1)
{
// The largest item in Heap is stored at the root. Replace
// it with the last item of the heap followed by reducing the
// size of heap by 1.
swap(&maxHeap->array[0], &maxHeap->array[maxHeap->size - 1]);
--maxHeap->size; // Reduce heap size

// Finally, heapify the root of tree.


maxHeapify(maxHeap, 0);

}
// A utility function to print a given array of given size
void printArray(int* arr, int size)
{
int i;
for (i = 0; i < size; ++i)
printf("%d ", arr[i]);
}
/* Driver program to test above functions */
int main()
{
int arr[] = {12, 11, 13, 5, 6, 7};
int size = sizeof(arr)/sizeof(arr[0]);
printf("Given array is \n");
printArray(arr, size);
heapSort(arr, size);

printf("\nSorted array is \n");


printArray(arr, size);
return 0;

Output:

Given array is
12 11 13 5 6 7
Sorted array is
5 6 7 11 12 13

Notes:
Heap sort is an in-place algorithm.
Its typical implementation is not stable, but can be made stable (See this)
Time Complexity: Time complexity of heapify is O(Logn). Time complexity of createAndBuildHeap()
is O(n) and overall time complexity of Heap Sort is O(nLogn).
Applications of HeapSort
1. Sort a nearly sorted (or K sorted) array
2. k largest(or smallest) elements in an array
Heap sort algorithm has limited uses because Quicksort and Mergesort are better in practice.
Nevertheless, the Heap data structure itself is enormously used. See Applications of Heap Data
Structure

You might also like