Estructura de Datos

Instituto Tecnológico Superior
Vida Nueva
COMPENDIO DE
ESTRUCTURA DE DATOS
4 CREDITOS
1. Datos informativos:
Carrera/s Nivel
Informática SEGUNDO
www.istvidanueva.edu.ec
Tecnológico Vida Nueva http://www.istvidanueva.edu.ec/aulavirtual
1
2. Índice
1. Datos informativos: .................................................................... 1
2. Índice......................................................................................... 2
3. Introducción ............................................................................... 7
4. Prerrequisitos ............................................................................ 8
5. Evaluación inicial ....................................................................... 8
6. Orientaciones generales para el estudio ................................... 9
7. Desarrollo de contenidos ......................................................... 10
I. Unidad: NOCIONES FUNDAMENTALES ........................... 10
Objetivos ................................................................................. 10
Contenidos .............................................................................. 10
1.1. Generalidades y definiciones de la memoria ............................. 10
1.2. Estructura de Datos conocidas (Variables y tipos de datos) ..... 16
1.3. Manipulación de variables a través de su dirección .................. 18
1.4. Representación Gráfica de las estructura de datos ................... 19
1.5. Acceso a las estructura de Datos (Estáticas) ............................ 19
1.6. Tipos de Estructuras de Datos .................................................. 20
Estrategias de enseñanza – aprendizaje ................................. 22
Evaluación ............................................................................... 22
Recursos ................................................................................. 24
II. Unidad: ESTRUCTURAS .................................................... 25
Objetivos ................................................................................. 25
Contenidos .............................................................................. 25
2.1. Definición................................................................................... 25
2.2. Formato de una estructura ........................................................ 26

2.3. Representación Gráfica de las estructura ................................. 27
2.4. Acceso a los campos de una estructura .................................... 27
2.5. Estructuras anidadas ................................................................. 28
Evaluación ............................................................................... 37
Recursos ................................................................................. 38
III. Unidad: PUNTEROS........................................................... 39
Objetivos ................................................................................. 39
Contenidos .............................................................................. 39
3.1. Definición de punteros ............................................................... 39
3.2. Representación gráfica de un puntero ...................................... 39
3.3. Operaciones con varios punteros .............................................. 40
3.4. Asignación dinámica de memoria .............................................. 42
3.5. Liberación dinámica de memoria ............................................... 45
3.6. La constante NULL .................................................................... 45
3.7. Ventajas y desventajas de punteros .......................................... 45
Evaluación ............................................................................... 47
Recursos ................................................................................. 48
IV. Unidad: LISTAS .................................................................. 49
Objetivos ................................................................................. 49
Contenidos .............................................................................. 49
4.1. Definición de listas .................................................................... 49
4.2. Declaración e implementación de una lista ............................... 49
4.3. Inserción de un nodo ................................................................. 50
4.4. Eliminación de un nodo ............................................................. 50

4.5. Búsqueda de un nodo ............................................................... 51
4.6. Otros algoritmos con listas ........................................................ 53
4.7. Tipos de listas ........................................................................... 54
Evaluación ............................................................................... 56
Recursos ................................................................................. 56
V. Unidad: PILAS .................................................................... 57
Objetivos ................................................................................. 57
Contenidos .............................................................................. 57
5.1. Definición de pilas ..................................................................... 57
5.2. Declaración e implementación de una pila ................................ 58
5.3. Inserción de un nodo (método Push) ........................................ 58
5.4. Impresión de la Pila ................................................................... 59
5.5. Búsqueda de un nodo (método Pop) ......................................... 60
Evaluación ............................................................................... 61
Recursos ................................................................................. 61
VI. Unidad: COLAS .................................................................. 62
Objetivos ................................................................................. 62
Contenidos .............................................................................. 62
6.1. Definición de colas .................................................................... 62
6.2. Declaración e implementación de una cola ............................... 62
6.3. Inserción de un nodo (método Push) ........................................ 63
6.4. Impresión de la Cola.................................................................. 64

Evaluación ............................................................................... 66
Recursos ................................................................................. 66
VII. Unidad: LISTAS CERRADAS O CIRCULARES .............. 67
Objetivos ................................................................................. 67
Contenidos .............................................................................. 67
7.6. Recorridos de una lista .............................................................. 70
Evaluación ............................................................................... 71
Recursos ................................................................................. 71
VIII. Unidad: LISTAS DOBLEMENTE ENLAZADAS ABIERTAS

Y CERRADAS ............................................................................ 72
Objetivos ................................................................................. 72
Contenidos .............................................................................. 72
8.6. Otros algoritmos con listas ........................................................ 78
Evaluación ............................................................................... 79
Recursos ................................................................................. 79
8. Evaluación final ....................................................................... 80
9. Bibliografía .............................................................................. 81
10. Anexos ................................................................................ 81
Qué es fácil... Qué es difícil... .................................................. 81
11. Glosario .............................................................................. 83

ESTRUCTURA DE DATOS
Error! Use the Home tab to apply Título 1 to the text that you want to
appear here.
3. Introducción
Como ya sabemos, las computadoras fueron diseñadas o ideadas
como una herramienta mediante la cual podemos realizar
operaciones de cálculo complicadas en un lapso de mínimo tiempo.
Pero la mayoría de las aplicaciones de este fantástico invento del
hombre, son las de almacenamiento y acceso de grandes
cantidades de información.
La información que se procesa en la computadora es un conjunto

de datos, que pueden ser simples o estructurados. Los datos
simples son aquellos que ocupan sólo una localidad de memoria,
mientras que los estructurados son un conjunto de casillas de
memoria a las cuales hacemos referencia mediante un identificador
único.
Debido a que por lo general tenemos que tratar con conjuntos de

datos y no con datos simples (enteros, reales, booleanos, etc.) que
por sí solos no nos dicen nada, ni nos sirven de mucho, es
necesario tratar con estructuras de datos adecuadas a cada
necesidad.
Las estructuras de datos son una colección de datos cuya

organización se caracteriza por las funciones de acceso que se
usan para almacenar y acceder a elementos individuales de datos.
Tecnológico Vida Nueva Página 7

ESTRUCTURA DE DATOS
appear here.
4. Prerrequisitos
Para continuar con el estudio de este módulo el estudiante/a deberá
de haber aprobado la asignatura de Fundamentos de
Programación.
5. Evaluación inicial
1. ¿Cuál es la función de un Diagrama de Flujo?
_________________________________________________
_________________________________________________
_________________________________________________
2. Señale 2 tipos de datos que utiliza en el lenguaje c
_________________________________________________
_________________________________________________
_________________________________________________
3. ¿Cuál es la función de los operadores lógicos?
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
4. Indique 2 operadores de asignación y su función
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
5. ¿Qué es una estructura de datos?
_________________________________________________
_________________________________________________

ESTRUCTURA DE DATOS
appear here.
_________________________________________________
_________________________________________________
6. ¿Cuál es la función de la sentencia IF-ELSE?
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
7. ¿Cuál es la función del WHILE?
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
6. Orientaciones generales para el estudio

Para llevar a cabo un buen desarrollo en el proceso enseñanza
aprendizaje sobre esta materia es necesario contar con los
siguientes materiales.
• Computadores procesador Dual Core o superior con 2gb de

Ram ó Superior.
• Software de programación Turbo C++ o Superior
Destine una o dos hora diarias de investigación sobre los temas a

tratar, existe video tutoriales sobre el manejo de estas herramientas
y su implementación en youtube, videos, etc.
Es importante conocer esta materia debido a que tiene relación

directa con Diseño gráfico y programación web.

ESTRUCTURA DE DATOS
appear here.
7. Desarrollo de contenidos
I. Unidad: NOCIONES FUNDAMENTALES
Objetivos
Analizar y explicar cada uno de los puntos necesarios e importantes
para comenzar con el desarrollo de la lógica de programación.
Contenidos
1.1. Generalidades y definiciones de la memoria

Todos los objetos tienen un tiempo de vida, es decir, el tiempo
durante el cual se garantiza que el objeto exista. En C, existen 3
tipos de duración: estática, automática y asignada. Las variables
globales y las variables locales declaradas con el especificador
static tienen duración estática. Se crean antes de que el programa
inicie su ejecución y se destruyen cuando el programa termina. Las
variables locales no static tienen duración automática. Se crean al
entrar al bloque en el que fueron declaradas y se destruyen al salir
de ese bloque. Duración asignada se refiere a los objetos cuya
memoria se reserva de forma dinámica. Como se explicó
anteriormente, esta memoria se crea y se debe liberar de forma
explícita. Los arreglos de longitud variable de C99 son un caso
especial. Tienen duración automática, con la particularidad de que
son creados a partir de su declaración.
La biblioteca estándar de C proporciona las funciones malloc,

calloc, realloc y free para el manejo de memoria dinámica. Estas
funciones están definidas en el archivo de cabecera stdlib.h.

ESTRUCTURA DE DATOS
appear here.
malloc
La función malloc reserva un bloque de memoria y devuelve un
puntero void al inicio de la misma. Tiene la siguiente definición:
void *malloc(size_t size);
donde el parámetro size especifica el número de bytes a reservar.

