UNIVERSIDAD DE ORIENTE

NUCLEO DE ANZOATEGUI
POSTGRADO EN INFORMATICA GERENCIAL
ESTRUCTURAS DE DATOS
Ing. Jose Manuel Diaz M.Sc.
En programacin, una estructura de datos es una forma de organizar un
conjunto de datos elementales con el objetivo de facilitar su manipulacin y
aumentar el rendimiento de un sistema. Un dato elemental es la mnima
informacin que se tiene en un sistema. Las Estructuras de Datos se pueden
clasificar de la siguiente manera:

1.- Internas
1.1- Estticas
1.1.1- Arreglos
1.1.2- Matrices
1.2- Dinmicas1.2.1- Lineales
1.2.1.1- Listas
1.2.1.2- Pilas
1.2.1.3- Colas
1.2.2- No Lineales
1.2.2.1- rboles
1.2.2.2- Grafos
2.- Externas
2.1- Bases de Datos
2.2- Archivos
Definiciones
En un lenguaje de programacin, un tipo de dato est definido por el conjunto de valores que
representa y por el conjunto de operaciones que se pueden realizar con dicho tipo de dato. Por
ejemplo, el tipo de dato entero en Java puede representar nmeros en el rango de -2^31 a 2^31-1 y
cuenta con operaciones como suma, resta, multiplicacin, divisin, etc.
Por otro lado, podemos decir que en la solucin de un problema a ser procesado por un computador
encontrar dos grandes tipos de datos: datos simples y datos estructurados. Los datos simples son
aquellos que, al ser representados por el computador, ocupan solo una casilla de memoria. Debido a
esto, una variable de un tipo de dato simple hace referencia a un nico valor a la vez. Ejemplo de
estos tipos de datos son los enteros, reales, caracteres y booleanos.
As mismo, los datos estructurados se caracterizan porque su definicin est compuesta de otros
tipos de datos simples, as como de otros datos estructurados. En este caso, un nombre (identificador
de la variable estructurada) hace referencia no solo a una casilla de memoria, sino a un grupo de
casillas.
En programacin, el trmino estructura de datos se utiliza para referirse a una forma de organizar
un conjunto de datos que se relacionan entre si, sean estos simples o estructurados, con el objetivo
de facilitar su manipulacin y de operarlo como un todo.
Por otro lado, tenemos el trmino Tipo de Dato Abstracto, o TDA, que es muy comnmente utilizado
como equivalente al trmino estructura de datos para referirse justamente a un tipo de dato

estructurado que representa un concepto a travs de la definicin de sus caractersticas (datos que lo
conforman) y de sus operaciones(algoritmos que manipulan los datos que lo conforman).

Operaciones
Sobre una estructura de datos se puede efectuar diferentes tipos de operaciones, entre las ms
importantes estn:
Insercin. Es aquella mediante la cual se incluye un nuevo elemento en la estructura.
Modificacin. Permite variar parcial o totalmente el contenido de la informacin de los elementos de
la estructura.
Eliminacin. Como su nombre lo indica, es la que permite suprimir elementos de la estructura.
Navegar por la estructura: Esta es una operacin bsica que garantiza que se puede recuperar
informacin almacenada.
Bsqueda. Permite determinar si un elemento se encuentra o no en la estructura.
Consulta de la informacin. Permite obtener informacin de uno o ms elementos de la estructura.
Copia parcial o total: Mediante esta operacin se puede obtener total o parcialmente una estructura
con caractersticas similares a la original.
Prueba. Permite determinar si uno o varios elementos cumplen determinadas condiciones.
Verificar si es vaca. Permite determinar si existen o no elementos sobre la estructura.
Clasificacin
Una clasificacin de estructuras de datos es, segn dnde residan: Internas y externas. Si una
estructura de datos reside en la memoria principal del computador se denomina estructura de datos
interna. Recprocamente, si reside en un soporte externo, se denomina estructura de datos externa.
Las estructuras de datos internas pueden ser de dos tipos:

Estructuras de Datos Estticas.

Estructuras de Datos Dinmicas.

Estructuras de Datos Estticas.

Tienen un nmero fijo de elementos que queda determinado desde la declaracin de la estructura en
el comienzo del programa. Ejemplo los arreglos. Las estructuras de datos estticas, presentan dos
inconvenientes:

1. La reorganizacin de sus elementos, si sta implica mucho movimiento puede ser muy
costosa. Ejemplo: insertar un dato en un arreglo ordenado.
2. Son estructuras de datos estticas, es decir, el tamao ocupado en memoria es fijo, el
arreglo podra llenarse y si se crea un arreglo de tamao grande se estara desperdiciando
memoria.

Estructuras de Datos Dinmicas.

