Republica Bolivariana de Venezuela

Ministerio del Poder Popular para la Defensa

Universidad Nacional Experimental Politécnica de la Fuerza Armada Nacional

Maracay – Estado Aragua

ESTRUCTURAS DINÁMICAS DE
INFORMACIÓN LISTAS Y ARBOLES

Autores: Ronney Matloo Bracho

Brian Rodríguez Quintana

Maracay 16 de noviembre 2020

INDICE

Tabla de contenido
ESTRUCTURAS DINÁMICAS DE INFORMACIÓN LISTAS Y ARBOLES..........1
Introducción.......................................................................................................................3
¿Qué es un Árbol?.............................................................................................................4
¿Qué son Listas?................................................................................................................4
Tipos de Listas y Operaciones con listas.........................................................................4
Listas Simples....................................................................................................................4
Operaciones con listas simples.........................................................................................5
Listas ordenadas................................................................................................................6
Operaciones con listas ordenadas....................................................................................6
Listas doblemente enlazadas............................................................................................8
Operaciones de listas doblemente enlazadas...................................................................8
Listas circulares...............................................................................................................10
Listas simples enlazadas.................................................................................................10
Listas doblemente enlazadas..........................................................................................10
Arboles generales.............................................................................................................11
Características.................................................................................................................11
Arboles Binarios..............................................................................................................11
Representación de un Árbol Binario.............................................................................11
Representación de árboles binarios en memorias........................................................12
Recorrido de árboles primarios.....................................................................................12
Arboles binarios de búsqueda........................................................................................13
 Búsqueda...................................................................................................................13
 Inserción:..................................................................................................................13
 Borrador:..................................................................................................................14
Conclusión........................................................................................................................15
ANEXOS..........................................................................................................................16

P á g i n a 2 | 23
Introducción
La presente investigación sobre las estructuras de listas y arboles contempla como es
estructurada y como se define y se comprende una forma esencial en la que se realizan las
estructuraciones de datos, que como bien se sabe, la informática esencialmente pone como un
elemento fundamental el uso y el manejo de datos para distintas funciones, ya sea en estructuras de
bases de datos que guardan información, como el manejo de las mismas entre entidades de software
que manejen información ya sea de caracteres o de otro tipo de formato que contenga alguna orden
o característica. Bien se sabe que una de las mas fundamentales es la estructuración a través de
arboles y listas de datos, que han comprendido una disciplina en la cual llevar le orden de una
estructura de datos en una característica forma de árbol que ordena funciones fundamentales y no
fundamentales, en la forma característica de un árbol, siendo la raíz la base y de donde parte la
estructura y sus ramas como sus características secundarias o complementarias.

P á g i n a 3 | 23
¿Qué es un Árbol?
Un Árbol, en informática, es una técnica de estructuración de datos e información que
tienen la forma estructurada basada en la jerarquía de los árboles, basándonos en su forma, siendo la
raíz y los llamados subárboles como los módulos principales, o llamados “nodos padres”
establecidos como un conjunto de elementos enlazados en un sistema funcional.

La estructura de tipo Árbol, se puede establecer de manera recursiva que cumple con la
definición base de la recursividad que expresa que un elemento puede llamarse a si mismo un
numero determinado de veces que sea requerida en la forma de una colección de elementos a partir
de la raíz ya mencionada donde cada uno tiene un rol y un valor determinado y enlazados a los
demás elementos secundarios que parten a partir de los elementos principales realmente es
representado como una estructura de datos en la que se trabaja con cada nodo por separado.
Mirando a un árbol como conjunto, se puede hablar del elemento principal de un elemento común,
pero en general se habla de una estructura de datos de un nodo dado que sólo contiene la lista de sus
hijos sin referencia a su principal. (Figura 1.0)

¿Qué son Listas?

