Documentos de Académico
Documentos de Profesional
Documentos de Cultura
ESTRUCTURAS DE DATOS
OBJETIVOS
Aprovechar la abstracción para definir
comportamiento y luego operaciones en nivel de
implementación
Visualizar las posibles implementaciones de un
TDA ya definido
Utilizar con seguridad el concepto de puntero en
implementaciones dinámicas
Reconocer la importancia de usar solo el
comportamiento de un TDA, y no su estado
LISTAS: DEFINICION
Una lista es
Una colección de 0 o mas elementos
Si la lista no tiene elementos, se dice que esta vacía
En una lista, todos los elementos son de un mismo tipo
Son estructuras lineales, es decir
Sus elementos están colocados uno detrás de otro
Cada elemento de una lista se conoce con el nombre de NODO
Las listas
Son mucho más flexibles que los arreglos
Permiten trabajo “dinámico” con un grupo de elementos
TIPOS
De acuerdo a su comportamiento, los conjuntos
lineales se clasifican en
Listas, Pilas y Colas
De acuerdo a su implementación, las listas se
clasifican en
Simples
Doblemente Enlazadas
Circulares
LISTAS SIMPLES
Se define como un conjunto de nodos
Uno detrás de otro
Del cual siempre se puede conocer al nodo inicial y al final
De cada nodo de la lista, se conoce
Un contenido, que es la información que almacena dentro
Puede ser de cualquier tipo de dato
Un sucesor único
Excepto el ultimo nodo de la lista
LISTA SIMPLE: NIVEL LOGICO
Comportamiento (a/con una lista se puede)
Crear y Eliminar
Conocer si esta vacía
Añadir elementos y removerlos
Consultar el primer y al ultimo elemento
Imprimir sus elementos en pantalla
Buscar un elemento con cierta información en la lista
Estado:
Al insertarse un
nuevo elemento,
25
en una cierta
posición, todos los 10 5 8 2
25 31
2 31
elementos
restantes ruedan
0 1 2 3 4 5 6 7 8
En uso Desperdicio
CONTIGUAS: OPERACIONES
Creación y Eliminación Busqueda y Recorrido
LSCont *LSCont_Crear(int n); int LSCont_BuscarNodo(LSCont L, Generico
void LSCont_Vaciar(LSCont *L); G, Generico_ComoComparar fn);
Añadir y Remover elementos bool LSCont_EsNodoDeLista(LSCont L, int i);
void LSCont_InsertarNodoInicio(LSCont *L,
void LSCont_Recorrer(LSCont L,
Generico G); Generico_ComoImprimir fn);
void LSCont_InsertarNodoFin(LSCont *L,
Generico G);
Generico LSCont_SacarNodoInicio(LSCont *L);
Generico LSCont_SacarNodoFin(LSCont *L);
Consultar indice del Ultimo
int LSCont_ConsultarUltimo(LSCont L);
Consultar estado de la lista, puede llenarse
bool LSCont_EstaVacia(LSCont L);
bool LSCont_EstaLlena(LSCont L);
CONTIGUAS: DECLARACION
La lista contigua
Es un arreglo de elementos de cualquier tipo realmente es un ARRAYU
No olvidemos que hay que predefinir el máximo de nodos de la lista
Para lograr mantener control sobre la cantidad de elementos en la lista
Debe existir una referencia que controle el ultimo elemento
La referencia al ultimo se moverá de acuerdo a las inserciones y eliminaciones
La primero nunca se mueve, siempre será 0
0 1 2 3 4 5 6 7 8 9
LSE: LISTAS SIMPLES ENLAZADAS
Es una implementación flexible y potente C S
Contenido Enlace
Los nodos ya no son adyacentes en memoria
NODO B
Un nodo A logra un enlace con otro B, C S
Almacenando dentro la dirección de memoria de B NODO A
Al insertar o eliminar un nodo ya no hay que “mover” al resto de
elemento, solo enlazarlo con la lista
25
25
10 5 8 25
2 2
31 31
TDA LSE_NODO: NIVEL DE
IMPLEMENTACION
Contenido: Datos enteros, reales, o incluso, de Estructuras: Estudiante, Auto,
etc....
Y además, el nodo también contiene un enlace con su nodo siguiente
Este enlace, puede no enlazar el nodo con nadie, el nodo esta solito, no forma parte de ninguna lista
} }
header
last
LSE: BUSQUEDA LSE_nodo *LSE_BuscarNodo(LSE L,
Generico G,
LSE_nodo *p;
Generico_fnComparar f){
Hay que ubicarse en el inicio: header for(p = L.header; p!= NULL; p = LSE_Nodo_Siguiente(p)){
if(f(LSE_Nodo_Contenido(p),G) ==0) return(p);
E ir avanzando hasta }
Encontrar el nodo con la información return(NULL);
buscada o }
Que ya no haya mas nodos
Recomendación:
Como no se usan índices, se usan punteros: Usemos el
Un puntero se ubicara en el header comportamiento
Y luego irá avanzando al siguiente, y al de LSE_Nodo, no el
siguiente y al siguiente estado
Al encontrar al nodo buscado, no se retorna
su posición como índice, esta no importa
Busco 30
25
Se retorna la dirección de este
nodo(puntero)
header last
10 5 8 25 2 31
pp pp pp pp p p
p
LSE: ANTERIOR
La
posición
Dada la dirección de un nodo(pos), esta función retorna la dirección del nodo panterior
es la
Hay que “buscar” desde el header de un
El nodo buscado es aquel cuyo siguiente es igual a pos nodo
fuera de
Si el elemento buscado es el primero en la lista, no hay anterior la lista
qq q qq qp q q
q q
LSE: PRIMERO Y ULTIMO
Se pueden obtener siempre y cuando la lista no este vacía
Retornaran la información del elemento apuntado por
header y last respectivamente.
last = nuevo;
INSERCION AL INICIO/FINAL
Si la lista esta vacía, tanto header como last apuntan al
nuevo nodo
Si no, si es al inicio el nuevo header, es el nuevo nodo last
Si no, si es al final, el nuevo last es el nuevo nodo
nuevo
header 18
header last
nuevo
10 5 8 25 2 31
9
nuevo
header = last = nuevo:
last p->sig = nuevo; 18 Nuevo->sig = p->sig;
header
last header
header p last
nuevo
10 5 8 25 2 31
18
LSE: SACAR DE LA LISTA
La lista no debe estar vacía!!, si tiene un solo elemento, dejarla vacía
Header = header->sig; tmp = last;
header header last last
Last = Anterior(Last);
Last->sig = NULL;
Tmp = header; 10 5 8 25 2 31
free(tmp);
free(tmp); tmp
tmp
LSE_nodo *LSE_SacarNodoFin(LSE *L){
LSE_nodo *LSE_SacarNodoInicio(LSE *L){ LSE_nodo *tmp=L->header;
LSE_nodo *tmp = L->header; if(LSE_EstaVacia(*L)) return NULL;
if(LSE_EstaVacia(*L)) return NULL; if(L->header == L->last)
if(L->header == L->last) LSE_InicializarLista(L);
LSE_InicializarLista(L); else{
else { tmp = L->last;
L->header = L->header->sig; L->last = LSE_Anterior(*L, L->last);
} L->last->sig = NULL;
return(tmp); }
return(tmp);
}
}
LSE: SACAR JUSTO UN NODO
bool LSE_EliminarxPos(LSE *L, LSE_nodo *p){
LSE_nodo *p_ant;
Lista no debe estar vacía if(LSE_EstaVacia(*L)) return 0;
La posición enviada debe existir en la lista if(!p || !LSE_ExisteNodo(*L, p))
Revisar si se desea eliminar el header o el return FALSE;
if(p==L->header)
last LSE_SacarNodoInicio(L);
else if(p == L->last)
LSE_SacarNodoFin(L);
else{
p_ant = LSE_Anterior(*L,p);
p_ant->sig = p->sig; p_ant->sig = p->sig;
p->sig = NULL;
}
return(TRUE);
} last
header p
10 5 8 25 2 31