AVL

#include "stdio.h"
#include "malloc.h"
#include "string.h"

using namespace std;


struct Produse {
    char* denumire;
    int cantitate;
    char* unitate_de_masura;
};

struct Comanda
{
    int id_comanda;
    char* denumire_client;
    int numar_produse_comanda;
    Produse** vector_produse_comandate;
    char* data_livrare;

};


struct BST
{
    Comanda* info;
    BST* left;
    BST* right;
    int GE;

};


Produse* creareProdus(char* den, int cant, char* um)
{
    Produse* newProdus = (Produse*)malloc(sizeof(Produse));
    newProdus->cantitate = cant;
    newProdus->denumire = (char*)malloc(strlen(den) + 1);
    newProdus->unitate_de_masura = (char*)malloc(strlen(um) + 1);
    strcpy(newProdus->denumire, den);
    strcpy(newProdus->unitate_de_masura, um);
    return newProdus;
}

Comanda* creareComanda(int id, char* den, int nr_prod,
    Produse** vector, char*data)
{
    Comanda* newComanda = (Comanda*)malloc(sizeof(Comanda));
    newComanda->id_comanda = id;
    newComanda->numar_produse_comanda = nr_prod;
    newComanda->vector_produse_comandate = (Produse**)malloc(sizeof(Produse*)*nr_prod);
    for (int i = 0; i < nr_prod; i++)
    {
        newComanda->vector_produse_comandate[i] = (Produse*)malloc(sizeof(Produse));
        newComanda->vector_produse_comandate[i] = vector[i];
    }
    newComanda->data_livrare = (char*)malloc(strlen(data) + 1);

    newComanda->denumire_client = (char*)malloc(strlen(den) + 1);
    strcpy(newComanda->data_livrare, data);
    strcpy(newComanda->denumire_client, den);

    return newComanda;
}

BST* creareNod(Comanda* c)
{
    BST* nod = (BST*)malloc(sizeof(BST));
    nod->info = creareComanda(c->id_comanda, c->denumire_client,
        c->numar_produse_comanda, c->vector_produse_comandate, c->data_livrare);
    nod->right = nod->left = NULL;
    return nod;

}




int calculInaltime(BST* root) {

    if (root) {

        int hsleft = calculInaltime(root->left);
        int hsright = calculInaltime(root->right);
        return 1 + (hsleft - hsright ? hsleft : hsright);
    }
    else {
        return 0;
    }
}

int calculGE(BST* root)
{
    int hsleft = 0, hsright = 0;
    if (root->right != NULL)
        hsright = calculInaltime(root->right);
    if (root->left != NULL)
        hsleft = calculInaltime(root->left);
    return hsright - hsleft;
}


BST* RotireDreapta(BST* pivot) {

    BST* desc = pivot->left;
    pivot->left = desc->right;
    desc->right = pivot;
    pivot = desc;
    return pivot;
}

BST* RotireStanga(BST* pivot) {

    BST* desc = pivot->right;
    pivot->right = desc->left;
    desc->left = pivot;
    pivot = desc;
    return pivot;

}


BST* reechilibrare(BST* root) {

    root->GE = calculGE(root);
    if (root->GE == 2) {

        BST* desc = root->right;
        if (desc->GE == 1)
        {
            //simpla rotire la stanga in pivot
            root = RotireStanga(root);
        }
        else
        {
            //simpla rotire la dr in desc
            root->right = RotireDreapta(desc);
            //simpla rotire la stg in pivot
            root = RotireStanga(root);
        }
    }
    else if (root->GE == -2)
    {
        BST* desc = root->left;
        if (desc->GE == -1) {
            root = RotireDreapta(root);
        }
        else {

            //simpla rotire la dr in desc
            root->left = RotireStanga(desc);
            //simpla rotire la stanga in pivot
            root = RotireDreapta(root);

        }
    }
    return root;
}

void inserareNod(BST*& radacina, BST* nod)
{
    if (radacina == NULL)
    {
        radacina = nod;
    }
    else
    {
        if (radacina->info->id_comanda < nod->info->id_comanda)
            inserareNod(radacina->left, nod);
        else
            if (radacina->info->id_comanda > nod->info->id_comanda)
                inserareNod(radacina->right, nod);
            else
                printf("Cheie existenta");
    }
    radacina = reechilibrare(radacina);

}

void creareArboreBinarCautare(BST** radacina, FILE* fisier)
{
    int id_comanda;
    char nume[20];
    int nr_produse;
    char data[20];
    char nume_produs[15];
    int cantitate;
    char unitate_masura[3];
    fscanf(fisier, "%d", &id_comanda);
    while (!feof(fisier))
    {
        Produse** vector_produse = NULL;
        fscanf(fisier, "%s", &nume);
        fscanf(fisier, "%d", &nr_produse);
        vector_produse = (Produse**)malloc(sizeof(Produse*)*nr_produse);
        fscanf(fisier, "%s", &data);
        for (int i = 0; i < nr_produse; i++)
        {
            vector_produse[i] = (Produse*)malloc(sizeof(Produse));
            fscanf(fisier, "%s", &nume_produs);
            fscanf(fisier, "%d", &cantitate);
            fscanf(fisier, "%s", &unitate_masura);
            Produse* p = creareProdus(nume_produs, cantitate, unitate_masura);
            vector_produse[i] = p;
        }
        Comanda* c = creareComanda(id_comanda, nume, nr_produse, vector_produse, data);
        BST* nod = creareNod(c);
        inserareNod(*radacina, nod);
        fscanf(fisier, "%d", &id_comanda);
    }
}