Las estructuras de datos dinmicas nos permiten lograr un importante objetivo de la programacin
orientada a objetos: la reutilizacin de objetos. Al contrario de un arreglo, que contiene espacio para
almacenar un nmero fijo de elementos, una estructura dinmica de datos se ampla y contrae
durante la ejecucin del programa.
A su vez, este tipo de estructuras se pueden dividir en dos grandes grupos segn la forma en la cual
se ordenan sus elementos.

Lineales
No lineales

Estructuras de Datos Lineales.

En este tipo de estructuras los elementos se encuentran ubicados secuencialmente. Al ser dinmica,
su composicin vara a lo largo de la ejecucin del programa que lo utiliza a travs de operaciones de
insercin y eliminacin. Dependiendo del tipo de acceso a la secuencia, haremos la siguiente
distincin:

Listas: podemos acceder (insertar y eliminar) por cualquier lado.

Pilas: slo tienen un nico punto de acceso fijo a travs del cual se aaden, se eliminan o se
consultan elementos.

Colas: tienen dos puntos de acceso, uno para aadir y el otro para consultar o eliminar
elementos.

Estructuras de Datos No Lineales.

Dentro de las estructuras de datos no lineales tenemos los rboles y grafos. Este tipo de estructuras
los datos no se encuentran ubicados secuencialmente. Permiten resolver problemas
computacionales complejos.
Introduccin al diseo y Anlisis de Algoritmos.
El diseo de la solucin a un problema que nos lleve a la generacin de un algoritmo tiene dos
principales componentes: la identificacin de los datos que intervienen en la solucin con su
respectiva especificacin de diseo y la especificacin de las instrucciones a ejecutar para resolver el
problema.
Los datos son los valores que manejamos en la resolucin de un problema, tanto los valores de
entrada, como los de proceso y los de salida. Es decir, los datos son informacin y por lo tanto, para
manejarlos se requieren varios tipos de datos.
Un tipo de dato se puede definir como un conjunto de valores y un conjunto de operaciones definidas
por esos valores. Clasificar los datos en distintos tipos aporta muchas ventajas, como por ejemplo
indicarle al compilador la cantidad de memoria que debe reservar para cada instancia dependiendo
del tipo de dato al que pertenezca. Los tipos de datos abstractos van todava ms all; extienden la
funcin de un tipo de dato ocultando la implementacin de las operaciones definidas por el usuario.
Esta capacidad de ocultamiento permite desarrollar software reutilizable y extensible.
Por otro lado, un algoritmo es sinnimo de procedimiento computacional y es fundamental para las
ciencias de la computacin. Un algoritmo es una secuencia finita de instrucciones, cada cual con un
significado concreto y cuya ejecucin genera un tiempo finito. Un algoritmo debe terminar en un
tiempo finito.

Algoritmo es toda receta, proceso, rutina, mtodo, etc. que adems de ser un conjunto de
instrucciones que resuelven un determinado problema, cumple las siguientes condiciones:

Ser finito. La ejecucin de un algoritmo acaba en un tiempo finito; un procedimiento que falle
en la propiedad de la finitud es simplemente un procedimiento de clculo.
Ser preciso. Cada instruccin de un algoritmo debe ser precisa; deber tenerse en cuenta un
rigor y no la ambigedad, esta condicin es la definicin: cada frase tiene un significado
concreto.

Posee entradas. Las entradas se toman como un conjunto especfico de valores que
inicializan el algoritmo.

Posee salida. Todo algoritmo posee una o ms salidas; la salida es la transformacin de la

entrada.

Ser eficaz. Un algoritmo es eficaz cuando resuelve el problema.

Ser eficiente. Un algoritmo es eficiente cuando resuelve el problema de la mejor manera

posible, o sea utilizando la mnima cantidad de recursos.

Aqu se pretende cubrir estas dos grandes reas: la relevancia de los datos y sus tipos en la solucin
de un problema, y el anlisis de eficiencia de las instrucciones que se eligen para resolver un
problema.
Cadenas
Las cadenas de caracteres como se les conoce se definen como secuencia de caracteres en un
alfabeto:
hola, casa, perro, y 67Frabe \#
Una cadena de caracteres (string) es un conjunto de caracteres (incluido el blanco) que se
almacenan en localidades contiguas de memoria. Se representa como un vector de caracteres donde
cada elemento del vector representa un caracter de la cadena.
Estructura de almacenamiento
Un byte (8 bits) por cada caracter de la cadena almacenada en bytes contiguos en memoria.
Operaciones
Longitud(cadena): Entero, regresa la longitud actual de la cadena
Lon(casa) regresa 4
Concatenar(cadena1, cadena2): Cadena, concatena dos cadenas.
Concatenar(casa, blanca) regresa casablanca
subcadena(cadena, inicio, longitud): cadena, regresa la subcadena de cadena que comienza en
inicio y que tiene la longitud especificada.
subcadena(casablanca, 3, 2) regresa sa
indice(cadena1, cadena2): Entero, regresa la posicin de inicio de la primera ocurrencia de
cadena2 en cadena1.
indice(casablanca, a) regresa 2
Las comparaciones (<, >, =, , , ) se efectan segn el orden lexicogrfico dado por el cdigo
ASCII.
A continuacin se presentan tres algoritmos en pseudocdigo
operaciones comunes con este tipo de datos:

