Tema2 EstructurasdeDatosDinamicas 2-2021 YCB

Universidad Central de Venezuela
Facultad de Ciencias
Escuela de Computación
Estructuras de Datos
Dinámicas
LISTA  PILA  COLA
LISTA DOBLEMENTE ENLAZADA  ÁRBOL
Profesora Yusneyi Carballo Barrera
LISTA simple o List
LISTA Enlazada Simple
 Forma más simple de estructura dinámica.

 Cada nodo apunta a un nodo siguiente.
 El último nodo apunta al valor Nulo, es decir, su puntero al
nodo siguiente tiene valor NULL.
 Las listas simples o abiertas tienen un nodo especial
llamado primero, cabecera o head. Este es el puntero que
nos permite acceder a toda la lista.
Profa. Yusneyi Carballo Barrera. Estructuras de Datos Dinámicas Sem. 2-2021, 1-2022
3
LISTA. Declaración
typedef struct _nodo { // nodo de lista con datos de tipo elem

elem valor; // o campo elem dato
struct _nodo *sig;
} tipoNodo;
typedef tipoNodo *pNodo;

typedef tipoNodo *Lista;
Lista NULL
4
LISTA. Principales operaciones
 Crear lista vacía

 Verificar si la lista está vacía
 Añadir, insertar o enlistar elementos
 Recorrer la lista
 Buscar elementos
 Borrar o desenlistar elementos
 Liberar (free) la memoria de un nodo
5
CREAR Lista vacía
 El proceso para crearla consiste en:

 Lista apunte a NULL
Lista  Null Lista

//
6
VERIFICAR si la Lista está vacía
 Consiste en comparar si la Lista es igual a NULL

 Lista == NULL
¿Lista  Null?
7
INSERTAR en una Lista vacía

 El proceso para insertar el primer nodo consiste en:
1. Crear una variable Lista (vacía) y una variable de tipo nodo en
donde almacenador el valor del nuevo elemento
2. nodo -> siguiente apunte a NULL
3. Lista apunte al nodo nuevo
8
INSERTAR en la primera posición

 El proceso de cambio de los apuntadores es:
1. Hacemos que nodo -> siguiente apunte a Lista
2. Hacemos que Lista apunte a nodo
9
INSERTAR en la última posición

1. Recorremos la Lista, desde el primer elemento hasta tener un
puntero que señale al último; esto lo hacemos avanzando por la
Lista hasta el nodo que tenga como siguiente el valor NULL
2. Hacer que nodo -> siguiente sea NULL
3. Hacer que último -> siguiente sea nodo
10
INSERTAR en cualquier posición

 Ahora el nodo anterior será aquel a continuación del cual
insertaremos el nuevo nodo.
1. Hacer que nodo->siguiente señale a anterior->siguiente
2. Hacer que anterior->siguiente señale a nodo
11
RECORRER la lista // ciclo para recorrer la lista enlazada, mientras //

