2.1.1 struct

Una estructura básica de un nodo para crear listas de datos seria:

struct nodo {

int dato;

struct nodo *otronodo;

};

El campo "otronodo" puede apuntar a un objeto del tipo nodo. De este modo, cada nodo puede usarse como un ladrillo para construir listas de datos, y cada uno mantendrá ciertas relaciones con otros nodos.

Para acceder a un nodo de la estructura sólo necesitaremos un puntero a un nodo.

Durante el presente curso usaremos gráficos para mostrar la estructura de las estructuras de datos dinámicas. El nodo anterior se representará asi:

Las estructuras dinámicas son una implementación de TDAs o TADs (Tipos Abstractos de Datos). En estos tipos el interés se centra más en la estructura de los datos que en el tipo concreto de información que almacenan.

Las estructuras dinámicas de datos se pueden dividir en dos grandes grupos:

Lineales: listas enlazadas, pilas, colas

No lineales: árboles , grafos

Las estructuras dinámicas de datos son de gran utilidad para almacenar datos del mundo real, que están cambiando constantemente. Por ejemplo si tenemos almacenados en un array los datos de los alumnos de un curso, los cuales estan ordenados de acuerdo al promedio, para insertar un nuevo alumno seria necesario correr cada elemento un espacio: Si en su lugar se utilizara una estructura dinámica de datos, los nuevos datos del alumno se pueden insertar fácilmente.

Una estructura (struct) permite agrupar variables de varios tipos bajo un mismo nombre. De esta forma es posible crear elementos de datos complejos, basándose en los tipos básicos que suministra el lenguaje de programación.

Una declaración de estructura define un tipo, y por lo tanto será posible definir variables de este nuevo tipo. Cada una de estas variables estará compuesto a su vez por las variables que se definieron en la estructura.

Una declaración típica de estructuras sería:

 struct nombre {
 componente1 ;
 componente2 ;
 ...
  componenteN ;
 } lista-variables ;

Cada uno de los componentes de la estructura tiene a su vez la forma de una declaración de variables:

 tipo nombre ;

Por ejemplo, para declarar una estructura que permita manejar, de manera conjunta, los datos de algunos alumnos de determinado curso, se podría hacer:

 struct Alumno {
 char Nombre[30];
 char NumAlumno[8];
 float Nota1;
 float Nota2;
 float Nota3;
 float NotaFinal;
 } A1, A2, A3;

Esta declaración define tres variables (A1, A2 y A3), cada una compuesta a su vez por un string para el nombre, un string para su número de alumno, tres float para sus notas parciales, y un float para su nota final.

Los elementos que componen una estructura se acceden mediante la notación:

 estructura.componente

Por ejemplo, el string que contiene el nombre del segundo alumno se referencia como:

 A2.Nombre

Al igual que con los tipos simples de C, es posible definir vectores compuestos de estructuras. Así, sería posible hacer la definición anterior aplicable a un mayor número de alumnos:

  struct Alumno {
 char nombre[30];
 char NumAlumno[8];
 float Nota1;
 float Nota2;
 float Nota3;
 float NotaFinal;
 } Alumnos[NUM_ALUMNOS];

En este caso, el nombre del primer alumno se referenciaría como:

 Alumnos[0].Nombre

En las versiones ANSI de C (como gcc), también es posible asignar estructuras, pasarlas como argumentos a funciones y retornarlas como resultado de funciones. En el caso del paso de estructuras como argumento, éstas se pasan por referencia, por lo que es posible cambiar el contenido de las variables dentro de la función y los cambios se propagarán al retornar. Las siguientes acciones y declaraciones serían válidas:

 A2 = A1; /* Asignacion de una estructura a otra */
 
 /* Funcion que retorna una estructura */
 struct Alumno NuevoAlumno(char Nombre[]) { ...
 
 /* Funcion que recibe como argumento una estructura */
 void CalculaNota(struct Alumno A1) { ...

Importante:

Observe que el nombre del tipo que debe usarse lleva incluido el prefijo struct. Para el caso de nuestro ejemplo:

 struct Alumno

Haciendo uso de typedef será posible manejar estos nuevos tipos sin necesidad de acarrear constantemente el prefijo mencionado.

Una vez dada la declaración inicial de una estructura, es posible definir más variables del nuevo tipo definido. Esto se hace siguiendo la sintaxis:

 struct nombre var1, var2, ... ;

Continuando con el ejemplo inicial, podrían definirse estructuras adicionales para almacenar la información de otros alumnos:

 struct Alumno A4, A5;

También es posible inicializar estructuras durante su declaración, empleando una sintaxis similar a la utilizada para inicializar vectores. Por ejemplo:

 struct Alumno A = {"Elvira", "98231465", 6.0, 5.5, 5.0, 5.5};