Leccion 3.3 Listas enlazadas

8/8/2019 Leccion 3.3 Listas enlazadas

1/26

ESTRUCTURAS DE DATOS LECCION 3.3. LISTAS ENLAZADAS Pgina 1

Leccion 3.3 LISTAS ENLAZADAS

En Ciencias de la Computacin, una lista enlazada es una de las estructuras de datos fundamentales, y

puede ser usada para implementar otras estructuras de datos. Consiste en una secuencia de nodos, en losque se guardan campos de datos arbitrarios y una o dos referencias (punteros) al nodo anterior oposterior. El principal beneficio de las listas enlazadas respecto a los array convencionales es que el

orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la memoria o el

disco, permitiendo que el orden de recorrido de la lista sea diferente al de almacenamiento.

Una lista enlazada es un tipo de dato auto-referenciado porque contienen un puntero o link a otro dato

del mismo tipo. Las listas enlazadas permiten inserciones y eliminacin de nodos en cualquier punto dela lista en tiempo constante (suponiendo que dicho punto est previamente identificado o localizado),

pero no permiten un acceso aleatorio. Existen diferentes tipos de listas enlazadas: Lista Enlazadas

Simples, Listas Doblemente Enlazadas, Listas Enlazadas Circulares y Listas Enlazadas Doblemente

Circulares.

Las listas enlazadas pueden ser implementadas en muchos lenguajes. Lenguajes tales como Lisp yScheme tiene estructuras de datos ya construidas, junto con operaciones para acceder a las listas

enlazadas. Lenguajes imperativos u orientados a objetos tales como C o C++ y Java, respectivamente,

disponen de referencias para crear listas enlazadas.

Listas simples enlazadas

La lista enlazada bsica es la lista enlazada simple la cual tiene un enlace por nodo. Este enlace apunta

al siguiente nodo en la lista, o al valorNULL o a la lista vaca, si es el ltimo nodo.

Una lista enlazada simple contiene dos valores: el valor actual del nodo y un enlace al siguiente nodo

Aplicaciones de las listas enlazadas

Las listas enlazadas son usadas como mdulos para otras muchas estructuras de datos, tales comopilas,colas y sus variaciones.

El campo de datos de un nodo puede ser otra lista enlazada. Mediante este mecanismo, podemosconstruir muchas estructuras de datos enlazadas con listas; esta practica tiene su origen en el lenguaje de

programacin Lisp, donde las listas enlazadas son una estructura de datos primaria (aunque no la nica),

y ahora es una caracterstica comn en el estilo de programacin funcional.

A veces, las listas enlazadas son usadas para implementar arrays asociativos, y estas en el contexto de

las llamadas listas asociativas. Hay pocas ventajas en este uso de las listas enlazadas; hay mejoresformas de implementar stas estructuras, por ejemplo con rboles binarios de bsqueda equilibrados. Sin


2/26


embargo, a veces una lista enlazada es dinmicamente creada fuera de un subconjunto propio de nodos

semejante a un rbol, y son usadas ms eficientemente para recorrer sta serie de datos

Ventajas

Como muchas opciones en programacin y desarrollo, no existe un nico mtodo correcto para resolverun problema. Una estructura de lista enlazada puede trabajar bien en un caso pero causar problemas enotros. He aqu una lista con un algunas de las ventajas ms comunes que implican las estructuras de tipo

lista. En general, teniendo una coleccin dinmica donde los elementos estn siendo aadidos y

eliminados frecuentemente e importa la localizacin de los nuevos elementos introducidos se incrementael beneficio de las listas enlazadas.

Lenguajes soportados

Muchos lenguajes de programacin tales como Lisp y Scheme tienen listas enlazadas simples ya

construidas. En muchos lenguajes de programacin, estas listas estn construidas por nodos, cada uno

llamado cons o celda cons. Las celdas cons tienen dos campos: el car, una referencia del dato al nodo, yel cdr, una referencia al siguiente nodo. Aunque las celdas cons pueden ser usadas para construir otras

estructuras de datos, este es su principal objetivo.

En lenguajes que soportan tipos abstractos de datos o plantillas, las listas enlazadas ADTs o plantillas

estn disponibles para construir listas enlazadas. En otros lenguajes, las listas enlazadas son tpicamente

construidas usando referencias junto con el tipo de dato record.

En la seccin de implementaciones hay un ejemplo completo en C y en Maude

Operaciones sobre listas enlazadas