typedef struct _nodo { el apuntador indice sea válido (no sea NULL)
int dato; while(indice) {
struct _nodo *siguiente; cout << indice -> dato;
} tipoNodo;
indice = indice -> siguiente;
typedef tipoNodo *pNodo; }
… Por ejemplo, si queremos mostrar la posición
// otras declaraciones de tipos de los elementos con valor igual a 100:
indice = Lista; n=0;
pNodo indice; while(indice && indice -> dato == 100) {
… // otras declaraciones de apuntadores n++;
indice = Lista; cout <<n;
… // otras inicializaciones indice = indice -> siguiente;
// o instrucciones previas }
... // otras instrucciones
12
ELIMINAR toda la lista

 Hacemos que Lista apunte a NULL, pero liberando la
memoria ocupada por cada uno de sus nodos.
1. Recorrer Lista, asignándole el apuntador a siguiente, mientras la
lista no esté vacía, es decir, mientras no se llegue a NULL.
2. Liberar la memoria de cada nodo.
… // instrucciones previas
while(*Lista) {
nodo = *Lista;
*Lista = nodo -> siguiente;
free(nodo); }
13
Para aprender más…
Analizar los apuntes de la profesora con

las instrucciones que implementan las
principales operaciones para la Lista
enlazada simple
14
Videos con ejemplos y programación de

estructuras enlazadas:
 Dani de Makigas: Estructuras de datos
enlazadas. Disponible en:
https://www.youtube.com/watch?v=0NzA
Fk1CwaQ
 Carlos Santana de CodeJobs: video
tutorial sobre programación con listas
enlazadas. Disponible en:
https://www.youtube.com/watch?v=KRtsu
oa9AOo
15
PILA o Stack (LIFO)
PILA. Declaración
typedef struct _nodo {

Pila
SÓLO se
elem dato; // (**) puede agregar
struct _nodo *siguiente; y eliminar por
} tipoNodo; un extremo:
typedef tipoNodo *pNodo; El final de la

typedef tipoNodo *Pila; pila.
(**) donde elem puede ser el tipo entero, real, carácter, matriz, string, un objeto,
incluso otras listas o estructuras enlazadas, etc.
17
PILA. Principales operaciones
 Crear pila vacía

 Verificar si la pila está vacía.
 Añadir o Apilar (Push): un elemento al final de la pila.
 Leer y eliminar o Desapilar (Pop): Leer y eliminar un
elemento del final de la pila.
Profa. Yusneyi Carballo Barrera. Estructuras de Datos Dinámicas Sem. 2-2021, 1-

2022
18
CREAR Pila vacía
 El proceso para crearla consiste en:
 Pila apunte a NULL
19
VERIFICAR si la Pila está vacía
 Consiste en comparar si la Pila es igual a NULL

 Pila == NULL
¿ ?
20
INSERTAR en una Pila vacía

1. Creamos una variable de tipo nodo en donde guardamos el valor
del nuevo elemento
2. nodo -> siguiente (nodo nuevo) apunte a NULL
3. Pila apunte a nodo
21
INSERTAR o APILAR (Push) en general

1. Creamos un nodo para el nuevo valor que agregamos a la pila
2. Hacemos que nodo -> siguiente apunte a Pila
3. Hacemos que Pila apunte a nodo
22
 INSERTAR o APILAR (Push) en general

void Push(Pila *pila, int v) {
pNodo nuevo;
// Crear un nodo nuevo

nuevo = (pNodo)malloc(sizeof(tipoNodo));
nuevo->valor = v;
// Añadimos la pila a continuación del nuevo nodo

nuevo->siguiente = *pila;
*pila = nuevo; // actualizar el comienzo de la pila hacia el nuevo

nodo
}
23
ELIMINAR toda la Pila

 Hacemos que Pila apunte a NULL, pero liberando la
memoria ocupada por cada uno de sus nodos.
a) Recorrer la lista, asignándole el puntero a siguiente, mientras la pila
no esté vacía, es decir, mientras no se llegue a NULL.
b) Liberar la memoria de cada nodo.
…
while(*pila) {
nodo = *pila;
*pila= nodo -> siguiente;
free(nodo); }
24

principales operaciones para la Pila
enlazada
25

pilas enlazadas:
Dani de Makigas y Estructuras de datos
 Lección 08: Pilas. Disponible en:
https://www.youtube.com/watch?v=JDlhpEu
LUrQ
 Lección 09: Pilas en C. Disponible en:
https://www.youtube.com/watch?v=KMbf3U
HaAs4
Lección 10: Pilas en Java. Disponible en:
https://www.youtube.com/watch?v=3q_2N
KCqRmA
26
COLA o Tail (FIFO)
COLA. Declaración
typedef struct _nodo {// nodo de lista con datos de tipo elem
struct _nodo *siguiente;
Para definir la cola se
} tipoNodo; utilizan dos (2)
apuntadores:
uno al inicio (primero)
typedef tipoNodo *pNodo; otro al final (último)
typedef tipoNodo *Cola;
Cola
28
COLA. Principales operaciones
 Crear cola vacía

 Verificar si la cola está vacía.
 Añadir, insertar o encolar: inserta un elemento al final o en
la punta de la cola.
 Borrar o desencolar : lee (obtiene el valor del dato
almacenado en el nodo) y elimina el elemento del principio
de la cola o cabecera. Inicio o primero
Punta o último
de la cola
29
VERIFICAR si la Cola está vacía
El proceso consiste en comparar si ambos apuntadores de la

Cola son NULL:
 primero == NULL y ultimo == NULL
¿primero == NULL y ultimo == NULL?

30
 CREAR Cola vacía
El proceso para crearla consiste en colocar los dos punteros

que definen la Cola apuntando a NULL:
 primero apunte a NULL
 ultimo apunte a NULL
31
Insertar (Encolar) en una Cola vacía

1. Creamos un nodo nuevo, guardando en su campo dato el valor
del nuevo elemento a agregar en la cola
2. Hacer que nodo -> siguiente apunte a NULL
3. Hacer que el puntero primero apunte a nodo
4. Que el puntero último también apunte a nodo
5. Hacer que los punteros primero y último apunten al nodo
nuevo, el único nodo que tiene la cola hasta el momento
32
Añadir o ENCOLAR, caso general

1. Creamos el nodo para el nuevo elemento
2. Hacemos que nodo -> siguiente apunte a NULL
3. Si ultimo no es NULL (es decir la cola no está vacía), entonces
ultimo -> siguiente apunta a nodo
4. Actualizamos ultimo, haciendo que apunte a nodo
5. Si primero es NULL, significa que la cola estaba vacía, así que
haremos que primero apunte también a nodo
33
Leer y Eliminar (DESENCOLAR) en una

Cola que tiene solo un (1) nodo
 Usaremos un puntero a un nodo auxiliar
