¿Cómo liberar () de forma correcta y segura toda la memoria usando una estructura anidada en C?

Tengo cuatro capas diferentes de estructura anidadas. El código es el siguiente:

typedef struct System system;  
typedef struct College college;
typedef struct Student student;
typedef struct Family family;

#define MAX_COLLEGES 10
#define MAX_NAME_LEN 32
#define MAX_STUDENTS 10

struct System {
    college *Colleges[MAX_COLLEGES];
};

struct College {
    char name[MAX_NAME_LEN];
    student *Students[MAX_STUDENTS];
};

struct Student {
    char name[MAX_NAME_LEN];
    int id;
    family *fam; //was typo familiy
};

struct Family {
    char fatherName[MAX_NAME_LEN];
    char motherName[MAX_NAME_LEN];
};

Y asigné memoria a todos ellos (no estoy seguro de si los asigné todos correctamente), de la siguiente manera:

system *collegeSys = malloc(sizeof(system));
college *colleges = malloc(sizeof(college));
student *students = malloc(sizeof(student));
family *fam = malloc(sizeof(family));

// then the following is initialization
...
...
...

Ahora, necesito eliminar la collegeSysestructura y cualquier cosa asociada con ella. Entonces, no sé si puedo liberar la primera collegeSysestructura sin liberar ninguna otra estructura, como esta:

free(collegeSys);

O para "eliminar cualquier cosa asociada con él", tengo que liberar todo de abajo hacia arriba, así:

free(fam);
free(students);
free(colleges);
free(collegeSys);

O con ese fin, incluso tengo que liberar todo lo que esté incluido dentro de cada estructura y liberarlo de abajo hacia arriba, así:

free (fam -> fatherName);
free (fam -> motherName);
free (fam);
free (students -> name);
free (students -> id);
free (students -> fam);
free (students)
.
. till
.
free (collegeSys -> colleges);
free (collegeSys);

¿Cuál es la forma correcta y segura de liberar la memoria? ¿O ninguno de ellos lo es?

Realmente no entiendo el punto de tener una matriz de punteros, se podría hacer con puntero.

Definición:

struct System {
    college *Colleges;
};

struct College {
    char name[MAX_NAME_LEN];
    student *Students;
};

struct Student {
    char name[MAX_NAME_LEN];
    int id;
    familiy *fam;
};

struct Family {
    char fatherName[MAX_NAME_LEN];
    char motherName[MAX_NAME_LEN];
};

Asignación e inicialización:

system *collegeSys = malloc(sizeof(*collegeSys));
collegeSys->colleges = malloc(MAX_COLLEGES * sizeof(*(collegeSys->colleges)));
collegeSys->colleges->students = malloc(MAX_STUDENTS * sizeof(*(collegeSys->colleges->students)));
collegeSys->colleges->students->fam = malloc(sizeof(*(collegeSys->colleges->students->fam)));

Liberando:

free(collegeSys->colleges->students->fam);
free(collegeSys->colleges->students);
free(collegeSys->colleges);
free(collegeSys);

Actualizar:

Como si quisiera tener un estudiante estructurado A, B, C, D bajo una estructura universitaria

 collegeSys->colleges->students[0] = A;
 collegeSys->colleges->students[1] = B;
 collegeSys->colleges->students[2] = C;
 collegeSys->colleges->students[3] = D;

Deberías hacerlo.

Si tiene una matriz de students, puede usar memcpyo copiar loop.

struct student stud[MAX_STUDENTS] = {...};

memcpy(collegeSys->colleges->students[2], stud, MAX_STUDENTS);

o

for (int i = 0; i< MAX_STUDENTS; i++)
     collegeSys->colleges->students[i] = stud[i];

Nota:

Puede asignar la matriz a, collegeSys->colleges->studentsen ese caso, no necesita asignación de memoria dinámica o liberación.

 // collegeSys->colleges->students = malloc(MAX_STUDENTS * sizeof(*(collegeSys->colleges->students)));  //Leaks memory

 collegeSys->colleges->students = stud;

//free(collegeSys->colleges->students); //wrong

Cuando asigne una estructura, establezca todos los punteros en NULL. Por ejemplo, para asignar la estructura de su universidad, debe establecer todos los estudiantes en NULL:

struct College* CollegeAlloc( char name[MAX_NAME_LEN] ) {
    struct College* college = malloc( sizeof(struct College) );
    if ( college ) {
        for ( int i = 0; i < MAX_STUDENTS; ++i )
            college->Students[i] = NULL;
        memcpy( college->name, name, MAX_NAME_LEN );
    }
    return college;
}

Alternativamente, puede agregar un campo de recuento en las estructuras de cada matriz, para contar el número de elementos de la matriz que se utilizan realmente.

Si establece el elemento de la matriz en NULL cuando no se usa, puede liberarlo de abajo hacia arriba primero.

void FamilyFree( struct Family *fam ) {
    free( fam );
}
void StudentFree( struct Student *student ) {
    if ( student ) {
        FamilyFree( student->fam );
        free( student );
    }
}
void CollegeFree( struct College *college ) {
    if ( college ) {
        for ( int i = 0; i < MAX_STUDENTS; ++i )
            StudentFree( college->Students[i] );
        free( college );
    }
}
void SystemFree( struct System *sys ) {
    if ( sys ) {
        for ( int i = 0; i < MAX_COLLEGES; ++i )
            CollegeFree( sys->Colleges[i] );
        free( sys );
    }
}

Tenga en cuenta que esto supone que no se comparten sugerencias, por ejemplo, el mismo estudiante está en más de una universidad (cuando la implementación ha asignado solo una estructura para cada estudiante), o cuando hay dos hermanos que comparten la misma estructura familiar. (la estructura familiar no modela muy bien a las familias, por ejemplo, padres solteros, divorciados, vueltos a casar, padres homosexuales, tutores legales). Cuando las estructuras se pueden compartir, puede poner un recuento de referencia en la estructura y liberar solo cuando se reduzca a cero.