Cuandos se manipulan listas enlazadas, hay que tener cuidado con no usar valores que hayamosinvalidado en asignaciones anteriores. Esto hace que los algoritmos de insertar y borrar nodos en las

listas sean algo especiales. A continuacin se expone elpseudocdigo para aadir y borrar nodos en

listas enlazadas simples, dobles y circulares.

Listas Enlazadas Lineales

Nuestra estructura de datos tendr dos campos. Vamos a mantener la variables PrimerNodos quesiempre apunta al primer nodo de tal lista, nulo para la lista vaca.

recordNode {data // El dato almacenado en el nodo

next // Una referencia al nodo siguiente, nulo para el ltimo nodo

}

recordList {

Node PrimerNodo // Apunta al primer nodo de la lista; nulo para la lista

vaca

}


3/26


El recorrido en una lista enlazada es simple, empezamos por el primer nodo y pasamos al siguiente hasta

que la lista llegue al final.

node := list.PrimerNodo

while node not null {

node := node.next

}

El siguiente cdigo inserta un elemento a continuacin de otro en una lista simple. El diagrama muestra

como funciona.

function insertAfter(Node node, Node newNode) {newNode.next := node.next

node.next := newNode

}

Insertar al principio de una lista requiere una funcin por separado. Se necesita actualizar PrimerNodo.

function insertBeginning(List list, Node newNode) {

newNode.next := list.firstNode

list.firstNode := newNode

}

De forma similar, tambin tenemos funciones para borrar un nodo dado para borrar un nodo delprincipio de la lista. Ver diagrama.

function removeAfter(Node node) {

obsoleteNode := node.next

node.next := node.next.next

destroy obsoleteNode

}

function removeBeginning(List list) {

obsoleteNode := list.firstNode

list.firstNode := list.firstNode.next

destroy obsoleteNode

}


4/26


Advertimos que BorrarPrincipio pone PrimerNodo a nulo cuando se borra el ltimo elemento de la lista.

Adjuntar una lista enlazada a otra puede resultar ineficiente a menos que se guarde una referencia a la

cola de la lista, porque si no tendramos que recorrer la lista en orden hasta llegar a la cola y luego aadirla segunda lista.

EJEMPLO

Recorrido

Definicin:

Recorrido simplemente despliega los datos almacenados en el arreglo Info, con ayuda de un segundo

arreglo llamado Indice el cual guarda el orden en el que encuentran enlazados cada uno de los datos.

Explicacin:

Apuntador toma el valor de Inicio, despus ve si la condicin cumple para efectuar un Ciclo mientras

Apuntador sea diferente de 0, si cumple lo que hace es que despliega la Info[Apuntador], despusApuntador toma el valor de Indice[Apuntador] (El cual nos indica el siguiente nodo que sigue en la lista)

y hace esto hasta que Apuntador sea igual a 0 (Cuando llega a este punto a llegado al fin de la Lista

Enlazada).

Algoritmo:

Recorrido(Inicio, Info, Indice)

Apuntador - Inicio

Repetir mientras Apuntador Nill

Imprimir Info[Apuntador]

Apuntador - Indice[Apuntador]

Fin del ciclo

Salir

Diagrama:


5/26


Programa:

#include

#include

void Recorrido(char Info[8][2],int Indice[8],int Inicio,int Disp);

void main()

{

char Info[8][2]={{"G"},{"I"},{" "},{"T"},{"O"},{"A"},

{" "},{"T"}};int Indice[8]={5,7,6,1,-999,3,-999,4};

int Inicio=0,Disp=2;

cout


6/26


Bsqueda

Definicin:

La Bsqueda su objetivo es encontrar un dato en el arreglo Info, si lo encuentra lo desplegara en la

pantalla, si no lo encuentra no desplegara nada ya que el dato no se encuentra en el arreglo Info.

Explicacin:

Apuntador toma el valor de Inicio, despus ve si la condicin cumple para efectuar un Ciclo mientras

Apuntador sea diferente de 0, si cumple lo que hace a continuacin es la comparacin de Elemento (El

dato que vamos a buscar) con Info[Apuntador], cuando lo encuentre lo despliega y sale del mtodo. Sino, regresa el valor de Apuntador para as saber que no se encontr el dato.

Algoritmo:

Recorrido(Inicio, Info, Indice, Elemento)

Apuntador - Inicio

Repetir mientras Apuntador Nill

Si Elemento = Info[Apuntador] entonces:

Imprimir Info[Apuntador]

Regresa Apuntador

Apuntador - Indice[Apuntador]

Fin del ciclo

Regresar Apuntador


7/26


Diagrama:

Programa:

#include

#include

int Busqueda(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento);

void main()

{

int Info[8]={12,10,0,9,5,3,0,20};

int Indice[8]={5,7,6,1,-999,3,-999,4};

int Inicio=0,Disp=2,Elemento,Res;

coutElemento;

Res=Busqueda(Info,Indice,Inicio,Disp,Elemento);

if(Res==-999)

cout


8/26


}

return Apuntador;

}

