Gestión Dinámica de Registros de Alumnos: Implementación de Carga, Inserción Ordenada y Persistencia

Algoritmo de Gestión de Registros de Alumnos

1. Inicialización y Asignación de Memoria

1. CLASE <- (T_ALUMNO *) MALLOC (TAM_MAXIMO * sizeof(T_ALUMNO))
2. NUM_ELEM <- 0

2. Carga de Datos desde el Fichero ALUMNOS.DAT

// Leo los datos desde ALUMNOS.DAT

3. PF <- FOPEN ("ALUMNOS.DAT", "R")
4. SI (PF = NULL) ENTONCES
   1. // Si se ha producido un error al abrir el fichero
   2. ESCRIBIR "Error al abrir el fichero"
5. SINO
   1. // Leer los datos
   2. FREAD(&ALUMNO, sizeof(T_ALUMNO), 1, PF)
   3. MIENTRAS (!FEOF(PF))
      1. SI (!FERROR(PF)) ENTONCES
         1. // Verificación de capacidad y redimensionamiento
         2. SI (NUM_ELEM = TAM_MAXIMO) ENTONCES
            1. // Si el array está lleno, lo amplio (Redimensionamiento)
            2. TAM_MAXIMO <- TAM_MAXIMO + 1
            3. CLASE <- (T_ALUMNO *) REALLOC(CLASE, TAM_MAXIMO * sizeof(T_ALUMNO))
         3. FIN_SI
         4. // Almacenar el registro leído
         5. CLASE[NUM_ELEM] <- ALUMNO
         6. NUM_ELEM <- NUM_ELEM + 1
      2. SINO
         1. // Si se ha producido un error de lectura
         2. ESCRIBIR "Error de Lectura"
         3. // Desactivo el indicador de error
         4. CLEARERR(PF)
      3. FIN_SI
      4. FREAD(&ALUMNO, sizeof(T_ALUMNO), 1, PF)
   4. FIN_MIENTRAS
   5. // Cierro el fichero
   6. FCLOSE(PF)
6. FIN_SI

3. Inserción Ordenada de Nuevos Registros

8. LEER ALUMNO.CODIGO
9. MIENTRAS (ALUMNO.CODIGO > 0)
   1. LEER ALUMNO.NOMBRE
   2. LEER ALUMNO.NOTA
   3. // Busco la posición donde lo voy a insertar (Búsqueda secuencial)
   4. POS <- 0
   5. MIENTRAS ( (POS < NUM_ELEM) Y (ALUMNO.CODIGO > CLASE[POS].CODIGO) )
      1. POS <- POS + 1
   6. FIN_MIENTRAS
   7. // Compruebo si está lleno el Array
   8. SI (NUM_ELEM = TAM_MAXIMO) ENTONCES
      1. // Redimensiono el Array
      2. TAM_MAXIMO <- TAM_MAXIMO + 1
      3. CLASE <- (T_ALUMNO *) REALLOC (CLASE, TAM_MAXIMO * sizeof(T_ALUMNO))
   9. FIN_SI
   10. // Desplazo los elementos del array desde esa posición y hasta el final una posición a la derecha
   11. POS_MOV <- NUM_ELEM
   12. MIENTRAS (POS_MOV > POS)
       1. CLASE[POS_MOV] <- CLASE[POS_MOV-1]
       2. POS_MOV <- POS_MOV – 1
   13. FIN_MIENTRAS
   14. // Introduzco el nuevo elemento en su posición
   15. CLASE[POS] <- ALUMNO
   16. NUM_ELEM <- NUM_ELEM + 1
   17. LEER ALUMNO.CODIGO
10. FIN_MIENTRAS

4. Visualización de Datos del Array

11. // Muestro los datos del array
12. SI (NUM_ELEM < 1) ENTONCES
    1. ESCRIBIR "Error. Array Vacío"
13. SINO
    1. POS <- 0
    2. MIENTRAS (POS < NUM_ELEM)
       1. ESCRIBIR CLASE[POS].CODIGO
       2. ESCRIBIR CLASE[POS].NOMBRE
       3. ESCRIBIR CLASE[POS].NOTA
       4. POS <- POS + 1
    3. FIN_MIENTRAS
14. FIN_SI

5. Persistencia de Datos y Liberación de Memoria

15. // Escribo los datos en ALUMNOS.DAT
16. PF <- FOPEN ("ALUMNOS.DAT", "W")
17. SI (PF = NULL) ENTONCES
    1. // Si se ha producido un error al abrir el fichero
    2. ESCRIBIR "Error al abrir el fichero"
18. SINO
    1. // Escribir los datos
    2. POS <- 0
    3. MIENTRAS (POS < NUM_ELEM)
       1. // Escribir el dato POS del array en el fichero
       2. ALUMNO <- CLASE[POS]
       3. FWRITE(&ALUMNO, sizeof(T_ALUMNO), 1, PF)
       4. SI (FERROR(PF)) ENTONCES
          1. // Si se ha producido un error de escritura
          2. ESCRIBIR "Error de Escritura"
          3. // Desactivo el indicador de error
          4. CLEARERR(PF)
       5. FIN_SI
       6. POS <- POS + 1
    4. FIN_MIENTRAS
    5. // Cierro el fichero
    6. FCLOSE(PF)
19. FIN_SI
20. // Libero la memoria del array
21. FREE(CLASE)