Las listas se definen como su nombre lo indica, como una lista de elementos en la cual, a
diferencia de los árboles, los elementos tienen una relación estrictamente lineal donde cada uno de
estos tienen únicamente un elemento predecesor y un elemento sucesor, o mas simplemente como
un solo antes y un solo después. Estos representan secuencias de elementos de un tipo, tienen una
dimensión fija. Estas listas pueden ser escritas en base a signos de puntuación básicos como comas,
puntos, paréntesis, etc. Esta se usa en distintos lenguajes de programación con distintos propósitos.
Siendo una forma apropiada para la organización Los tipo de datos de lista son usualmente
implementados usando estructuras de datos de array o listas enlazadas, pero otras estructuras de
dato pueden ser más apropiadas para algunas aplicaciones. En algunos contextos, como en
programación en Lisp, el término lista se puede referir específicamente a una lista enlazada más que
un array. (Figura 2.0)

P á g i n a 4 | 23
Tipos de Listas y Operaciones con listas
Listas Simples
Se determina una lista simple como un conjunto de “Nodos” linealmente definidos uno
detrás de otro en un orden establecido de un inicio y un fin, con un nodo inicial y un nodo que
termina el proceso. Cada uno de estos posee una información característica y cumple una función
determinada a la que fue predispuesto que es la información que se almacena en dichos nodos que
puede ser de información de cualquier tipo de carácter, un elemento sucesivo. Estableciendo
esencialmente un nodo de marcha y un nodo de cierre.

Operaciones con listas simples

De manera teórica, la forma de operar una lista simple es siguiendo una secuencia y orden
de la siguiente forma.

 Creación de la lista.

crearLista (nombreLista)

 Comprobación del estado

listaVacia(nombreLista) → Booleano
listaVacia(referenciaNodo) → Booleano
listaLlena(nombreLista) → Booleano

 Inserción de nodos

insertar(nombreLista, valorInfo, posición)

insertar(nombreLista, valorInfo)

 Borrado de nodos

P á g i n a 5 | 23
 borrar(nombreLista, valorInfo)

 búsqueda de Nodo

buscar(nombreLista, dato)→información
buscar(nombreLista, dato)→referenciaNodo
pertenece(nombreLista,informacion) → Booleano

 Recorrido de una Lista

recorrer(nombreLista)

 Acceso a los nodos

info(referenciaNodo) → Informacion
siguiente(referenciaNodo) → enlace

 Modificación de nodos

asignarInfo(referenciaNodo, valorInformacion)
asignarEnlace(referenciaNodo, valorEnlace)

 Acotación sobre las operaciones

ListaLlena sólo tiene sentido si lista es acotada.

Acceso y modificación serán métodos get y put.

P á g i n a 6 | 23
Listas ordenadas
Este tipo de lista tiene la característica fundamental de que viene determinado por el valor
de cada uno de sus nodos que son estrictamente de valor propio lo cual quiere decir que la
estructura de los nodos al ser determinados, “Claves” no se les permite ser replicados o repetidos en
la estructura de la lista.

Operaciones con listas ordenadas

 Creación de la lista

crearLista (nombreLista)

 Comprobación de estado

listaVacia(nombreLista) → Booleano
listaVacia(referenciaNodo) → Booleano
listaLlena(nombreLista) → Booleano

 Inserción del nodo

insertar(nombreLista, valorClave, valorInfo)

 Borrado de nodos

borrar(nombreLista, valorClave)

 Búsqueda de un nodo

buscar(nombreLista, valorClave) → Informacion

P á g i n a 7 | 23
 buscar(nombreLista, valorClave)→ReferenciaNodo
pertenece(nombreLista,valorClave) → Booleano

 Acceso de los nodos

clave(referenciaNodo) → Clave
info(referenciaNodo) → Informacion
siguiente(referenciaNodo) → enlace

 Modificación de los nodos

asignarClave(referenciaNodo, valorClave)
asignarInfo(referenciaNodo, valorInformacion)
asignarEnlace(referenciaNodo, valorEnlace)

Listas doblemente enlazadas

Se definen estas como las que presentan una relación bilineal en ambos sentidos, este consta
de elementos en sus nodos que cada enlace posee un predecesor y un antecesor lo que le da la
capacidad de funcionar desde su origen hasta su final o viceversa