CORRIDA:

Insercin al Principio

Definicin:

La Insercin al Principio bsicamente busca si existe algn lugar disponible en el arreglo Info y loagrega como primer Nodo si es que es posible.

Explicacin:

Hace una comparacin para ver si es posible insertar otro Elemento al arreglo Info, para esto checa si

Disp es Diferente de Nulo. Si no cumple con la condicin se desplegar Sobre Carga ya que no sepuede insertar un Nuevo Elemento. Si es cierto Apuntador toma el valor de Inicio, Disp cambia a

Indice[Disp] ya que el primer Disp tomara el valor del Nuevo Elemento, despus de esto solo copia la

informacin de Elemento al arreglo Info en la posicin que guarda Apuntador, Indice[Apuntador] tomael valor de Inicio y finalmente Inicio toma el valor de Apuntador.

Algoritmo:


9/26


InsPr(Inicio, Disp, Info, Indice, Elemento)

Si Disp Nill entonces:

Apuntador - Disp

Disp - Indice[Disp]

Info[Apuntador] - Elemento

Indice[Apuntador] - Inicio

Inicio - Apuntador

Si no:

Imprimir Sobre Carga

Salir

Diagrama:

Programa:


10/26


#include

#include

void Recorrido(int Info[8],int Indice[8],int Inicio,int Disp);

void InsPr(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento);

void main()

