You are on page 1of 36

LISTAS ENLAZADAS

PARTE 1
CLASE N6
Leissi M. Castaeda Len
lcl@upnorte.edu.pe
lcl@comunidad.upn.edu.pe
https://sites.google.com/site/leissicl/

Que veremos hoy?


1.
2.
3.
4.

Introduccin
Listas Simplemente Enlazadas
Listas Doblemente Enlazadas
Listas Circulares

1. Introduccin


Las estructura de datos como arreglos y registros, se


denominan estticas (durante la compilacin se le
asigna un espacio de memoria, y no se altera durante la
ejecucin)
La estructura de datos lista, es lineal (cada elemento le
puede seguir a otro) y dinmica (manejar memoria de
manera flexible) de datos.
VENTAJA principal: dinamismo, se puede adquirir
posiciones de memoria y liberar a medida que se
necesiten.
Considerar que NO pueden reemplazar en todas las
aplicaciones a los arreglos.
3

Introduccin


Las listas enlazadas son colecciones de elementos


llamados nodos; el orden entre stos se establece por
medio de un tipo de datos denominado punteros,
apuntadores o referencias a otros nodos.
Entonces se podr distinguir: el dato de tipo apuntador y
el dato contenido en la celda al cual ste apunta.
Operaciones ms importantes: bsqueda (no muy
eficiente), insercin y eliminacin.
Tipos:




Listas simplemente enlazadas


Listas doblemente enlazadas
Listas circulares
4

2. Listas Simplemente
Enlazadas

Listas Simplemente Enlazadas

Una LSE constituye una coleccin de elementos


llamados nodos.
El orden entre los nodos se establece por punteros
(referencias a otros nodos).
Un tipo especial: la lista vaca

Un nodo est formado por:

Un campo INFORMACIN, del tipo de dato que se quiere


almacenar.
Un campo ENLACE, de tipo puntero, para enlazar con otro nodo.
Si fuera el ltimo tendra como valor NULL.

Estructura Nodo para una LSE


typedef struct Nodo
{
int dato;
struct Nodo *sgt;
} TNodo;

INFORMACIN
ENLACE

Creando un puntero cabecera




Crearemos un puntero, de tipo de la estructura


Nodo (Tnodo), que apunte al nodo inicial de la
LSE
typedef struct LSE
{
TNodo *pInicio;
} TLSE;

Para crear una lista vaca




Crea una lista devolviendo un puntero Tnodo


TLSE *crearLista()
{
TLSE *l=(TLSE*)malloc(sizeof(struct LSE));
l->pInicio=NULL;
return l;
NULL
}
pInicio
9

Ejemplo

NULL

pInicio

10

Operaciones con LSE




Recorrido de la lista



Iterativo
Recursivo

Insercin de un elemento





Al Inicio
Al Final
Antes que un determinado nodo
Despus que un determinado nodo

11

Operaciones con LSE




Eliminacin de un elemento






El primer nodo
El ltimo nodo
Eliminar un nodo con informacin X
Eliminar el nodo anterior al nodo con informacin X
Eliminar el nodo posterior al nodo con informacin X

Bsqueda de un elemento




Desordenada
Ordenada
Recursivo

12

Recorrido de la lista


Esta operacin consiste en visitar cada uno de los nodos


que forman la lista. La visita puede implicar una
operacin simple; por ejemplo, imprimir la informacin
del nodo, o una compleja, dependiendo del problema
que se intente resolver.

Para recorrer todos los nodos de una LSE se comienza


con el primero. Se toma el valor del campo ENLACE de
ste y se avanza al segundo, as hasta llegar al ltimo
nodo, cuyo campo ENLACE tenga el valor NULL.
En general, la direccin de un nodo, excepto el primero
est dada por el campo ENLACE de su predecesor.

13

Recorrido de la lista: Iterativa


/*Imprimiremos los datos en el recorrido iterativo de la lista*/

void recorridoIterativo(TLSE *lista)


{
TNodo *p=NULL;
p=lista->pInicio;
while(p!=NULL)
{
printf(" %d ->",p->dato);
p=p->sgt;
}
}
14

Recorrido de la lista: Recursiva


/*Imprimiremos los datos en el recorrido recursivo de la lista*/