Operaciones de listas doblemente enlazadas

 Creación de una lista

crearLista(nombreLista)

P á g i n a 8 | 23
 Comprobación del estado

listaVacia(nombreLista) → Booleano
listaVacia(referenciaNodo) → Booleano
listaLlena(nombreLista) → Booleano

 Inserción de nodos

insertar(nombreLista, valorInfo, posición)

insertar(nombreLista, valorInfo)

 Borrado de nodos

borrar(nombreLista, valorInfo)

 Busqueda de un nodo

buscar(nombreLista, dato) → informacion

buscar(nombreLista, dato) → referenciaNodo
pertenece(nombreLista,informacion) → Booleano

 Recorrido de la lista

recorrer(nombreLista, sentido)

 Acceso a los nodos

info(referenciaNodo) → Informacion

P á g i n a 9 | 23
 anterior(referenciaNodo) → enlace
siguiente(referenciaNodo) → enlace

 Modificación de los nodos

asignarInfo(referenciaNodo, valorInformacion)
asignarAnterior(referenciaNodo, valorEnlace)
asignarSiguiente(referenciaNodo, valorEnlace)

Listas circulares
Las listas circulares constan de la característica principal de ser listas cuyo módulos o nodos
de cierre se encuentran conectados en un mismo punto. Esto a consecuencia genera una estructura
cíclica en la que la lista empieza y termina en un mismo punto. Esto puede ser aplicado en listas
simples y doblemente enlazadas. 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.

Estas se dividen en dos tipos de listas dependiendo de su estructura, teniendo las listas
circulares simples y las listas doblemente ordenadas.

En la definición de las listas circulares simples el nodo no contiene un enlace definido,

similar al de las listas enlazadas simples, excepto que el siguiente nodo del ultimo apunta al
primero. Este consiste en que los nuevos nodos pueden ser solo insertados eficientemente después
de que ya se tenga una referencia establecida. Por ello es común que se quede el ultimo elemento en
una lista circular simple, esto nos permite crear una estructura desde un inicio y hace posibles
accesos desde algún punto.

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 tiene ni principio ni

P á g i n a 10 | 23
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. (Figura 3.0)

Listas simples enlazadas

Una lista simple de nodos, se estructura en la forma en la que cada nodo tiene un único
conector de enlace con otro nodo, una variable referente contiene un elemento de primer nodo, cada
uno de estos exceptuando el ultimo, enlaza al siguiente y así sucesivamente hasta el último nodo
donde se rompe esta estructura por condición el cual el ultimo nodo contiene un NULL que
confirma la acción de su detención. Aaunque normalmente a la variable de referencia se la suele
llamar top, se le podría llamar como se desee . (Figura 4.0)

Listas doblemente enlazadas

Un tipo de lista enlazada más sofisticado es la lista doblemente enlazada a diferencia de las
listas simples enlazadas. Cada nodo tiene dos enlaces a diferencia de su versión más simple: 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. (Figura 5.0)

Arboles generales
Un árbol general se le conoce como una estructura de nodos de tipo T que se define como
un par, formado por un nodo r y una lista L A de arboles generales de su mismo tipo. Esta se le
conoce popularmente en la informática como “bosque”. Cada uno de estos arboles secundarios
pueden llamarse “Hijos” y es un conjunto en vez de una lista. ES importante tener en cuenta que no
puede haber arboles generales vacíos si no que es estrictamente necesario que haya al menos un
elemento en estos árboles. (Figura 6.0)

Características
En este tipo contaremos con una única operación generadora, ÁrbolGen, que construye un
árbol a partir de un elemento y un bosque de árboles. Como selectores contaremos con una
operación Raíz que devuelva la raíz de un árbol y otra operación Hijos que devuelva el bosque de
hijos de un árbol.
P á g i n a 11 | 23
Arboles Binarios
Se define “Arboles Binarios” en la informática, como una estructura de información o
estructura de datos con características propias similares de una manera no lineal en forma de nodos,
vértices, vectores, que pueden tener diferentes formas y patrones dependiendo de la estructura que
este posee. Estos se caracterizan principalmente porque tienen un vértice principal el cual se
distribuye a través de ramas donde se ramifican los demás módulos de información

