Question

c++,

hello, can someone please explain the following questions preferably in code with an explanation of how & why it happened? the professor said this was going to be on a final but i am very confused on this.

a) transfer an array into a binary tree?

b) how to make it into a heap?

c) how to make it sorted?

d) and how to work with its children and parents?

Answer 1

#include <iostream>
#include <cstdlib>
using namespace std ;

// here the array elements are passed as reference so the actual value inside the passed array will be modified
void swap(int *a, int *b)
{
    int temp = *a; // copy value at address a and place it to temp
    *a = *b; // content of what pointed by  pointer b will be updated inside the variable pointed by pointer b
    *b = temp;
}
void display(int arr[], int n)
{
    for (int i=0; i<n; ++i)
        cout << arr[i] << " ";
    cout << "\n";
}


void MinHeapify(int *arr, int index, int size)
{
    // We need to find the minimum of ( parent , left child , right child )


    // if parent is at index i then left child will be at array index 2*index +1
    int left = 2*index + 1;
    int right = 2*index + 2; // for parent at index i its parent will be at index 2* index + 2
    int smallest = index; // initialize index as the smallest of ( parent , left child and the right child )

    if (left < size  /* we should remain inside the array scope */  && arr[left] < arr[index])
        smallest = left;
    if (right < size && arr[right] <arr[smallest])
        smallest = right;

    // now you found the smallest between( parent , left child , and right child )

    // if smallest is parent then for min heap there is no problem but

    // but if parent is greater than any of the child we need to swap the ( parent( index i ) and the smallest )
    if (smallest != index)
    {
        swap(&arr[index], &arr[smallest]);
        MinHeapify(arr, index, smallest);// since the index element reached to the new position now we need to check
        // wether the element at the new position satisfy the property of min heap so again call minHeapify() on the
        // swapped element
    }
}


void heapSort(int *arr, int size)
{

    // we will take the minimum( root ) and place it at the last array[last _ index]  and take the second last
    // element and make it root
    for (int i=size-1 ; i>=0; i--)
    {
        // swap current root to end
        swap(arr[0], arr[i]);

        // since the root element has  been modified  in order to ensure that the tree satisfy  minHeap property we
        // apply the minHeapify() on the reduced size heap( size is reduced by -1) so

        // minHeapify() will not check the prevoius root( minimum ) at each pass 
        MinHeapify(arr, 0 , i   );//
    }
}



void buildMinHeap(int *arr, int size)
{
    /* this method will start its action from the first non leaf that is
     * since lowest level( leaf)  contain size/2 +  1  ( index    size to size/2 -1 ) nodes so
     * skip all leaves and start from the first non leaf node
     * which is at the index size/2 - 1 and iterate till you reach the root ( index 0 ) */


    int index;
    for(index = size/2 -1; index >= 0; index-- ) // for all non leaf nodes
        MinHeapify(arr, index, size);
}



int main()
{
    int *arr, size, index;
    printf("Enter size of heap\n");
    scanf("%d", &size);

    //allocate memory
    arr = (int *) malloc(sizeof(int) * size);

    printf("Enter elements in heap\n");
    // Here we are adding the elements in array and this array will be converted to min heap
    for(index = 0; index < size; index++)
        scanf("%d", &arr[index]);


cout<< "display the initial array  : ";
    display(arr , size );

    buildMinHeap(arr, size);
    cout << "The min heap array is :";
    display(arr , size);


    // for sorting we can apply heap sort procedure which will take the min heaped( array) as input and produce the
    // sorted array
    heapSort(arr , size );
    cout<< "The sorted array using heap-sort  :" << endl ;

    display(arr , size );





}

Enter size of heap Enter elements in heap 23 23 54 54 34 34 75 75 31 31 display the initial array23 54 66 22 34 75 31 The min heap array is :22 23 31 54 34 75 66 The sorted array using heap-sort 5 66 54 34 31 23 22 Process finished with exit code Activate Win