{

int Info[8]={12,10,0,9,5,3,0,20};

int Indice[8]={5,7,6,1,-999,3,-999,4};


cout


11/26


Insercin despus de UN Nodo Determinado

Definicin:

La Insercin despus de un Nodo Determinado bsicamente hace lo mismo que la insercin al principio,la nica diferencia es que este recibe la posicin del nodo en la que ser Insertada. Este Algoritmo se usa

para Insercin Ordenada que mas adelante explicaremos.

Explicacin:

Primero confirma que sea posible insertar el Dato, si no es posible solo desplegara Sobre Carga. Si es

posible insertar un dato nuevo lo posiciona en la primer posicin Disponible en el arreglo Info, despuscompara la Nueva Posicin (Npos) que le mandamos con Nill si cumple la condicin el dato es insertadoen la primer posicin, de otra forma se posicionara en la posicin que guarde Npos.

Algoritmo:


12/26


InsNd(Inicio, Disp, Info, Indice, Elemento, Npos)

Si Disp Nill entonces:

Apuntador - Disp

Disp - Indice[Disp]

Info [Apuntador] - Elemento

Si Npos = Nill entonces:

Indice[Apuntador] - Inicio

Inicio - Apuntador

Si no:

Indice[Apuntador] - Indice[Npos]

Indice[Npos] - Apuntador

Si no:

Imprimir Sobre Carga

Salir

Insercin Ordenada

Definicin:

La Insercin Ordenada busca la posicin en donde ser Insertado el Elemento y la posicin anterior

donde ser Insertado, despus de encontrar la posicin en la que ser Insertado el Elemento nos regresa

ese valor y lo mandamos al mtodo de la Insercin despus de un Nodo.

Explicacin:

En esta ocasin usaremos dos variables para determinar la posicin deseada, comparamos si Inicio es

igual a Nill si Elemento es menor al dato que se encuentra en Info[Inicio], si alguna de las dos cumpleregresamos Nill, de esta manera Indicamos que el Elemento ser el primero de todo el Arreglo Info, si

no es as Temp tomara el valor de Inicio y Temp2 de la posicin que le sigue a Inicio. Hace un ciclo

hasta encontrar la posicin en donde se insertara el Nuevo Elemento y va movindose de posicin conlas variables Temp y Temp2 para as determinar que posicin debe de regresar.


13/26


Algoritmo:

InsOrd(Inicio, Info, Indice, Elemento)

Si Inicio = Nill Elemento < Info[Inicio] entonces:

Regresar Nill

Temp - Inicio

Temp2 - Indice[Inicio]

Repetir mientras Temp2 Nill

Si Elemento < Info[Temp2]

Regresar Temp

Temp - Temp2

Temp2 - Indice[Temp2]

Regresar Temp

Diagrama:


14/26


Programa:

#include

#include

int InsOrd(int Info[8],int Indice[8],int Inicio,int Elemento);


void InsNd(int Info[8],int Indice[8],int Inicio,int Disp, int Elemento, int Npos);

void main(){

int Info[8]={12,10,0,9,5,3,0,20};

int Indice[8]={5,7,6,1,-999,3,-999,4};


cout


15/26


void InsNd(int Info[8],int Indice[8],int Inicio,int Disp, int Elemento, int Npos)

{

if(Disp!=-999)

{

int Apuntador=Disp;

Disp=Indice[Disp];

Info[Apuntador]=Elemento;

if(Npos==-999)

{

Indice[Apuntador]=Inicio;

Inicio=Apuntador;

}

else

{

Indice[Apuntador]=Indice[Npos];

Indice[Npos]=Apuntador;

}

Recorrido(Info,Indice,Inicio,Disp);

}else

cout


16/26


Eliminacin por Bsqueda

Definicin:

La Eliminacin simplemente cambia los nodos para que el dato que se desea eliminar sea el primer

disponible, de esta forma ya no estar en el Arreglo de Info.

Explicacin:

Lo primero que hace es ver si existe algn dato en la lista para eliminar, si Inicio es igual a Nill entonces

solo desplegara Imposible Eliminar. De otra formas cambiar de Posicin en Posicin hasta encontrar

el Elemento que sea desea Eliminar con ayudar de dos variables que guardan la Posicin actual y laanterior en donde se encuentre el dato. Ya que lo encuentra cambia ese dato como la primera posicinDisponible y lo apunta al siguiente nodo disponible. Si no encuentra el dato simplemente desplegara

Dato no encontrado

Algoritmo:

EliBusq(Inicio, Info, Indice, Elemento)

Temp - Inicio

Si Temp = Nill

Imprimir Lista Vacia Imposible Eliminar y Retornar

Repetir mientras Temp Nill


17/26


Si Elemento = Info[Temp] entonces:

Si Temp = Inicio entonces:

Inicio - Indice[Inicio]

Si no:

Indice[Temp2] - Indice[Temp]

Indice[Temp] Disp

Disp - Temp

Recorrido(Inicio, Info, Indice) y Retornar

Si no:

Temp2 - Temp

Temp - Indice[Temp]

Imprimir Dato no encontrado Imposible Eliminar y Retornar

Diagrama:


18/26


Programa:

#include

#include


void EliBusq(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento);

void main()

{

int Info[8]={12,10,0,9,5,3,0,20};

int Indice[8]={5,7,6,1,-999,3,-999,4};


cout


19/26


}

}

cout


20/26


APENDICE

Codigo de Listas enlazadas en C++

#include

#include

#include

#include

class Alumno

{

private:

char Nombre[10][30];

int N_control[10],Edad[10],Indice1[10],Indice2[10],Inicio,Fin,Disp;

public:

//ConstructorAlumno()

{

int i,j;

Inicio=0;

Fin=0;

Disp=1;

Indice1[Inicio]=-999;

Indice2[Fin]=-999;

for(i=1,j=2;i


21/26


else

cout


22/26


}

else

Temp=Indice2[Temp];

}

}

return -999;

}

//Funcion de Busqueda Sobrecargada para una Cadena de Caracteres

int Busqueda(char Elem[30])

{

if((strcmp(Elem,Nombre[Inicio]))


23/26


Temp=Temp2;

Temp2=Indice1[Temp2];

}

return Temp;

}

//Funcion Sobrecargada de Orden para una Cadena de Caracteres

int Enca(char E_nom[30])

{

int Temp=Indice1[Inicio],Temp2;

if(Temp==-999)

return -999;

if((strcmp(E_nom,Nombre[Temp]))


24/26


Fin=Temp;

}

else

{

Indice2[Temp]=Npos;

Indice2[Indice1[Npos]]=Temp;

}

Indice1[Npos]=Temp;

}

}

else

cout


25/26


//Funcion Sobrecargada para Borrar una Cadena de Caracteres

void Borrar(char Elem[30])

{

int Temp2,Temp=Indice1[Inicio];

if(Temp==Inicio)

{

cout


26/26

gotoxy(1,10);

switch (op)

{

case 1:

tec.Recorrido(1);

break;

case 2:

tec.Recorrido(2);

break;

case 3:

cout

Leccion 3.3 Listas enlazadas

Documents

Transcript of Leccion 3.3 Listas enlazadas