Guía No.

3
Estructura autorreferenciada o Nodo

Recordemos lo que es una estructura dinámica de datos… una estructura dinámica o registro es un conjunto
organizado de datos de diversos tipos que se almacenan en variables, las cuales referencian a dichos datos en
posiciones aleatorias de memoria de acceso temporal, ya que su propósito es manejar tales datos de manera
dinámica –valga la redundancia–; es decir, en tiempo de ejecución.

Al manejar dichas estructuras dinámicas surge la necesidad de vincular o ligar un registro con otro, acorde a las
necesidades del usuario cuando está utilizando la aplicación. Una de las maneras más prácticas y poderosas de
satisfacer tal requerimiento es mediante un apuntador que pertenezca al registro y que sea del mismo tipo de la
estructura en cuestión. La construcción descrita recibe el nombre de “Nodo”.

Dicho de otra manera, un “Nodo” es un registro que contiene diversas variables miembro de las cuales –y como
condición sine qua non–, una de ellas es un apuntador que se direcciona hacia una estructura dinámica idéntica a
él. Cuando un registro se define de tal modo que apunte a otro del mismo tipo, se dice que tal registro es una
“estructura autorreferenciada”.

Siguiendo con la metodología del curso, se describirá en detalle el modo de gestionar una estructura
autorreferenciada a nodo que permita almacenar un dato sencillo (un carácter) y presentarlo. Dicha gestión se
realizará teniendo en cuenta el prototipado, la declaración, la inicialización y la presentación de la estructura en
cuestión.

Igualmente, el manejo de funciones para una estructura autorreferenciada o nodo, requiere de las características
de prototipado, declaración, desarrollo o cuerpo y por último, la presentación.

1. Prototipado de una estructura autorreferenciada o nodo

Como ya es conocido, un prototipo es la definición de un mecanismo de control de datos, ya sea a nivel de

almacenamiento o de procesamiento de los mismos. Un nodo para un dato sencillo (un carácter) se prototipa
como sigue:

//Prototipado de un nodo o estructura autorreferenciada

struct nodo_lista{
char dato;
struct nodo_lista *ptrSiguiente;
};

Para prototipar un nodo o estructura autorreferenciada de datos se utiliza la palabra reservada “struct” y a
continuación el nombre de la estructura (nodo_lista). Dentro de un juego de llaves se definen las variables en
cuanto a su tipo de dato y nombre. Para el ejemplo en cuestión se estableció una primera variable miembro de
nombre “dato” con tipo de dato “char”. De igual manera, se determinó una segunda variable miembro apuntador
(denotada por el símbolo “ * ” como prefijo) de nombre “ptrSiguiente” y tipo de dato “struct nodo_lista”, lo cual
le permite al nodo apuntar hacia otra estructura del mismo tipo, i.e. idéntica a ella misma (por lo que se le da el
nombre de “estructura autorreferenciada”). Es de tener en cuenta que después de la llave de cerramiento de la
estructura se debe colocar el símbolo punto y coma “ ; ”.
2. Definición de un alias para la estructura autorreferenciada o nodo

//Definición de un alias para un nodo o estructura autorreferenciada

typedef struct nodo_lista NodoLista;

Acto seguido, el prototipo de la estructura autorreferenciada o nodo se ha de acompañar de la definición de un

alias o nombre calificativo para la misma, de tal manera que sea sencillo nominarla dentro del código fuente.
Para ello se hace uso de la palabra reservada “typedef” (que significa definir alias tipo), acompañada de la
palabra “struct” y el nombre de la estructura (nodo_lista) y por último, el calificativo para dicho registro
(NodoLista). Esta expresión se ubica a continuación del prototipado de la estructura autorreferenciada o nodo.

3. Definición de un alias para el apuntador a la estructura dinámica

//Definición de un alias para un apuntador al nodo o estructura autorreferenciada

typedef NodoLista *ptrNodoLista;

Una vez definido el alias para referenciar la estructura (nodo_lista) es necesario definir un apuntador a dicho
registro y su correspondiente calificativo, con el propósito de asignarle memoria de manera dinámica y acceder a
las variables o miembros de dicha estructura (dato y ptrSiguiente). La manera de hacerlo es mediante la palabra
reservada “typedef”, acompañada del alias del registro (NodoLista) y a continuación, el alias del apuntador
(ptrNodoLista). No olvidar que un apuntador se establece colocando como prefijo el símbolo asterisco “ * ”. Esta
expresión se ubica a continuación del alias de la estructura autorreferenciada o nodo.

