Communities

Writing
Writing
Codidact Meta
Codidact Meta
The Great Outdoors
The Great Outdoors
Photography & Video
Photography & Video
Scientific Speculation
Scientific Speculation
Cooking
Cooking
Electrical Engineering
Electrical Engineering
Judaism
Judaism
Languages & Linguistics
Languages & Linguistics
Software Development
Software Development
Mathematics
Mathematics
Christianity
Christianity
Code Golf
Code Golf
Music
Music
Physics
Physics
Linux Systems
Linux Systems
Power Users
Power Users
Tabletop RPGs
Tabletop RPGs
Community Proposals
Community Proposals
tag:snake search within a tag
answers:0 unanswered questions
user:xxxx search by author id
score:0.5 posts with 0.5+ score
"snake oil" exact phrase
votes:4 posts with 4+ votes
created:<1w created < 1 week ago
post_type:xxxx type of post
Search help
Notifications
Mark all as read See all your notifications »
Q&A

Welcome to Software Development on Codidact!

Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.

Comments on Regarding the heap sort algorithm.

Post

Regarding the heap sort algorithm.

+1
−3

I get the concept of the heap sort algorithm and its like first you have a heap(ordered binary tree) then we have the Max heap which has the highest element value in the array at the top of the tree. The parent nodes will be basically > than the child nodes. But I don't get the heapify sample code here. Can someone explain? Thank you.

#include <stdio.h>

void swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

//can someone explain the heapify function of the coding?
void heapify(int arr[], int n, int i) {
    int max = I;  
    int leftChild = 2 * i + 1; coding
    int rightChild = 2 * i + 2;

    //If left child is greater than root
    if (leftChild < n && arr[leftChild] > arr[max])
        max = leftChild;

    //If right child is greater than max
    if (rightChild < n && arr[rightChild] > arr[max])
        max = rightChild;

        //If max is not root
    if (max != i) {
        swap(&arr[i], &arr[max]);
        //heapify the affected sub-tree recursively
        heapify(arr, n, max);
    }
}

//Main function to perform heap sort
void heapSort(int arr[], int n) {
    //Rearrange array (building heap)
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    //Extract elements from heap one by one
    for (int i = n - 1; i >= 0; i--) {
        swap(&arr[0], &arr[i]); //Current root moved to the end
        heapify(arr, i, 0); //calling max heapify on the heap reduced
    }
}

//print size of array n using utility function
//print size of array n using utility function
void display(int arr[], int n) {
    for (int i = 0; i < n; ++i)
    printf("%d ", arr[i]);
    printf("\n");
}

//main function coding not included```
History
Why does this post require moderator attention?
You might want to add some details to your flag.
Why should this post be closed?

2 comment threads

"Heapify" is just the process of building the "max heap"... (3 comments)
Please fix the formatting (1 comment)
"Heapify" is just the process of building the "max heap"...
elgonzo‭ wrote over 2 years ago · edited over 2 years ago

... in other words "heapify" describes the act of turning something into a heap data structure. Within the context of heapsort, this describes turning a binary tree into a "max heap" / "binary heap". The heapify() method does just that. (Btw, a max/binary heap is just a binary tree obeying specific ordering/relationship rules.)

The source array can be thought of as a representation of a source binary tree containing all the elements, specifically a "complete binary tree". A "complete binary tree", because it allows a straightforward representation of such a tree by an array. By rearranging/swapping the elements in the array, the binary tree represented by that array is turned into a max heap / binary heap (the array now not just representing some binary tree, but now representing a max heap / binary heap).

It's still all part of the concept. If you understand the concept, you will then also understand the implementation.

hamburgersarecool‭ wrote over 2 years ago

Why is: int leftChild = 2 * i + 1;

int rightChild = 2 * i + 2;

??

elgonzo‭ wrote over 2 years ago · edited over 2 years ago

Because the array can be thought of as a representation of a binary tree, specifically a "complete binary tree". Now, if you know the array index of some node/element in the tree, how would you get the array indices of the two children nodes/elements, or the array index of the parent node/element?

If you don't know anything about how a "complete binary tree" can be represented by an array, i suggest to search the interwebs for something like complete binary tree as array. Different web sites/blog posts might explain this in various different ways, so spend some time looking at different search results. Random pick (no endorsement): https://opendsa-server.cs.vt.edu/ODSA/Books/Everything/html/CompleteTree.html

If you don't know what the definition of "complete binary tree" is, again, i would like to encourage you to search the internet for blog posts or some such explaining what conditions/rules a binary tree must satisfy to be a "complete binary tree"...