listas

Empezaremos por una definicin sencilla:

Las listas son una sucesin de cero o ms elementos.
Esta es una definicin muy simple y que no aclara demasiado en trminos informticos, as que
profundizaremos un poco ms.
Hay varios tipos de listas, las hay enlazadas, no enlazadas, ordenadas y no ordenadas. Nosotros
vamos a estudiar las listas enlazadas, tanto ordenadas como no ordenadas.
La diferencia que existe entre las listas enlazadas y las no enlazadas es que las enlazadas utilizan
punteros, es decir, asignacin dinmica de memoria, lo que optimiza la gestin de la misma. Una lista
no enlazada es un simple array, y por lo tanto es un bloque contiguo de memoria, mientras que una
lista enlazada es un conjunto de nodos que no tienen por qu ocupar posiciones contiguas de
memoria.
La diferencia entre listas ordenadas y no ordenadas es obvia, las ordenadas mantienen cierto orden
entre sus elementos.
A partir de ahora nos centraremos en las listas enlazadas no ordenadas.
Una lista es una sucesin de nodos en la que a partir de un nodo se puede acceder al que ocupa la
siguiente posicin en la lista. Esta caracterstica nos indica que el acceso a las listas es secuencial y no
indexado, por lo que para acceder al ltimo elemento de la lista hay que recorrer los n-1 elementos
previos (n es el tamao de la lista).
Para que un nodo pueda acceder al siguiente y la lista no se rompa en varias listas cada nodo tiene
que tener un puntero que guarde la direccin de memoria que ocupa el siguiente elemento. De esta
forma un nodo se podra representar esquemticamente as:

En el campo informacin se almacena el objeto a guardar y el puntero mantendr la conexin con el

nodo siguiente.
De esta forma al ir aadiendo nodos se ira formando una sucesin de nodos encadenados mediante
punteros.

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 y Scheme 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 enlazadas lineales[editar]

Listas simples enlazadas[editar]

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 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
Listas doblemente enlazadas[editar]
Artculo principal: Lista doblemente enlazada

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.

Listas enlazadas circulares[editar]

En una lista enlazada circular, el primer y el ltimo nodo estn unidos juntos. Esto se puede
hacer tanto para listas enlazadas simples como para las doblemente enlazadas. Para recorrer
una lista enlazada circular podemos empezar por cualquier nodo y seguir la lista en
cualquier direccin hasta que se regrese hasta el nodo original. Desde otro punto de vista,
las listas enlazadas circulares pueden ser vistas como listas sin comienzo ni fin. Este tipo de
listas es el ms usado para dirigir buffers para ingerir datos, y para visitar todos los nodos
de una lista a partir de uno dado.

Una lista enlazada circular que contiene tres valores enteros

Listas enlazadas simples circulares[editar]

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
Listas enlazadas doblemente circulares[editar]

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[editar]
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.

Aplicaciones de las listas enlazadas[editar]

Las listas enlazadas son usadas como mdulos para otras muchas estructuras de datos, tales
como pilas, colas y sus variaciones.
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[editar]
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.

Listas enlazadas vs. vectores o matrices[editar]

Vect
Lista
or Enlazada
Indexado

O(1) O(n)

Insercin / Eliminacin al
final

O(1)

O(1) or
O(n)2

Insercin / Eliminacin en la
O(n) O(1)
mitad
Persistencia

No

Simples s

Localidad

Buen
Mala
a

Las listas enlazadas poseen muchas ventajas sobre los vectores. Los elementos se pueden
insertar en una lista indefinidamente mientras que un vector tarde o temprano se llenar o
necesitar ser redimensionado, una costosa operacin que incluso puede no ser posible si la
memoria se encuentra fragmentada.
En algunos casos se pueden lograr ahorros de memoria almacenando la misma cola de
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.

Doblemente enlazadas vs. simplemente

enlazadas[editar]
Las listas doblemente enlazadas requieren ms espacio por nodo y sus operaciones bsicas
resultan ms costosas pero ofrecen una mayor facilidad para manipular ya que permiten el
acceso secuencial a lista en ambas direcciones. En particular, uno puede insertar o borrar un
nodo en un nmero fijo de operaciones dando nicamente la direccin de dicho nodo (Las
listas simples requieren la direccin del nodo anterior para insertar o suprimir
correctamente). Algunos algoritmos requieren el acceso en ambas direcciones.

