Heap sort algorithm

Heap sort algorithm

In this tutorial, we will learn about the Heap sort algorithm.

Sorting is one of the fundamental operations in computer science, and there are numerous sorting algorithms available. Merge sort is one such algorithm, which is efficient and widely used in programming languages. In this article, we will discuss the merge sort algorithm and its implementation in C++, Java, and Python.

Heap Sort is a comparison-based sorting algorithm that uses a binary heap data structure to sort an array in ascending or descending order. Heap Sort has a time complexity of O(n*log n), which makes it an efficient sorting algorithm for large datasets. In this article, we will explore the implementation of Heap Sort in C++, Java, and Python, along with an explanation of each pass of the algorithm.

C++ Implementation of Heap Sort:

void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2*i + 1;
    int r = 2*i + 2;

    if (l < n && arr[l] > arr[largest])
        largest = l;

    if (r < n && arr[r] > arr[largest])
        largest = r;

    if (largest != i) {
        swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    for (int i = n - 1; i >= 0; i--) {
        swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6, 7};
    int n = sizeof(arr)/sizeof(arr[0]);

    heapSort(arr, n);

    cout << "Sorted array is: \n";
    for (int i = 0; i < n; ++i)
        cout << arr[i] << " ";
}

In the C++ implementation, the heapify() function is used to create a heap from an array, and the heapSort() function is used to sort the array using the heap data structure. In the main() function, we create an array, call the heapSort() function, and print the sorted array.

See also  Data Structures and Algorithms | C++ STLs

In the first pass of the algorithm, the heapify() function is called on each non-leaf node of the binary tree, starting from the bottom of the tree and working up to the root. The heapify() function compares the parent node with its left and right child nodes, and swaps the parent node with the largest child node if necessary. This creates a heap structure, where the largest element is at the root of the tree.

In the second pass of the algorithm, the heapSort() function repeatedly extracts the largest element from the root of the heap and places it at the end of the array. The heap is then reconstructed by calling heapify() on the remaining elements of the heap. This process continues until the entire array is sorted.

Java Implementation of Heap Sort:

Java Implementation of Heap Sort:

public class HeapSort {
    public void sort(int arr[]) {
        int n = arr.length;

        // Build heap (rearrange array)
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(arr, n, i);

        // One by one extract an element from heap
        for (int i = n - 1; i >= 0; i--) {
            // Move current root to end
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            // call max heapify on the reduced heap
            heapify(arr, i, 0);
        }
    }

    void heapify(int arr[], int n, int i) {
        int largest = i; // Initialize largest as root
        int l = 2 * i + 1; // left = 2*i + 1
        int r = 2 * i + 2; // right = 2*i + 2

        // If left child is larger than root
        if (l < n && arr[l] > arr[largest])
            largest = l;

        // If right child is larger than largest so far
        if (r < n && arr[r] > arr[largest])
            largest = r;

        // If largest is not root
        if (largest != i) {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;

            // Recursively heapify the affected sub-tree
            heapify(arr, n, largest);
        }
    }
}

In the Java implementation, the HeapSort class has a sort() method that takes an array as input and sorts it using the heap sort algorithm. The heapify() method is used to create a heap from an array, and the sort() method calls the heapify() method on each non-leaf node of the binary tree to create a heap structure. The largest element is then repeatedly extracted from the root of the heap and placed at the end of the array, and the heap is reconstructed by calling heapify() on the remaining elements of the heap.

See also  Binary Search Implementation and Time Complexity Analysis

Python Implementation of Heap Sort:

def heapify(arr, n, i):
    largest = i
    l = 2 * i + 1
    r = 2 * i + 2

    if l < n and arr[i] < arr[l]:
        largest = l

    if r < n and arr[largest] < arr[r]:
        largest = r

    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heapSort(arr):
    n = len(arr)

    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)

    for i in range(n - 1, 0, -1):
        arr[0], arr[i] = arr[i], arr[0]
        heapify(arr, i, 0)

arr = [12, 11, 13, 5, 6, 7]
heapSort(arr)
print("Sorted array is:")
for i in range(len(arr)):
    print("%d" % arr[i])

The Python implementation of Heap Sort is similar to the C++ and Java implementations, with the heapify() function used to create a heap from an array, and the heapSort() function used to sort the array using the heap data structure. In the first pass of the algorithm, the heapify() function is called on each non-leaf node of the binary tree to create a heap structure. In the second pass of the algorithm, the largest element is repeatedly extracted from the root of the heap and placed at the end of the array, and the heap is reconstructed by calling heapify() on the remaining elements of the heap.

Each pass of the Heap Sort algorithm involves creating a heap from an array and then sorting the array using the heap data structure. In the first pass, the heapify() function is called on each non-leaf node of the binary tree to create a heap structure. In the second pass, the largest element is repeatedly extracted from the root of the heap and placed at the end of the array, and the heap is reconstructed by calling heapify() on the remaining elements of the heap.

See also  SELECTION SORT ALGORITHM

Conclusion

In conclusion, Heap Sort is an efficient sorting algorithm with a time complexity of O(n*log n). It uses a binary heap data structure to sort an array in ascending or descending order. In this article, we explored the implementation of Heap Sort in C++, Java, and Python, along with an explanation of each pass of the algorithm. By understanding how Heap Sort works and how it can be implemented in various programming languages, developers can choose the best sorting algorithm for their applications and optimize their code for performance.

Leave a Comment

Your email address will not be published. Required fields are marked *

Ads Blocker Image Powered by Code Help Pro

Ads Blocker Detected!!!

we provide projects, courses, and other stuff for free. in order for running we use Google ads to make revenue. please disable adblocker to support us.