4. Prototipado de funciones para manejar una estructura autorreferenciada o nodo

//Prototipado de las funciones

void presentar_nodo(ptrNodoLista nodo2);

La funciones se prototipan antes de la declaración de la función principal (main) y como manejan apuntadores de
tipo estructura, no retornan ningún resultado cuando son invocadas; por lo cual estas se definen de tipo “void”.

La función “presentar_nodo” posee solamente un parámetro llamado “nodo2” de tipo estructura “ptrNodoLista”.
Dado que no se trabajará la estructura para acceder a su contenido sino para leerlo unicamente, no es necesario
crear un apuntador para dicha labor de presentación; por esto el nombre del parámetro carece del símbolo “*”
como prefijo.

5. Declaración de una estructura autorreferenciada o nodo

//Declaración de un nodo o estructura autorreferenciada

ptrNodoLista Cliente;
Al interior de la función principal (main) se declara una estructura autorreferenciada o nodo a partir del alias del
apuntador correspondiente (ptrNodoLista) y a continuación el nombre de la estructura a manipular durante la
ejecución del programa (Cliente).

6. Inicialización de una estructura autorreferenciada o nodo

//Inicialización de un nodo o estructura autorreferenciada

Cliente = NULL;

A continuación de la declaración de la estructura autorreferenciada o nodo, se realiza su respectiva inicialización

asignando a la misma la palabra reservada “NULL”, la cual significa que dicha estructura se ha definido mas no
tiene asignada memoria, por lo que no está apuntando o referenciando ninguna localización de almacenamiento
(por ahora).

7. Asignación dinámica de memoria a la estructura autorreferenciada o nodo

//Asignación de memoria al nodo o estructura autorreferenciada

Cliente = (NodoLista *)malloc(sizeof(NodoLista));

Acto seguido, se asigna memoria a la estructura o registro de datos (Cliente) en tiempo de ejecución; es decir, de
manera dinámica. Para ello se toma la definición del alias para la estructura dinámica (NodoLista) y se calcula su
tamaño o peso en bytes mediante la palabra reservada “sizeof”. A continuación se reserva la cantidad de
memoria de acceso aleatorio, ya calculada en bytes, a través de una función del lenguaje C llamada “malloc” y
se establece el uso que se le va a dar a dicha localización de almacenamiento valiéndose del alias de la estructura
dinámica (NodoLista) referenciándose como un apuntador (por ello se utiliza el operador “ * ”). Esta instrucción
es fundamental para manipular posteriormente la estructura dinámica; sin ella la ejecución del programa se
bloquea o se anula de manera abrupta.

8. Inicialización de las variables o miembros de la estructura autorreferenciada o nodo

//Inicialización de los miembros del nodo

Cliente->dato = 'H';
Cliente->ptrSiguiente = NULL;

Una vez reservada la memoria de manera dinámica a la estructura (Cliente), es necesario dar consistencia a las
variables de la misma. La manera de acceder a dichas variables o miembros se realiza a través de un operador o
recurso llamado “operador apuntador (->)”, el cual consiste en la asociación de un par de signos: el guión “ - ” y
el paréntesis angular de cierre ” > ”. Por lo tanto, el acceso a la variable “dato” de la estructura “Cliente” se
realiza mediante la expresión “Cliente->dato” para asignarle un valor cualesquiera, como por ejemplo “ ’H‘ ”,
aunque también se podría inicializar con el valor vacío “ ‘ ’ “. Así mismo, el acceso a la variable “ptrSiguiente”
de la estructura “Cliente” se realiza por medio de la expresión “Cliente->ptrSiguiente” para asignarle el valor
“NULL”, lo que significa que dicha variable apuntador se ha definido mas no tiene asignada memoria, por lo que
no está apuntando o referenciando ninguna localización de almacenamiento (por el momento).
9. Presentación de la estructura autorreferenciada o nodo

//Presentación del contenido de un nodo o estructura autorreferenciada

printf("\nCONTENIDO DE UN NODO O ESTRUCTURA AUTORREFERENCIADA...\n");

La visualización del contenido de la estructura autorreferenciada o nodo, es decir, de los datos contenidos de sus
variables o miembros, se efectúa mediante la invocación de la función “presentar_nodo”, la cual se describe en
el siguiente inciso.

10. Invocación de la función de presentación de una estructura autorreferenciada o nodo

//Presentación del contenido de un nodo o estructura autorreferenciada

