aggeggio

//
//  main.c
//  SKProject
//
//  Created by Luca Orizio on 31/07/18.
//  Copyright © 2018 Luca Orizio. All rights reserved.
//
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct {
    char label;
    struct Ramo* riferimenti[50];
    int i;
    bool print;
}Nodo;

typedef struct {
    int w;
    struct Nodo* prec;
    struct Nodo* succ;
    bool isDrawed;
}Ramo;

typedef struct {
    Nodo* nodi[50];
    int size;
    int risultatoRicerca;
}Grafo;

Nodo* getNodo(Grafo* G, char n){
    Nodo* daConfrontare;
    for(int i=0; i < G -> size; i++){
        daConfrontare = G -> nodi[i];
        if (daConfrontare -> label == n) {
            G -> risultatoRicerca = i;
            return daConfrontare;
        }
    }
    return NULL;
}
/*
 Ramo* getRamo(Nodo* source, Nodo* sk){
 Ramo* daRestituire;
 Nodo* daConfrontare;
 for (int i = 0; i < source -> i; i++) {
 daRestituire = (Ramo *) source -> riferimenti[i];
 
 if (daRestituire -> succ == sk) {
 return daRestituire;
 }
 }
 return NULL;
 }
 */
void addRamoNelNodo(Nodo* n, Ramo* r){
    int pos = n -> i;
    n -> riferimenti[pos] = r;
    n -> i = ++pos;
}

void addRamo(Nodo* source, Nodo* sk, int peso){
    Ramo* nuovo = malloc(sizeof(Ramo));
    nuovo -> w = peso;
    nuovo -> prec = source;
    nuovo -> succ = sk;
    addRamoNelNodo(source, nuovo);
    addRamoNelNodo(sk, nuovo);
}

Nodo* addNodo (Grafo* G, char n, int peso, char altro){
    int i = G -> size;
    Nodo* nuovo = getNodo(G, n);
    if (nuovo == NULL) {
        nuovo = malloc(sizeof(Nodo));
        nuovo -> label = n;
        nuovo -> i = 0;
        G -> nodi[i] = nuovo;
        G -> size = ++i;
    }else printf("Attenzione! è già stato trovato un nodo con lo stesso nome!");
    
    if (altro != NULL) {
        Nodo* daCollegare = getNodo(G, altro);
        if (daCollegare != NULL) {
            addRamo(nuovo, daCollegare, peso);
        } else printf("Attenzione! Nodo %c non trovato!", altro);
    }
    return nuovo;
}
void eliminaRiferimenti(Nodo* nodo, Ramo* ramo){
    for (int i = 0; i < nodo -> i; i++) {
        if ((Ramo *) nodo -> riferimenti[i] == ramo) {
            nodo -> riferimenti[i] = NULL;
        }
    }
}

void eliminaNodo(Grafo* G, char n){
    Ramo* riferimentoDaEliminare;
    Nodo* daEliminare = getNodo(G, n);
    Nodo* nodoCollegato;
    if (daEliminare != NULL) {
        for (int i = 0; i < daEliminare -> i; i++) {
            riferimentoDaEliminare = (Ramo *) daEliminare -> riferimenti[i];
            if (daEliminare == (Nodo *)riferimentoDaEliminare -> prec) {
                nodoCollegato = (Nodo *) riferimentoDaEliminare -> succ;
                eliminaRiferimenti(nodoCollegato, riferimentoDaEliminare);
            }else{
                nodoCollegato = (Nodo *) riferimentoDaEliminare -> prec;
                eliminaRiferimenti(nodoCollegato, riferimentoDaEliminare);
            }
        }
        G -> nodi[G -> risultatoRicerca] = NULL;
        free(daEliminare);
    }
}

bool isPrint(Nodo* nodo){
    return nodo -> print == true;
}

void inizializzaPrint(Grafo* G){
    Nodo* nodo;
    for (int i = 0; i < G -> size; i++) {
        nodo = G -> nodi[i];
        if (nodo != NULL) {
            nodo -> print = false;
        }
    }
}

