#include<bits/stdc++.h>
using namespace std;

int parent(int i){
    return i/2;
}
int left(int i){
    return 2*i+1
}
int right(int i){
    return 2*i+2
}
void maxheap(int a, int i){
    int l = left(i);
    int r = right(i);
    if (l>a[l]){
        largest=l;
    }
    else () {largest = i};
    if
}

void maxheap(int A[], int heapSize, int i) {
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;

    if (l < heapSize && A[l] > A[largest]) {
        largest = l;
    }

    if (r < heapSize && A[r] > A[largest]) {
        largest = r;
    }

    if (largest != i) {
        swap(A[i], A[largest]);
        maxheap(A, heapSize, largest);
    }
}





int main(){
    int element[] = {23, 17, 14, 6, 13, 10, 1, 5, 7, 12};
    int arraySize = sizeof(element)/sizeof(element[0]);

        cout << "Before MAX_HEAPIFY: ";
    for (int i = 0; i < arraySize; i++)
    {
        cout << A[i] << " ";
    }
    cout << endl;

    MAX_HEAPIFY(A, arraySize, 0);

    cout << "After MAX_HEAPIFY: ";
    for (int i = 0; i < arraySize; i++)
    {
        cout << A[i] << " ";
    }
    cout << endl;

    return 0;
}


________________________________________________
  
#include <iostream>
using namespace std;


void MAX_HEAPIFY(int A[], int heapSize, int i)
{
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;

    if (l < heapSize && A[l] > A[largest])
    {
        largest = l;
    }

    if (r < heapSize && A[r] > A[largest])
    {
        largest = r;
    }

    if (largest != i)
    {
        swap(A[i], A[largest]);
        MAX_HEAPIFY(A, heapSize, largest);
    }
}

int main()
{
    int A[] = {4, 10, 3, 5, 1};
    int heapSize = sizeof(A)/sizeof(A[0]);



    return 0;
}


_________________________________________________________

#include<bits/stdc++.h>
using namespace std;

int parent(int i){
    return i/2;
}

int left(int i){
    return 2*i+1;
}

int right(int i){
    return 2*i+2;
}

void maxheap(int A[], int heapSize, int i) {
    int largest = i;
    int l = left(i);
    int r = right(i);

    if (l < heapSize && A[l] > A[largest]) {
        largest = l;
    }

    if (r < heapSize && A[r] > A[largest]) {
        largest = r;
    }

    if (largest != i) {
        swap(A[i], A[largest]);
        maxheap(A, heapSize, largest);
    }
}

void buildMaxHeap(int A[], int heapSize) {
    for (int i = heapSize / 2 - 1; i >= 0; i--) {
        maxheap(A, heapSize, i);
    }
}

void heapSort(int A[], int heapSize) {
    buildMaxHeap(A, heapSize);
    for (int i = heapSize - 1; i >= 1; i--) {
        swap(A[0], A[i]);
        maxheap(A, i, 0);
    }
}

int main(){
    int element[] = {23, 17, 14, 6, 13, 10, 1, 5, 7, 12};
    int arraySize = sizeof(element)/sizeof(element[0]);

    heapSort(element, arraySize);

    cout << "Sorted array: ";
    for (int i = 0; i < arraySize; i++) {
        cout << element[i] << " ";
    }
    cout << endl;

    return 0;
}

____________________________________________________