Ejercicio captura de nodos

Presentado por:
Jorge Iván Bernal Silva
Cod: 20172015064

Presentado a:
Ingeniero Mauricio Bermúdez

Universidad distrital Francisco José De Caldas

Facultad de ingenierías
Proyecto curricular: Ingeniería Industrial
Programación Básica
Abril 28 del 2018
un “Nodo” es un registro que contiene diversas variables miembros 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”.
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 autorreferencida 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 apuntador al nodo o estructura autorreferenciada typedef

NodoLista *ptrNodoLista;
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

void capturar_nodo(ptrNodoLista *nodo1, char dato1);

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 capturar_nodo posee un oarametro “nodo2” de tipo de estructura “ptrnodo_2”.
Ya que no se trabajara la función para retornar si no que se utilizara para almacenar un tipo
de dato “char”(carácter) para luego ser presentado por la función presentar nodo

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.Declaracion de un 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.Declaracion de la variable para la captura de datos del nodo
//Declaración de variables para la captura de los datos del nodo
char caracter;
Se declara al interior de la función principal (main) el parámetro o tipo de dato que se va a
registrar en este caso es de tipo “char” o sea de tipo carácter.
7.Inicializacion de un nodo
//Inicialización de un nodo o estructura autorreferenciada Cliente = NULL;
A continuación de la declaración de la estructura autorreferenciada o nodo y la variable, 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).
8.Inicializacion de la variable captura de datos.
//Inicialización de variable de captura de datos
caracter = ' ';
Se inicializa la variable captura_datos y se define el tipo de carácter en este caso tipo “char”
9.Captura de datos desde teclado
//Captura de datos desde teclado
printf("\nINGRESO DE DATOS A UN NODO...\n");
printf("\nPor favor digite una letra: ");
scanf("%s", &caracter);
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 asigna el carácter a la variable capturar_nodo
almacenándolo en la ya dicha, de esta manera de guarda el dato registrado.
10.Asignar datos al nodo
//Asignación de los datos al nodo
capturar_nodo(&Cliente, caracter);
A continuación, se asignarán los datos previamente ingresados, pata eso utilízanos la
definición de los parámetros de la siguiente forma &Cliente, carácter. Cerrando la
instrucción con un “;”, asignando así los datos s las variables del nodo.
11. 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.

12. desarrollo de la función capturar_nodo

//Función de captura de los datos de un nodo

void capturar_nodo(ptrNodoLista *nodo1, char dato1){
//Declaración de un apuntador tipo nodo
ptrNodoLista ptrNuevo;
: //Asignación de memoria al nodo
ptrNuevo = (NodoLista *)malloc(sizeof(NodoLista));
//Asignación de los datos al apuntador de tipo nodo
ptrNuevo->dato = dato1;
ptrNuevo->ptrSiguiente = NULL;
//Asignación del apuntador al nodo
*nodo1 = ptrNuevo;
} //Cierre función capturar_nodo
Primero se definen los parámetros de la función (ptrNodoLista *nodo1, char dato1),
es decir tipo de dato ingresado y apuntador a donde se dirige; una vez declarados los
parámetros se declara el apuntador de tipo nodo (ptrNodoLista ptrNuevo;), seguido de esto
se asignara una posición de memoria al dato capturado ptrNuevo = (NodoLista
*)malloc(sizeof(NodoLista)); 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.
Seguido de esto se asignara los datos al apuntador tipo nodo (ptrNuevo->dato = dato1;
ptrNuevo->ptrSiguiente = NULL;), definiendo así el destino del dato capturado el cual será
utilízado en una variable nula con un espacio de memoria definido previamente.
13.Desarrollo función presentación
//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 de la siguiente aplicación quedaría de la siguiente manera

1: /*Captura y presentación de un nodo.
2: J10/11/2016 - 08:32 - MOBA*/
3:
4: #include <stdio.h>
5: #include <stdlib.h>
6:
7: //Prototipado de un nodo
8: struct nodo_lista{
9: char dato;
10: struct nodo_lista *ptrSiguiente;
11: };
12:
13: //Definición de un alias para un nodo
14: typedef struct nodo_lista NodoLista;
15:
16: //Definición de un alias para un apuntador al nodo
17: typedef NodoLista *ptrNodoLista;
18:
19: //Prototipado de las funciones
20: void capturar_nodo(ptrNodoLista *nodo1, char dato1);
21: void presentar_nodo(ptrNodoLista nodo2);
22:
23: int main(){
24:
25: //Declaración de un nodo
26: ptrNodoLista Cliente;
27:
28: //Declaración de variables para la captura de los datos del nodo
29: char caracter;
30:
31: //Inicialización de un nodo
32: Cliente = NULL;
33:
34: //Inicialización de variable de captura de datos
35: caracter = ' ';
36:
37: /*Nota: La asignación de memoria al nodo y la inicialización de sus miembros
38: no se llevan a cabo dentro de la función principal; se realizan al interior
39: de la función de captura de datos del nodo*/
40:
41: //Captura de datos desde teclado
42: printf("\nINGRESO DE DATOS A UN NODO...\n");
43: printf("\nPor favor digite una letra: ");
44: scanf("%s", &caracter);
45:
46: //Asignación de los datos al nodo
47: capturar_nodo(&Cliente, caracter);
48:
49: //Presentación del contenido de un nodo
50: printf("\nCONTENIDO DE UN NODO...\n");
51: presentar_nodo(Cliente);
52:
53: printf("\n\n");
54: system("PAUSE");
55: return 0;
56:
57: } //Cierre función principal

58:
59:
60: //Función de captura de los datos de un nodo
61: void capturar_nodo(ptrNodoLista *nodo1, char dato1){
62: //Declaración de un apuntador tipo nodo
63: ptrNodoLista ptrNuevo;
64:
65: //Asignación de memoria al nodo
66: ptrNuevo = (NodoLista *)malloc(sizeof(NodoLista));
67:
68: //Asignación de los datos al apuntador de tipo nodo
69: ptrNuevo->dato = dato1;
70: ptrNuevo->ptrSiguiente = NULL;
71:
72: //Asignación del apuntador al nodo
73: *nodo1 = ptrNuevo;
74:
75: } //Cierre función capturar_nodo
76:
77:
78: //Función de presentación de un nodo
79: void presentar_nodo(ptrNodoLista nodo2){
80: printf("\nDato: %c", nodo2->dato);
81: printf("\nApuntador a otro nodo: %p", nodo2->ptrSiguiente);
82: } //Cierre función presentar_nodo