a traves del cual visualizaremos

La funcin INDEX devuelve la posicin de P en T

La funcin Borrar elimina la primera aparicin de P en T.

Bsqueda

Listas
Las Listas son tipos de datos abstractos lineales que representan secuencias de elementos y que
presentan una particular flexibilidad en su manejo: pueden crecer y acortarse segn se necesite,
todos los elementos del conjunto se pueden acceder, se puede aadir nuevos elementos en cualquier
lugar de la secuencia donde se especifique, as como se puede eliminar cualquier elemento del
conjunto.
Una lista es equivalente a un contenedor de elementos, donde los valores pueden repetirse. Los
valores almacenados en ella se conocen como tem o elementos de la lista. Con frecuencia se
representan las listas como una sucesin de elementos separados por comas:
a1, a2, ...., an
Donde n representa la longitud de la lista y es mayor a cero y ai representa a cada elemento. Si n = 0
tendremos una lista vaca.
Las listas difieren de los arreglos porque sus elementos no se encuentran indexados, es decir, el
acceso a cada elemento debe ser hecho de forma secuencial, mientras que en los arreglos se hace
de forma aleatoria.
El TDA Lista puede ser implementado utilizando diferentes estructuras de datos: la implementacin
esttica de las Listas implica la utilizacin de un arreglo para representar al conjunto de datos,
mientras que la implementacin dinmica se basa en el uso de referencias a objetos o punteros.
Muchos lenguajes de programacin proveen una implementacin del tipo de dato Lista.
En este captulo se ofrecern defunciones informales y formales del TDA (sus caractersticas y
operaciones), se discutirn sus posibles implementaciones, se pondr a disposicin cdigo fuente de
algunas implementaciones en varios lenguajes y se propondrn problemas de aplicacin de las
Listas.

Recuperacin de espacio en lista Enlazadas.

Dos listas utilizan la misma lista disponible.

Insercin en una lista

Insercin al principio de una lista

Insercin en una lista enlazada y ordenada

Eliminacin de un nodo sucesor de uno determinado.

Localizacin de un nodo N y su predecesor

Pilas
Una pila (stack en ingls) es una lista ordinal o estructura de datos en la que el modo de acceso a
sus elementos es de tipo LIFO (del ingls Last In First Out, ltimo en entrar, primero en salir) que
permite almacenar y recuperar datos. Se aplica en multitud de ocasiones en informtica debido a su
simplicidad y ordenacin implcita en la propia estructura.

Las pilas son muy utilizadas en programacin, para evaluar expresiones, reconocer lenguajes,
recorrer rboles y simular procesos recursivos. En todo momento, el nico elemento visible de la
estructura es el ltimo que se coloc. Se define el tope de la pila como el punto donde se encuentra
dicho elemento, y el fondo, como el punto donde se encuentra el primer elemento incluido en la
estructura.
Colas.
La Cola o Queue es otra de las estructuras de datos que estudiaremos. Como las pilas, las colas son
muy simples de entender e implementar. La idea de la cola es simular el funcionamiento de una cola
de la vida real, por ejemplo, la cola de un banco. Imaginemos que tienes una pistola de juguete
parecida a la del ejemplo de pila, pero ahora, para cargarla, debes introducir las pelotas por la parte
trasera del can. Eso es una Cola. La cola es una estructura que se basa en el concepto FIFO:
First In First Out, es decir, el primer elemento que entra es el primero que sale. Tal como las pilas, la
implementacin de la pila es muy parecida a la de lista enlazada, y slo difiere en la forma que

gestionamos los elementos almacenados. En una cola, crearemos mtodos que cumplan las
funciones expuestas anteriormente y aclaradas con la Fig. 4.1.1, es decir, un mtodo que agregue un
nodo al principio de la cola y otro que elimine el ltimo nodo de sta. Para esta implementacin, los
nodos sern instancias de la clase Nodo, definida anteriormente en el archivo Nodo.java. Para poder
continuar, es necesario que revises detalladamente la definicin de esta clase. La explicacin de su
funcionamiento fue agregada en el mismo cdigo en forma de comentario.

Tipos
De acuerdo a su comportamiento, los conjuntos lineales se clasifican en:

Listas, Pilas y Colas

De acuerdo a su implementacin, las listas se clasifican en :

Simples
Doblemente Enlazadas

Circulares