1. Hacemos que nodo apunte al primero de la cola
2. Asignamos NULL a primero.
3. Guardamos el contenido del nodo (contenido del campo valor o
data) en una variable para devolverlo como retorno, ya que
Desencolar muestra el elemento y también lo borra.
4. Liberamos la memoria asignada al primer nodo para eliminarlo.
5. Hacemos que ultimo apunte a NULL, ya que esta lectura o
desencolar ha dejado la cola vacía.
34
DESENCOLAR: Leer y Eliminar

Caso: una cola de con un sólo nodo o elemento
Variable para almacenar en valor o dato

nodo auxiliar
que estaba el nodo
35
Leer y Eliminar (DESENCOLAR), caso general

 Usaremos un puntero a un nodo auxiliar.
1. Hacemos que nodo apunte al primero de la cola
2. Asignamos NULL a primero
3. Asignamos al apuntador primero la dirección del segundo nodo de
la cola: primero = primero -> siguiente
4. Guardamos el contenido del nodo en una variable para devolverlo
como retorno, porque añ Desencolar ese nodo se borra
5. Liberamos la memoria asignada al primer nodo para eliminarlo
6. Si primero es NULL, hacemos que ultimo también apunte a
NULL, ya que esta lectura o desencolar ha dejado la cola vacía
36
DESENCOLAR: Leer y Eliminar

Caso: una cola con dos o más nodos
nodo auxiliar
Variable para almacenar en valor o dato

que estaba el nodo
37

principales operaciones para la Cola
38

colas enlazadas:
Dani de Makigas y Estructuras de datos
 Lección 05: Colas. Disponible en:
https://www.youtube.com/watch?v=6i2f6k5P
Pjs
 Lección 06: Colas en C. Disponible en:
https://www.youtube.com/watch?v=nicbZo7
sI_w
39
LISTA Doblemente Enlazada
LISTA Doblemente Enlazada (2E)
 Una lista doblemente enlazada es una lista lineal en la

que cada nodo tiene dos enlaces, uno al nodo siguiente,
como en la lista simple, y otro al nodo anterior.
 El nodo típico de la Lista 2E es el mismo que para
construir las listas simples, pero agregando otro puntero al
nodo anterior. Esto permite recorrer la lista hacia adelante
y hacia atrás.
Siguiente
Anterior
41
LISTA 2E. Declaración
typedef struct _nodo { // nodo de lista 2E con datos de tipo elem

struct _nodo *anterior;
} tipoNodo;

42
LISTA 2E. Principales operaciones
 Crear lista vacía

 Verificar si la lista está vacía
 Añadir, insertar o enlistar elementos
 Buscar un valor en la lista
 Moverse a través de la lista, hacia adelante (con apuntador
al nodo siguiente) y hacia atrás (con el apuntador al nodo
anterior)
 Borrar o desenlistar elementos de la lista
43
CREAR Lista 2E vacía
El proceso para crearla consiste en:
 lista apunte a NULL
44
VERIFICAR si la Lista2E está vacía
 Consiste en comparar si Lista es igual a NULL
 lista == NULL
¿ ?
45
INSERTAR o Enlistar en una Lista 2E vacía

 El proceso para insertar el primer nodo consiste en:
1. Creamos un nodo nuevo, almacenando en su campo Dato el
valor del nuevo elemento de la Lista 2E
2. Lista apunte al nodo nuevo
3. Lista -> siguiente apunte a NULL y
Lista -> anterior apunte a NULL
Como la lista 2E estaba vacía, este primer nodo no tiene anterior y
tampoco tiene un nodo siguiente.
¿Cómo sería la representación
gráfica de los pasos de esta
operación?
46
INSERTAR en la primera posición

 Condición: partimos de una lista 2E que no está vacía y
asumimos que Lista apunta a su primer nodo
1. Creamos un nodo nuevo y almacenamos en su campo Dato el
valor a agregar a la Lista
2. Hacemos que nodo -> siguiente apunte a Lista
3. Nodo -> anterior apunta a Lista -> anterior
4. Lista -> anterior apunta al nuevo nodo
47
INSERTAR en la última posición

 Igual que en el caso anterior, partiremos de una lista no
vacía, y para simplificar, asumimos que el apuntador Lista
está apuntando al último nodo.
1. Creamos un nodo nuevo para el elemento a enlistar
2. Hacemos que nodo -> siguiente apunte a Lista -> siguiente
(que tiene el valor NULL)
3. Lista -> siguiente debe apuntar a nodo
4. nodo -> anterior apuntará a Lista
48
INSERTAR en cualquier posición

 Ahora el nodo anterior será aquel a continuación del cual