void esploraGrafo(Nodo* nodo){
    Ramo* ramo;
    if (!isPrint(nodo)) {
        printf("%c -> ", nodo -> label);
        nodo -> print = true;
    }
    for (int i = 0; i < nodo -> i; i++) {
        ramo =(Ramo *) nodo -> riferimenti[i];
        if (ramo != NULL) {
            if ((Nodo *) ramo -> prec != nodo) {
                if (!isPrint((Nodo*) ramo -> prec)) {
                    esploraGrafo((Nodo *)ramo -> prec);
                }
            } else {
                if (!isPrint((Nodo *) ramo -> succ)) {
                    esploraGrafo((Nodo *) ramo -> succ);
                }
            }
        } //primo if, confronta il ramo con null. In seguito ad una cancellazione controllerebbe un elemento dell'array vuoto
    }
}

void ripristinaDrawed(Grafo* G){
    Nodo* nodo;
    Ramo* ramo;
    for (int i = 0; i < G -> size; i++) {
        nodo = G -> nodi[i];
        if (nodo != NULL) {
            for (int j = 0; j < nodo -> i; j++) {
                ramo = (Ramo *) nodo -> riferimenti[j];
                if (ramo != NULL) {
                    ramo -> isDrawed = false;
                }
            }
        }
    }
}

void creaPNG(Grafo* G){
    FILE* file;
    Nodo*  nodo;
    Nodo* prec;
    Nodo* succ;
    Ramo* ramo;
    ripristinaDrawed(G);
    file = fopen("grafo.dot", "w");
    fprintf(file, "%s\n", "digraph Grafo {");
    for (int i = 0; i < G -> size; i++) {
        nodo = G -> nodi[i];
        if (nodo != NULL) {
            for (int j = 0; j < nodo -> i; j++) {
                ramo =(Ramo *) nodo -> riferimenti[j];
                if (ramo != NULL) {
                    prec =(Nodo *) ramo -> prec;
                    succ =(Nodo *) ramo -> succ;
                    if (!ramo -> isDrawed) {
                        fprintf(file, "%c -> %c\n", prec -> label, succ -> label);
                        ramo -> isDrawed = true;
                    }
                }
            }
        }
    }
    fprintf(file, "%s", "}");
    fclose(file);
    system("neato-Tpng grafo.dot -o grafo.png");
    system("open grafo.png");
    
}


int main (void) {
    Grafo graf;
    graf.size = 0;
    char a = 'a', b = 'b', c = 'c', d = 'd', e = 'e';
    Nodo* aN = addNodo(&graf, a, 2, NULL);
    addNodo(&graf, b, 4, a);
    addNodo(&graf, c, 3, b);
    addNodo(&graf, d, 4, c);
    addNodo(&graf, e, 6, b);//addNodo(&graf,a,12,c)
    addRamo(getNodo(&graf, c), getNodo(&graf, a), 3);
    addNodo(&graf, '4', 3, d);
    addNodo(&graf, 'r', 3, c);
    addNodo(&graf, '2', 3, '4');
    addNodo(&graf, 'y', 3, a);
    addNodo(&graf, 'm', 3, b);
    addNodo(&graf, '9', 3, 'r');
    addNodo(&graf, 'o', 3, d);
    addNodo(&graf, 't', 3, a);
    addNodo(&graf, 'C', 3, c);
    addNodo(&graf, '0', 3, 'C');
    addNodo(&graf, 'u', 3, a);
    addNodo(&graf, 'z', 10, NULL);
    addNodo(&graf, 'f', 7, NULL);
    addNodo(&graf, 'g', 3, 'y');
    addNodo(&graf, 'k', 3, 'C');
    addNodo(&graf, 'q', 3, NULL);
    addNodo(&graf, 's', 3, NULL);
    addNodo(&graf, 'z', 9, 'q');
    addRamo(getNodo(&graf, 'y'), getNodo(&graf, 'c'), 11);
    addRamo(getNodo(&graf, 'y'), getNodo(&graf, 'C'), 11);
    addRamo(getNodo(&graf, 'z'), getNodo(&graf, 'g'), 11);
    addRamo(getNodo(&graf,'o'), getNodo(&graf, '4'), 11);
    addRamo(getNodo(&graf, '0'), getNodo(&graf, 'a'), 11);
    addRamo(getNodo(&graf, 's'), getNodo(&graf, 'c'), 11);
    creaPNG(&graf);
    //esploraGrafo(aN);
    return 0;
}