void recorridoRecursivo(TNodo *p)


{
if(p!=NULL)
{
printf(" %d ->",p->dato);
recorridoRecursivo(p->sgt);
}
}
Nota: el TNodo *p que ingresa en la primera llamada es el nodo Inicio
15

Insercin de un elemento


Esta operacin en las LSE consiste en agregar un nuevo


nodo a la lista.
Dependiendo de la posicin en la que se deba insertar el
nodo, se pueden presentar diferentes casos, como los
que se sealan a continuacin:





Al Inicio
Al Final
Antes que un determinado nodo
Despus que un determinado nodo

16

Insercin: al Inicio de la lista


void insertarInicio(int dato, TLSE *lista)
{
TNodo *nodo=NULL;
nodo=(TNodo*)malloc(sizeof(struct Nodo));
nodo->dato=dato;
nodo->sgt=lista->pInicio;
lista->pInicio=nodo;
}

17

Insercin: al Final de la lista


void insertarFinal(int dato, TLSE *lista)
{
TNodo *p=NULL, *nodo=NULL;
nodo=(TNodo*)malloc(sizeof(struct Nodo));
nodo->dato=dato;
nodo->sgt=NULL;
p=lista->pInicio;
if(p==NULL) //si la lista est vaca
{
lista->pInicio=nodo;
}
18

Insercin: al Final de la lista (cont.)


else //si la lista NO est vaca
{
while(p->sgt!=NULL)
{
p=p->sgt;
}
p->sgt=nodo;
}
}

19

Insercin: Antes que otro


void insertarAntes(int dato, TLSE *lista, int X)
{
TNodo *p=NULL, *ant=NULL;
int band=1;
p=lista->pInicio;
if(p==NULL)
{
band=0; }
else
{
while((p->dato!=X) && (band==1))
{
if(p->sgt!=NULL)
{
ant=p;
p=p->sgt;
}
else
band=0;
}
20

Insercin: Antes que otro


if(band==1) //si se encontr el nodo referencia: X
{
TNodo *nodo=NULL;
nodo=(TNodo*)malloc(sizeof(struct Nodo));
nodo->dato=dato;
nodo->sgt=NULL;
if(ant==NULL) //si se va a insertar al inicio
{
nodo->sgt=p;
lista->pInicio=nodo;
}
else
{
ant->sgt=nodo;
nodo->sgt=p;
}
}
else
printf("El nodo de referencia no se encontr en la lista\n");
}
}

21

Insercin: Despus de otro


void insertarDespues(int dato, TLSE *lista, int X)
{
TNodo *p=NULL;
int band=1;
p=lista->pInicio;
if(p==NULL)
{
band=0; }
else
{
while((p->dato!=X) && (band==1))
{
if(p->sgt!=NULL)
{
p=p->sgt;
}
else
band=0;
}
22

Insercin: Despus de otro (cont.)


if(band==1)
{
TNodo *nodo=NULL;
nodo=(TNodo*)malloc(sizeof(struct Nodo));
nodo->dato=dato;
nodo->sgt=p->sgt;
p->sgt=nodo;
}
else
printf("El nodo de referencia no se encontr en la lista\n");
}
}

23

Eliminacin de un elemento


Consiste en eliminar un nodo de la lista y liberar el


espacio de memoria correspondiente.
Dependiendo de la posicin en la que se encuentre, se
pueden presentar diferentes casos, como los que se
sealan a continuacin:






El primer nodo
El ltimo nodo
Eliminar un nodo con informacin X
Eliminar el nodo anterior al nodo con informacin X
Eliminar el nodo posterior al nodo con informacin X

24

Eliminar: el Primer nodo


void eliminarInicio(TLSE *lista)
{
TNodo *p=lista->pInicio;
lista->pInicio=p->sgt;
free(p);
}

25

Eliminar: el ltimo nodo


void eliminarFinal(TLSE *lista)
{
TNodo *p=lista->pInicio, *ant=NULL;
if(p!=NULL)
{
if(p->sgt!=NULL)
{
while((p->sgt!=NULL))
{
ant=p;
p=p->sgt;
}
ant->sgt=NULL;
}
else
p=NULL;
free(p);
}
}

26

