Академический Документы
Профессиональный Документы
Культура Документы
org/wiki/Lista_enlazada
Lista enlazada
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 los que se
guardan campos de datos arbitrarios y una o dos referencias, enlaces o punteros al nodo anterior o posterior.
El principal beneficio de las listas enlazadas respecto a los vectores 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 autorreferenciado porque contienen un puntero o enlace (en ingls link,
del mismo significado) a otro dato del mismo tipo. Las listas enlazadas permiten inserciones y eliminacin
de nodos en cualquier punto de la 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:
listas 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, Scheme y
Haskell tienen 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.
ndice
1 Historia
2 Tipos de listas enlazadas
2.1 Listas enlazadas lineales
2.1.1 Listas simples enlazadas
2.1.2 Listas doblemente enlazadas
2.2 Listas enlazadas circulares
2.2.1 Listas enlazadas simples circulares
2.2.2 Listas enlazadas doblemente circulares
2.3 Nodos centinelas
3 Aplicaciones de las listas enlazadas
4 Ventajas
4.1 Listas enlazadas vs. vectores o matrices
4.2 Doblemente enlazadas vs. simplemente enlazadas
4.3 Circulares enlazadas vs. lineales enlazadas
4.4 Nodos centinelas (header nodes)
5 Listas enlazadas usando vectores de nodos
6 Lenguajes soportados
7 Almacenamiento interno y externo
8 Agilizacin de la bsqueda
9 Estructuras de datos relacionadas
10 Implementaciones
10.1 Operaciones sobre listas enlazadas
10.1.1 Listas enlazadas lineales
10.1.1.1 Listas simples enlazadas
10.1.1.2 Listas doblemente enlazadas
10.1.2 Listas enlazadas circulares
1 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
Historia
Las listas enlazadas fueron desarrolladas en 1955-56 por Cliff Shaw y Herbert Simon en RAND
Corporation, como la principal estructura de datos para su Lenguaje de Procesamiento de la Informacin
(IPL). IPL fue usado por los autores para desarrollar varios programas relacionados con la inteligencia
artificial, incluida la Mquina de la Teora General, el Solucionador de Problemas Generales, y un
programa informtico de ajedrez. Se public en IRE Transactions on Information Theory en 1956, y en
distintas conferencias entre 1957-1959, incluida Proceedings of the Western Joint Computer en 1957 y
1958, y en Information Processing (Procendents de la primera conferencia internacional del procesamiento
de la informacin de la Unesco) en 1959. El diagrama clsico actual, que consiste en bloques que
representan nodos de la lista con flechas apuntando a los sucesivos nodos de la lista, apareci en
Programming the Logic Theory Machine, de Newell y Shaw. Newell y Simon fueron reconocidos por el
ACM Turing Award en 1975 por hacer contribuciones bsicas a la inteligencia artificial, a la psicologa del
conocimiento humano y al procesamiento de las listas.
El problema de los traductores del procesamiento natural del lenguaje condujo a Victor Yngve del Instituto
Tecnolgico de Massachusetts (MIT) a usar listas enlazadas como estructura de datos en su COMIT,
lenguaje de programacin para computadoras, que investig en el campo de la Lingstica computacional.
Un informe de este lenguaje, titulado A programming language for mechanical translation apareci en
Mechanical Translation en 1958.
LISP, el principal procesador de listas, fue creado en 1958. Una de las principales estructuras de datos de
LISP es la lista enlazada.
En torno a los 60, la utilidad de las listas enlazadas y los lenguajes que utilizaban estas estructuras como su
principal representacin de datos estaba bien establecida. Bert Green, del Lincoln Laboratory del MIT,
public un estudio titulado Computer languages for symbol manipulation en IRE Transaction on Human
Factors in Electronics en marzo de 1961 que resuma las ventajas de las listas enlazadas. Un posterior
artculo, A Comparison of list-processing computer languages de Bobrow y Raphael, apareca en
Communications of the ACM en abril de 1964.
Muchos sistemas operativos desarrollados por la empresa Technical Systems Consultants (originalmente de
West Lafayette Indiana y despus de Raleigh, Carolina del Norte) usaron listas enlazadas simples como
estructuras de ficheros. Un directorio de entrada apuntaba al primer sector de un fichero y daba como
resultado porciones de la localizacin del fichero mediante punteros. Los sistemas que utilizaban esta
tcnica incluan Flex (para el Motorola 6800 CPU), mini-Flex (la misma CPU) y Flex9 (para el Motorola
6809 CPU). Una variante desarrollada por TSC se comercializ a Smoke Signal Broadcasting en California,
usando listas doblemente enlazadas del mismo modo.
El sistema operativo TSS, desarrollado por IBM para las mquinas System 360/370, usaba una lista
doblemente enlazada para su catlogo de ficheros de sistema. La estructura de directorios era similar a Unix,
2 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
donde un directorio poda contener ficheros u otros directorios que se podan extender a cualquier
profundidad. Una utilidad fue creada para arreglar problemas del sistema despus de un fallo desde las
porciones modificadas del catlogo de ficheros que estaban a veces en memoria cuando ocurra el fallo. Los
problemas eran detectados por comparacin de los enlaces posterior y anterior por consistencia. Si el
siguiente de ellos era corrupto y el anterior enlace del nodo infectado era encontrado, el enlace posterior era
asignado al nodo marcado con el enlace anterior.
Es una lista enlazada de nodos, donde cada nodo tiene un nico campo de enlace. Una variable de referencia
contiene una referencia al primer nodo, cada nodo (excepto el ltimo) enlaza con el nodo siguiente, y el
enlace del ltimo nodo contiene NULL para indicar el final de la lista. Aunque normalmente a la variable de
referencia se la suele llamar top, se le podra llamar como se desee.
Un tipo de lista enlazada ms sofisticado es la lista doblemente enlazada o lista enlazadas de dos vas.
Cada nodo tiene dos enlaces: 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.
En algn lenguaje de muy bajo nivel, XOR-Linking ofrece una va para implementar listas doblemente
enlazadas, usando una sola palabra para ambos enlaces, aunque esta tcnica no se suele utilizar.
Cada nodo tiene un enlace, similar al de las listas enlazadas simples, excepto que el siguiente nodo del
ltimo apunta al primero. Como en una lista enlazada simple, los nuevos nodos pueden ser solo
eficientemente insertados despus de uno que ya tengamos referenciado. Por esta razn, es usual quedarse
con una referencia solamente al ltimo elemento en una lista enlazada circular simple, esto nos permite
rpidas inserciones al principio, y tambin permite accesos al primer nodo desde el puntero del ltimo
nodo.1
3 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
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 algn nodo cercano. Aunque estructuralmente una lista circular
doblemente enlazada no tiene ni principio ni 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.
Nodos centinelas
A veces las listas enlazadas tienen un nodo centinela (tambin llamado falso nodo o nodo ficticio) al
principio o al final de la lista, el cual no es usado para guardar datos. Su propsito es simplificar o agilizar
algunas operaciones, asegurando que cualquier nodo tiene otro anterior o posterior, y que toda la lista
(incluso alguna que no contenga datos) siempre tenga un primer y ltimo nodo.
El campo de datos de un nodo puede ser otra lista enlazada. Mediante este mecanismo, podemos construir
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 vectores asociativos, y estas en el contexto de las
llamadas listas asociativas. Hay pocas ventajas en este uso de las listas enlazadas; hay mejores formas de
implementar stas estructuras, por ejemplo con rboles binarios de bsqueda equilibrados. Sin 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 resolver un
problema. Una estructura de lista enlazada puede trabajar bien en un caso pero causar problemas en otros.
He aqu una lista con 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 incrementa el beneficio de
las listas enlazadas.
4 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
elementos entre dos o ms listas es decir, la lista acaba en la misma secuencia de elementos. De este
modo, uno puede aadir nuevos elementos al frente de la lista manteniendo una referencia tanto al nuevo
como a los viejos elementos - un ejemplo simple de una estructura de datos persistente.
Por otra parte, los vectores permiten acceso aleatorio mientras que las listas enlazadas slo permiten acceso
secuencial a los elementos. Las listas enlazadas simples, de hecho, solo pueden ser recorridas en una
direccin. Esto hace que las listas sean inadecuadas para aquellos casos en los que es til buscar un
elementos por su ndice rpidamente, como el heapsort. El acceso secuencial en los vectores tambin es ms
rpido que en las listas enlazadas.
Otra desventaja de las listas enlazadas es el almacenamiento extra necesario para las referencias, que a
menudos las hacen poco prcticas para listas de pequeos datos como caracteres o valores booleanos.
Tambin puede resultar lento y abusivo el asignar memoria para cada nuevo elemento. Existe una variedad
de listas enlazadas que contemplan los problemas anteriores para resolver los mismos. Un buen ejemplo que
muestra los pros y contras del uso de vectores sobre listas enlazadas es la implementacin de un programa
que resuelva el problema de Josephus. Este problema consiste en un grupo de personas dispuestas en forma
de crculo. Se empieza a partir de una persona predeterminadas y se cuenta n veces, la persona n-sima se
saca del crculo y se vuelve a cerrar el grupo. Este proceso se repite hasta que queda una sola persona, que
es la que gana. Este ejemplo muestra las fuerzas y debilidades de las listas enlazadas frente a los vectores,
ya que viendo a la gente como nodos conectados entre s en una lista circular se observa como es ms fcil
suprimir estos nodos. Sin embargo, se ve como la lista perder utilidad cuando haya que encontrar a la
siguiente persona a borrar. Por otro lado, en un vector el suprimir los nodos ser costoso ya que no se puede
quitar un elemento sin reorganizar el resto. Pero en la bsqueda de la n-sima persona tan slo basta con
indicar el ndice n para acceder a l resultando mucho ms eficiente.
5 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
Entonces una lista enlazada puede ser construida, creado un vector con esta estructura, y una variable entera
para almacenar el ndice del primer elemento. (ver en la seccin de implementaciones).
La lista enlazada puede ser movida sobre la memoria y tambin ser rpidamente serializada para
almacenarla en un disco o transferirla sobre una red.
Especialmente para una lista pequea, los vectores indexados pueden ocupar mucho menos espacio
que un conjunto de punteros.
La localidad de referencia puede ser mejorada guardando los nodos juntos en memoria y siendo
reordenados peridicamente.
Por estas razones, la propuesta se usa principalmente para lenguajes que no soportan asignacin de memoria
dinmica. Estas desventajas se atenan tambin si el tamao mximo de la lista se conoce en el momento en
el que el vector se crea.
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, y el
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.
6 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
hacer accesos a los datos ms eficientes, requiriendo menos almacenamiento global, teniendo mejor
referencia de localidad, y simplifica la gestin de memoria para la lista (los datos son alojados y desalojados
al mismo tiempo que los nodos de la lista).
El almacenamiento externo, por otro lado, tiene la ventaja de ser ms genrico, en la misma estructura de
datos y cdigo mquina puede ser usado para una lista enlazada, no importa cual sea su tamao o los datos.
Esto hace que sea ms fcil colocar el mismo dato en mltiples listas enlazadas. Aunque con el
almacenamiento interno los mismos datos pueden ser colocados en mltiples listas incluyendo mltiples
referencias siguientes en la estructura de datos del nodo, esto podra ser entonces necesario para crear
rutinas separadas para aadir o borrar celdas basadas en cada campo. Esto es posible creando listas
enlazadas de elementos adicionales que usen almacenamiento interno usando almacenamiento externo, y
teniendo las celdas de las listas enlazadas adicionales almacenadas las referencias a los nodos de las listas
enlazadas que contienen los datos.
En general, si una serie de estructuras de datos necesita ser incluida en mltiples listas enlazadas, el
almacenamiento externo es el mejor enfoque. Si una serie de estructuras de datos necesitan ser incluidas en
una sola lista enlazada, entonces el almacenamiento interno es ligeramente mejor, a no ser que un paquete
genrico de listas genricas que use almacenamiento externo est disponible. Asimismo, si diferentes series
de datos que pueden ser almacenados en la misma estructura de datos son incluidos en una lista enlazada
simple, entonces el almacenamiento interno puede ser mejor.
Otro enfoque que puede ser usado con algunos lenguajes implica tener diferentes estructuras de datos, pero
todas tienen los campos iniciales, incluyendo la siguiente (y anterior si es una lista doblemente enlazada)
referencia en la misma localizacin. Despus de definir estructuras distintas para cada tipo de dato, una
estructura genrica puede ser definida para que contenga la mnima cantidad de datos compartidos por todas
las estructuras y contenidos al principio de las estructuras. Entonces las rutinas genricas pueden ser creadas
usando las mnimas estructuras para llevar a cabo las operaciones de los tipos de las listas enlazadas, pero
separando las rutinas que pueden manejar los datos especficos. Este enfoque es usado a menudo en rutinas
de anlisis de mensajes, donde varios tipos de mensajes son recibidos, pero todos empiezan con la misma
serie de campos, generalmente incluyendo un campo para el tipo de mensaje. Las rutinas genricas son
usadas para aadir nuevos mensajes a una cola cuando son recibidos, y eliminarlos de la cola en orden para
procesarlos. El campo de tipo de mensaje es usado para llamar a la rutina correcta para procesar el tipo
especfico de mensaje.
En la seccin implementaciones (en este mismo artculo) se expone cdigo referente a este tema.
Hay que notar que cuando usamos almacenamiento externo, se necesita dar un paso extra para extraer la
informacin del nodo y hacer un casting dentro del propio tipo del dato. Esto es porque ambas listas, de
familias y miembros, son almacenadas en dos listas enlazadas usando la misma estructura de datos (nodo), y
este lenguaje no tiene tipos paramtricos.
Si conocemos el nmero de familias a las que un miembro puede pertenecer en tiempo de compilacin, el
almacenamiento interno trabaja mejor. Si, sin embargo, un miembro necesita ser incluido en un nmero
arbitrario de familias, sabiendo el nmero especfico de familias solo en tiempo de ejecucin, el
almacenamiento externo ser necesario.
Agilizacin de la bsqueda
Buscando un elemento especfico en una lista enlazada, incluso si esta es ordenada, normalmente requieren
tiempo O (n) (bsqueda lineal). Esta es una de las principales desventajas de listas enlazadas respecto a otras
estructuras. Adems algunas de las variantes expuestas en la seccin anterior, hay numerosas vas simples
para mejorar el tiempo de bsqueda.
En una lista desordenada, una forma simple para decrementar el tiempo de bsqueda medio es el mover al
7 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
frente de forma heurstica, que simplemente mueve un elemento al principio de la lista una vez que es
encontrado. Esta idea, til para crear cachs simples, asegura que el tem usado ms recientemente es
tambin el ms rpido en ser encontrado otra vez.
Otro enfoque comn es indizar una lista enlazada usando una estructura de datos externa ms eficiente. Por
ejemplo, podemos construir un rbol rojo-negro o una tabla hash cuyos elementos estn referenciados por
los nodos de las listas enlazadas. Pueden ser construidos mltiples ndices en una lista simple. La
desventaja es que estos ndices puede necesitar ser actualizados cada vez que un nodo es aadido o
eliminado (o al menos, antes que el ndice sea utilizado otra vez).
La skip list, o lista por saltos, es una lista enlazada aumentada con capas de punteros para saltos rpidos
sobre grandes nmeros de elementos, y descendiendo haca la siguiente capa. Este proceso contina hasta
llegar a la capa inferior, la cual es la lista actual.
Un rbol binario puede ser visto como un tipo de lista enlazada donde los elementos estn enlazados entre
ellos mismos de la misma forma. El resultado es que cada nodo puede incluir una referencia al primer nodo
de una o dos listas enlazadas, cada cual con su contenido, formando as los subrboles bajo el nodo.
Una lista enlazada desenrollada es una lista enlazada cuyos nodos contiene un vector de datos. Esto mejora
la ejecucin de la cach, siempre que las listas de elementos estn contiguas en memoria, y reducen la
sobrecarga de la memoria, porque necesitas menos metadatos para guardar cada elemento de la lista.
Una tabla hash puede usar listas enlazadas para guardar cadenas de tems en la misma posicin de la tabla
hash.
Implementaciones
Aqu se expone el cdigo necesario para complementar el artculo a fin de poder realizar una lectura gil
sobre el artculo y a su vez quien necesite el cdigo pueda fcilmente encontrar el mismo si est contenido.
Nuestra estructura de datos tendr dos campos. Vamos a mantener la variables PrimerNodos que siempre
apunta al primer nodo de tal lista, nulo para la lista vaca.
record Node {
data // El dato almacenado en el nodo
next // Una referencia al nodo siguiente, nulo para el ltimo nodo
}
8 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
record List {
Node PrimerNodo // Apunta al primer nodo de la lista; nulo para la lista vaca
}
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.
Insertar al principio de una lista requiere una funcin por separado. Se necesita actualizar PrimerNodo.
De forma similar, tambin tenemos funciones para borrar un nodo dado para borrar un nodo del principio
de la lista. Ver diagrama.
9 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
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 aadir la
segunda lista.
Con estas listas es necesario actualizar muchos ms punteros pero tambin se necesita menos informacin
porque podemos usar un puntero para recorrer hacia atrs y consultar elementos. Se crean nuevas
operaciones y elimina algunos casos especiales. Aadimos el campo anterior a nuestros nodos, apuntando al
elemento anterior, y UltimoNodo a nuestra estructura, el cual siempre apunta al ltimo elemento de la lista.
PrimerNodo y UltimoNodo siempre estn a nulo en la lista vaca.
record Node {
data // El dato almacenado en el nodo
next // Una referencia al nodo siguiente, nulo para el ltimo nodo
prev // Una referencia al nodo anterior, nulo para el primer nodo
}
record List {
Node firstNode // apunta al primer nodo de la lista; nulo para la lista vaca
Node lastNode // apunta al ltimo nodo de la lista; nulo para la lista vaca
}
Hacia Delante
node := list.firstNode
while node null
<do something with node.data>
node := node.next
Hacia Atrs
node := list.lastNode
while node null
<do something with node.data>
node := node.prev
10 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
list.firstNode := newNode
else
node.prev.next := newNode
node.prev := newNode
Tambin necesitamos una funcin para insertar un nodo al comienzo de una lista posiblemente vaca.
Borrar un nodo es fcil, solo requiere usar con cuidado firstNode y lastNode.
Una consecuencia especial de este procedimiento es que borrando el ltimo elemento de una lista se ponen
PrimerNodo y UltimoNodo a nulo, habiendo entonces un problema en una lista que tenga un nico
elemento.
Estas pueden ser simples o doblemente enlazadas. En una lista circular todos los nodos estn enlazados
como un crculo, sin usar nulo. Para listas con frente y final (como una cola), se guarda una referencia al
ltimo nodo de la lista. El siguiente nodo despus del ltimo sera el primero de la lista. Los elementos se
pueden aadir por el final y borrarse por el principio en todo momento. Ambos tipos de listas circulares
tienen la ventaja de poderse recorrer completamente empezando desde cualquier nodo. Esto nos permite
normalmente evitar el uso de PrimerNodo y UltimoNodo, aunque si la lista estuviera vaca necesitaramos
un caso especial, como una variable UltimoNodo que apunte a algn nodo en la lista o nulo si est vaca.
Las operaciones para estas listas simplifican el insertar y borrar nodos en una lista vaca pero introducen
casos especiales en la lista vaca.
Asumiendo que someNodo es algn nodo en una lista no vaca, esta lista presenta el comienzo de una lista
con someNode.
11 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
Hacia Delante
node := someNode
do
do something with node.value
node := node.next
while node != someNode
Hacia Atrs
node := someNode
do
do something with node.value
node := node.prev
while node := someNode
Esta funcin inserta un nodo en una lista enlazada doblemente circular despus de un elemento dado:
Para hacer "insertBefore", podemos simplificar "insertAfter (node.prev, newNode)". Insertar un elemento en
una lista que puede estar vaca requiere una funcin especial.
Como una lista doblemente enlazada, "removeAfter" y "removeBefore" puede ser implementada con
"remove (list, node.prev)" y "remove (list, node.next)".
record Entry {
integer next; // ndice de la nueva entrada en el vector
integer prev; // entrada previa
string name;
12 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
real balance;
}
Entry Records[1000];
typedef struct ns {
int data;
struct ns *next;
} node;
int main(void) {
node *n = NULL;
13 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
list_print(n);
return 0;
}
//--Unit2.h-------------------------------------------------------------------------
#ifndef Unit2H
#define Unit2H
#include <iostream.h>
//---------------------------------------------------------------------------
class TElemento{
protected:
int aInfo;
TElemento *aSeguinte ;
public:
TElemento(int pInfo){aInfo = pInfo; aSeguinte=NULL;}; //Construtor
~TElemento(){}; //Destruidor
//Operaes
int LerInfo(){return aInfo;}; //Ler
void EscInfo(int pInfo){aInfo = pInfo;}; //Escrever
TElemento *LerSeguinte(){return aSeguinte;}; //Ler
void EscSeguinte(TElemento *pSeguinte){aSeguinte = pSeguinte;}; //Escrever
};
class TListaSL{
private:
TElemento *aPrimeiro;
int alongitude;
public:
TListaSL(){aPrimeiro = NULL; alongitude = 0;}; //Construtor
TListaSL(int pnovoelemento); //Construtor
~TListaSL(); //Destruidor
//Operaes
int Longitud(){return alongitude;};
bool Vazia(){return !alongitude;};
void Adicionar(int pnovoelemento);
void Inserir(int pnovoelemento, int pIndice);
void Eliminar(int pIndice);
int Obter(int pIndice);
void Mostrar();
};
#endif
//--Final Unit2.h-------------------------------------
//--Unit2.cpp-------------------------------------------------------------------------
#pragma hdrstop
#include "Unit2.h"
#include <vcl.h>
#pragma argsused
//---------------------------------------------------------------------------
TListaSL::TListaSL(int pnovoelemento){
aPrimeiro = new TElemento(pnovoelemento);
alongitude = 1;
}
TListaSL::~TListaSL(){
TElemento *cursor;
while(aPrimeiro){
cursor = aPrimeiro;
cursor = aPrimeiro->LerSeguinte();
delete cursor;
}
}
14 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
void TListaSL::Mostrar(){
TElemento *cursor = aPrimeiro;
for(int i = 0; i <= alongitude - 1; i++){
printf("%i ", cursor->LerInfo());
cursor = cursor->LerSeguinte();
}
}
15 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
Lista->Adicionar(7);
printf("\n Lista de elementos: ");
Lista->Mostrar();
//printf("\n%i", Lista->Obter(3));
Lista->Inserir(20,2);
printf("\n Lista mas uno insertado: ");
Lista->Mostrar();
Lista->Eliminar(6);
printf("\n Lista menos uno eliminado: ");
Lista->Mostrar();
cin >> espera;
return 0;
};
//---------------------------------------------------------------------------
#pragma package(smart_init)
struct camera_t {
int idcam;
string serial;
int idroom;
camera_t *next;
};
//Insertar al principio de una lista requiere una funcin por separado. Se necesita actualizar PrimerNodo.
void list_add(camera_t **node_cam)
{
camera_t *newnode = new (nothrow) camera_t;
if(newnode==NULL){
cout << "Error. No possible allocate memory to new node.";
}
else{
newnode->next = *node_cam;
*node_cam = newnode;
cout << "Hola";
}
}
//El recorrido en una lista enlazada es simple, empezamos por el primer nodo y pasamos al siguiente hasta
// que la lista llegue al final.
void list_print(camera_t *node_cam)
{
if (node_cam == NULL){
cout << "Lista vacia";
}
else{
while (node_cam!=NULL)
{
cout << "idcam: " << node_cam->idcam << "\nName: " << node_cam->name << "\nModel: " << node_cam->
cout << "\nSerial: " << node_cam->serial << "\nIdRoom: " << node_cam->idroom << "\nNameRoom: " <<
cout << "\n\n";
node_cam = node_cam->next;
}
}
}
int main(void)
{
string mystr;
camera_t *node_cam = 0;
list_add(&node_cam);
16 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
list_print(node_cam);
}
protecting NAT .
*** tipos
*** generadores
*** constructores
op _::_ : ListaGen{X} ListaGen{X} -> ListaGen{X} [assoc id: crear ] . *** concatenacin
*** selectores
*** variables
vars L L1 L2 : ListaGen{X} .
vars E E1 E2 : X$Elt .
*** ecuaciones
eq esVacia?(crear) = true .
eq esVacia?(cons(E, L)) = false .
eq primero(cons(E, L)) = E .
eq resto(cons(E, L)) = L .
eq longitud(crear) = 0 .
eq longitud(cons(E, L)) = 1 + longitud(L) .
eq invertir(crear) = crear .
eq invertir(cons(E, L)) = invertir(L) :: cons(E, crear) .
endfm
17 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
Para mostrar una lista completa de familias y sus miembros usando almacenamiento interno podramos
escribir algo como esto:
Para mostrar una lista completa de familias y sus miembros usando almacenamiento externo, podramos
escribir:
Referencias
18 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
1. Preiss, Bruno R. (1999), Data Structures and Algorithms with Object-Oriented Design Patterns in Java
(http://www.brpreiss.com/books/opus5/html/page97.html), Wiley, p. page 97, 165, ISBN 0471-34613-6
2. If maintaining a link to the tail of the list, time is O(1); if the entire list must be searched to locate the tail link,
O(n)
National Institute of Standards and Technology (August 16, 2004). Definition of a linked list
(http://nist.gov/dads/HTML/linkedList.html). Retrieved December 14, 2004.
Antonakos, James L. and Mansfield, Kenneth C., Jr. Practical Data Structures Using C/C++ (1999).
Prentice-Hall. ISBN 0-13-280843-9, pp. 165190
Collins, William J. Data Structures and the Java Collections Framework (2002,2005) New York, NY:
McGraw Hill. ISBN 0-07-282379-8, pp. 239303
Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford Introductions to
Algorithms (2003). MIT Press. ISBN 0-262-03293-7, pp. 205213, 501505
Green, Bert F. Jr. (1961). Computer Languages for Symbol Manipulation. IRE Transactions on
Human Factors in Electronics. 2 pp. 3-8.
McCarthy, John (1960). Recursive Functions of Symbolic Expressions and Their Computation by
Machine, Part I. Communications of the ACM. [1] (http://www-formal.stanford.edu/jmc/recursive.html) HTML
(http://www-formal.stanford.edu/jmc/recursive/recursive.html) DVI (http://www-formal.stanford.edu/jmc/recursive.dvi)
PDF (http://www-formal.stanford.edu/jmc/recursive.pdf) PostScript (http://www-formal.stanford.edu/jmc/recursive.ps)
Donald Knuth. Fundamental Algorithms, Third Edition. Addison-Wesley, 1997. ISBN 0-201-89683-4.
Sections 2.2.32.2.5, pp.254298.
Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. Introduction to
Algorithms, Second Edition. MIT Press and McGraw-Hill, 2001. ISBN 0-262-03293-7. Section 10.2:
Linked lists, pp.204209.
Newell, Allen and Shaw, F. C. (1957). Programming the Logic Theory Machine. Proceedings of the
Western Joint Computer Conference. pp. 230-240.
Parlante, Nick (2001). Linked list basics. Stanford University. PDF (http://cslibrary.stanford.edu
/103/LinkedListBasics.pdf)
Sedgewick, Robert Algorithms in C (1998). Addison Wesley. ISBN 0-201-31452-5, pp. 90109
Shaffer, Clifford A. A Practical Introduction to Data Structures and Algorithm Analysis (1998). NJ:
Prentice Hall. ISBN 0-13-660911-2, pp. 77102
Wilkes, Maurice Vincent (1964). An Experiment with a Self-compiling Compiler for a Simple List-
Processing Language. Annual Review in Automatic Programming 4, 1. Published by Pergamon Press.
Wilkes, Maurice Vincent (1964). Lists and Why They are Useful. Proceeds of the ACM National
Conference, Philadelphia 1964 (ACM Publication P-64 page F1-1); Also Computer Journal 7, 278
(1965).
Kulesh Shanmugasundaram (April 4, 2005). Linux Kernel Linked List Explained (http://isis.poly.edu
/kulesh/stuff/src/klist/).
Enlaces externos
Obtenido de https://es.wikipedia.org/w/index.php?title=Lista_enlazada&oldid=101660793
Se edit esta pgina por ltima vez el 5 sep 2017 a las 18:59.
El texto est disponible bajo la Licencia Creative Commons Atribucin Compartir Igual 3.0; pueden
aplicarse clusulas adicionales. Al usar este sitio, usted acepta nuestros trminos de uso y nuestra
poltica de privacidad.
Wikipedia es una marca registrada de la Fundacin Wikimedia, Inc., una organizacin sin nimo de
lucro.
19 de 20 07/09/2017 17:33
Lista enlazada - Wikipedia, la enciclopedia libre https://es.wikipedia.org/wiki/Lista_enlazada
20 de 20 07/09/2017 17:33