Circulares enlazadas vs. lineales enlazadas[editar]

Las listas circulares son ms tiles para describir estructuras circulares y tienen la ventaja
de poder recorrer la lista desde cualquier punto. Tambin permiten el acceso rpido al
primer y ltimo elemento por medio de un puntero simple.

Nodos centinelas (header nodes)[editar]

La bsqueda comn y los algoritmos de ordenacin son menos complicados si se usan los
llamados Nodos Centinelas o Nodos Ficticios, donde cada elemento apunta a otro elemento
y nunca a nulo. El Nodo Centinela o Puntero Cabeza contiene, como otro, un puntero
siguiente que apunta al que se considera como primer elemento de la lista. Tambin
contiene un puntero previo que hace lo mismo con el ltimo elemento. El Nodo Centinela
es definido como otro nodo en una lista doblemente enlazada, la asignacin del puntero
frente no es necesaria y los puntero anterior y siguiente estarn apuntando a s mismo en
ese momento. Si los punteros anterior y siguiente apuntan al Nodo Centinela la lista se
considera vaca. En otro caso, si a la lista se le aaden elementos ambos puntero apuntarn
a otros nodos. Estos Nodos Centinelas simplifican muchos las operaciones pero hay que
asegurarse de que los punteros anterior y siguiente existen en cada momento. Como ventaja
eliminan la necesidad de guardar la referencia al puntero del principio de la lista y la
posibilidad de asignaciones accidentales. Por el contrario, usan demasiado almacenamiento
extra y resultan complicados en algunas operaciones.

Listas enlazadas usando vectores de nodos[editar]

Los lenguajes que no aceptan cualquier tipo de referencia pueden crear uniones
reemplazando los punteros por ndices de un vector. La ventaja es de mantener un vector de
entradas, donde cada entrada tiene campos enteros indicando el ndice del siguiente
elemento del vector. Pueden haber nodos sin usarse. Si no hay suficiente espacio, pueden
usarse vectores paralelos.

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).
Las utilidades de esta propuesta son:

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.

Algunas desventajas son:

Incrementa la complejidad de la implementacin.

Usar un fondo general de memoria deja ms memoria para otros datos si

la lista es ms pequea de lo esperado si muchos nodos son liberados.

El crecimiento de un vector cuando est lleno no puede darse lugar (o

habra que redimensionarlo) mientras que encontrar espacio para un
nuevo nodo en una lista resulta posible y ms fcil.

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[editar]
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.
En la seccin de implementaciones hay un ejemplo completo en C y en Maude

Almacenamiento interno y externo[editar]

Cuando se construye una lista enlazada, nos enfrentamos a la eleccin de si almacenar los
datos de la lista directamente en los nodos enlazados de la lista, llamado almacenamiento
interno, o simplemente almacenar una referencia al dato, llamado almacenamiento externo.
El almacenamiento interno tiene la ventaja de 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[editar]
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 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).

Estructuras de datos relacionadas[editar]

Tanto las pilas como las colas son a menudo implementadas usando listas enlazadas, y
simplemente restringiendo el tipo de operaciones que son soportadas.
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[editar]
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.

Operaciones sobre listas enlazadas[editar]

Cuando se manipulan listas enlazadas, hay que tener cuidado con no usar valores que
hayamos invalidado en asignaciones anteriores. Esto hace que los algoritmos de insertar y
borrar nodos en las listas sean algo especiales. A continuacin se expone el pseudocdigo
para aadir y borrar nodos en listas enlazadas simples, dobles y circulares.
Listas enlazadas lineales[editar]
Listas simples enlazadas[editar]

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
}
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.

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 del principio 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
}

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.
Listas doblemente enlazadas[editar]

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
}

Formas de recorrer la lista:

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

Estas funciones simtricas aaden un nodo despus o antes de uno dado:

function insertAfter(List list, Node node, Node newNode)
newNode.prev := node
newNode.next := node.next
if node.next = null
node.next := newNode
list.lastNode := newNode
else

node.next.prev := newNode
node.next := newNode
function insertBefore(List list, Node node, Node newNode)
newNode.prev := node.prev
newNode.next := node
if node.prev is null
node.prev := newNode
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.
function insertBeginning(List list, Node newNode)
if list.firstNode = null
list.firstNode := newNode
list.lastNode := newNode
newNode.prev := null
newNode.next := null
else
insertBefore (list, list.firstNode, newNode)

Una funcin simtrica que inserta al final:

function insertEnd(List list, Node newNode)
if list.lastNode = null
insertBeginning (list, newNode)
else
insertAfter (list, list.lastNode, newNode)

Borrar un nodo es fcil, solo requiere usar con cuidado firstNode y lastNode.
function remove(List list, Node node)
if node.prev = null
list.firstNode := node.next
else
node.prev.next := node.next
if node.next = null
list.lastNode := node.prev
else
node.next.prev := node.prev
destroy node

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.
Listas enlazadas circulares[editar]

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.
Listas enlazadas doblemente circulares[editar]

Asumiendo que someNodo es algn nodo en una lista no vaca, esta lista presenta el
comienzo de una lista con someNode.
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:
function insertAfter(Node node, Node newNode)
newNode.next := node.next
newNode.prev := node
node.next.prev := newNode
node.next
:= newNode

Para hacer "insertBefore", podemos simplificar "insertAfter (node.prev, newNode)".

Insertar un elemento en una lista que puede estar vaca requiere una funcin especial.
function insertEnd(List list, Node node)
if list.lastNode = null
node.prev := node
node.next := node
else
insertAfter (list.lastNode, node)
list.lastNode := node

Para insertar al principio simplificamos "insertAfter (list.lastNode, node)".

function remove(List list, Node node)
if node.next = node
list.lastNode := null
else
node.next.prev := node.prev
node.prev.next := node.next
if node = list.lastNode
list.lastNode := node.prev;
destroy node

Como una lista doblemente enlazada, "removeAfter" y "removeBefore" puede ser

implementada con "remove (list, node.prev)" y "remove (list, node.next)".

Listas enlazadas usando vectores de nodos[editar]

Previamente se crea una estructura que contiene los apuntadores:
record Entry {
integer next; // ndice de la nueva entrada en el vector
integer prev; // entrada previa
string name;
real balance;
}

Y finalmente se declara el vector: integer listHead;

Entry Records[1000];

Implementacin de una lista enlazada en C

Las listas enlazadas son tpicamente construidas usando referencias junto con el tipo de
dato record
#include <stdio.h>
#include <stdlib.h>

/* for printf */
/* for malloc */

typedef struct ns {
int data;
struct ns *next;
} node;
node *list_add(node **p, int i) {
/* algunos compiladores no requieren un casting del valor del retorno
para malloc */
node *n = (node *)malloc(sizeof(node));
if (n == NULL)
return NULL;
n->next = *p;
*p = n;
n->data = i;
return n;
}
void list_remove(node **p) { /* borrar cabeza*/
if (*p != NULL) {
node *n = *p;
*p = (*p)->next;
free(n);
}
}
node **list_search(node **n, int i) {
while (*n != NULL) {
if ((*n)->data == i) {
return n;
}
n = &(*n)->next;
}
return NULL;

}
void list_print(node *n) {
if (n == NULL) {
printf("lista esta vaca\n");
}
while (n != NULL) {
printf("print %p %p %d\n", n, n->next, n->data);
n = n->next;
}
}
int main(void) {
node *n = NULL;
list_add(&n, 0); /* lista: 0 */
list_add(&n, 1); /* lista: 1 0 */
list_add(&n, 2); /* lista: 2 1 0 */
list_add(&n, 3); /* lista: 3 2 1 0 */
list_add(&n, 4); /* lista: 4 3 2 1 0 */
list_print(n);
list_remove(&n);
/* borrar primero(4) */
list_remove(&n->next);
/* borrar nuevo segundo (2) */
list_remove(list_search(&n, 1)); /* eliminar la celda que contiene el
1 (primera) */
list_remove(&n->next);
/* eliminar segundo nodo del final(0)*/
list_remove(&n);
/* eliminar ultimo nodo (3) */
list_print(n);
}

return 0;

Implementacin de una lista enlazada en C++

#include <iostream>
// Para cout
#include <sstream>
// Utilizado para validar entradas del teclado
#include <new>
// Utilizado para validad reservacion de memoria
al utilizar el operator NEW.
using namespace std
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->model;
cout << "\nSerial: " << node_cam->serial << "\nIdRoom: " <<
node_cam->idroom << "\nNameRoom: " << node_cam->room;
cout << "\n\n";
node_cam = node_cam->next;
}
}
}
int main(void)
{
string mystr;
camera_t *node_cam = 0;
cout << "Ingrese los datos de la camara." << endl;
list_add(&node_cam);
cout << "Indentificador de camara: 23";
node_cam->idcam = N_globalCamera;
node_cam->name = "PanSonyc";
cout << "Precione una tecla para regresar al menu principal.";
getline(cin,mystr);
}

