GRAF

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


struct Fruct

{
    char* nume;
    int id;
};

struct Nod
{
    Fruct* info;
    Nod* pNext;
};


struct Graf
{
    Nod** elemente;
    int size;
};



Fruct* creareFructe(int id, char* nume)
{
    Fruct* newFruct = (Fruct*)malloc(sizeof(Fruct));

    newFruct->nume = (char*)malloc(strlen(nume) + 1);
    strcpy(newFruct->nume,nume);
    newFruct->id = id;
    return newFruct;
}


Nod* creareNod(Fruct* info)
{
    Nod* newNod = (Nod*)malloc(sizeof(Nod));
    newNod->info = info;
    newNod->pNext = NULL;
    return newNod;
}


Graf* initGraf(int size)
{

    Graf* graf = (Graf*)malloc(sizeof(Graf));
    graf->elemente = (Nod**)malloc(size * sizeof(Nod*));
    graf->size = size;
    for (int i = 0; i < size; i++)
    {

        graf->elemente[i] = NULL;
    }
    return graf;
}


void adaugareMuchie(Graf** graf, Nod* sursa, Nod* destinatie)
{
    //Nod* sursaDest = (Nod*)malloc(sizeof(Nod));
    Nod* sursaDest = (Nod*)malloc(sizeof(Nod));
    sursaDest->info = destinatie->info;
    sursaDest->pNext = NULL;
    if ((*graf)->elemente[sursa->info->id] == NULL)
        (*graf)->elemente[sursa->info->id] = sursaDest;
    else
    {
        Nod* temp = (*graf)->elemente[sursa->info->id];
        while (temp->pNext)
        {
            temp = temp->pNext;
        }
        temp->pNext = sursaDest;

    }




    /*sursaDest->info=destinatie->info;
    sursaDest->pNext = (*graf)->elemente[(sursa->info->id)];
    (*graf)->elemente[(sursa->info->id)] = sursaDest;*/


    Nod* Destsursa = (Nod*)malloc(sizeof(Nod));
    Destsursa->info = sursa->info;
    Destsursa->pNext = NULL;
    if ((*graf)->elemente[destinatie->info->id] == NULL)
        (*graf)->elemente[destinatie->info->id] = Destsursa;
    else
    {
        Nod* temp = (*graf)->elemente[destinatie->info->id];
        while (temp->pNext)
        {
            temp = temp->pNext;

        }
        temp->pNext = Destsursa;

    }
    //Nod* Destsursa = (Nod*)malloc(sizeof(Nod));//temp2
    //Destsursa->info=sursa->info;
    //Destsursa->pNext = (*graf)->elemente[(destinatie->info->id)];
    //(*graf)->elemente[(destinatie->info->id)] = Destsursa;

}



void matriceAdiacenta(Graf* graf, int matrice[5][5])
{
    for (int i = 0; i < 5; i++)
    {
        Nod* temp = graf->elemente[i];

        while (temp)
        {
            matrice[i][temp->info->id] = 1;
            temp = temp->pNext;
        }


    }


}

void printeazaVecini(Graf* graf, int id)
{

    for (int i = 0; i < graf->size; i++)
    {
        if (graf->elemente[i])
        {
            if ((i+1) == id)
            {
                Nod* temp = graf->elemente[i];

                while (temp)
                {
                    printf("%d ", temp->info->id+1);
                    temp = temp->pNext;
                }


                /*while (graf->elemente[i])
                {
                    printf("%d ", graf->elemente[i]->info->id + 1);
                    graf->elemente[i] = graf->elemente[i]->pNext;

                }*/
            }
        }
    }
    printf("\n");
}


void parcurgerePeLatime(Graf* graf, int nod_start, int matrice[5][5])
{

    int pInitial=0;
    int noduri_vizitate=0;
    int vector[5] = { 0,0,0,0,0 };
    vector[nod_start - 1] = 1;

    int coada[5];
    coada[0] = nod_start-1;
    while (noduri_vizitate >= pInitial)
    {
        for (int i = 0; i < 5; i++)
        {
            if (matrice[coada[pInitial]][i] == 1 && vector[i] == 0)
            {
                noduri_vizitate++;
                coada[noduri_vizitate] = i;
                vector[i] = 1;

            }

        }
        printf("%d ", coada[pInitial]+1);

        pInitial++;
    }


    printf("\n");
}



void stergereNodDinVecini(Nod** graf, Nod* nod, int& OK)
{


        if ((*graf))
        {
            if((*graf)->info)
            if ((*graf)->info->id == nod->info->id)
            {

                Nod* temp = (*graf);
                (*graf) = (*graf)->pNext;
                if (OK == 0)
                {
                    free(temp->info->nume);
                    temp->info = NULL;
                    OK = 1;
                }

            }

            else
            {
                stergereNodDinVecini(&(*graf)->pNext, nod, OK);
            }
        }

}



void stergereNod(Graf** graf, Nod* nod, int OK)
{

    for (int i = 0; i < (*graf)->size; i++)
    {

            if (i == nod->info->id)
            {
                while ((*graf)->elemente[i])
                {

                    (*graf)->elemente[i] = (*graf)->elemente[i]->pNext;

                }

            }

            else
            {
                if ((*graf)->elemente[i])
                {
                    stergereNodDinVecini(&(*graf)->elemente[i], nod, OK);
                }
            }



    }



}


void main()
{


    Fruct* f1 = creareFructe(0, "para");
    Fruct* f2 = creareFructe(1, "caisa");
    Fruct* f3 = creareFructe(2, "capsuna");
    Fruct* f4 = creareFructe(3, "pepene");
    Fruct* f5 = creareFructe(4, "mar");


    Nod* n1 = creareNod(f1);
    Nod* n2 = creareNod(f2);
    Nod* n3 = creareNod(f3);
    Nod* n4 = creareNod(f4);
    Nod* n5 = creareNod(f5);


    Graf* graf = initGraf(5);


    adaugareMuchie(&graf, n1, n3);
    adaugareMuchie(&graf, n1, n5);
    adaugareMuchie(&graf, n1, n4);

    adaugareMuchie(&graf, n3, n5);
    adaugareMuchie(&graf, n4, n3);


    int matrice[5][5];
    for (int i = 0; i < 5; i++)

        for (int j = 0; j < 5; j++)
            matrice[i][j] = 0;


    matriceAdiacenta(graf, matrice);



    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
            printf("%d ", matrice[i][j]);
        printf("\n");
    }
    printf("\n");

    printeazaVecini(graf,5);
    printeazaVecini(graf, 5);
    printeazaVecini(graf, 5);
    printeazaVecini(graf, 4);




    parcurgerePeLatime(graf, 1,matrice);
    parcurgerePeLatime(graf, 2, matrice);
    parcurgerePeLatime(graf, 3, matrice);
    parcurgerePeLatime(graf, 4, matrice);
    parcurgerePeLatime(graf, 5, matrice);

    int OK = 0;

    for (int i = 0; i < 5; i++)

        for (int j = 0; j < 5; j++)
            matrice[i][j] = 0;

    stergereNod(&graf, n1, OK);

    matriceAdiacenta(graf, matrice);

    printf("\n");
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
            printf("%d ", matrice[i][j]);
        printf("\n");
    }
    printf("\n");


}