printf("\nCONTENIDO DE UN NODO O ESTRUCTURA AUTORREFERENCIADA...\n");
presentar_nodo(Cliente);

La invocación de la función “presentar_nodo” posee un sólo argumento, el cual atañe a la estructura dinámica
creada en tiempo de ejecución y cuyo nombre es “Cliente”. Su transferencia requiere únicamente del nombre, ya
que se está trabajando directamente con la memoria asignada de manera dinámica.

11. Declaración de de la función de presentación de datos para una estructura autorreferenciada o nodo

//Función de presentación de un nodo o estructura autorreferenciada

void presentar_nodo(ptrNodoLista nodo2){

} //Cierre función presentar_nodo

La función de presentación de datos se declara posterior a la función principal (main), la cual coincide con el
prototipado de la misma con la salvedad de cambiar el símbolo “ ; ” de terminación de la instrucción por un
juego de llaves “ {} ”, para ubicar posteriormente dentro de ellas el desarrollo de la función en cuestión.

12. Desarrollo o cuerpo de la función de presentación de datos para una estructura autorreferenciada o nodo

//Función de presentación de un nodo o estructura autorreferenciada

void presentar_nodo(ptrNodoLista nodo2){
printf("\nDato: %c", nodo2->dato);
printf("\nApuntador a otro nodo: %p", nodo2->ptrSiguiente);
} //Cierre función presentar_nodo

El desarrollo de la función de presentación de datos atañe a un par de instrucciones:

La primera instrucción consiste en la visualización en pantalla de la primera variable miembro del nodo, lo
cual se efectúa accediendo al miembro “dato” en la estructura autorreferenciada “nodo2” recibida como
parámetro en la función, desde la invocación de la misma (la cual se detalló en el décimo inciso). El acceso
 en cuestión se lleva a cabo mediante el uso del operador apuntador (->) por lo que la instrucción queda como
sigue: printf("\nDato: %c", nodo2->dato);
La segunda y última instrucción se refiere a la observación de la variable miembro de autorreferenciación; es
decir, el apuntador de tipo “struct nodo_lista”, el cual se realiza accediendo al miembro “ptrSiguiente” en la
estructura dinámica “nodo2” recibida como parámetro en la función desde la invocación de la misma (la cual
se detalló en los incisos 4 y 11). El acceso en cuestión se lleva a cabo mediante el uso del operador
apuntador (->) por lo que la instrucción queda como sigue: printf("\nApuntador a otro nodo: %p", nodo2-
>ptrSiguiente);

…………………………………..

El código fuente completo de una aplicación que implementa una estructura autorreferenciada de datos o nodo
desde su prototipado, declaración, inicialización, y presentación (mediante función), se desarrolla a
continuación:

/*Declaración, inicialización y presentación (mediante función) de un nodo

o estructura autorreferenciada. – D07/051/2017 - 21:43 - MOBA*/

#include <stdio.h>
#include <stdlib.h>

//Prototipado de un nodo
struct nodo_lista{
char dato;
struct nodo_lista *ptrSiguiente;
};

//Definición de un alias para un nodo

typedef struct nodo_lista NodoLista;

//Definición de un alias para un apuntador al nodo

typedef NodoLista *ptrNodoLista;

//Prototipado de las funciones

void presentar_nodo(ptrNodoLista nodo2);

int main(){

//Declaración de un nodo
ptrNodoLista Cliente;

//Inicialización de un nodo
Cliente = NULL;

//Asignación de memoria al nodo

Cliente = (NodoLista *)malloc(sizeof(NodoLista));
 //Inicialización de los miembros del nodo
Cliente->dato = 'H';
Cliente->ptrSiguiente = NULL;

//Presentación del contenido de un nodo

printf("\nCONTENIDO DE UN NODO...\n");
presentar_nodo(Cliente);

printf("\n\n");
system("PAUSE");
return 0;

} //Cierre función principal

//Función de presentación de un nodo

void presentar_nodo(ptrNodoLista nodo2){
printf("\nDato: %c", nodo2->dato);
printf("\nApuntador a otro nodo: %p", nodo2->ptrSiguiente);
} //Cierre función presentar_nodo

Con el fin de apropiarse del concepto descrito, se recomienda construir línea por línea la aplicación anterior y
así, poder trabajar posteriormente la gestión de diversas estructuras dinámicas de datos en conjunto, como son
las listas, las pilas y las colas; ellas se detallarán en la siguiente guía.