Representación de un Árbol Binario

La forma de representar un Árbol binario puede hacerse determinando un vector en una lista
ligada cuya atención estará enfocada potencialmente en los vectores ya mencionados. Para esto, un
árbol binario en general se representa por niveles de los nodos en el árbol de una manera ordenada
comprendiendo una función de prioridad y funcionalidad que va principalmente de izquierda a
derecha. Esta representación es poco eficiente cuando el árbol no es completo, en vista del gran
desperdicio de memoria que podría haber por las posiciones libres que quedarían en el vector.
Si k es la posición en un vector de un nodo de un árbol con n niveles, se tiene:

El vector tendrá 2n+1 -1 posiciones.

El padre estará en la posición k/2 (con k>1)

El hijo izquierdo estará en la posición 2*I (con 2*k<n) y el hijo derecho en la posición 2*k+1.

Representación de árboles binarios en memorias

Es importante destacar que para la realización de un árbol binario en memoria se tienen dos
formas fundamentales de representar y estas son:

 Por medio de datos de tipo puntero, también conocidos como variables dinámicas o litas.
 Por medio de arreglos.

Los conocidos nodos del árbol binario están representados como registros que contendrán como
mínimo tres campos fundamentales estructurados en un nodo principal de información, así como
uno izquierdo y otro derecho que representaba dos módulos secundarios

P á g i n a 12 | 23
Recorrido de árboles primarios
Para los arboles binarios existen estructuras diferentes a las usuales que constan de listas y
arreglos, que tienen un elemento base que es un recorrido lineal u unidimensional. A diferencia de
las estructuras de arboles primarios, estos poseen un recorrido no lineal que puede cambiar
dependiendo de la situación, aunque fundamentalmente siempre debe empezar por una raíz puesto
que, a pesar de ser un recorrido no lineal, este debe poseer estrictamente un punto de partida. Esto
atado a la representación de arboles de memoria descritos anteriormente o en una de sus variantes,
tomando como punto de acción su nodo principal.

Cabe a destacar que estos se nombran esencialmente basándose en la posición de su partida

y recorrido, partiendo dependiendo de sus características desde la izquierda lo que le daría el
nombre de “Pre-onden”, en el nodo central llamado “In-orden” y por ultimo el que parte de
izquierda a derecha llamado “Post-orden”

 Pre-orden: Para recorrer un árbol binario no vacio en modo preorden, hay que realizar el
siguiente seguimiento operativo partiendo con el nodo raíz ya conocido y establecido como
ley básica:
1. Visite la raíz.
2. Atraviese el subárbol izquierdo.
3. Atraviese el subárbol derecho.
 In-orden: Para recorrer un árbol binario no vacío en modo in-orden, hay que realizar el
siguiente seguimiento operativo partiendo con el nodo raíz ya conocido y establecido como
ley básica:
1. Atraviese el subárbol izquierdo.
2. Visite la raíz.
3. Atraviese el subárbol derecho.
 Post-orden: Para recorrer un árbol binario no vacío en modo post-orden, hay que realizar el
siguiente seguimiento operativo partiendo con el nodo raíz ya conocido y establecido como
ley básica:
1. Atraviese el subárbol izquierdo.
2. Atraviese el subárbol derecho.
3. Visite la raíz.

Arboles binarios de búsqueda

P á g i n a 13 | 23
 Un árbol binario de búsqueda (ABB) es un árbol binario con la propiedad de que todos los
elementos almacenados en el subárbol izquierdo de cualquier nodo x son menores que el elemento
almacenado en x, y todos los elementos almacenados en el subárbol derecho de x son mayores que
el elemento almacenado en x.