list_print(node_cam);

Implementacin de una lista enlazada en Maude

fmod LISTA-GENERICA {X :: TRIV} is
protecting NAT .
*** tipos
sorts ListaGenNV{X} ListaGen{X} .
subsort ListaGenNV{X} < ListaGen{X} .

*** generadores
op crear : -> ListaGen{X} [ctor] .
op cons : X$Elt ListaGen{X} -> ListaGenNV{X} [ctor] .
*** constructores
op _::_ : ListaGen{X} ListaGen{X} -> ListaGen{X} [assoc id: crear ] . ***
concatenacin
op invertir : ListaGen{X} -> ListaGen{X} .
op resto

: ListaGenNV{X} -> ListaGen{X} .

*** selectores
op primero : ListaGenNV{X} -> X$Elt .
op esVacia? : ListaGen{X} -> Bool .
op longitud : ListaGen{X} -> Nat .
*** 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 cons(E1, L1) :: cons(E2, L2) = cons(E1, L1 :: cons(E2, L2)) .
eq invertir(crear) = crear .
eq invertir(cons(E, L)) = invertir(L) :: cons(E, crear) .
endfm

Ejemplos de almacenamiento interno y externo

Suponiendo que queremos crear una lista enlazada de familias y sus miembros. Usando
almacenamiento interno, la estructura podra ser como la siguiente:
record member { // miembro de una familia
member next
string firstName
integer age
}
record family { // // la propia familia
family next
string lastName
string address
member members // de la lista de miembros de la familia
}

Para mostrar una lista completa de familias y sus miembros usando almacenamiento interno
podramos escribir algo como esto:
aFamily := Families // comienzo de la lista de familias
while aFamily null { // bucle a travs de la lista de familias
print information about family
aMember := aFamily.members // coger cabeza de esta lista de miembros
de esta familia
while aMember null { //bucle para recorrer la lista de miembros
print information about member
aMember := aMember.next
}
aFamily := aFamily.next
}

Usando almacenamiento externo, nosotros podramos crear las siguientes estructuras:

record node { // estructura genrica de enlace
node next
pointer data // puntero genrico del dato al nodo
}
record member { // estructura de una familia
string firstName
integer age
}
record family { // estructura de una familia
string lastName
string address
node members // cabeza de la lista de miembros de esta familia
}

Para mostrar una lista completa de familias y sus miembros usando almacenamiento
externo, podramos escribir:
famNode := Families // comienzo de la cabeza de una lista de familias
while famNode null { // bucle de lista de familias
aFamily = (family) famNode.data // extraer familia del nodo
print information about family
memNode := aFamily.members // coger lista de miembros de familia
while memNode null { bucle de lista de miembros
aMember := (member) memNode.data // extraer miembro del nodo
print information about member

memNode := memNode.next
}
famNode := famNode.next
}
Uso de listas
Las listas se utilizan para organizar informacin. Pueden estar incluidas
dentro de un artculo, o conformar un anexo independiente. En esta gua
se explica cundo y cmo usar listas apropiadamente.

Nombre[editar]
Al ponerle nombre a la lista, o a la seccin en la cual se incluya una lista, evite en lo posible
llamarla de una forma similar a "Lista de X elementos...", suele preferirse "X elementos" a
secas. El lector puede darse cuenta solo si est viendo una lista o texto desarrollado.

Introduccin[editar]
Ninguna lista debera ser slo la lista en s. Incluso si el nombre fuera claro en s mismo,
siempre se debe incluir una introduccin que presente y contextualice el tema de la lista,
enlace a los artculos relacionados y establezca las caractersticas de los campos utilizados
(si stos no fueran explcitos) y el criterio de inclusin.
En el caso de los artculos que incluyan listas, la seccin con la lista puede prescindir de
una introduccin si las secciones previas ya cumplen dicha funcin, por ejemplo en el caso
de un artculo sobre un disco musical, que seguramente incluir la lista de canciones.

Contenido[editar]
El contenido de una lista debe respetar las polticas de contenido de Wikipedia

Lo que Wikipedia no es[editar]

Artculo principal: Wikipedia:Lo que Wikipedia no es