insertaremos el nuevo nodo, además se asume que no
estamos en la última posición de la lista.
1. Creamos un nodo nuevo para el elemento a enlistar
2. Hacemos que nodo -> siguiente apunte a Lista -> siguiente
3. Hacemos que lista -> siguiente apunte a nodo
4. Hacemos que nodo->anterior apunte a Lista
5. Hacemos que nodo -> siguiente -> anterior apunte a nodo
49
INSERTAR, caso general

 Creamos un nodo nuevo y almacenamos en su campo Dato el valor a
agregar a la Lista
 Si Lista está vacía:
 Hacemos que Lista apunte a nodo
 nodo->anterior apunte a NULL y nodo->siguiente apunte a NULL
 Si Lista no está vacía, hacemos que
 nodo->siguiente apunte a Lista->siguiente
 Después que Lista->siguiente apunte a nodo
 Hacemos que nodo->anterior apunte a Lista
 Si nodo->siguiente no es NULL, entonces hacemos que nodo-
>siguiente->anterior apunte a nodo
50
Indica cómo sería la representación gráfica de los pasos para

agregar en una lista doblemente enlazada en los casos de:
 Enlistar al inicio de la lista 2E
 Agregar al final de la lista 2E
 Insertar en cualquier posición de la lista
51
//Recorrido desde el INICIO hasta el FINAL

RECORRER la lista 2E // de la lista, suponiendo que el apuntador
// indice está en cualquier lugar de lista
typedef struct _nodo {
// retrocedemos hasta el inicio
int dato;
while(indice -> anterior) {
indice = indice -> anterior;
struct _nodo *anterior;
}
} tipoNodo;
// ahora, recorremos mostrando los datos
while(indice) {
printf("%d\n", indice -> dato);
indice = indice -> siguiente;
…
}
// otras declaraciones de tipos
…
pNodo indice;
… // otras declaraciones de apuntadores
indice = Lista; ¿Cómo adaptamos el código anterior
… // otras inicializaciones para recorrer la lista desde el FINAL
// o instrucciones previas hacia el INICIO?
52
ELIMINAR un elemento de la lista 2E

 El proceso de actualización de los apuntadores es:
 Recorremos la lista con un nodo auxiliar hasta llegar al elemento
con valor v que queremos eliminar
 Si llegamos al final de la lista y el elemento no está en la lista, se lo
informamos usuario
 Si encontramos el valor, entonces nodo apunta a su posición en la
lista.
Continúa en la próxima diapositiva
53
ELIMINAR un elemento de la lista 2E

 Actualización cuando en valor es encontrado:
 Si nodo apunta a la misma posición que lista, actualizamos el
apuntador de la lista para que apunte al nodo anterior o al nodo
siguiente del actual, según se necesite
 Si nodo->anterior no es NULL (no es el primero):
nodo->anterior->siguiente = nodo->siguiente
 Si nodo->siguiente no es NULL (no es el último):
nodo->siguiente->anterior = nodo->anterior
 Eliminamos o liberamos el elemento apuntado por nodo
54
DESENCOLAR en la lista 2E
void Desencolar(Lista *lista, int v) {
// Caso 2. Si está en la lista: borrar el nodo
pNodo nodo;
// Si lista apunta al nodo que queremos
nodo = *lista;
// borrar, la actualizamos apuntando a otro
if(nodo == *lista)
// Buscando el nodo con valor v
if(nodo->anterior)
while(nodo && nodo->valor < v)
*lista = nodo->anterior;
nodo = nodo->siguiente;
else
*lista = nodo->siguiente;
// Caso 1. El valor v no está en la lista
if(!nodo || nodo->valor != v) {
if(nodo->anterior) // no es el primero
// no tengo un nodo válido o
nodo->anterior->siguiente = nodo->siguiente;
// no encontré el valor v buscado
if(nodo->siguiente) // no es el último nodo
cout <<“El valor ” <<v <<“ no fue
nodo->siguiente->anterior = nodo->anterior;
encontrado”;
return;
free(nodo); //liberamos la memoria del nodo
}
}
55
56
Analizar los apuntes de

la profesora con las
instrucciones que
implementan las
principales operaciones
para una Lista
Multienlazada, una
variación de las listas
doblemente enlazadas.
57

colas enlazadas:
 Edwin Anaya: Lista enlazada simple y doble.
Disponible en:
https://www.youtube.com/watch?v=8HdvMDZHS7
4
 Héctor Jaimes: Lista doblemente enlazada en C.
Disponible en:
https://www.youtube.com/watch?v=NN_iS0jnJas
 Asaeldev: Lista doblemente enlazada en C.
Disponible en:
https://www.youtube.com/watch?v=ABZIs-lMSlA
58
Tareas
Vamos a
aplicar lo
aprendido
• Fecha tope de envío: hasta el viernes 10 de marzo del 2022

• Enviar en archivo .docx o .pdf al correo electrónico YusneyiCarballo@gmail.com
• Asunto del correo-e y nombre del archivo(s) anexo(s):
AyED_TareaTema2_NombreyApellidos_Cedula.ext
59
Tareas
Desarrolla algoritmos en pseudocódigo para:

LISTA:
1. Crear una lista con datos de alumnos.
2. Inicializarla con datos suministrados por el usuario.
3. Imprimir la lista de estudiantes, incluyendo su número de
cédula.
COLA:
4. Crear una cola que guarde información de aplicaciones que
se ejecutan en un computador.
5. Inicializar la cola con datos de varias aplicaciones,
incluyendo su identificador (id), tiempo de ejecución
(tiempo), memoria que ocupa (memoria).
6. Indicar cual o cuáles son las aplicaciones con mayor tiempo
de ejecución.
7. Eliminar una aplicación con un id dado por el usuario.
60
Tareas
Desarrolla algoritmos en pseudocódigo para:

PILA:
8. Crear una pila con información de libros.
9. Solicitar al usuario el nombre de un autor o autora y
mostrar todos los libros de la pila escritos por esa persona.
LISTA MULTIENLAZADA:
Analizar las notas de clase de la profesora para las listas
multienlazadas (diapositiva 57) y responder:
10. ¿Qué se está representando con las estructuras
declaradas?
11. Desarrollar el algoritmo para agregar un producto.
12. Calcular cuál es el promedio de todos los precios de los
productos.
13. Recibiendo el valor del precio promedio y listar los códigos
de los productos con un precio mayor a este valor.
61
¿Puede volar?
no si
¿Puede ladrar? Pájaro
no si
Gato Perro
Árboles enlazados
ÁRBOL
 Un árbol A es una estructura no lineal en la que cada nodo

puede apuntar a ninguno, uno, dos o varios nodos.
 Tiene un nodo especial r llamado raíz.
 Tiene un conjunto de estructuras disjuntas y no conectadas
A1, A2, … Am, llamadas subárboles (ramas del árbol).
 Recursivamente puede definirse como una estructura:
 Vacía, o
 Compuesta por uno o varios campos con un datos y campos con
apuntadores a subárboles o al valor Null.
63
ÁRBOL general o n-ario
 Gráficamente un árbol general se puede representar como

un conjunto de nodos enlazados, con un nodo raíz, ramas
que conforman subárboles y nodos que representan hojas.
Nodo raíz del árbol
Rama derecha o
Rama izquierda o
Nodo grado 2 subárbol derecho
subárbol izquierdo
Nodo con grado 1
Nodo con grado 2

Hoja
Null Null
Fuente: Carballo Barrera (2005)
64
ÁRBOL Binario
 Un árbol binario es una estructura no lineal en la que cada

nodo tiene como máximo dos nodos a los cuales apuntar,
llamados izquierdo y derecho
 Tiene un nodo especial llamado raíz.
 El nodo de un árbol binario puede enlazar hacia ninguno, uno o
hasta dos nodos, es decir, su grado máximo es 2.
 Los nodos con enlace izquierdo y derecho apuntando a Null son
hojas.
 Recursivamente puede definirse como una estructura:
 Vacía, o
 Compuesta por campos para dato y campos con apuntadores a NULL, a
un sub-árbol izquierdo o a un subárbol derecho.
65
ÁRBOL Binario
*izquierda *derecha
Hojas apuntan a NULL
Raíz
Rama Rama
Izquierda Derecha
66
ÁRBOL Binario. Principales operaciones
 Raíz  Recorridos
 esVacío  Pre-orden
 nodoDerecho  In-orden
 Post-orden
 nodoIzquierdo
 Creación y carga
 existeDerecho
(InicializarÁrbol o
 existeIzquierdo LlenarÁrbol)
 valor  Insertar
 esRaíz  Buscar
 esHoja  Eliminar
 gradoNodo
67
Analizar los apuntes de

la profesora con las
instrucciones que
implementan las
principales operaciones
para un Árbol Binario
con apuntadores
Fuente: Apuntes de clase sobre Árboles de la Profa. Yusneyi Carballo Barrera
68

procedimientos y recorridos en Árboles
Binarios:
Coding Tree, ¿Qué son los Árboles Binarios y por qué
son tan geniales? Disponible en:
 https://www.youtube.com/watch?v=lMTaNbJAqvM
Dani de Makigas y Estructuras de datos:
 Introducción a los árboles. Disponible en:
https://www.youtube.com/watch?v=Qexq1k8LB6k
 Lección 12: Árboles Binarios. Disponible en:
https://www.youtube.com/watch?v=OVCNzj5BMcs
69

procedimientos y recorridos en
Árboles Binarios:
David Julián Guzmán Cárdenas. Tutorías con Ingenio
Universidad Nacional:
 Recorridos en Árboles Binarios. Disponible en:
https://www.youtube.com/watch?v=95CgVIsOxLA
 Construcción en Árboles Binarios a partir de los