Listas Simples

Se define como un conjunto de nodos

Uno detrs de otro

Del cual siempre se puede conocer al nodo inicial y final.

De cada nodo de la lista se conoce:

Un contenido, que es la informacin que almacena dentro.La informacin puede ser cualquier tipo de
dato.
Un sucesor nico, excepto el ltimo nodo de la lista.

Listas Simples: Nivel Lgico

Comportamiento
Crear y eliminar
Conocer si est vaca

Aadir elementos y removerlos

Consultar el primer y el ltimo elemento

Imprimir sus elementos en pantalla

Buscar un elemento con cierta informacin en la lista

Estado:
Usando notacin BNF (Backus-Naur-Form)
<listaSimple> ::=<comienzo>+{<ref nodo>}+<final>
<comienzo> ::=<enlace>
<final>
::=<enlace>

Una lista esta compuesta de nodos, y por eso es importante definir el TDA Nodo.

TDA NODO: Nivel Lgico

Un nodo de una lista

Almacena informacin de cualquier tipo

Es capaz de "viajar" o conocer otro nodo ( el nodo siguiente)

Comportamiento

Crear y Eliminar
Consultar y modificar la informacin que almacena

Consultar y modificar el enlace que mantiene con otro nodo

Usando notacin BNF (Backus-Naur-Form) para el TDA Nodo

<nodo>
::=<contenido>+<enlace>
<contenido> ::=<dato>{<dato>}
<enlace>
::=<ref_nodo> | <ref_invalida>

Listas Simples: Nivel de Implementacin

Para darle vida a una lista hay varias posibilidades de implementacin:

Esttica o Contigua, usando arreglos de longitud "variable"

Dinmica, utilizando punteros.

Estructuras de Datos No Lineales.

rboles.
Muchas veces los seres humanos nos inspiramos en la naturaleza para resolver nuestros problemas. En el caso
de las estructuras de datos, cuando debemos representar jerarquas o taxonomas y otro tipo de problemas un
poco ms complejos, nos es fcil pensar en ellas como estructuras arbreas invertidas en las cuales el elemento
de mayor jerarqua se considera como la raz, los elementos de menor jerarqua ocupan los niveles inferiores
dentro de un orden estipulado permitiendo un manejo de informacin adecuado del problema que deseamos
modelar.
As por ejemplo los organigramas tpicos de una organizacin se representan de forma natural cmo rboles en
los cuales el presidente ocupa la raz, los vicepresidentes el siguiente nivel del rbol y as sucesivamente hasta
completar la planta d personal de una organizacin.

Ejemplo de Informacin representada con rboles.

La gran ventaja del almacenamiento de informacin en rboles es que muchos de los problemas que se
resuelven mediante esta representacin reducen su complejidad en razn de la misma representacin y no de
los algoritmos que se utilicen. Tal es el caso de la bsqueda de elementos en un rbol ordenado, como se
detallar ms adelante.
rboles binarios.
Los rboles binarios son estructuras de datos no lineales, tambin denominadas recursivas en razn de que su
construccin puede hacerse en la aplicacin de estructuras bsicas aplicadas sobre s mismas, tal y como
ocurre con el caso de los fractales. En este caso un rbol binario es una estructura recursiva que consta de un
elemento que denominaremos raz y dos elementos adicionales que pueden ser vacos a los que
denominaremos el subrbol izquierdo y el subrbol derecho, los cuales a su vez son rboles con su respectiva
raz, subrbol izquierdo y subrbol derecho.
Al igual que en otras estructuras la informacin que se almacena en todos y cada uno de los rboles, debe ser
del mismo tipo para garantizar la integridad y coherencia de la informacin almacenada. En este sentido
decimos que los rboles almacenan elementos de un mismo conjunto y que dichos elementos pueden mantener
o no una relacin de orden entre ellos dependiendo de la necesidad del problema a resolver.
Para representar grficamente un rbol podemos hacer uso de representaciones como las siguientes en las
cuales el nivel de abstraccin marca la diferencia. Todas estas representaciones son vlidas y depende de la
necesidad especfica, su uso
.

Implementacin en C
Implementacin Contigua
Se utilizan arreglos, por lo tanto

Tiene lmites, que no pueden ser rebasados al aadir nuevos elementos

Los nodos son adyacentes en memoria, cada nodo es un elemento del arreglo.

El enlace con el siguiente nodo sera el ndice del siguiente elemento del arreglo.

Para este tipo de implementacin no es necesario crear el TDA Nodo.

Al utilizar arreglos se debe indicar el tamao mximo del arreglo.

Al insertar o remover un elemento ,todos los elementos restantes avanzarn o retroceddern.

Operaciones

Creacin y Eliminacin
LSCont *LSCont_Crear(int n);
void LSCont_Vaciar(LSCont *L);