Una lista no debe tener elementos asociados libremente o sin un criterio claro. En
consecuencia, las listas no deberan incluir secciones como "otros" o "miscelnea".
Las listas de citas, material multimedia o documentos en el dominio pblico no se escriben
en Wikipedia sino en sus proyectos hermanos, Wikiquote, Commons y Wikisource.
No se aceptan las listas de enlaces externos, sino slo a un nmero reducido de enlaces
principales. Sin embargo, cuando un artculo se redacta a partir de informacin consultada
en varias pginas de internet fiables diferentes, s es aceptable crear una lista de tales
enlaces pero en forma de notas al pie.

Punto de vista neutral[editar]

Artculo principal: Wikipedia:Punto de vista neutral

El criterio de inclusin de la lista debe basarse en hechos o en caractersticas claras de los

elementos, no pudiendo estar sujetos a las opiniones subjetivas de los redactores. Los
criterios que recurran a palabras como "importantes", "distinguidos", "mejores" u otros
juicios de valor deben reformularse o retirarse.
Asimismo, si el criterio fuese controvertido y generase disputas sobre si es o no aplicable a
cada elemento en concreto, no es un buen criterio. Incluso aunque se incluyeran las debidas

referencias de quin considera que el elemento cumple el criterio y quin considera que no,
la misma inclusin o exclusin de elementos en la lista podra ser objetada.

Verificabilidad[editar]
Artculos principales: Wikipedia:Verificabilidad y Wikipedia:Wikipedia no es una
fuente primaria.

Los datos reflejados en las listas, ya sean parte del criterio de inclusin o informacin
relacionada con cada elemento, deben poder ser consultables en fuentes externas a
Wikipedia. Si por ejemplo se ordena un grupo de ciudades por poblacin, debe indicarse de
dnde se obtuvo dicha informacin. Las fuentes que permiten verificar a todos los
elementos de la tabla (aunque sea slo uno de los varios campos de todos los elementos)
son preferibles al ingreso individual de referencias por cada elemento, especialmente en el
caso de tablas ordenadas.
Asimismo, los criterios de inclusin no pueden basarse en anlisis personales o
interpretaciones no refrendadas por ninguna fuente.

Nivel de detalle[editar]
An aplicando las polticas mencionadas, los criterios a partir de los cuales se podran crear
listas son infinitos, slo limitables por la imaginacin.
Una lista abierta es una lista con un criterio lo bastante abierto o general tal que
posiblemente nunca llegue a estar completa y siempre sea suceptible de tener ms
elementos. Por ejemplo, una lista de polticos: Cuntos polticos puede haber en el
mundo? Aunque el que el criterio sea abierto no es en s un obstculo para la creacin de la
lista, las listas demasiado abiertas no son recomendables, ya que requeriran un
mantenimiento excesivo y seran enormemente ilegibles. En dichos casos se recomienda
acotar el criterio combinndolo con otros criterios ms especficos, que permitan listas ms
acotadas y con elementos ms homogneos entre s. Una categora puede ser tambin una
solucin alternativa o preferible a una lista abierta.
Una lista demasiado especfica y excesivamente corta, por su parte, tambin puede ser poco
recomendable. Puede ser preferible reformularla para ampliarla, o bien describir sus
elementos simplemente con texto, sin generar ninguna lista con ellos.

Listas desaconsejadas[editar]
Una lista debera consistir en elementos individualizables, concretos y anlogos entre s.
Cuando son conceptos generales, no delimitables, superpuestos entre s, u ordenados
simplemente por la forma en que se presenta la informacin, se prefiere no crear ninguna
lista y en lugar de ello explicarla con texto de corrido.
Una lista no debera crearse si se trata de:

Una lista creada slo por el acto en s de crear la lista

Una lista que rena informacin indiscriminadamente

Una lista cuyo criterio de inclusin no es verificable en fuentes

confiables, requiere asumir un punto de vista, realizar investigacin
original o interpretar libremente la informacin disponible.

Una lista cuyo concepto o criterio de inclusin no es relevante o

enciclopdico. Dicha relevancia es independiente de la de los elementos
de la lista

Una lista excesivamente abierta, o excesivamente especfica.

Una lista voltil por naturaleza, con elementos que entren y salgan de la
misma ms rpidamente de lo que fuera razonablemente posible
mantener.