Eliminar: nodo con informacin X


void eliminarNodoX(TLSE *lista, int X)
{
TNodo *p=NULL, *ant=NULL;
int band=1;
p=lista->pInicio;
if(p==NULL)
{
band=0; }
else
{
while((p->dato!=X) && (band==1))
{
if(p->sgt!=NULL)
{
ant=p;
p=p->sgt;
}
else
band=0;
}
27

Eliminar: nodo con informacin X


(cont.)
if(band==1)
{
if(ant==NULL) //si es el primer nodo
{
lista->pInicio=p->sgt;
}
else
{
ant->sgt=p->sgt;
}
free(p);
}
else
printf("El nodo de referencia no se encontr en la lista\n");
}
}
28

Eliminar: nodo Anterior al nodo X


void eliminar_Antes_X(TLSE *lista, int X)
{
TNodo *p=NULL, *ant=NULL, *q=NULL;
int band=1;
p=lista->pInicio;
if(p==NULL)
band=0;
else
{
while((p->dato!=X) && (band==1))
{
if(p->sgt!=NULL)
{
q=ant;
ant=p;
p=p->sgt;
}
else
band=0;
}

29

Eliminar: nodo Anterior al nodo X


if(band==1)
{
if(ant==NULL) //si p es el primer nodo
{
printf("No existe nodo que preceda a el nodo de referencia: %d",
X,"\n");
}
else
{
if(ant!=NULL && q==NULL) //se va a eliminar el primer nodo
lista->pInicio=p;
else
q->sgt=p;
}
free(ant);
}
else
printf("El nodo de referencia no se encontr en la lista\n");
}
}

30

Eliminar: nodo Posterior al nodo X


void eliminar_Despues_X(TLSE *lista, int X)
{
TNodo *p=NULL, *q=NULL;
int band=1;
p=lista->pInicio;
if(p==NULL)
band=0;
else
{
while((p->dato!=X) && (band==1))
{
if(p->sgt!=NULL)
p=p->sgt;
else
band=0;
}
31

Eliminar: nodo Posterior al nodo X


if(band==1)
{
if(p->sgt==NULL) //si p es el ultimo nodo
{
printf("No existe nodo posterior a el nodo de referencia:
%d ",X,"\n");
}
else
{
q=p->sgt;
p->sgt=q->sgt;
}
free(q);
}
else
printf("El nodo de referencia no se encontr en la lista\n");
}
}
32

Bsqueda de un elemento


Esta operacin en una LSE es muy simple de realizar,


aunque ineficiente ya que se lleva a cabo de forma
secuencial.
Debemos ir recorriendo los nodos hasta encontrar el que
estamos buscando o hasta que se llegue al final de la
lista.
Al igual que en el caso de las operaciones vistas
anteriormente, existe diferencia en los algoritmos si las
listas se encuentran ordenadas o desordenadas.

33

Bsqueda: en lista Desordenada




Asumimos que la LSE se encuentra desordenada

void busquedaDesordenada(TLSE *lista, int X)


{
TNodo *p=lista->pInicio;
if(p!=NULL)
{
while((p!=NULL) && (p->dato!=X))
p=p->sgt;
if(p==NULL)
printf("No se encontro el elemento en la lista\n");
else
printf("Si se encontro el elemento en la lista\n");
}
else
printf("Error, la lista esta vacia\n");
}
34

Bsqueda: en lista Ordenada




Asumimos que la LSE se encuentra ordenada

void busquedaOrdenada(TLSE *lista,int X)


{
TNodo *p=lista->pInicio;
if(p!=NULL)
{
while((p!=NULL) && (p->dato<X))
p=p->sgt;
if((p==NULL) || (p->dato>X))
printf("No se encontro el elemento en la lista\n");
else
printf("Si se encontro el elemento en la lista\n");
}
else
printf("Error, la lista esta vacia\n");
}
35

Bsqueda: en forma Recursiva


void busquedaRecursiva(TNodo *p,int X)
{
if(p!=NULL)
{
if(p->dato==X)
printf("Si se encontro el elemento en la lista\n");
else
busquedaRecursiva(p->sgt,X);
}
else
printf("No se encontro el elemento en la lista\n");
}
36

You might also like