LASD

-------MAIN--------
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "libreria_heap.h"
#define MAX 50

int scelta_arraysize(void);
void riempi_array(int[], int);
int ricerca(int [], int, int);

int main()
{
    int dim_array, heapsize, array[], elem, i, indice_elem = 0;
    dim_array = scelta_arraysize();
    riempi_array(array, dim_array);
    //Costruisco heap:
    heapsize = build_heap(array, dim_array);
    //Stampo heap:
    printf("Heap generato:\n");
    for(i = 0; i < dim_array; i++)
        printf("%d ", array[i]);
    do
    {
        printf("\nQuale elemento vuoi eliminare?\n");
        scanf("%d", &elem);
        indice_elem = ricerca(array, elem, dim_array);
        if (indice_elem == - 1)
        printf("Elemento non presente.\n");
    }while(indice_elem == - 1);
    heapsize = delete_elem(array, heapsize, indice_elem);
    printf("Nuovo heap:\n");
    for(i = 0; i < dim_array; i++)
        printf("%d ", array[i]);

    return 0;
}

int ricerca(int array[], int elem, int dim_array)
{
    int indice_array;
    for(indice_array = 0; indice_array < dim_array; indice_array++)
    {
        if(array[indice_array] == elem)
            return indice_array;
    }
    return -1;
}

int scelta_arraysize(void)
{
    printf("Quanti elementi vuoi inserire nell'array?\n");
    do
    {
        scanf("%d", &dim_array);
        if(dim_array > MAX)
            printf("\nMassima dimensione dell'array e' %d! Inserire dimensione:\n", MAX);
    }while(dim_array > MAX);
}

void riempi_array(int array[], int dim_array)
{
    int i, x;
    srand(time(NULL));
    printf("Come vuoi riempire l'array?\n1. Manualmente\n2.Casualmente");
    scanf("%d", &x);
    switch(x)
    {
        case 1:
            printf("Dammi gli elementi dello heap (solo elementi positivi):\n");
            for(i = 0; i < dim_array; i++)
                scanf("%d", &array[i]);
            break;
        case 2:
            //Riempio l'array con numeri da 1 a 50 scelti da una distribuzione pseudocasuale:
            for(i = 0; i < dim_array; i++)
                array[i] = rand() % 50 + 1;
            break;
    }
    printf("Array riempito correttamente!\n");
    return;
}

----- libreria_heap.h -----
int left(int);
int right(int);
int parent(int);
void heapify(int [], int, int);
void build_heap(int [], int);
void heapsort(int []);
void swap(int, int, int[]);

----- libreria_heap.c -----
#include <stdio.h>
#include <stdlib.h>
#include "libreria_heap.h"

int left(int);
int right(int);
int parent(int);
void heapify(int [], int, int);
void build_heap(int [], int);
void heapsort(int []);
void swap(int, int, int[]);
int delete_elem(int [], int, int);

void heapify(int array[], int nodo, int dim_array)
{
    int figlio_sx, figlio_dx, largest, heapsize = dim_array;
    figlio_sx = left(nodo);
    figlio_dx = right(nodo);
    if (figlio_sx < heapsize && A[figlio_sx] > A[nodo])
        largest = figlio_sx
    else
        largest = nodo;
    if (figlio_dx < heapsize && A[figlio_dx] > A[largest])
        largest = figlio_dx
    if(nodo != largest)
    {
        swap(nodo, largest, array);
        heapify(array, largest, dim_array);
    }
    return;
}

int build_heap(int A[], int dim_array)
{
    int i, heapsize;
    heapsize = dim_array;
    for (i=ArraySize/2; i>=0; i--)
        heapify(A, i, dim_array);
    return heapsize;
}

void heapsort(int A[], int dim_array)
{
    int i, heapsize;
    heapsize = dim_array;
    build_heap(A, dim_array);
    for (i = dim_array - 1; i >= 1; i--) {
        swap(0, i, A);
        heapsize--;
        heapify(A, 0, dim_array);
    }
}

void swap(int i, int j, int A[])
{
    int tmp = A[i];
    A[i] = A[j];
    A[j] = tmp;
}

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

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

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

int delete_elem(int array[], int heapsize, int indice_elem)
{
    array[indice_elem] = -1;
    heapify(array, indice_elem, heapsize);
    return heapsize - 1;
}