Listas y categoras[editar]
Adems de las listas, los artculos pueden agruparse en categoras. Cada sistema tiene sus
propias ventajas y desventajas, por lo que cada caso debe analizarse por separado para
evaluar si se debera crear una lista, una categora o ambas cosas.
Una lista permite aadir notas a cada entrada, diagramar sus elementos repartiendo
informacin en varias columnas, y seguir un orden cronolgico o estructurado de fcil
comprensin. Tambin permite crear listas con elementos que an no tengan escrito un
artculo propio, o con elementos que no justifiquen artculos individuales. Adems,
permiten verificar en el historial qu elementos fueron aadidos y retirados, por quin y
cundo, lo cual es imposible de realizar con categoras. Asimismo, los nombres con
aclaraciones en su ttulo (debido a la existencia de otros artculos que puedan usar el mismo
nombre, tales como Semana Trgica (Argentina) y Semana Trgica (Espaa)) pueden ser
modificados al realizar el enlace, de forma que al leer la lista se lea slo el nombre,
mientras que la categora muestra el ttulo exactamente como fue escrito.
Pero, por otra parte, no garantizan el enlace mutuo (la lista enlaza a sus elementos, pero los
elementos no necesariamente a la lista) y no suele facilitar la navegacin a travs de temas
ms complejos o ms especficos como permiten las supercategoras y subcategoras de
cada categora. Una buena lista requiere determinar y aplicar un criterio de ordenamiento,
mientras que una categora se limita a ordenar automticamente por orden alfabtico.
Adems, la correccin, aadido o substraccin de elementos de una lista mediante un bot es
mucho ms elaborada que la tarea anloga en una categora.

Anexos y artculos con listas[editar]

En general, una lista puede estar localizada en un anexo o en un artculo. El criterio general
para decidir si la pgina en cuestin debera permanecer en uno u otro espacio de nombres
es el contenido que haya adems de la lista.
Si lo nico que hay, adems de la lista en s, es una simple contextualizacin y definicin
del criterio de la lista, entonces seguramente debera pertenecer al espacio de nombres
Anexo. Si, en cambio, omitiendo la lista se dispone de un artculo coherente y cohesionado,
aunque incompleto sin la lista, entonces es un artculo con una lista. Si el artculo se
sostiene por mrito propio y puede considerarse razonablemente completo incluso sin la
lista, pero la lista en s es legtima, entonces dicha lista debera ser desprendida del artculo
y llevada a un anexo.
Las pginas pueden ser trasladadas de uno a otro espacio de nombres segn el caso. Una
lista que figure en el espacio principal y presente las condiciones de un anexo puede ser
trasladada a dicho espacio, mientras que un anexo que fuera reescrito y alcanzara la
elaboracin propia de un artculo con lista podra ser trasladado a dicho espacio.

Estilos de listas[editar]
La siguiente es una lista de los estilos CSS y plantillas que los implementan definidos para
mostrar listas:

Lista horizontal[editar]

clase CSS: hlist

plantilla: {{lista plana}}

Ejemplos
Descripcin

Uso con la plantilla {{lista plana}}

Uso normalmente en una plantilla

Cdigo

Resultado

{{lista plana|
* entrada1
* entrada2
* entrada3
* entrada4
* entrada5
}}

entrada1
entrada2
entrada3
entrada4
entrada5

<div
class="hlist">
* entrada1
* entrada2
* entrada3
</div>

entrada1
entrada2
entrada3
[Contraer]

{{campaa
militar|
batallas=
Uso en una plantilla que ya tiene definido * entrada1
* entrada2
el estilo hlist por defecto
* entrada3
}}

{{{nomb
re}}}

entrada1

entrada2

entrada3

Para mostrar la lista con guiones separando las entradas basta editar el CSS personal
definido en las preferencias y aadir:
.hlist li:after {
content: " ";
}

Lista vertical sin vietas[editar]

clase CSS: plainlist

plantillas: {{lista simple}} y {{lista sin vietas}}. El uso de las

plantillas est desaconsejado porque normalmente es posible modificar
el cdigo de la ficha donde se incluye la lista sin vietas haciendo que
utilice la clase plainlist de forma que baste escribir algo de la forma:

* entrada1
* entrada2
* entrada3

Ejemplos
Cdigo

{{lista simple|
* entrada1
* entrada2
* entrada3
* entrada4
* entrada5
}}

Resulta
do
en
trada1
en
trada2
en
trada3
en
trada4
en
trada5
en
trada1