En caso de que no se pueda realizar la asignación, devuelve el
valor nulo (definido en la macro NULL), lo que permite saber si hubo
errores en la asignación de memoria.
Ej:
int *puntero;
char *puntcarc;
puntero=(int *)malloc(4);
puntcarc=(char *)malloc(200);
calloc
La función calloc funciona de modo similar a malloc, pero además
de reservar memoria, inicializa a 0 la memoria reservada. Se usa
comúnmente para arreglos y matrices. Está definida de esta forma:
void *calloc(size_t nmemb, size_t size);
El parámetro nmemb indica el número de elementos a reservar, y

size el tamaño de cada elemento. El ejemplo anterior se podría
reescribir con calloc de esta forma:
int *vect1, n;
printf("N£mero de elementos del vector: ");

ESTRUCTURA DE DATOS
appear here.
scanf("%d", &n);
/* Reservar memoria para almacenar n enteros */
vect1 = calloc(n, sizeof(int));
/* Verificamos que la asignación se haya realizado correctamente */
if (vect1 == NULL) {
/* Error al intentar reservar memoria */
realloc
La función realloc redimensiona el espacio asignado de forma
dinámica anteriormente a un puntero. Tiene la siguiente definición:
void *realloc(void *ptr, size_t size);
Donde ptr es el puntero a redimensionar, y size el nuevo tamaño, en

bytes, que tendrá. Si el puntero que se le pasa tiene el valor nulo,
esta función actúa como malloc. Si la reasignación no se pudo
hacer con éxito, devuelve un puntero nulo, dejando intacto el
puntero que se pasa por parámetro. Al usar realloc, se debería usar
un puntero temporal. De lo contrario, podríamos tener una fuga de
memoria, si es que ocurriera un error en realloc.
Ejemplo de realloc usando puntero temporal:
/* Reservamos 5 bytes */
void *ptr = malloc(5);

ESTRUCTURA DE DATOS
appear here.
/* Redimensionamos el puntero (a 10 bytes) y lo asignamos a un
puntero temporal */
void *tmp_ptr = realloc(ptr, 10);
if (tmp_ptr == NULL) {
/* Error: tomar medidas necesarias */
else {
/* Reasignación exitosa. Asignar memoria a ptr */
ptr = tmp_ptr;
Cuando se redimension la memoria con realloc, si el nuevo tamaño

(parámetro size) es mayor que el anterior, se conservan todos los
valores originales, quedando los bytes restantes sin inicializar. Si el
nuevo tamaño es menor, se conservan los valores de los primeros
size bytes. Los restantes también se dejan intactos, pero no son
parte del bloque regresado por la función.
free
La función free sirve para liberar memoria que se asignó
dinámicamente. Si el puntero es nulo, free no hace nada. Tiene la
siguiente definición:
void free(void *ptr);

ESTRUCTURA DE DATOS
appear here.
El parámetro ptr es el puntero a la memoria que se desea liberar:
int *i;
i = malloc(sizeof(int));
free(i);
Una vez liberada la memoria, si se quiere volver a utilizar el puntero,

primero se debe reservar nueva memoria con malloc o calloc:
int *i = malloc(sizeof(int));
free(i);
/* Reutilizamos i, ahora para reservar memoria para dos enteros */
i = malloc(2 * sizeof(int));
/* Volvemos a liberar la memoria cuando ya no la necesitamos */
free(i);
Memoria dinámica
Es memoria que se reserva en tiempo de ejecución. Su principal
ventaja frente a la estática, es que su tamaño puede variar durante
la ejecución del programa. (En C, el programador es encargado de
liberar esta memoria cuando no la utilice más). El uso de memoria
dinámica es necesario cuando a priori no conocemos el número de
datos/elementos a tratar.

ESTRUCTURA DE DATOS
appear here.
Memoria estática
Es el espacio en memoria que se crea al declarar variables de
cualquier tipo de dato (primitivas [int,char...] o derivados
[struct,matrices,punteros...]). La memoria que estas variables
ocupan no puede cambiarse durante la ejecución y tampoco puede
ser liberada manualmente.
Diferencias, ventajas y desventajas

La memoria reservada de forma dinámica suele estar alojada en el
heap o almacenamiento libre, y la memoria estática en el stack o
pila (con excepción de los objetos de duración estática, que se
verán más adelante, los cuales normalmente se colocan en una
zona estática de datos). La pila generalmente es una zona muy
limitada. El heap, en cambio, en principio podría estar limitado por la
cantidad de memoria disponible durante la ejecución del programa y
el máximo de memoria que el sistema operativo permita direccionar
a un proceso. La pila puede crecer de forma dinámica, pero esto
depende del sistema operativo. En cualquier caso, lo único que se
puede asumir es que muy probablemente dispondremos de menor
espacio en la pila que en el heap.
Otra ventaja de la memoria dinámica es que se puede ir

incrementando durante la ejecución del programa. Esto permite, por
ejemplo, trabajar con arreglos dinámicos. Aunque en C, a partir del
estándar C99 se permite la creación de arreglos cuyo tamaño se
determina en tiempo de ejecución, no todos los compiladores
implementan este estándar. Además, se sigue teniendo la limitante
de que su tamaño no puede cambiar una vez que se especifica,
cosa que sí se puede lograr asignando memoria de forma dinámica.

ESTRUCTURA DE DATOS
appear here.
Una desventaja de la memoria dinámica es que es más difícil de
manejar. La memoria estática tiene una duración fija, que se
reserva y libera de forma automática. En contraste, la memoria
dinámica se reserva de forma explícita y continúa existiendo hasta
que sea liberada, generalmente por parte del programador.
La memoria dinámica puede afectar el rendimiento. Puesto que con

la memoria estática el tamaño de las variables se conoce en tiempo
de compilación, esta información está incluida en el código objeto
generado, por lo cual el proceso es muy eficiente. Cuando se
reserva memoria de manera dinámica, se tienen que llevar a cabo
varias tareas, como buscar un bloque de memoria libre y almacenar
la posición y tamaño de la memoria asignada, de manera que
pueda ser liberada más adelante. Todo esto representa una carga
adicional, aunque esto depende de la implementación y hay
técnicas para reducir su impacto.
1.2. Estructura de Datos conocidas (Variables y tipos de

datos)
VARIABLES
Una variable puede verse simplemente como un hueco en el que se
puede almacenar un objeto de un determinado tipo al que se le da
un cierto nombre. Para poderla utilizar sólo hay que definirla
indicando cuál era su nombre y cuál será el tipo de datos que podrá
almacenar, lo que se hace siguiendo la siguiente sintaxis:
<tipoVariable> <nombreVariable>;
Ejemplo:
int numero;

ESTRUCTURA DE DATOS
appear here.
TIPOS DE DATOS
El tipo de la variable nos indica el conjunto de valores que puede
tomar y las operaciones que pueden realizarse con ella. Existen
cinco tipos de datos básicos en C:
Tipos
de Descripción Memoria
Datos
2 bytes o una
int Cantidad entera palabra (varía
según compilador).
char Carácter 1 byte.
Almacena valores reales en punto

float 1 palabra (4 bytes).
flotantes.
Almacena valores reales en doble 2 palabras (8

double
precisión. bytes).
Se utiliza para definir una función

que no devuelve ningún valor o
void
declarar punteros genéricos (lo
veremos más tarde).

ESTRUCTURA DE DATOS
appear here.
1.3. Manipulación de variables a través de su dirección
Todas las variables se almacenan en una dirección predeterminada
en memoria.
El monto del área de memoria es determinada por el tipo de

variable, es decir; una variable int ocupa 2 bytes, un float 4 bytes,
un arreglo ocupara el tipo del arreglo multiplicado por la cantidad de
elementos, una estructura es igual a la suma de los campos.
En C++ existe una nueva clase de variables llamadas apuntadores

o punteros, que permiten almacenar la dirección de memoria de
alguna otra variable normal.
En el caso de variables apuntadores a strings o arreglos esta

variable solo podrá almacenar la posición más relevante del arreglo
es decir la ocupada por el primer elemento del arreglo, mismo caso
para estructuras.
Las utilidad principal de las variables apuntadores es la facilidad

que tienen para accesar y manipular datos estructurados más
rápidamente, también son muy útiles para permitir pasar y recibir
valores en funciones.
Existen dos operadores a tener en cuenta cuando trabajamos con

punteros. El operador de dirección (&) que devuelve la dirección de
memoria de su operando y el operador de indirección (*) que
devuelve un alias para el objeto al cual apunta el operando del
puntero.
En el siguiente ejemplo vemos como se inicializa una variable X con

el valor 15. Luego se crea un puntero a int y por último el puntero
pasa a apuntar a la variable X. Esto es, ptrX es un puntero a X.

ESTRUCTURA DE DATOS
appear here.
int X = 15;
int *ptrX;
ptrX = &X;
printf("%p n", &ptrX); //Imprimimos la dirección de memoria del

puntero ptrX
1.4. Representación Gráfica de las estructura de datos

Una estructura básica de un nodo para crear listas de datos seria:
//DECLARACIÓN EN C++
struct nodo {
int dato;
struct nodo *otronodo;
};
//REPRESENTACIÓN GRÁFICA
1.5. Acceso a las estructura de Datos (Estáticas)

Una estructura contiene varios datos. La forma de definir una
estructura es haciendo uso de la palabra clave struct. Aquí hay
ejemplo de la declaración de una estructura:
struct mystruct

ESTRUCTURA DE DATOS
appear here.
int int_member;
double double_member;
char string_member[25];
} variable;
"variable" es una instancia de "mystruct" y no es necesario ponerla

aquí. Se podria omitir de la declaracion de "mystruct" y más tarde
declararla usando:
struct mystruct variable;
Y es aquella que nos permitirá unir con nuevos nodos que el

usuario creará.
1.6. Tipos de Estructuras de Datos

Una estructura de Datos es una colección de datos que pueden ser
caracterizados por su organización y las operaciones que se
definen en ella.
Los tipos de datos más frecuentes utilizados en los diferentes

lenguajes de programación son:
Para ver el gráfico seleccione la opción "Descargar" del menú

superior
Los tipos de datos simples pueden ser organizados en diferentes

estructuras de datos: estáticas y dinámicas.
Datos estructurados:
Estructura de Datos es una colección de datos que se caracterizan
por su organización y las operaciones que se definen en ella. Los

ESTRUCTURA DE DATOS
appear here.
datos de tipo estándar pueden ser organizados en diferentes
estructuras de datos: estáticas y dinámicas.
Estructura de Datos estáticas

Son aquellas en las que el espacio ocupado en memoria se define
en tiempo de compilación y no puede ser modificado durante la
ejecución del programa. Corresponden a este tipo los arrays y
registros
Estructuras de Datos Dinámicas

Son aquellas en las que el espacio ocupado en memoria puede ser
modificado en tiempo de ejecución. Corresponden a este tipo las
listas, árboles y grafos. Estas estructuras no son soportadas en
todos los lenguajes. La elección de la estructura de datos idónea
dependerá de la naturaleza del problema a resolver y, en menor
medida, del lenguaje. Las estructuras de datos tienen en común que
un identificador, nombre, puede representar a múltiples datos
individuales.

ESTRUCTURA DE DATOS
appear here.
Estrategias de enseñanza – aprendizaje
Crear ejercicios en clase que permitan dirigir el conocimiento a los
punteros y direcciones de memoria de una o más variables.
Evaluación
1. ¿Qué representa la librería malloc?
_________________________________________________
_________________________________________________
_________________________________________________
2. ¿Cuál es la sintaxis de la función free?
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
3. ¿Qué representa la librería realloc?

_________________________________________________
_________________________________________________
_________________________________________________
4. ¿Cuál es la sintaxis de la función free?
_________________________________________________
_________________________________________________
_________________________________________________
5. ¿Qué funcionalidad tiene la función size?
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
ESTRUCTURA DE DATOS
appear here.
6. ¿Qué es la memoria dinámica y estática?
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
7. ¿Qué es una variable?
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
8. ¿Qué es un tipo de dato?
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
9. ¿Qué es una Estructura de Datos?
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
10. ¿Qué es una Estructura de Datos Estática?
_________________________________________________
_________________________________________________

ESTRUCTURA DE DATOS
appear here.
_________________________________________________
_________________________________________________
11. Dibuje la representación gráfica de una estructura de
datos e identifique sus partes.
Recursos
• Módulo de Instrucción
• Internet
• Moodle

ESTRUCTURA DE DATOS
appear here.
II. Unidad: ESTRUCTURAS
Objetivos
Identificar una estructura de datos y sus partes como registro de
datos.
Contenidos
2.1. Definición
En programación, una estructura de datos es una forma de
organizar un conjunto de datos elementales con el objetivo de
facilitar su manipulación. Un dato elemental es la mínima
información que se tiene en un sistema.
Una estructura de datos define la organización e interrelación de

estos y un conjunto de operaciones que se pueden realizar sobre
ellos. Las operaciones básicas son:
- Alta, adicionar un nuevo valor a la estructura.

- Baja, borrar un valor de la estructura.
- Búsqueda, encontrar un determinado valor en la estructura
para realizar una operación con este valor, en forma
secuencial o binario (siempre y cuando los datos estén
ordenados).
Otras operaciones que se pueden realizar son:
- Ordenamiento, de los elementos pertenecientes a la

estructura.
- Apareo, dadas dos estructuras originar una nueva ordenada y
que contenga a las apareadas.

ESTRUCTURA DE DATOS
appear here.
Cada estructura ofrece ventajas y desventajas en relación a la
simplicidad y eficiencia para la realización de cada operación. De
esta forma, la elección de la estructura de datos apropiada para
cada problema depende de factores como la frecuencia y el orden
en que se realiza cada operación sobre los datos.
2.2. Formato de una estructura

struct nombre {
tipo miembro1;
tipo miembro2;
...
} identificador1, identificador2, ...;
nombre es el nombre de la estructura y los identificadores

corresponden a variables del tipo de la estructura, tanto el nombre
como las variables pueden no existir, los miembros son las
componentes de la estructura, la forma de declarar variables del
tipo definido en la estructura es:
struct nombre identificador1, identificador2, ...;
Para acceder a los campos de la estructura se usa la misma técnica

que en pascal: variable.miembro
Se admite el uso de estructuras dentro de la declaración de otra

estructura ya que los miembros, en general, pueden tener cualquier
tipo.
Ejemplos:
struct fecha {

ESTRUCTURA DE DATOS
appear here.
int mes;
int día;
int año;
}; /* estructura fecha */
struct cuenta {
int cuen_no;
char cuen_tipo;
float saldo;
struct fecha ultimo_pago;
} cliente[100]; /* estructura cuenta y declaración */
2.3. Representación Gráfica de las estructura
Dato. Representa a los miembros que estarán declaradas dentro

del nodo y que servirá como campo de almacenamiento de
registros.
Enlace. Es un apuntador que se declara conjuntamente con el

nombre de la estructura y que servirá para enlazar a los nuevos
nodos creados, así como también para recorrer cada uno de ellos.
2.4. Acceso a los campos de una estructura

Para acceder a los campos de la estructura, lo haremos de la
manera siguiente:

ESTRUCTURA DE DATOS
appear here.
variable.campo;
Donde variable es el nombre de la variable de tipo estructura que

hemos creado, y campo es el nombre de la variable que forma parte
de la estructura. Lo veremos mejor con un ejemplo basado en la
estructura definida anteriormente:
amigo.edad=27;
Con esta sentencia lo que estamos haciendo es almacenar el valor

27 en el campo edad de la variable amigo.
Una opción que nos permiten las estructuras es pasar el contenido

de una estructura a otra, siempre que sean del mismo tipo
naturalmente. Por ejemplo, si hemos declarado las estructuras del
mismo tipo persona1 y persona2, podemos asignarle los datos
almacenados en todos los campos de la estructura persona1, a la
persona2 de la siguiente manera:
persona2=persona1;
2.5. Estructuras anidadas

La conveniencia de coger nombres de funciones y datos fuera del
espacio de nombre global es aplicable a las estructuras. Puede
anidar una estructura dentro de otra estructura, y por tanto guardar
juntos elementos asociados. La sintaxis de declaración es la que
podría esperarse, tal como puede ver en la siguiente estructura, que
implementa una pila como una lista enlazada simple de modo que
«nunca» se queda sin memoria.
//: C04:Stack.h
// Nested struct in linked list

ESTRUCTURA DE DATOS
appear here.
#ifndef STACK_H
#define STACK_H
struct Stack {
struct Link {
void* data;
Link* next;
void initialize(void* dat, Link* nxt);
}* head;
void initialize();
void push(void* dat);
void* peek();
void* pop();
void cleanup();
};
#endif // STACK_H ///:~
Listado 4.9. C04/Stack.h
La struck anidada se llama Link, y contiene un puntero al siguiente

Link en la lista y un puntero al dato almacenado en el Link. Si el
siguiente puntero es cero, significa que es el último elemento de la
lista.
Fíjese que el puntero head está definido a la derecha después de la

declaración de la struct Link, es lugar de una definición separada

ESTRUCTURA DE DATOS
appear here.
Link* head. Se trata de una sintaxis que viene de C, pero que hace
hincapié en la importancia del punto y coma después de la
declaración de la estructura; el punto y coma indica el fin de una
lista de definiciones separadas por comas de este tipo de estructura
(Normalmente la lista está vacía.)
La estructura anidada tiene su propia función initialize(), como todas

las estructuras hasta el momento, para asegurar una inicialización
adecuada. Stack tiene tanto función initialice() como cleanup(),
además de push(), que toma un puntero a los datos que se desean
almacenar (asume que ha sido alojado en el montículo), y pop(),
que devuelve el puntero data de la cima de la Stack y elimina el
elemento de la cima. (El que hace pop() de un elemento se
convierte en responsable de la destrucción del objeto apuntado por
data.) La función peak() también devuelve un puntero data a la cima
de la pila, pero deja el elemento en la Stack.
Aquí se muestran las definiciones de los métodos:
//: C04:Stack.cpp {O}
// Linked list with nesting
#include "Stack.h"
#include "../require.h"
using namespace std;
void
Stack::Link::initialize(void* dat, Link* nxt) {
data = dat;
next = nxt;

ESTRUCTURA DE DATOS
appear here.
}
void Stack::initialize() { head = 0; }
void Stack::push(void* dat) {
Link* newLink = new Link;
newLink->initialize(dat, head);
head = newLink;
void* Stack::peek() {
require(head != 0, "Stack empty");
return head->data;
void* Stack::pop() {
if(head == 0) return 0;
void* result = head->data;
Link* oldHead = head;
head = head->next;
delete oldHead;
return result;
void Stack::cleanup() {
require(head == 0, "Stack not empty");
} ///:~

ESTRUCTURA DE DATOS
appear here.
La primera definición es particularmente interesante porque
muestra cómo se define un miembro de una estructura
anidada. Simplemente se usa un nivel adicional de resolución
de ámbito para especificar el nombre de la struct interna.
Stack::Link::initialize() toma dos argumentos y los asigna a
sus atributos.
Stack::initialize() asgina cero a head, de modo que el objeto

sabe que tiene una lista vacía.
Stack::push() toma el argumento, que es un puntero a la

variable a la que se quiere seguir la pista, y la apila en la
Stack. Primero, usa new para pedir alojamiento para el Link
que se insertará en la cima. Entonces llama a la función
initialize() para asignar los valores apropiados a los miembres
del Link. Fijese que el siguiente puntero se asigna al head
actual; entonces head se asigna al nuevo puntero Link. Esto
apila eficazmente el Link en la cima de la lista.
Stack::pop() captura el puntero data en la cima actual de la

Stack; entonces mueve el puntero head hacia abajo y borra la
anterior cima de la Stack, finalmente devuelve el puntero
capturado. Cuando pop() elemina el último elemento, head
vuelve a ser cero, indicando que la Stack está vacía.
Stack::cleanup() realmente no hace ninguna limpieza. En su

lugar, establece una política firme que dice «el programador
cliente que use este objeto Stack es responsable de des-apilar
todos los elementos y borrarlos». require() se usa para indicar
que ha ocurrido un error de programación si la Stack no está
vacía.
ESTRUCTURA DE DATOS
appear here.
¿Por qué no puede el destructor de Stack responsabilizarse
de todos los objetos que el programador cliente no des-apiló?
El problema es que la Stack está usando punteros void, y tal
como se verá en el Capítulo 13 usar delete para un void* no
libera correctamente. El asunto de «quién es el responsable
de la memoria» no siempre es sencillo, tal como veremos en
próximos capítulos.
Un ejemplo para probar la Stack:
//: C04:StackTest.cpp
//{L} Stack
//{T} StackTest.cpp
// Test of nested linked list
#include "Stack.h"
#include "../require.h"
#include <fstream>
#include <iostream>
#include <string>
using namespace std;
int main(int argc, char* argv[]) {
requireArgs(argc, 1); // File name is argument
ifstream in(argv[1]);
assure(in, argv[1]);
Stack textlines;
ESTRUCTURA DE DATOS
appear here.
textlines.initialize();
string line;
// Read file and store lines in the Stack:
while(getline(in, line))
textlines.push(new string(line));
// Pop the lines from the Stack and print them:
string* s;
while((s = (string*)textlines.pop()) != 0) {
cout << *s << endl;
delete s;
textlines.cleanup();
} ///:~
Listado 4.11. C04/StackTest.cpp
Es similar al ejemplo anterior, pero en este se apilan líneas de un

fichero (como punteros a cadena) en la Stack y después los des-
apila, lo que provoca que el fichero sea imprimido en orden inverso.
Fíjese que pop() devuelve un void* que debe ser moldeado a string*
antes de poderse usar. Para imprimir una cadena, el puntero es de
referenciado.
Como textlines se llena, el contenido de line se «clona» para cada

push() creando un new string(line). El valor devuelto por la
expresión new es un puntero al nuevo string que fue creado y al que
se ha copiado la información de la line. Si se hubiera pasado

ESTRUCTURA DE DATOS
appear here.
directamente la dirección de line a push(), la Stack se llenaría con
direcciones idénticas, todas apuntando a line. Más adelante en ese
libro aprenderá más sobre este proceso de «clonación».
El nombre del fichero se toma de línea de comando. Para garantizar

que hay suficientes argumentos en la línea de comando, se usa una
segunda función del fichero de cabecera require.h: requireArgs()
que compara argc con el número de argumentos deseado e
imprime un mensaje de error y termina el programa si no hay
suficientes argumentos.
2.5.1. Resolución de ámbito global

El operador de resolución de ámbito puede ayudar en situaciones
en las que el nombre elegido por el compilador (el nombre «más
cercano») no es el que se quiere. Por ejemplo, suponga que tiene
una estructura con un identificador local a, y quiere seleccionar un
identificador global a desde dentro de un método. El compilador, por
defecto, elegirá el local, de modo que es necesario decirle que haga
otra cosa. Cuando se quiere especificar un nombre global usando la
resolución de ámbito, debe usar el operador sin poner nada delante
de él. A continuación aparece un ejemplo que muestra la resolución
de ámbito global tanto para una variable como para una función:
//: C04:Scoperes.cpp
// Global scope resolution
int a;
void f() {}
struct S { int a;
void f();};

ESTRUCTURA DE DATOS
appear here.
void S::f() {
::f(); // Would be recursive otherwise!
::a++; // Select the global a
a--; // The a at struct scope
int main() { S s; f(); } ///:~
Sin resolución de ámbito en S::f(), el compilador elegiría por defecto

las versiones miembro para f() y a.

Realizar una estructura que permita llevar información de algún
animal, persona o cosa, crear el código en C.

ESTRUCTURA DE DATOS
appear here.
Evaluación
1. ¿Qué es una Estructura?
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
2. ¿Indique la estructura en código para su creación?
3. Grafique la estructura y sus partes
4. ¿Cómo se debe de acceder a los campos en una

estructura (Explique)?
_________________________________________________
_________________________________________________
_________________________________________________

ESTRUCTURA DE DATOS
appear here.
_________________________________________________
_________________________________________________
5. ¿Qué es una estructura anidada?
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
_________________________________________________
Recursos
• Módulo de instrucción
• Moodle
• Internet

ESTRUCTURA DE DATOS
appear here.
III. Unidad: PUNTEROS
Objetivos
Aplicar un puntero de forma efectiva dentro de un proceso de
programación.
Contenidos
3.1. Definición de punteros

Un puntero o apuntador es una variable que da referencia
a una región de memoria; en otras palabras es una variable
cuyo valor es una dirección de memoria. Si se tiene una
variable ' p ' de tipo puntero que contiene una dirección de
memoria en la que se encuentra almacenado un valor ' v '
se dice que 'p' apunta a 'v'. El programador utilizará
punteros para guardar datos en memoria en muchas
ocasiones, de la forma que se describe a continuación.
3.2. Representación gráfica de un puntero

int v= 20;
int *p; /* Declara el puntero p */
p= &v; /* Obtiene la dirección de v */

ESTRUCTURA DE DATOS
appear here.
El * en la declaración int *p indica que p es un puntero, es decir una
variable que almacena la dirección de otra variable. El int en int *p
especifica además que la dirección almacenada es la de una
variable de tipo int. La siguiente figura muestra conceptualmente
como se relacionan las variables v y p:
Para no entrar a usar valores numéricos de la direcciones en

memoria graficaremos una dirección simplemente como una
flecha hacia la variable de destino. Diremos que el puntero p
apunta al variable v.
3.3. Operaciones con varios punteros

Un puntero es un tipo de dato similar a un entero, y hay un
conjunto de operaciones definidas para punteros:
La suma o resta de un entero produce una nueva localización de

memoria.
Se pueden comparar punteros, utilizando expresiones lógicas,

para ver si están apuntando o no a la misma dirección de
memoria.
La resta de dos punteros da como resultado el número de

variables entre las dos direcciones.

ESTRUCTURA DE DATOS
appear here.
Veamos un ejemplo de utilización de punteros:
#include <iostream.h>
main()
int vector[3];
int* princPunt = vector;
int* finPunt = &vector[2];
vector[2] = 15;
cout << *(princPunt+2) << '\t' << *finPunt <<'\n';
if (princPunt == finPunt)
cout << " Esto no puede suceder " << '\n';
cout << "Numero de elementos \t" <<finPunt-princPunt << '\n';
El resultado de la ejecución de este programa es:
15 15
Número de elementos 2
La siguiente tabla resume los operadores que manipulan

punteros:

ESTRUCTURA DE DATOS
appear here.
3.4. Asignación dinámica de memoria

Los punteros se utilizan para almacenar y administrar las
direcciones de los bloques de memoria asignados dinámicamente.
Dichos bloques se utilizan para almacenar objetos o conjuntos de
objetos de datos. Los lenguajes más estructurados y orientados a
objetos proporcionan un área de memoria, llamada el montón o
tienda libre, de la que objetos dinámicamente asignados.
El código de ejemplo C siguiente ilustra cómo se asignan

dinámicamente objetos de estructura y referencia. La biblioteca C
estándar proporciona la función malloc() para asignar bloques de
memoria desde el montón. Se necesita el tamaño de un objeto para

ESTRUCTURA DE DATOS
appear here.
asignarlo como parámetro y devolver un puntero a un bloque recién
asignado de memoria adecuado para almacenar el objeto, o se
devuelve un puntero nulo si la asignación falla.
/* Item de inventario de partes */
struct Item {
int id; /* Número de parte */
char * name; /* Nombre de parte */
float cost; /* Costo */
};
/* Asignar e inicializar un nuevo objeto de elemento */
struct Item * make_item(const char *name) {
struct Item * Item;
/* Asignar un bloque de memoria para un nuevo objeto de

elemento */
Item = (struct Item *)malloc(sizeof(struct Item));
if (Item == NULL)
return NULL;
/* Inicializa los miembros del nuevo elemento */
memset(Item, 0, sizeof(struct Item));
Item->id = -1;
Item->name = NULL;
Item->cost = 0.0;

ESTRUCTURA DE DATOS
appear here.
/* Guarde una copia del nombre en el nuevo elemento */
Item->name = (char *)malloc(strlen(name) + 1);
if (Item->name == NULL) {
free(Item);
return NULL;
strcpy(Item->name, name);
/* Devuelve el objeto de artículos recientemente creados */
return Item;
El código siguiente muestra cómo se desasignan dinámicamente

objetos de memoria, es decir, retorna al montón o tienda libre. La
biblioteca C estándar proporciona la función free() para cancelar
la asignación de un bloque de memoria previamente asignado y
retornar de nuevo al montón.
/* Desasignar un objeto Item */
void destroy_item(struct Item *item) {
/* Check for a null object pointer */
if (item == NULL)
return;
/* Desasignar la cadena de nombre guardado en el Item */
if (item->name != NULL) {
free(item->name);

ESTRUCTURA DE DATOS
appear here.
item->name = NULL;
/* Desasignar el propio objeto Item */
free(item);
3.5. Liberación dinámica de memoria

La liberación dinámica se realiza con la siguiente línea de código:
fflush(stdin) y la librería que le acompaña a esta función es

#include<stdlib.h> y se la utiliza después de reservar memoria en
la estructura, ejemplo:
int estruct pila *nuevo;
//Reservamos espacio de memoria
nuevo=(struct pila*)malloc(sizeof(struct pila));
//liberamos memoria
Fflush(stdin);
3.6. La constante NULL

- Se usa con punteros en donde indicamos que el valor que en ese
momento adquiere es a ningún dato en específico, ejemplo:
int *puntero; //Declaramos el puntero
puntero=NULL; //Apuntamos a valor cero o Nulo.
3.7. Ventajas y desventajas de punteros
3.7.1. Ventajas
Ofrecen potencia y la flexibilidad en C.

ESTRUCTURA DE DATOS
appear here.
Se pueden tener apuntadores a cualquier tipo de variable.
También son útiles para pasarle parámetros a las funciones de tal

modo que les permiten modificar y regresar valores a la rutina que
las llama.
· Es la única forma de expresar algunos cálculos.
· Se genera código compacto y eficiente.
· Es una herramienta muy poderosa
El operador unario o monódico y devuelve la dirección de memoria

de una variable.
Declarar e inicializar apuntadores es bastante fácil.
Existe una relación estrecha entre los punteros y los arreglos. En C,

un nombre de un arreglo es un índice a la dirección de comienzo del
arreglo. En esencia, el nombre de un arreglo es un puntero al
arreglo.
Mientras un programa está corriendo todas las variables se guardan

en memoria, cada una tiene su dirección o localidad única.
3.7.2. Desventajas
No es posible en otros lenguajes.
Un apuntador a cualquier tipo de variables es una dirección en

memoria -- la cual es una dirección entera, pero un apuntador NO
es un entero.
El manejo complicado del almacenamiento.
Alta sobrecarga por el movimiento de líneas.

ESTRUCTURA DE DATOS
appear here.
No asignar un apuntador a una dirección de memoria antes de
usarlo.

Con la ayuda de su docente, realizar ejercicios que permitan
representar cada uno de los puntos que en esta unidad se han
tratado.
Evaluación
1. ¿Defina, qué es un puntero?
______________________________________________________
______________________________________________________
______________________________________________________
_____________________________________________________
2. Ponga un ejemplo de declaración y asignación de un
puntero.
______________________________________________________
______________________________________________________
______________________________________________________
______________________________________________________
_____________________________________________________
3. Indique la función que permite realizar liberación de memoria
en c.
______________________________________________________
______________________________________________________
______________________________________________________
_____________________________________________________
4. ¿Qué función cumple la sentencia NULL?
______________________________________________________
______________________________________________________
ESTRUCTURA DE DATOS
appear here.
______________________________________________________
_____________________________________________________
5. Indique 2 ventajas del uso de punteros
______________________________________________________
______________________________________________________
______________________________________________________
_____________________________________________________
6. Indique 2 desventajas del uso de punteros
______________________________________________________
______________________________________________________
______________________________________________________
_____________________________________________________
Recursos
• Moodle
• Internet

ESTRUCTURA DE DATOS
appear here.
IV. Unidad: LISTAS
Objetivos
Definir y conocer cada uno de los códigos que permiten realizar una
estructura de pila en C++.
Contenidos
4.1. Definición de listas

La forma más simple de estructura dinámica es la lista abierta. En
esta forma los nodos se organizan de modo que cada uno apunta al
siguiente, y el último no apunta a nada, es decir, el puntero del nodo
siguiente vale NULL.
En las listas abiertas existe un nodo especial: el primero.

Normalmente diremos que nuestra lista es un puntero a ese primer
nodo y llamaremos a ese nodo la cabeza de la lista. Eso es porque
mediante ese único puntero podemos acceder a toda la lista.
Cuando el puntero que usamos para acceder a la lista vale NULL,

diremos que la lista está vacía.
4.2. Declaración e implementación de una lista

El nodo típico para construir listas tiene esta forma:
struct nodo {
int dato;
struct nodo *siguiente;
};

ESTRUCTURA DE DATOS
appear here.
4.3. Inserción de un nodo
Este es, evidentemente, el caso más sencillo. Partiremos de que
ya tenemos el nodo a insertar y, por supuesto un puntero que
apunte a él, además el puntero a la lista valdrá NULL:
Lista vacía
Lista vacía
El proceso es muy simple, bastará con que:
1. nodo->siguiente apunte a NULL.

2. Lista apunte a nodo.
4.4. Eliminación de un nodo
Es el caso más simple. Partiremos de

una lista con uno o más nodos, y
usaremos un puntero auxiliar, nodo:
1. Hacemos que nodo apunte al primer elemento de la lista, es

decir a Lista.
2. Asignamos a Lista la dirección del segundo nodo de la lista:
Lista->siguiente.
3. Liberamos la memoria asignada al primer nodo, el que
queremos eliminar.

ESTRUCTURA DE DATOS
appear here.
Si no guardamos el puntero al primer nodo antes de actualizar
Lista, después nos resultaría imposible liberar la memoria que
ocupa. Si liberamos la memoria antes de actualizar Lista,
perderemos el puntero al segundo nodo.
Primer nodo eliminado
Primer nodo eliminado
Si la lista sólo tiene un nodo, el proceso es también válido, ya

que el valor de Lista->siguiente es NULL, y después de eliminar
el primer nodo la lista quedará vacía, y el valor de Lista será
NULL.
De hecho, el proceso que se suele

usar para borrar listas completas es
eliminar el primer nodo hasta que la
lista esté vacía.
4.5. Búsqueda de un nodo

Muy a menudo necesitaremos recorrer una lista, ya sea buscando
un valor particular o un nodo concreto. Las listas abiertas sólo
pueden recorrerse en un sentido, ya que cada nodo apunta al
siguiente, pero no se puede obtener, por ejemplo, un puntero al
nodo anterior desde un nodo cualquiera si no se empieza desde el
principio.
Para recorrer una lista procederemos siempre del mismo modo,

usaremos un puntero auxiliar como índice:
1. Asignamos al puntero índice el valor de Lista.

ESTRUCTURA DE DATOS
appear here.
2. Abriremos un bucle que al menos debe tener una condición,
que el índice no sea NULL.
3. Dentro del bucle asignaremos al índice el valor del nodo
siguiente al índice actual.
Por ejemplo, para mostrar todos los valores de los nodos de una
lista, podemos usar el siguiente bucle en C:
typedef struct _nodo {
int dato;
struct _nodo *siguiente;
} tipoNodo;
typedef tipoNodo *pNodo;
typedef tipoNodo *Lista;
...
pNodo indice;
...
indice = Lista;
while(indice) {
printf("%d\n", indice->dato);
indice = indice->siguiente;

ESTRUCTURA DE DATOS
appear here.
Supongamos que sólo queremos mostrar los valores hasta que
encontremos uno que sea mayor que 100, podemos sustituir el
bucle por:
indice = Lista;
while(indice && indice->dato <= 100) {
4.6. Otros algoritmos con listas
Elemento siguiente a uno cualquiera

Supongamos que tenemos un puntero nodo que señala a un
elemento de una lista. Para obtener un puntero al siguiente bastará
con asignarle el campo "siguiente" del nodo, nodo->siguiente.
Elemento anterior a uno cualquiera

Ya hemos dicho que no es posible retroceder en una lista, de modo
que para obtener un puntero al nodo anterior a uno dado tendremos
que partir del primero, e ir avanzando hasta que el nodo siguiente
sea precisamente nuestro nodo.
Último elemento de una lista

Para obtener un puntero al último elemento de una lista partiremos
de un nodo cualquiera, por ejemplo el primero, y avanzaremos
hasta que su nodo siguiente sea NULL.

ESTRUCTURA DE DATOS
appear here.
Saber si una lista está vacía
Basta con comparar el puntero Lista con NULL, si Lista vale NULL
la lista está vacía.
Borrar una lista completa

El algoritmo genérico para borrar una lista completa consiste
simplemente en borrar el primer elemento sucesivamente mientras
la lista no esté vacía.
4.7. Tipos de listas
Listas simples enlazadas

La lista enlazada básica es la lista enlazada simple la cual tiene un
enlace por nodo. Este enlace apunta al siguiente nodo (o indica que
tiene la dirección en memoria del siguiente nodo) en la lista, o al
valor NULL o a la lista vacía, si es el último nodo.
Listas doblemente enlazadas

Un tipo de lista enlazada más sofisticado es la lista doblemente
enlazada o lista enlazadas de dos vías. Cada nodo tiene dos
enlaces: uno apunta al nodo anterior, o apunta al valor NULL si es
el primer nodo; y otro que apunta al nodo siguiente, o apunta al
valor NULL si es el último nodo.
En algún lenguaje de muy bajo nivel, XOR-Linking ofrece una vía

para implementar listas doblemente enlazadas, usando una sola
palabra para ambos enlaces, aunque esta técnica no se suele
utilizar.
Listas enlazadas circulares

En una lista enlazada circular, el primer y el último nodo están
unidos juntos. Esto se puede hacer tanto para listas enlazadas

ESTRUCTURA DE DATOS
appear here.
simples como para las doblemente enlazadas. Para recorrer una
lista enlazada circular podemos empezar por cualquier nodo y
seguir la lista en cualquier dirección hasta que se regrese hasta el
nodo original. Desde otro punto de vista, las listas enlazadas
circulares pueden ser vistas como listas sin comienzo ni fin. Este
tipo de listas es el más usado para dirigir buffers para “ingerir”
datos, y para visitar todos los nodos de una lista a partir de uno
dado.
Listas enlazadas simples circulares

Cada nodo tiene un enlace, similar al de las listas enlazadas
simples, excepto que el siguiente nodo del último apunta al primero.
Como en una lista enlazada simple, los nuevos nodos pueden ser
solo eficientemente insertados después de uno que ya tengamos
referenciado. Por esta razón, es usual quedarse con una referencia
solamente al último elemento en una lista enlazada circular simple,
esto nos permite rápidas inserciones al principio, y también permite
accesos al primer nodo desde el puntero del último nodo.
Listas enlazadas doblemente circulares

En una lista enlazada doblemente circular, cada nodo tiene dos
enlaces, similares a los de la lista doblemente enlazada, excepto
que el enlace anterior del primer nodo apunta al último y el enlace
siguiente del último nodo, apunta al primero. Como en una lista
doblemente enlazada, las inserciones y eliminaciones pueden ser
hechas desde cualquier punto con acceso a algún nodo cercano.
Aunque estructuralmente una lista circular doblemente enlazada no

ESTRUCTURA DE DATOS
appear here.
tiene ni principio ni fin, un puntero de acceso externo puede
establecer el nodo apuntado que está en la cabeza o al nodo cola, y
así mantener el orden tan bien como en una lista doblemente
enlazada.

Con la ayuda de su docente, realice cada uno de los temas tratados
anteriormente utilizando funciones públicas en C++.
Evaluación
Realizar el siguiente menú de Pilas:
1. Ingresar Datos a la Pila
2. Imprimir Pila
3. Buscar Datos en la Pila
4. Ingresar Nodo al Inicio
5. Ingresar Nodo al Final
6. Ingresar Nodo en Cualquier Posición
7. Salir
Recursos
• Moodle
• Internet

ESTRUCTURA DE DATOS
appear here.
V. Unidad: PILAS
Objetivos
estructura de pila en c++.
Contenidos
5.1. Definición de pilas

Una pila es un tipo especial de lista abierta en la que sólo se
pueden insertar y eliminar nodos en uno de los extremos de la
lista. Estas operaciones se conocen como "push" y "pop",
respectivamente "empujar" y "tirar". Además, las escrituras de
datos siempre son inserciones de nodos, y las lecturas siempre
eliminan el nodo leído.
Estas características implican un comportamiento de lista LIFO

(Last In First Out), el último en entrar es el primero en salir.
El símil del que deriva el nombre de la estructura es una pila de

platos. Sólo es posible añadir platos en la parte superior de la
pila, y sólo pueden tomarse del mismo extremo.

ESTRUCTURA DE DATOS
appear here.
5.2. Declaración e implementación de una pila
Declaración de la Pila
La declaración de la Pila lo hacemos seguido de la palabra struct:
struct nombre_pila{
tipo_dato campo1;
tipo_dato campo2;}; struct nombre_pila *apuntador;
5.3. Inserción de un nodo (método Push)

Para insertar un nodo iniciaremos creando la base de ella.
//Declaramos la pila
struct pila{
int num;
struct pila *apunt;
};

ESTRUCTURA DE DATOS
appear here.
struct pila *nuevo, *ultimo;
void main()
//Creamos la base de la pila
ultimo=nuevo;
ultimo->apunt=NULL;
scanf(“%d”,&nuevo->num);
//Enlazamos un nuevo nodo al nodo base creado anteriormente
nuevo->apunt=ultimo;
ultimo=nuevo;
5.4. Impresión de la Pila

Para realizar la impresión adjuntamos un nuevo puntero para que
nos ayude haciendo el proceso de impresión:
struct pila *nuevo, *ultimo,*recorre;
recorre=ultimo;
while(recorre!=NULL){
printf(“%d”,recorre->num);
recorre=recorre->apunt;

ESTRUCTURA DE DATOS
appear here.
5.5. Búsqueda de un nodo (método Pop)
printf("\n\n\t\tBUSQUEDA DE ELEMENTOS INGRESADOS A LA COLA");
printf("\n\nIngrese el valor a buscar :");scanf("%d",&num);
recorre=primero;
while(recorre!=NULL){
cont++;
if(num==recorre->n)
printf("\n\tNodo %d : %d",cont,recorre->n);
aux=1;
break;
recorre=recorre->apun;
if(aux==0)
printf("\n\tDato no Existe");


ESTRUCTURA DE DATOS
appear here.
Evaluación
Realizar el siguiente menú de Pilas:
1. Ingresar Datos a la Pila

2. Imprimir Pila
3. Buscar Datos en la Pila
7. Salir
Recursos
• Moodle
• Internet

ESTRUCTURA DE DATOS
appear here.
VI. Unidad: COLAS
Objetivos
estructura de cola en C++.
Contenidos
6.1. Definición de colas

Una cola es un tipo especial de lista abierta en la que sólo se
puede insertar nodos en uno de los extremos de la lista y sólo se
pueden eliminar nodos en el otro. Además, como sucede con las
pilas, las escrituras de datos siempre son inserciones de nodos,
y las lecturas siempre eliminan el nodo leído.
Este tipo de lista es conocido como lista FIFO (First In First Out),
el primero en entrar es el primero en salir.
El símil cotidiano es una cola para comprar, por ejemplo, las

entradas del cine. Los nuevos compradores sólo pueden
colocarse al final de la cola, y sólo el primero de la cola puede
comprar la entrada.
6.2. Declaración e implementación de una cola

struct nodo {
int dato;
struct nodo *siguiente;};

ESTRUCTURA DE DATOS
appear here.
6.3. Inserción de un nodo (método Push)
Para insertar un nodo iniciaremos creando la base de ella.
//Declaramos la pila
struct cola{
int num;
struct cola *apunt;
};
struct cola *nuevo, *ultimo,primero;
void main()
//Creamos la base de la cola
nuevo=(struct cola*)malloc(sizeof(struct cola));
ultimo=nuevo;
ultimo->apunt=NULL;
//Enlazamos un nuevo nodo al nodo base creado anteriormente
nuevo->apunt=ultimo;
ultimo=nuevo;

ESTRUCTURA DE DATOS
appear here.
6.4. Impresión de la Cola
int cont=0;
clrscr();
printf("\n\n\t\tIMPRESION DE ELEMENTOS INGRESADOS A LA

COLA");
recorre=primero;
while(recorre!=NULL)
cont++;

//CODIGO DE BUSQUEDA DE DATOS EN C++
int cont=0,num,aux=0;
clrscr();
printf("\n\n\t\tBUSQUEDA DE ELEMENTOS INGRESADOS A LA COLA");
printf("\n\nIngrese el valor a buscar :");scanf("%d",&num);
recorre=primero;
while(recorre!=NULL)
cont++;

ESTRUCTURA DE DATOS
appear here.
if(num==recorre->n)
aux=1;
break;
if(aux==0)
printf("\n\tDato no Existe");


ESTRUCTURA DE DATOS
appear here.
Evaluación
Realizar el siguiente menú de Colas:
1. Ingresar Datos a la Cola

2. Imprimir Cola
3. Buscar Datos en la Cola
7. Salir
Recursos
• Moodle
• Internet

ESTRUCTURA DE DATOS
appear here.
VII. Unidad: LISTAS CERRADAS O CIRCULARES
Objetivos
Estudiar el proceso de creación y recorrido de una lista circular en
C++
Contenidos

Una lista circular es una lista lineal en la que el último nodo a
punta al primero.
Las listas circulares evitan excepciones en las operaciones que

se realicen sobre ellas. No existen casos especiales, cada nodo
siempre tiene uno anterior y uno siguiente.
En algunas listas circulares se añade un nodo especial de

cabecera, de ese modo se evita la única excepción posible, la de
que la lista esté vacía.

El nodo típico es el mismo que para construir listas abiertas:
struct nodo {
int dato;
};

ESTRUCTURA DE DATOS
appear here.
Partiremos de que ya tenemos el nodo a insertar y, por supuesto
un puntero que apunte a él, además el puntero que define la
lista, que valdrá NULL:
El proceso es muy simple, bastará con hacer que:
lista apunte a nodo.
Y lista->siguiente apunte a nodo.
De nuevo partiremos de un nodo a insertar, con un puntero que

apunte a él, y de una lista, en este caso, el puntero no será nulo:
El proceso sigue siendo muy sencillo:
1. Hacemos que nodo->siguiente apunte a lista->siguiente.

2. Después que lista->siguiente apunte a nodo.

Para ésta operación podemos encontrar tres casos diferentes:

ESTRUCTURA DE DATOS
appear here.
1. Eliminar un nodo cualquiera, que no sea el apuntado por lista.
2. Eliminar el nodo apuntado por lista, y que no sea el único
nodo.
3. Eliminar el único nodo de la lista.
En el primer caso necesitamos localizar el nodo anterior al que

queremos borrar. Como el principio de la lista puede ser
cualquier nodo, haremos que sea precisamente lista quien
apunte al nodo anterior al que queremos eliminar.
Esto elimina la excepción del segundo caso, ya que lista nunca

será el nodo a eliminar, salvo que sea el único nodo de la lista.
Una vez localizado el nodo anterior y apuntado por lista,

hacemos que lista->siguiente apunte a nodo->siguiente. Y a
continuación borramos nodo.
En el caso de que sólo exista un nodo, será imposible localizar el

nodo anterior, así que simplemente eliminaremos el nodo, y
haremos que lista valga NULL.
Eliminar un nodo en una lista circular con más de un elemento

Consideraremos los dos primeros casos como uno sólo.
1. El primer paso es conseguir que lista apunte al nodo anterior

al que queremos eliminar. Esto se consigue haciendo que lista
valga lista->siguiente mientras lista->siguiente sea distinto
de nodo.

ESTRUCTURA DE DATOS
appear here.
2. Hacemos que lista->siguiente apunte a nodo->siguiente.
3. Eliminamos el nodo.
Eliminar el único nodo en una lista circular

Este caso es mucho más sencillo. Si lista es el único nodo de una
lista circular:
Borramos el nodo apuntado por lista.
Hacemos que lista valga NULL.

A la hora de buscar elementos en una lista circular sólo hay que
tener una precaución, es necesario almacenar el puntero del
nodo en que se empezó la búsqueda, para poder detectar el
caso en que no exista el valor que se busca. Por lo demás, la
búsqueda es igual que en el caso de las listas abiertas, salvo que
podemos empezar en cualquier punto de la lista.
7.6. Recorridos de una lista

void print_list (GSList *list) {
gint i = 0;
while (list != NULL) {
g_print ("Node %d content: %d.\n", i, list->data);
/* apunta al siguiente nodo de la lista */
list = g_slist_next (list);

ESTRUCTURA DE DATOS
appear here.
i++;

Evaluación
Realizar el siguiente menú de Listas Circulares:
1. Ingresar Datos a la Lista

2. Imprimir Lista
3. Buscar Datos en la Lista
5. Eliminar un nodo cualquiera
6. Vaciar Lista
7. Salir
Recursos
• Moodle
• Internet

ESTRUCTURA DE DATOS
appear here.
VIII. Unidad: LISTAS DOBLEMENTE ENLAZADAS ABIERTAS Y
CERRADAS
Objetivos
Conceptualizar y conocer cada uno de los pasos al construir y
recorrer una lista cerrada
Contenidos

Una lista doblemente enlazada es una lista lineal en la que cada
nodo tiene dos enlaces, uno al nodo siguiente, y otro al anterior.
Las listas doblemente enlazadas no necesitan un nodo especial

para acceder a ellas, pueden recorrerse en ambos sentidos a
partir de cualquier nodo, esto es porque a partir de cualquier
nodo, siempre es posible alcanzar cualquier nodo de la lista,
hasta que se llega a uno de los extremos.
El nodo típico es el mismo que para construir las listas que

hemos visto, salvo que tienen otro puntero al nodo anterior:
struct nodo {
int dato;
struct nodo *anterior;
};

Para C, y basándonos en la declaración de nodo que hemos
visto más arriba, trabajaremos con los siguientes tipos:

ESTRUCTURA DE DATOS
appear here.
int dato;
struct _nodo *anterior;
} tipoNodo;
tipoNodo es el tipo para declarar nodos, evidentemente.
pNodo es el tipo para declarar punteros a un nodo.
Lista es el tipo para declarar listas abiertas doblemente

enlazadas. También es posible, y potencialmente útil, crear listas
doblemente enlazadas y circulares.
El movimiento a través de listas doblemente enlazadas es más

sencillo, y como veremos las operaciones de búsqueda,
inserción y borrado, también tienen más ventajas.

Nos encontramos ahora ante un tipo de estructura algo diferente de
las que hemos estado viendo, así que entraremos en más detalles.

ESTRUCTURA DE DATOS
appear here.
Vamos a intentar ver todos los casos posibles de inserción de
elementos en listas doblemente enlazadas.
Partiremos de que ya tenemos el nodo a insertar y, por supuesto un

puntero que apunte a él, además el puntero que define la lista, que
valdrá NULL:
El proceso es muy simple, bastará con que:
1. lista apunta a nodo.

2. lista->siguiente y lista->anterior apunten a null.
Partimos de una lista no vacía. Para simplificar, consideraremos

que lista apunta al primer elemento de la lista doblemente enlazada:
El proceso es el siguiente:
1. nodo->siguiente debe apuntar a Lista.

2. nodo->anterior apuntará a Lista->anterior.
3. Lista->anterior debe apuntar a nodo.

ESTRUCTURA DE DATOS
appear here.
Recuerda que Lista no tiene por qué apuntar a ningún miembro

concreto de una lista doblemente enlazada, cualquier miembro es
igualmente válido como referencia.

Analizaremos tres casos diferentes:
Eliminar el único nodo de una lista doblemente enlazada.

En este caso, ese nodo será el apuntado por Lista.
El proceso es simple:
1. Eliminamos el nodo.
2. Hacemos que Lista apunte a NULL.
Eliminar el primer nodo.

Tenemos los dos casos posibles, que el nodo a borrar esté
apuntado por Lista o que no. Si lo está, simplemente hacemos que
Lista sea Lista->siguiente.
1. Si nodo apunta a Lista, hacemos que Lista apunte a Lista-

>siguiente.
2. Hacemos que nodo->siguiente->anterior apunte a NULL
3. Borramos el nodo apuntado por nodo.

ESTRUCTURA DE DATOS
appear here.
El paso 2 depara el nodo a borrar del resto de la lista,
independientemente del nodo al que apunte Lista.

En muchos aspectos, una lista doblemente enlazada se comporta
como dos listas abiertas que comparten los datos. En ese sentido,
todo lo dicho en el capítulo sobre la localización de elementos en
listas abiertas se puede aplicar a listas doblemente enlazadas.
Pero además tenemos la ventaja de que podemos avanzar y

retroceder desde cualquier nodo, sin necesidad de volver a uno de
los extremos de la lista.
Por supuesto, se pueden hacer listas doblemente enlazadas no

ordenadas, existen cientos de problemas que pueden requerir de
este tipo de estructuras. Pero parece que la aplicación más sencilla
de listas doblemente enlazadas es hacer arrays dinámicos
ordenados, donde buscar un elemento concreto a partir de cualquier
otro es más sencillo que en una lista abierta corriente.
Pero de todos modos veamos algún ejemplo sencillo.
Para recorrer una lista procederemos de un modo parecido al que

usábamos con las listas abiertas, ahora no necesitamos un puntero
auxiliar, pero tenemos que tener en cuenta que Lista no tiene por
qué estar en uno de los extremos:
1. Retrocedemos hasta el comienzo de la lista, asignamos a lista

el valor de lista->anterior mientras lista->anterior no sea
NULL.
2. Abriremos un bucle que al menos debe tener una condición,
que el índice no sea NULL.

ESTRUCTURA DE DATOS
appear here.
3. Dentro del bucle asignaremos a lista el valor del nodo
siguiente al actual.
Por ejemplo, para mostrar todos los valores de los nodos de una
lista, podemos usar el siguiente bucle en C:
int dato;
struct _nodo *anterior;
} tipoNodo;
...
pNodo = indice;
...
indice = Lista;
while(indice->anterior) indice = indice->anterior;
while(indice) {

ESTRUCTURA DE DATOS
appear here.
Es importante que no perdamos el nodo Lista, si por error le
asignáramos un valor de un puntero a un nodo que no esté en la
lista, no podríamos acceder de nuevo a ella.
Es por eso que tendremos especial cuidado en no asignar el valor

NULL a Lista.
8.6. Otros algoritmos con listas

Añadir elemento en una lista doblemente enlazada, caso general
Para generalizar todos los casos anteriores, sólo necesitamos

añadir una operación:
1. Si lista está vacía hacemos que Lista apunte a nodo. Y nodo-

>anterior y nodo->siguiente a NULL.
2. Si lista no está vacía, hacemos que nodo->siguiente apunte a
Lista->siguiente.
3. Después que Lista->siguiente apunte a nodo.
4. Hacemos que nodo->anterior apunte a Lista.
5. Si nodo->siguiente no es NULL, entonces hacemos que nodo-
>siguiente->anterior apunte a nodo.

Con la ayuda de su docente realizar todos los puntos aquí tratados
mediante funciones públicas y enlazadas a un menú en general.

ESTRUCTURA DE DATOS
appear here.
Evaluación
Realizar el siguiente menú de Listas Doblemente Enlazadas:
1. Ingresar Datos a la Lista

2. Imprimir Lista
3. Buscar Datos en la Lista
5. Eliminar un nodo cualquiera
6. Eliminar Nodo Intermedio
7. Vaciar Lista
8. Salir
Recursos
• Moodle
• Internet

ESTRUCTURA DE DATOS
appear here.
8. Evaluación final
Tomando cualquiera de los tipos de estructuras estudiadas sean
estas pilas, colas, listas, simples, dobles o doblemente enlazadas
realizar el siguiente menú de la siguiente estructura:
struct nombre_estuctura{
char codigo[10]; char nombre[70]; char observaciones[100];
struct nombre_estructura _apuntador;}
nombre_estructura se define con las estructuras creadas, y

realizar de ellas el siguiente menú:
1. Crear
2. Imprimir
3. Insertar
3.1. Insertar al Inicio
3.2. Insertar al Final
3.3. Insertar en el Intermedio
3.4. Insertar en cualquier Posición
4. Eliminar
4.1. Eliminar al Inicio
4.2. Eliminar al Final
4.3. Eliminar en el Intermedio
4.4. Eliminar Cualquier Elemento
5. Salir

ESTRUCTURA DE DATOS
appear here.
9. Bibliografía
http://www.monografias.com/trabajos14/estruct-datos/estruct-
datos.shtml#INTRO#ixzz2v1UFdFII
http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Manejo_din%C3%A1
mico_de_memoria#Memoria_din.C3.A1mica
http://tutorialms-dos.bligoo.com/lenguaje-c-estructuras-de-datos-y-declaracion-
de-variables
http://www.pablin.com.ar/computer/cursos/c1/operations.html
http://www.monografias.com/trabajos10/esda/esda.shtml#li
http://c.conclase.net/edd/?cap=005c#5_6
10. Anexos
Qué es fácil... Qué es difícil...

Fácil es ocupar un lugar en la agenda telefónica.
Difícil es ocupar el corazón de alguien...
Fácil es herir a quien nos ama.
Difícil es curar esa herida...
Fácil es dictar reglas.
Difícil es seguirlas...
Fácil es soñar todas las noches.
Difícil es luchar por un sueño...
Fácil es exhibir la victoria.
Difícil es asumir la derrota con dignidad...
Fácil es admirar una luna llena.

ESTRUCTURA DE DATOS
appear here.
Difícil es ver su otra cara...
Fácil es tropezar en una piedra.
Difícil es levantarte...
Fácil es disfrutar la vida todos los días.
Difícil es darle el verdadero valor...
Fácil es orar todas las noches.
Difícil es encontrar a Dios en las cosas pequeñas...
Fácil es prometerle algo a alguien.
Difícil es cumplirle esa promesa...
Fácil es decir que amamos.
Difícil es demostrarlo todos los días...
Fácil es criticar a los demás.
Difícil es mejorar uno mismo...
Fácil es cometer errores.
Difícil es aprender de ellos...
Fácil es llorar por el amor perdido.
Difícil es cuidarlo para no perderlo...
Fácil es pensar en mejorar.
Difícil es dejar de pensarlo y realmente hacerlo...

ESTRUCTURA DE DATOS
appear here.
11. Glosario
Elemento dato: Son los bloques básicos para todos los demás datos del
sistema, por si mismos no le dan un significado suficiente al usuario. Se
agrupan para formar una estructura de datos.
Descripción: Cada entrada en el diccionario consiste de un conjunto de

detalles que describen los datos utilizados o producidos por el sistema.
Cada uno está identificado con:
Un nombre: para distinguir un dato de otro.
Descripción: indica lo que representa en el sistema.
Alias: porque un dato puede recibir varios nombres, dependiendo de quién uso
este dato.
Longitud: porque es de importancia de saber la cantidad de espacio necesario

para cada dato.
Valores de los datos: porque en algunos procesos solo son permitidos valores
muy específicos para los datos. Si los valores de los datos están restringidos a
un intervalo especifico, esto debe estar en la entrada del diccionario.
Estructura de datos: es un grupo de datos que están relacionados con otros y

que en conjunto describen un componente del sistema.
2016-2016

Estructura de Datos

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Estructura de Datos

Diunggah oleh

Hak Cipta:

Format Tersedia

Instituto Tecnológico Superior

5. Evaluación inicial ....................................................................... 8

6. Orientaciones generales para el estudio ................................... 9

7. Desarrollo de contenidos ......................................................... 10

I. Unidad: NOCIONES FUNDAMENTALES ........................... 10

1.2. Estructura de Datos conocidas (Variables y tipos de datos) ..... 16

1.3. Manipulación de variables a través de su dirección .................. 18

1.4. Representación Gráfica de las estructura de datos ................... 19

1.5. Acceso a las estructura de Datos (Estáticas) ............................ 19

1.6. Tipos de Estructuras de Datos .................................................. 20

Estrategias de enseñanza – aprendizaje ................................. 22

II. Unidad: ESTRUCTURAS .................................................... 25

2.2. Formato de una estructura ........................................................ 26

2.4. Acceso a los campos de una estructura .................................... 27

2.5. Estructuras anidadas ................................................................. 28

Estrategias de enseñanza – aprendizaje ................................. 36

III. Unidad: PUNTEROS........................................................... 39

3.2. Representación gráfica de un puntero ...................................... 39

3.3. Operaciones con varios punteros .............................................. 40

3.4. Asignación dinámica de memoria .............................................. 42

3.5. Liberación dinámica de memoria ............................................... 45

3.6. La constante NULL .................................................................... 45

3.7. Ventajas y desventajas de punteros .......................................... 45

Estrategias de enseñanza – aprendizaje ................................. 47

IV. Unidad: LISTAS .................................................................. 49

4.2. Declaración e implementación de una lista ............................... 49

4.3. Inserción de un nodo ................................................................. 50

4.4. Eliminación de un nodo ............................................................. 50

4.6. Otros algoritmos con listas ........................................................ 53

4.7. Tipos de listas ........................................................................... 54

Estrategias de enseñanza – aprendizaje ................................. 56

V. Unidad: PILAS .................................................................... 57

5.2. Declaración e implementación de una pila ................................ 58

5.3. Inserción de un nodo (método Push) ........................................ 58

5.4. Impresión de la Pila ................................................................... 59

5.5. Búsqueda de un nodo (método Pop) ......................................... 60

Estrategias de enseñanza – aprendizaje ................................. 60

VI. Unidad: COLAS .................................................................. 62

6.2. Declaración e implementación de una cola ............................... 62

6.3. Inserción de un nodo (método Push) ........................................ 63

6.4. Impresión de la Cola.................................................................. 64

6.5. Búsqueda de un nodo ............................................................... 64

Estrategias de enseñanza – aprendizaje ................................. 65

VII. Unidad: LISTAS CERRADAS O CIRCULARES .............. 67

7.2. Declaración e implementación de una lista ............................... 67

7.3. Inserción de un nodo ................................................................. 68

7.4. Eliminación de un nodo ............................................................. 68

7.5. Búsqueda de un nodo ............................................................... 70

7.6. Recorridos de una lista .............................................................. 70

Estrategias de enseñanza – aprendizaje ................................. 71

VIII. Unidad: LISTAS DOBLEMENTE ENLAZADAS ABIERTAS

8.2. Declaración e implementación de una lista ............................... 72

8.3. Inserción de un nodo ................................................................. 73

8.4. Eliminación de un nodo ............................................................. 75

8.5. Búsqueda de un nodo ............................................................... 76

8.6. Otros algoritmos con listas ........................................................ 78

Estrategias de enseñanza – aprendizaje ................................. 78

8. Evaluación final ....................................................................... 80

10. Anexos ................................................................................ 81

Qué es fácil... Qué es difícil... .................................................. 81

11. Glosario .............................................................................. 83

La información que se procesa en la computadora es un conjunto

Debido a que por lo general tenemos que tratar con conjuntos de

void realloc(void ptr, size_t size);