Aadir y Remover elementos

void LSCont_InsertarNodoInicio(LSCont *L, Generico G);
void LSCont_InsertarNodoFin(LSCont *L, Generico G);
Generico LSCont_SacarNodoInicio(LSCont *L);
Generico LSCont_SacarNodoFin(LSCont *L);
int LSCont_ConsultarUltimo(LSCont L);

Consultar estado de la lista, puede llenarse.

bool LSCont_EstaVacia(LSCont L);
bool LSCont_EstaLlena(LSCont L);

Bsqueda y recorrido.
intLSCont_BuscarNodo(LSCont L, Generico G, Generico_ComoCompararfn);

boolLSCont_EsNodoDeLista(LSCont L, int i);

voidLSCont_Recorrer(LSCont L, Generico_ComoImprimirfn);

Declaracin
La lista contigua es un arreglo de elementos de cualquier tipo ,realmente es un ARRAYU.FIg
Para lograr mantener control sobre la cantidad de elementos en la lista debe existir una
referencia que controle el ltimo elemento.
La referencia al ltimo se mover de acuerdo a las inserciones y eliminaciones.

El primero nunca se mueve, siempre ser 0.

typedef struc {
int ultimo;
ArrayU Elementos;
}LSCont;

Funciones Bsicas
voidLSCont_VaciarLista(LSCont *L){L->ultimo = -1; }
LSCont *LSCont_CrearLista(intmax){
LSCont *nuevalista;
nuevalista->Elementos =
ArrayU_Crear(max, 0);
nuevalista->ultimo = -1;
returnnuevalista;
}
voidLSCont_EliminarLista(LSCont *L){
ArrayU_Eliminar(&(L->Elementos));
LSCont_VaciarLista(L);
}
boolLSCont_EstaVacia(LSCont L){
return(L.ultimo<0);
}
boolLSCont_EstaLlena(LSCont L){
return (L.ultimo == ArrayU_Tamanio(L.Elementol)-1);
}

//Bsqueda
int LSCont_BuscarNodo(LSCont L, Generico G, Generico_Comparacionfn){
int i;
Generico elemento;
for(i = 0; i <=L.ultimo;i++){
elemento = ArrayU_ElemC(L.Elementos, i);
if(f(elemento, G) == 0) return (i)
}
return(-1);
}