{{lista sin vietas|entrada1|entrada2|entrada3|entrada4|

entrada5}}

en
trada2
en
trada3
en
trada4
en
trada5

<div class="plainlist">
* entrada1
* entrada2
* entrada3
</div>

entrada1 </br>
entrada2 </br>
entrada3
Operaciones bsicas de las listas

en
trada1
en
trada2
en
trada3

entrada1
entrada2
entrada3

En toda estructura de datos hay dos operaciones que sobresalen por encima del resto: Insertar y
borrar. Estas dos operaciones aparecern en toda estructura de datos, puede que con otro nombre, o
con una funcionalidad ligeramente diferente, pero su filosofa ser la misma, proporcionar unas
operaciones para la construccin de la estructura de datos.

Insertar
La operacin insertar consiste en la introduccin de un nuevo elemento en la lista.
En una lista no ordenada no es necesario mantener ningn orden, por lo tanto la insercin de
elementos se puede realizar en cualquier lugar de la lista, al principio, al final, en una posicin
aleatoria, ...
Generalmente se realiza la insercin de tal forma que la complejidad temporal sea mnima, es decir,
que sea una operacin sencilla para que se realice en el menor tiempo posible. La operacin ms
sencilla depende de la implementacin de la estructura de datos, en unos casos puede ser la insercin
al inicio, en otros la insercin al final y en este caso la insercin la realiza en el segundo nodo de la
lista.
Si tenemos la lista...

... e insertamos el elemento 0, la lista quedara de la siguiente forma:

Borrar
La operacin borrar consiste en la eliminacin de la lista de un elemento concreto. El elemento a
borrar ser escogido por el programador.
La eliminacin en una lista no conlleva ningn trabajo adicional ms que el propio de la eliminacin del
elemento en s. Para borrar un elemento cualquiera habra que realizar un recorrido secuencial de la
lista hasta encontrar el nodo buscado y una vez localizado reestructurar los punteros para saltarse el
nodo a borrar y as poder eliminarlo.
Vamos a verlo con un ejemplo. Borrado del elemento 76 en la lista anterior:
Paso 1: Localizar el elemento a borrar.

Paso 2: Reestructurar punteros y eliminar nodo.

Otras operaciones
A partir de estas dos operaciones bsicas cada lista puede presentar muchas operaciones diferentes,
vamos a comentar algunas de ellas, dejando claro que las dos bsicas que siempre aparecern son las
anteriores.

Tamao: Esta operacin suele informar sobre el nmero de elementos que tiene en ese
instante la lista.

Buscar: Comprueba si existe un determinado elemento en la lista.

Recorrer lista: Recorre toda la lista, realizando una operacin en cada nodo. Por ejemplo,
mostrar el contenido por pantalla.

Pila (informtica)
Una pila (stack en ingls) es una lista ordenada 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. Esta estructura se aplica en multitud de ocasiones en el
rea de informtica debido a su simplicidad y ordenacin implcita de la
propia estructura.
Para el manejo de los datos se cuenta con dos operaciones bsicas:
apilar, que coloca un objeto en la pila, y su operacin inversa, retirar
(o desapilar, pop), que retira el ltimo elemento apilado.
En cada momento slo se tiene acceso a la parte superior de la pila, es
decir, al ltimo objeto apilado (denominado TOS, Top of Stack en ingls).
La operacin retirar permite la obtencin de este elemento, que es
retirado de la pila permitiendo el acceso al siguiente (apilado con
anterioridad), que pasa a ser el nuevo TOS.
Por analoga con objetos cotidianos, una operacin apilar equivaldra a
colocar un plato sobre una pila de platos, y una operacin retirar a
retirarlo.
Las pilas suelen emplearse en los siguientes contextos:
Evaluacin de expresiones en notacin postfija (notacin polaca inversa).
Reconocedores sintcticos de lenguajes independientes del contexto
Implementacin de recursividad.
Operaciones con las pilas
Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a
las que en las implementaciones modernas de las pilas se suelen aadir
ms de uso habitual.
Crear: se crea la pila vaca. (constructor)
Tamao: regresa el nmero de elementos de la pila. (size)
Apilar: se aade un elemento a la pila.(push)
Desapilar: se elimina el elemento frontal de la pila.(pop)
Cima: devuelve el elemento que esta en la cima de la pila. (top o peek)
Vaca: devuelve cierto si la pila est sin elementos o falso en caso de
que contenga uno. (empty).