complessità funzione main che c'era nel progetto dev c++

vvv LA COMPLESSITA' E' ALLA FINE vvv

#include "fun.h"

int main(){
    int i=2, a, S=2, N, iterazioni=10, delay_istantanee=2, time=0, log=1;;  //Le variabili sono inizializzate a valori tali da non dare problemi nei controlli all'avvio del programma
    struct strada *confluenti[N_S]={NULL,NULL,NULL,NULL,NULL};// Ovvero tutte le strade sono vuote
    struct strada rotatoria[N_P]={};
    do {
            printf("1 - Carica da file situazione iniziale azzerando situazioni precedenti\n2 - Inserisci macchine\n3 - Rimuovi macchina\n4 - Stampa situazione\n5 - Simula rotatoria (Standard: 10 istantanee)\n6 - Salva situazione su file (Sovrascrivera' situazioni precedenti)\n7 - Impostazioni\n0 - EXIT\n");
            while(S<0 || S>7 || scanf("%d", &S)!=1){
                while (getchar() != '\n');
               printf("Input non valido\n\n1 - Carica da file situazione iniziale azzerando situazioni precedenti\n2 - Inserisci macchine\n3 - Rimuovi macchina\n4 - Stampa situazione\n5 - Simula rotatoria (Standard: 10 istantanee, 2 secondi per ognuna)\n6 - Salva situazione su file (Sovrascrivera' situazioni precedenti)\n7 - Impostazioni\n0 - EXIT\n");
               scanf("%d", &S);
               system("cls");
            }
               switch (S){
                   case 1:
                       read_file(rotatoria); break;
                   case 2:
                       printf("In quale strada vuoi inserirle? [0-4]\n");
                       while(i<0 || i>4 || scanf("%d", &i)!=1){
                            while (getchar() != '\n');
                           printf("Input non valido, riprovare\n");
                           scanf("%d", &i);
                       }
                           printf("Quante macchine vuoi inserire?\n");
                           scanf("%d", &N);
                       for(; N>=1; N--)
                           new_road(confluenti, i); break;
                    case 3:
                        remove_car(confluenti); break;
                   case 4:
                       stampa_situazione(confluenti,rotatoria); break;
                   case 5:
                           system("cls");
                           for (a=0;a<10;a++){
                                if(time==a){
                                    Sleep(2000);
                                    stampa_situazione(confluenti,rotatoria);
                                    time+=delay_istantanee;
                                }
                               shift_L(rotatoria);
                               check_exit(rotatoria, &time, &log);
                               check_enter(rotatoria,confluenti);
                           }time=0; break;
                    case 6:
                        save_file(rotatoria); break;
                    case 7:
                         impostazioni(&iterazioni,&delay_istantanee,&log, rotatoria);
                         printf("%d iterazioni con %d delay quindi %d istanee\n",iterazioni,delay_istantanee,iterazioni/delay_istantanee);
                         printf("L'uscita delle auto viene ");
                         if(log==0)
                            printf("visualizzata a video\n\n");
                         else printf("stampata su file\n\n");break;
               }
    }
    while (S!=0);
    pulizia(rotatoria, confluenti);
    return 0;
}

COMPLESSITA' v v v

comp_17 - main
{
    TEMPO
    L'algoritmo fa eseguire un ciclo do-while e fintanto che si inserisce un input valido, si attiva uno switch case che in base all'input richiama
    un qualche particolare algoritmo o funzione.
    Nel caso 1, si richiama la funzione read_file che ha complessità O(N_P) dove N_P è la dimensione della struttura dati usata per la rotatoria;
    nel caso 2, si richiama un ciclo for nel quale si richiama la funzione new_road che ha complessità O(N_S) (N_S è la dimensione della variabile
    confluenti); per cui la complessità del caso 2 è N*O(N_S) con N numero di macchine da inserire;
    nel caso 3 si richiama la funzione remove_car che ha complessità O(N_S);
    nel caso 4 si richiama la funzione stampa_situazione che ha complessità O(n) dove n è la somma di N_S e N_P;
    nel caso 5 c'è un ciclo for al cui interno c'è un if che se valutato vero richiama la funzione stampa_situazione (complessità O(n)); poi si
    richiama la funzione shift_L che ha complessità O(N_P) e poi si richiamano le funzioni check_exit e check_enter che hanno complessità O(N_P),
    facendo avere al caso 5 una complessità asintotica di tempo nel caso peggiore (if valutato vero) di O(n);
    nel caso 6 si attiva la funzione save_file che ha complessità O(N_P);
    nel caso 7 si attiva la funzione impostazioni, che ha complessità nel suo caso peggiore di O(N_P).
    Alla fine del do-while si attiva la funzione pulizia che ha complessità costante.
    In definitiva, la complessità asintotica di tempo nel caso peggiore di tutto l'algoritmo corrisponde all'attivazione del caso 5 che ha complessità
    O(n).
    SPAZIO
    Come nella complessità temporale, poichè le strutture dati utilizzate sono due array di struct con dimensione N_P e N_S e poichè le funzioni chiamate
    alterano la loro dimensione, la complessità spaziale massima corrisponde a O(n) con n = N_P + N_S.
}