recorridos. Disponible en:
https://www.youtube.com/watch?v=KY_6Xduq8jc
70
Árboles Binarios de Búsqueda
Fuente imagen: Hacks-LRLeon
71
ÁRBOL BINARIO DE BÚSQUEDA (ABB)
72
ÁRBOL BINARIO DE BÚSQUEDA (ABB)
DECLARACIÓN de un ABB:
typedef struct _nodo // definición de un tipo de dato

{ // nodo de árbol binario de búsqueda con datos de tipo entero
int dato;
struct _nodo *izquierda; *izquierda *derecha
struct _nodo *derecha;

dato
} tipoNodo;
typedef tipoNodo *pNodo; // se declara una variable apuntador

typedef tipoNodo *arbolBB; // se declara una variable árbol
73
ÁRBOL BB. Principales operaciones
 Crear ABB vacío.

 Verificar si el ABB está vacío.
 Añadir o insertar en el ABB.
 Buscar o Encontrar elementos en un ABB.
 Recorridos o moverse a través del ABB en:
 Pre-Orden
 In-Orden
 Post-Orden
 Borrar elementos del ABB.
 Eliminar el ABB.
74
ÁRBOL BB. Principales Operaciones
CREAR Árbol Binario de Búsqueda (ABB) vacío
 El proceso para crearlo consiste en:
 La variable arbol que es de tipo ABB apunta a NULL.
arbol NULL
75
VERIFICAR si el ABB es vacío
 Consiste en comparar si el valor del apuntador a la variable

de tipo ABB es igual a NULL.
 arbol == NULL
¿ arbol NULL ?
76
VERIFICAR si un nodo es una hoja
 Consiste en verificar que no hay apuntador hacia un

próximo elemento, ni por el enlace izquierdo, ni por el
enlace derecho.
Es decir, un nodo hoja no tiene rama izquierda, ni rama
derecha (sus apuntadores apuntan a NULL).
int EsHoja(pNodo r) {
// el nodo al cual apunta r no tiene hijo izquierdo ni derecho
return ( !r -> izquierdo && !r -> derecho );
}
77
BUSCAR un elemento en el árbol BB
 Partiendo siempre del nodo raíz, el modo de buscar un elemento se define de

forma recursiva:
1. Si el árbol está vacío, terminamos la búsqueda: el elemento no está en el árbol.
2. Si el valor del nodo raíz es igual que el del elemento que buscamos, terminamos la búsqueda
con éxito.
3. Si el valor del nodo raíz es mayor que el elemento que buscamos, continuaremos la búsqueda
en el árbol izquierdo.
4. Si el valor del nodo raíz es menor que el elemento que buscamos, continuaremos la
búsqueda en el árbol derecho.
 El valor de retorno de una función de búsqueda en un ABB puede ser un
puntero al nodo encontrado, o NULL, si no se ha encontrado el elemento.
78
ÁRBOL AB. Principales Operaciones
int Buscar(ArbolBB *a, int v) {

pNodo actual = *a;
while(!Vacio(actual)) {
if(v == actual->dato)
return true; // el dato fue encontrado
else
if(v < actual->dato)
actual = actual->izquierdo; //buscamos hacia el nodo izquierdo
else
if(v > actual->dato)
actual = actual->derecho; //buscamos hacia el nodo derecho
}
return false; // el elemento con valor v no está en árbol a
}
79
INSERTAR un elemento en el árbol BB
 Para insertar un elemento nos basamos en el algoritmo de

Búsqueda en el árbol binario.
 Si el elemento está en el árbol no lo insertaremos.
 Si no lo está, lo insertaremos a continuación del último
nodo visitado, según corresponda por la rama izquierda o
por la rama derecha.
 Necesitamos un puntero auxiliar para conservar una