//Insertar
bool LSCont_InsertarInicio(LSCont *L, Generico G){
int i;
Generico ele1, ele2;
//No insertar si ya esta llena
if(LSCont_EstaLlena(L)) return FALSE;
//Mover todo hacia delante
for(i = L->ultimo; i >=0 ;i--){
ele1 = ArrayU_ElemC(L->Elementos,i);
ArrayU_ElemM(L->Elementos,i+1, ele1);
}
ArrayU_ElemM(L->Elementos, 0, G);
L->ultimo++;
return(TRUE);
}
bool LSCont_Insertar(LSCont *L, int P, Generico G){
int i,
Generico ele1;

if(LSCont_EstaLlena(L)) return FALSE;

if(P<=-1) return FALSE;
//MOVER TODOS
for(i = L->ultimo; i >=P ;i--){
ele1 = ArrayU_ElemC(L->Elementos,i);
ArrayU_ElemM(L->Elementos,i+1, ele1);
}
ArrayU_ElemM(L->Elementos, P, G);
L->utlimo ++;
return TRUE;
//Sacar
bool LSCont_EliminarNodo(LSCont *L, int P){
int i;
Generico ele1;
if(LSCont_EstaVacia(L)) return FALSE;
if(P<=-1) return FALSE
//RETROCEDER TODOS
for(i = P; i < L->ultimo;i++){
ele1 = ArrayU_ElemC(L->Elementos, i+1);
ArrayU_ElemM(L->Elementos, i, ele1);
}
L->last --;
return TRUE;
}

LSE: Listas Simples Enlazadas

Es una implementacin flexible y potente, los nodos ya no son adyacentes en memoria.
Un nodo A logra un enlace con otro B almacenando dentro la direccin de memoria de B.
Al insertar o eliminar un nodo ya no hay que mover al resto de elemento, solo enlazarlo con la lista.

TDA LSE_NODO : Nivel de implementacin

Contenido: Tiene como contenido cualquier tipo de dato, por ejemplo : datos enteros, reales , estructuras.
El nodo adems contiene un enlace con su nodo siguiente. Puede darse el caso que no enlace el nodo con nadie,
lo que significa que es un solo nodo, o que el nodo no forma parte de ninguna lista.

TDA LSE_NODO : Comportamiento (Operaciones)

//Crear y Eliminar

LSE_nodo *LSE_Nodo_Crear(Generico G);

void LSE_nodo_Eliminar (LSE_nodo *p);
//Consultar y Modificar Contenido
Generico LSE_nodo_GetContenido(LSE_nodo *p);
void LSE_nodo_SetContenido(LSE_nodo *p, Generico G);
//Consultar y Modificar Enlaces
LSE_nodo *LSE_nodo_Siguiente(LSE_nodo *p);
void LSE_nodo_SetSiguiente(LSE_nodo *p, LSE_nodo *Enlace);

//Cuando se crea un nodo se le asignar un valor inicial.

LSE_nodo *LSE_CrearNodo(Generico G)
{ LSE_nodo *p;
p = (LSE_nodo *)malloc(sizeof(LSE_nodo));
if(p)
{ p->G = G;
p->sig = NULL;
}
return p;

//Cuando se elimina un nodo se libera la memoria que est ocupada

voidLSE_EliminarNodo(LSE_nodo *p)
{ if(p)
{ free(p);
p = NULL;
}
}

Lista Enlazada Simple (LSE) : Declaracin

Existen varias formas de definir una lista , una forma es solo a travs del primer elemento
a la misma. Por ejemplo :
typedef LSE_Nodo *LSE;

Otra forma es llevar el control del primero y el ltimo elemento, por ejemplo:
typedefstruct{
LSE_Nodo*header; //header y last son punteros a nodo en una lista enlazada
LSE_Nodo*last;
}LSE;

Lista Enlazada Simple (LSE) : Comportamiento

//Crear y Eliminar
LSE * LSE_CrearLista();
void LSE_Eliminar(LSE **L);

//Consultar Primer y Ultimo

LSE_nodo *LSE_NodoInicio(LSE L);
LSE_nodo *LSE_NodoFin(LSE L);
//Conocer Estado
bool LSE_EstaVacia(LSE L);
//Aadir y Remover

bool LSE_InsertarNodoInicio(LSE *L, LSE_nodo *pNodo);

bool LSE_InsertarNodoFin(LSE *L, LSE_nodo *pNodo);
bool LSE_Insertar(LSE *L, LSE_nodo *p, LSE_nodo *nuevo);
LSE_nodo *LSE_SacarNodoInicio(LSE *L);
LSE_nodo *LSE_SacarNodoFin(LSE *L);
bool LSE_EliminarxPos(LSE *L, LSE_nodo *p);
//Busqueda y Recorrido
LSE_nodo *LSE_BuscarNodo(LSE L, Generico G, Generico_fnComparar f);
bool LSE_ExisteNodo(LSE L, LSE_nodo *p);
void LSE_Recorrer(LSE L, Generico_fnImprimir f);

Implementacin de Funciones para una Lista Enlazada Simple

Al crear una lista, estar vaca.Lo cual significa que su primero y ltimo nodo no apuntaran a
nadie. En otras palabras inicialmente apuntarn a NULL.
//Implementacin para la funcin crear
LSE *LSE_CrearLista(){
LSE *lnueva;
lnueva = malloc(sizeof(LSE));
lnueva->header = lnueva->last = NULL;
returnlnueva;
}
Cuando se elimina una lista, cada uno de los nodos debe ser liberado.
//Implementacin para la funcin eliminar
voidLSE_Vaciar(LSE *L){
LSE_nodo *p;
while(!LSE_EstaVacia(*L)){
p = LSE_SacarNodoFin(L);
LSE_Nodo_Eliminar(p);
}
}

//Funcin de Bsqueda
Hay que ubicarse en el inicio: header e ir avanzando hasta encontrar el nodo con la
informacin buscada o que ya no haya mas nodos.Como no se usan ndices, se usan punteros:

Un puntero se ubicar en el header y luego ir avanzando al siguiente, y al siguiente y al

siguiente.
Al encontrar el nodo buscado, se retorna la direccin de este nodo (mediante un puntero),no
se retorna su posicin como ndice, esta no importa.

LSE_nodo *LSE_BuscarNodo(LSE L,
Generico G,

Generico_fnComparar f){

LSE_nodo *p;
for(p = L.header; p!= NULL; p = LSE_Nodo_Siguiente(p)){
if(f(LSE_Nodo_Contenido(p),G) ==0) return(p);
}
return(NULL);
}

En el ejemplo se busca el nmero 25, un puntero se ubicar en el header y luego ir avanzando al siguiente, y al
siguiente y al siguiente.
Si el nmero que se busca se encuentra en la lista, se retorna la direccin de se nodo.

// Funcin Insertar

La operacin de insertar recibir el nodo que se va a insertar, para lo cual este nodo ya debi
haber sido creado antes de insertarlo. Hay varios tipos de insercin: insertar al inicio o al final
,insertar en medio de la lista.
nuevo->sig = header;
header = nuevo;

boolLSE_InsertarNodoInicio(LSE *L, LSE_nodo *nuevo){

if (!nuevo) return FALSE;
if(LSE_EstaVacia(*L)){
L->header = L->last = nuevo;
} else{
LSE_Nodo_ModificarEnlace(

nuevo, L->header);
L->header = nuevo;
}
return(TRUE);
}

En el ejemplo se desea insertar un nuevo nodo al inicio de la lista.Si la lista esta vaca, tanto header como last
apuntan al nuevo nodo.

//Insertar en medio de la lista

Debe recibir la posicin donde se va a insertar.

Insertamos despus ,si la lista esta vaca, el nuevo header y last, es el nuevo nodo.
Si la posicin no existe no se efectua la insercin.Si la lista solo tiene un elemento, el nuevo
last es el nuevo nodo.

boolLSE_Insertar(LSE *L,
LSE_nodo *p,
LSE_nodo *nuevo){
if(L->last==p){//Insertar al final
return(LSE_InsertarNodoFin(L, nuevo));
}else{
if(!p || ! LSE_ExisteNodo(*L,p))
return FALSE;
if(LSE_EstaVacia(*L))
L->header = L->last = nuevo;
else{
LSE_Nodo_ModificarEnlace(
nuevo, LSE_Nodo_Siguiente(p));
LSE_Nodo_ModificarEnlace(p, nuevo);
}
}
return(TRUE);

//Quitar un nodo al final de la lista

LSE_nodo *LSE_SacarNodoFin(LSE *L){

LSE_nodo *tmp=L->header;
if(LSE_EstaVacia(*L)) return NULL;
if(L->header == L->last)
LSE_InicializarLista(L);
else{
tmp = L->last;
L->last = LSE_Anterior(*L, L->last);
L->last->sig = NULL;
}
return(tmp);

En el ejemplo se pide eliminar el primer nodo de la lista.

tmp= header;

header=header->siguiente;
fre(tmp);

Eliminar el ltimo nodo de la lista.

LSE_nodo *LSE_SacarNodoFin(LSE *L){
LSE_nodo *tmp=L->header;
if(LSE_EstaVacia(*L)) return NULL;
if(L->header == L->last)
LSE_InicializarLista(L);
else{
tmp = L->last;
L->last = LSE_Anterior(*L, L->last);

L->last->sig = NULL;
}
return(tmp);

//Quitar un nodo intermedio de la lista

Lista no debe estar vaca.
La posicin enviada debe existir en la lista.
Revisar si se desea eliminar el header o el last

boolLSE_EliminarxPos(LSE *L, LSE_nodo *p){

LSE_nodo *p_ant;
if(LSE_EstaVacia(*L)) return 0;

if(!p || !LSE_ExisteNodo(*L, p))

return FALSE;
if(p==L->header)
LSE_SacarNodoInicio(L);
elseif(p == L->last)
LSE_SacarNodoFin(L);
else{
p_ant = LSE_Anterior(*L,p);
p_ant->sig = p->sig;
p->sig = NULL;
}
return(TRUE);
}

Listas Especiales
TDA: LISTAS DOBLEMENTE ENLAZADAS
En las listas enlazadas solo se avanza en un sentido, en las listas doblemente enlazadas, se puede
avanzar hacia la derecha o hacia la izquierda.
En estas listas cada nodo tiene un predecesor, excepto el primero, un sucesor, excepto el ltimo.
Cada nodo ya no tiene un solo enlace, tiene dos, hacia el siguiente y hacia el anterior.
Implementacin

typedefstructLDE_Nodo {
Generico G;
structLDE_nodo *sig;
structLDE_nodo *ant;
} LDE_nodo ;

typedefstruct {
LDE_Nodo *header;
LDE_Nodo *last;
}LDE;

Insertar Nodos

Insertar nodo al inicio de la lista

bool LDE_InsertarNodoInicio(LDE *L, LDE_nodo *nuevo){

if(!nuevo) return FALSE;
if(LDE_EstaVacia(*L)) L->header = L->last = nuevo;
else{
nuevo->sig = L->header;
L->header->ant = nuevo;
L->header = nuevo;
}
return TRUE;
}

Insertar al final de la lista

bool LDE_InsertarNodoFin (LDE *L,

LDE_nodo *nuevo){

if(!nuevo) return FALSE;

if(LDE_EstaVacia(&L))

L->header = L->last = nuevo;

else{

nuevo->ant = L->last;

L->last->sig = nuevo;

L->last = Nuevo;

return FALSE;

Listas Circulares
El avance en las listas enlazadas es solo a la derecha(siguiente) y limitado hasta el ltimo nodo.Hay
ocasiones en las que se deseara, poder avanzar ilimitadamente ,es decir, del ltimo nodo, pasar al
primero.
last->siguiente = header

TDA LISTA CIRCULAR

No es necesario mantener un control de: Primero y ltimo.
Solo con el ltimo ya se tiene todo, pues last ->siguiente es igual a header.

typedefLCE_nodo *LCE;

typedefstructLCE_nodo{
Generico G;

structLCE_nodo *sig;
}LCE_nodo;

//Funcin para crear un nodo de una lista circular

LCE_Nodo * LCE_Nodo_Crear(Generico G){
LCE_Nodo *nuevo;
nuevo = malloc(sizeof(LCE_Nodo));
nuevo->G = G;
nuevo->sig = nuevo;
return nuevo;
}

//Funcin para buscar

LCE_nodo *LC_Buscar(LCE *L, Generico G, Generico_Compararfn){

LCE_nodo *p;
if(LCE_EstaVacia(*L)) return NULL;
p = L;
do{
if(fn(p->G, G) == 0) return(p);
p = p->sig;
}while(p!= L);
return(NULL);
}
En el ejemplo se busca el nmero 25

//Nodo anterior
Se busca el anterior a un nodo dado.

LCE_Nodo *LCE_Anterior(LCE *L, LCE_nodo *p){

LCE_Nodo *q;
if(LCE_EstaVacia(L) || p== NULL) LCE_Anterior = NULL;
q = L;
do{
if(q->sig == p) return(q);
q = q->sig;
}while(q!=L);
return(NULL);
}

//Insertar nodo al final de una lista circular.

//Insertar en medio
boolLCE_Insertar(LCE *L, LCE_Nodo *P, LCE_Nodo *nuevo){
if(P == NULL || !LCE_Existe(*L,P)) return FALSE;
if(LCE_EstaVacia(*L) || p==L) LCE_InsertarNodoFin(L,nuevo);
else {
nuevo->sig = P->sig;
P->sig = Nuevo;
}
return TRUE;
}

LISTAS CIRCULARES DOBLEMENTE ENLAZADAS

Es una implementacin de listas circulares con nodos que tienen dos punteros, as se recorre
la lista en el sentido del avance del reloj y en sentido contrario
Y tambin se contina llevando control solo el ltimo nodo de la lista.

//Recorrer lista
Con esta funcin se puede recorrer un lista circular hacia atrs.

voidLCDE_Recorre_R(LCDE L, Generico_Imprimirfn){
LCDE_nodo *pos;
if(!LCDE_EstaVacia(L)) return;
pos = L;
while(TRUE){
pos = pos->ant;
if(pos == L) break;
fn(pos->G);
}

}
Ejercicios para la Evaluacin del curso:

SISTEMA DE CONTROL DE CUENTAS POR COBRAR.

Para este sistema debe crearse dos archivos de datos, uno para clientes y otro para facturas, ambos
deben ser asociados de manera tal que se tenga rpidamente las facturas de cada cliente con su
fecha de emisin, nmero, monto, y estado ( el estado no es un campo de factura) . Las facturas
podrn ser almacenadas de dos formas, en orden la primera en entrar es la primera en salir (FiFo),
para las facturas pendientes por cancelar, la ltima en entrar es la primera en salir (LiFo), para las
facturas canceladas. Segn la conveniencia para la empresa, debe permitir agregar nuevas facturas
y clientes.
Para cada cliente se tiene un cobrador asociado, del cual se posee su numero de cedula, nombre,
direccin, estos deben estar almacenados en un rbol de modo que cuando: el rbol se recorra
utilizando recorrido en orden, los nmeros de cedula se ordenen en orden ascendentes , b) el rbol
se recorra utilizando recorrido preorden, los montos cobrados por cada uno se ordenen
descendentemente, c) el rbol se recorra utilizando recorrido postorden, el numero de facturas
cobradas se ordenen en forma descendente . Dado que los nombres en el archivo de clientes se
almacenaron por separado: primer nombre, segundo nombre, primer apellido, segundo apellido,
debe manipularse estos a los fines de que en el listado aparezca primer nombre, inicial del segundo,
primer apellido e inicial del segundo, en un espacio mximo de 50 caracteres.
1.- Primera Entrega (Primera Clase Presencial). Plantee esquemticamente las estructuras de datos
que servirn para desarrollar el sistema planteado. Recuerde que el uso de las estructuras no es
excluyente. Justifique el uso de las estructuras escogidas. Plantee el uso de clases y otros recursos
disponibles por uso de lenguajes.
2.- Segunda Entrega (Segunda Clase Presencial). Plantee en forma de bloques la estructura de
programacin para desarrollar el sistema planteado. Considere las ventajas del uso de los diferentes
lenguajes de programacin: delphi, C, Java. Justifique su escogencia. Especifique consideraciones
que no hayan sido mencionadas en el planteamiento.
3.- Desarrolle el sistema en el lenguaje de su preferencia. Elabore una presentacin con la solucin,
el sistema funcionando y las estructuras de datos que utilizo.