Los Árboles binarios de búsqueda poseen una interesante característica que se basa en que
son elementos de in-orden. Esto hace que sea mas simple diseñar un procedimiento de búsqueda
esto fundamentalmente es debido a que proporciona elementos ordenados de forma ascendente y
crea un criterio de búsqueda más eficiente.

 Búsqueda: Se determina como un sistema de tipo árbol cuyos elementos nos permite
localizar en base a un elemento clave que entre en coincidencia con lo que se busca, si el
elemento es menor se busca en el subárbol izquierdo y si es mayor en el derecho por los
términos mencionados anteriormente sobre los arboles de búsqueda. Y si este no cumple
ninguna característica simplemente el elemento no existe en el árbol.
 Inserción: Este consta de características similares al criterio de búsqueda, y se puede dar
una estructura y solución tanto iterativa como recursiva. Si tenemos inicialmente como
parámetro principal un árbol vacío, crea un nuevo nodo como único contenido a insertar.
Cumpliendo con sus características en tamaño a definición de árbol de búsqueda. En
resumen, este cumple el propósito principal de generar o bien, insertar información nueva
en los nodos de búsqueda.
 Borrador: Este a diferencia de sus otros métodos se define en partes fundamentales que
definen sus características y de cómo se comprende su funcionamiento.
1. Borrar nodo sin hijos o nodo hoja: Este se encarga de borra el nodo, y se
establece nulo en el nodo raíz o nodo padre.
2. Borrar un nodo con un subárbol hijo: Se borra el nodo y se asigna su subárbol
hijo como subárbol de su padre subiendo su nivel de jerarquía para que el nodo no
quede aislado e infusional.
3. Borrar nodo con dos subárboles hijo:  la solución en este particular está en
reemplazar el valor del nodo por el de su predecesor o por el de su sucesor en
inorden y posteriormente borrar este nodo. Su predecesor en inorden será el nodo
más a la derecha de su subárbol izquierdo, y su sucesor el nodo más a la izquierda
de su subárbol derecho. En la siguiente figura se muestra cómo existe la posibilidad
de realizar cualquiera de ambos reemplazos.

P á g i n a 14 | 23
Conclusión
Actualmente en la programación y la informática, el manejo ordenado de la información a
través de una estructura organizada ha sido fundamental para manejar datos y funciones y muchas
de sus disciplinas son actualmente leyes que se deben cumplir si se quiere llevar una eficiente
gestión de la información o generar un entorno de software donde se pueda manejar esta dicha con
total comprensión y orden en base a sus características, ampliándose a muchos lenguajes de
comprensión y lenguajes de programación volviéndose en sí, un valor fundamental si se quieren
manejar datos a través de un entorno.

P á g i n a 15 | 23
ANEXOS

P á g i n a 16 | 23
Figura 1.0

Figura 2.0

Figura 3.0

P á g i n a 17 | 23
Figura 4.0

Código de lista simple enlazada realizada en Java:

public class Nodo {

// Variable en la cual se va a guardar el valor.
private int valor;
// Variable para enlazar los nodos.
private Nodo siguiente;
/**
* Constructor que inicializamos el valor de las variables.
*/
public void Nodo(){
this.valor = 0;
this.siguiente = null;
}

// Métodos get y set para los atributos.

public int getValor() {

return valor;
}

public void setValor(int valor) {

this.valor = valor;
}

public Nodo getSiguiente() {

return siguiente;
}

public void setSiguiente(Nodo siguiente) {

P á g i n a 18 | 23
 this.siguiente = siguiente;
}
}

Figura 5.0

Código de una lista doblemente enlazada realizada en C++:

#include <iostream>
using namespace std;

#define ASCENDENTE 1
#define DESCENDENTE 0

class nodo {
public:
nodo(int v, nodo *sig = NULL, nodo *ant = NULL) :
valor(v), siguiente(sig), anterior(ant) {}

private:
int valor;
nodo *siguiente;
nodo *anterior;

friend class lista;

};

typedef nodo *pnodo;