void afisareStructuraInOrdine(BST* radacina)
{
    if (radacina)
    {
        afisareStructuraInOrdine(radacina->left);
        printf("%d\n",radacina->info->id_comanda);

        afisareStructuraInOrdine(radacina->right);
    }
}

int* IntoareUnVector(BST* radacina, char* data,int &i, int* vector2)
{

    int vector[5];

    if (radacina) {
        if (strcmp(radacina->info->data_livrare, data) == 0)
        {
            vector[i] = radacina->info->id_comanda;

            vector2[i] = vector[i];
            i++;
        }
            IntoareUnVector(radacina->left, data ,i,vector2);
            IntoareUnVector(radacina->right, data,i,vector2);
        }



    return vector2;

}


int NumarNoduriFrunza(BST* radacina, char* nume_client,int &numar)
{
    if (radacina)
    {
        if(radacina->left==NULL&&radacina->right==NULL)
            if (strcmp(radacina->info->denumire_client, nume_client)==0)
            {
                numar++;
            }
        NumarNoduriFrunza(radacina->left, nume_client, numar);
        NumarNoduriFrunza(radacina->right, nume_client, numar);
    }
    return numar;
}


void AfisarePeNiveleFrumos(BST* radacina, int nivel)
{
    if (radacina)
    {
        for (int i = 0; i < nivel; i++)
        {
            printf("\t");

        }

        printf("%d\n", radacina->info->id_comanda);


        AfisarePeNiveleFrumos(radacina->left, nivel + 1);


        AfisarePeNiveleFrumos(radacina->right, nivel + 1);
    }
    else
    {
        for (int i = 0; i < nivel; i++)
        {
            printf("\t");

        }
        printf("NULL\n");

    }

}


void ModificaProduseComandate(BST** radacina,int numar_produse, char** denumiri, int* cantitati, char** unitati_masura,int id_comanda)
{
    if ((*radacina))
    {
        if ((*radacina)->info->id_comanda == id_comanda)
        {
            free((*radacina)->info->vector_produse_comandate);
            (*radacina)->info->vector_produse_comandate = (Produse**)malloc(sizeof(Produse*)*numar_produse);
            (*radacina)->info->numar_produse_comanda = numar_produse;

            for (int i = 0; i < numar_produse; i++)
            {
                (*radacina)->info->vector_produse_comandate[i] = (Produse*)malloc(sizeof(Produse));
                (*radacina)->info->vector_produse_comandate[i]->cantitate = cantitati[i];
                (*radacina)->info->vector_produse_comandate[i]->denumire = (char*)malloc(sizeof(strlen(denumiri[i] + 1)));
                (*radacina)->info->vector_produse_comandate[i]->unitate_de_masura = (char*)malloc(sizeof(strlen(unitati_masura[i] + 1)));
                strcpy((*radacina)->info->vector_produse_comandate[i]->denumire, denumiri[i]);
                strcpy((*radacina)->info->vector_produse_comandate[i]->unitate_de_masura, unitati_masura[i]);


            }

        }

        ModificaProduseComandate(&(*radacina)->right, numar_produse, denumiri, cantitati, unitati_masura, id_comanda);
        ModificaProduseComandate(&(*radacina)->left, numar_produse, denumiri, cantitati, unitati_masura, id_comanda);

    }
}




void main()
{
    BST* radacina = NULL;
    FILE* fisier = fopen("Date.txt", "r");
    char buffer[20];

    creareArboreBinarCautare(&radacina, fisier);
    printf("Afisare structura \n");
    //afisareStructuraInOrdine(radacina);
    char data[20] = "15.06.2019";
    int i = 0;
    int* vector2=NULL;
    vector2 = (int*)malloc(sizeof(int) * 5);
    vector2 = IntoareUnVector(radacina,data,i,vector2);
    if (i==0)
        printf("nu exista nicio comanda care sa corespunda");
    else

        for (int j = 0; j < i; j++)
            printf("vectorul cu id comenzi : vector[%d]= %d\n", j,vector2[j]);

    char nume[20] = "Mihai";
    int numar = 0;
    numar = NumarNoduriFrunza(radacina, nume, numar);
    printf("Numarul de frunze cu numele Mihai%d\n", numar);

    printf("=====AFISARE PE NIVELE======\n");
    AfisarePeNiveleFrumos(radacina, 0);

    char* denumiri[10] = { "Pepene","Morcov" };
    char* unitati_de_masura[10] = { "kg","kg" };
    int numar_produse = 2;
    int cantitati[2] = { 333,333 };

    ModificaProduseComandate(&radacina, numar_produse, denumiri, cantitati, unitati_de_masura, 2);

    afisareStructuraInOrdine(radacina);




}