referencia al nodo padre del nodo raíz actual en donde toca
hacer la inserción.
80
INSERTAR o AGREGAR if(Vacio(padre)) { // el árbol no tiene hijos, por lo tanto
está vacío, se insertar su único nodo
void Insertar(ArbolBB *a, int v) { *a = (ArbolBB)malloc(sizeof(tipoNodo)); //memoria
pNodo padre = NULL; //creamos un apuntador al padre para el nuevo nodo
del nodo raíz donde se va a insertar (*a)->dato = v;
pNodo actual = *a; // comenzamos el recorrido desde la (*a)->izquierdo = (*a)->derecho = NULL;
raíz del árbol }
else // el árbol ya tiene nodos, se inserta en la rama
while(!Vacio(actual) && v != actual->dato) { conveniente
// buscamos el lugar a insertar el nuevo nodo o if(v < padre->dato) { // se inserta a la izquierda
// si el valor ya existe en el árbol, en cuyo caso no se actual = (ArbolBB)malloc(sizeof(tipoNodo));
insertaría 2 veces //memoria para el nuevo nodo
padre = actual; padre->izquierdo = actual;
actual->dato = v;
if(v < actual->dato) actual->izquierdo = actual->derecho = NULL;
actual = actual->izquierdo; // se busca por la rama }
izquierda else
else if(v > padre->dato) { // se inserta a la derecha
if(v > actual->dato) actual = (ArbolBB)malloc(sizeof(tipoNodo));
actual = actual->derecho; // se busca por la rama //memoria para el nuevo nodo
derecha padre->derecho = actual;
} actual->dato = v;
if(!Vacio(actual)) return; actual->izquierdo = NULL;
// el valor a insertar ya está en el árbol actual->derecho = NULL;
// también podemos preguntar por if(v == actual->dato) }
}
81
ELIMINAR o BORRAR un elemento del Árbol BB
 Para borrar un elemento también nos basamos en el algoritmo de búsqueda.

Si el elemento no está en el árbol NN no lo podremos borrar. Si está, hay dos
casos posibles:
1. Se trata de un nodo hoja: en ese caso lo borraremos directamente.
2. Se trata de un nodo rama: en ese caso no podemos eliminarlo, puesto que
perderíamos todos los elementos del árbol de que el nodo actual es padre.
En su lugar buscamos el nodo más a la izquierda del subárbol derecho, o el
nodo más a la derecha del subárbol izquierdo e intercambiamos sus
valores.
3. A continuación eliminamos el nodo hoja.
 Necesitamos un puntero auxiliar para conservar una referencia al padre del
nodo raíz actual. El valor inicial para ese puntero es NULL.
82
ELIMINAR o BORRAR un elemento del árbol BB
Caso particular: Borrar un elemento que está en un nodo

hoja:
En el árbol de ejemplo de la próxima diapositiva, borrar el nodo 3.

 Localizamos el nodo a borrar, el que contiene en dato con valor 3,
menteniendo un puntero a Padre.
 Hacemos que el puntero de Padre que apuntaba a nodo, ahora
apunte a NULL.
 Borramos el nodo.
83
ELIMINAR o BORRAR un elemento del árbol BB

BORRAR un elemento que está en un nodo hoja, por
ejemplo, el nodo hoja con valor valor 3
84
ELIMINAR o BORRAR un
elemento del árbol
Caso general:
Borrar cualquier elemento del Árbol  El nodo no es un nodo hoja:
 Si Padre = NULL  Buscamos el 'nodo' más a la izquierda del
Si el árbol está vacío: el elemento no está en el árbol derecho de raíz o el más a la
árbol, por lo tanto salimos sin eliminar ningún derecha del árbol izquierdo. Hay que
elemento. tener en cuenta que puede que sólo
exista uno de esos árboles. Al mismo
 Si valor del nodo raíz = elemento buscado
tiempo, actualizamos 'Padre' para que
Se encontró el elemento a eliminar y estamos apunte al padre de 'nodo'.
ante uno de los siguientes casos:
 Intercambiamos los elementos de los
 El nodo raíz es un nodo hoja: nodos raíz y 'nodo'.
 Si 'Padre' es NULL, el nodo raíz es el  Borramos 'nodo'. Esto significa volver a
único del árbol, por lo tanto el puntero al (3), ya que puede suceder que 'nodo' no
árbol debe ser NULL. sea una hoja.
 Si raíz es la rama derecha de 'Padre',  Si valor del nodo raíz > elemento buscado
hacemos que esa rama apunte a NULL. Continuaremos la búsqueda en el árbol
 Si raíz es la rama izquierda de 'Padre', izquierdo.
hacemos que esa rama apunte a NULL.  Si valor del nodo raíz < elemento buscado
 Eliminamos el nodo, y salimos. Continuaremos la búsqueda en el árbol derecho.
85
ELIMINAR o BORRAR un elemento del árbol
BORRAR un elemento que está en cualquier nodo del árbol BB

Borrar nodo con valor 4 Borrar nodo con valor 6
86
RECORRER un árbol
 Los recorridos dependen en gran medida del tipo y propósito

del árbol, realizándose a través de sus apuntadores.
 Los recorridos son usados frecuentemente para inicializar un
árbol, procesar sus valores, buscar un elemento, entre otras
acciones.
 Tres de las formas de recorrer o visitar los nodos de un árbol
son los recorridos recursivos:
 Pre-Orden (notación polaca prefija)
 In-Orden (notación simétrica o convencional)
 Post-Orden (notación polaca postfija)
87
Recorrido: Pre-Orden en árboles BB

 En este tipo de recorrido, el valor del nodo se procesa antes de recorrer
las ramas: Visita – Rama Izquierda – Rama Derecha
 Si recorremos el árbol del ejemplo en Pre-Orden los datos almacenados en
las hojas se muestran en este orden:
A - B - E - K - F - C -G - L - M - D - H - I -J - N - O
88
Recorrido: In-Orden en árboles BB

 En este recorrido, el valor del nodo se procesa después de recorrer la
primera rama y antes de recorrer la última. Esto tiene más sentido en
el caso de árboles binarios: Rama Izquierda – Visita – Rama Derecha
 Si seguimos el árbol del ejemplo en In-Orden se obtiene :
K - E - B - F - A - L - G - M - C - H - D - I - N - J - O
89
Recorrido: Post-Orden en árboles BB

 En este tipo de recorrido, el valor del nodo se procesa después de
recorrer todas las ramas: Rama Izquierda – Rama Derecha – Visita
 Si seguimos el árbol del ejemplo en Post-Orden, los valores del arbol se
muestran de la siguiente manera:
K - E - F - B - L - M -G - C - H - I - N - O - J - D - A
90
Analizar los apuntes de la profesora con algoritmos para la
estructura de datos dinámica Árbol y sus variaciones:
 Árbol binario
 Árbol binario de búsqueda
 Árbol binario de expresión
91
Para practicar…
Ejercicio de Tarea ABB:
 Implemente una clase que represente la estructura Árbol Binario,

incorporando los atributos y métodos que considere convenientes
para representar su comportamiento.
 Utilice la clase Árbol para:
 Representar su árbol genealógico, comenzando por sus abuelos
paternos y maternos. Incluya los miembros de tres (3) o a lo sumo
cuatro (4) generaciones, en el caso de que haya bisnietos en su
familia.
 Recorra la clase árbol para indicar el nombre de sus abuelos
(nodos iniciales) y de los nietos que no tienen hijos (hojas).
92

procedimientos y recorridos en
Árboles Binarios de Búsqueda:
Kevin García Ríos, Árboles Binarios: Recorrido
Inorden, Preorden, Postorden. Disponible en:
 https://www.youtube.com/watch?v=H9ObBBoGS9
E
David Julián Guzmán Cárdenas. Tutorías con Ingenio
Universidad Nacional. Construcción de Árboles
binarios a partir de sus recorridos. Disponible en
 https://www.youtube.com/watch?v=KY_6Xduq8jc
93

Tema2 EstructurasdeDatosDinamicas 2-2021 YCB

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tema2 EstructurasdeDatosDinamicas 2-2021 YCB

Cargado por

Copyright:

Formatos disponibles

Universidad Central de Venezuela

 Forma más simple de estructura dinámica.

typedef struct _nodo { // nodo de lista con datos de tipo elem

typedef tipoNodo *pNodo;

 Crear lista vacía

CREAR Lista vacía

 El proceso para crearla consiste en:

Lista  Null Lista

VERIFICAR si la Lista está vacía

 Consiste en comparar si la Lista es igual a NULL

INSERTAR en una Lista vacía

INSERTAR en la primera posición

INSERTAR en la última posición

INSERTAR en cualquier posición

RECORRER la lista // ciclo para recorrer la lista enlazada, mientras //

ELIMINAR toda la lista

Analizar los apuntes de la profesora con

Videos con ejemplos y programación de

typedef struct _nodo {

typedef tipoNodo *pNodo; El final de la

 Crear pila vacía

Profa. Yusneyi Carballo Barrera. Estructuras de Datos Dinámicas Sem. 2-2021, 1-

CREAR Pila vacía

 El proceso para crearla consiste en:

 Pila apunte a NULL

VERIFICAR si la Pila está vacía

 Consiste en comparar si la Pila es igual a NULL

INSERTAR en una Pila vacía

INSERTAR o APILAR (Push) en general

 INSERTAR o APILAR (Push) en general

// Crear un nodo nuevo

// Añadimos la pila a continuación del nuevo nodo

*pila = nuevo; // actualizar el comienzo de la pila hacia el nuevo

ELIMINAR toda la Pila

Analizar los apuntes de la profesora con

Videos con ejemplos y programación de

 Crear cola vacía

VERIFICAR si la Cola está vacía

El proceso consiste en comparar si ambos apuntadores de la

¿primero == NULL y ultimo == NULL?

 CREAR Cola vacía

El proceso para crearla consiste en colocar los dos punteros

Insertar (Encolar) en una Cola vacía

Añadir o ENCOLAR, caso general

Leer y Eliminar (DESENCOLAR) en una

DESENCOLAR: Leer y Eliminar

Variable para almacenar en valor o dato

Leer y Eliminar (DESENCOLAR), caso general

DESENCOLAR: Leer y Eliminar

Variable para almacenar en valor o dato

Analizar los apuntes de la profesora con

Videos con ejemplos y programación de

 Una lista doblemente enlazada es una lista lineal en la

typedef struct _nodo { // nodo de lista 2E con datos de tipo elem

typedef tipoNodo *pNodo;

 Crear lista vacía

CREAR Lista 2E vacía

El proceso para crearla consiste en:

 lista apunte a NULL

VERIFICAR si la Lista2E está vacía

 Consiste en comparar si Lista es igual a NULL

INSERTAR o Enlistar en una Lista 2E vacía

INSERTAR en la primera posición

INSERTAR en la última posición