class lista {
public:
lista() : plista(NULL) {}
~lista();

void Insertar(int v);

void Borrar(int v);
bool ListaVacia() { return plista == NULL; }
void Mostrar(int);
void Siguiente();
P á g i n a 19 | 23
 void Anterior();
void Primero();
void Ultimo();
bool Actual() { return plista != NULL; }
int ValorActual() { return plista-&gt;valor; }

private:
pnodo plista;
};

lista::~lista() {
pnodo aux;

Primero();
while(plista) {
aux = plista;
plista = plista->siguiente;
delete aux;
}
}

void lista::Insertar(int v) {
pnodo nuevo;

Primero();
// Si la lista está vacía
if(ListaVacia() || plista->valor > v) {
// Asignamos a lista un nuevo nodo de valor v y
// cuyo siguiente elemento es la lista actual
nuevo = new nodo(v, plista);
if(!plista) plista = nuevo;
else plista->anterior = nuevo;
}
else {
// Buscar el nodo de valor menor a v
// Avanzamos hasta el último elemento o hasta que el siguiente
tenga
// un valor mayor que v
while(plista->siguiente && plista->siguiente->valor <= v)
Siguiente();
// Creamos un nuevo nodo después del nodo actual
nuevo = new nodo(v, plista->siguiente, plista);
plista->siguiente = nuevo;
if(nuevo->siguiente) nuevo->siguiente->anterior = nuevo;
}
}

void lista::Borrar(int v) {
pnodo nodo;

P á g i n a 20 | 23
 nodo = plista;
while(nodo && nodo->valor < v) nodo = nodo->siguiente;
while(nodo && nodo->valor > v) nodo = nodo->anterior;

if(!nodo || nodo->valor != v) return;

// Borrar el nodo

if(nodo->anterior) // no es el primer elemento

nodo->anterior->siguiente = nodo->siguiente;
if(nodo->siguiente) // no el el último nodo
nodo->siguiente->anterior = nodo->anterior;
delete nodo;
}

void lista::Mostrar(int orden) {

pnodo nodo;
if(orden == ASCENDENTE) {
Primero();
nodo = plista;
while(nodo) {
cout << nodo->valor << "-> ";
nodo = nodo->siguiente;
}
}
else {
Ultimo();
nodo = plista;
while(nodo) {
cout << nodo->valor << "-> ";
nodo = nodo->anterior;
}
}
cout << endl;
}

void lista::Siguiente() {
if(plista) plista = plista->siguiente;
}

void lista::Anterior() {
if(plista) plista = plista->anterior;
}

void lista::Primero() {
while(plista && plista->anterior) plista = plista->anterior;
}

void lista::Ultimo() {
while(plista && plista->siguiente) plista = plista->siguiente;
}
P á g i n a 21 | 23
int main() {
lista Lista;

Lista.Insertar(20);
Lista.Insertar(10);
Lista.Insertar(40);
Lista.Insertar(30);

Lista.Mostrar(ASCENDENTE);
Lista.Mostrar(DESCENDENTE);

Lista.Primero();
cout << "Primero: " << Lista.ValorActual() << endl;

Lista.Ultimo();
cout << "Ultimo: " << Lista.ValorActual() << endl;

Lista.Borrar(10);
Lista.Borrar(15);
Lista.Borrar(45);
Lista.Borrar(40);

Lista.Mostrar(ASCENDENTE);
Lista.Mostrar(DESCENDENTE);

return 0;
}

Figura 6.0

Figura 7.0

P á g i n a 22 | 23
 Bibliografía

https://www.it.uc3m.es/java/2012-13/units/pilas-colas/guides/2/guide_es_solution.html

https://www.monografias.com/trabajos101/las-istas-enlazadas/las-istas-enlazadas.shtml

http://www.calcifer.org/documentos/librognome/glib-lists-queues.html

https://es.wikipedia.org/wiki/Lista_enlazada

http://decsai.ugr.es/~jfv/ed1/tedi/cdrom/docs/arb_gen.htm

www.hackerrank.com

P á g i n a 23 | 23