Está en la página 1de 20

Estructura de datos Unidad 3.

- Listas enlazadas
Listas Enlazadas
o
Lista de Enlace Simple
o
Los Algoritmos de Concatenacin e Inversin
o
Lista Doblemente Enlazada
Algoritmo de Insercin-Ordenada
o
Lista de Enlace Circular
o
Listas Enlazadas frente a Arrays
Listas Enlazadas
Adems de los arrays! otra de las estructuras de datos muy utilizada es la lista enlazada" Esta estructura
implica cuatro conceptos# clase auto-refenciada! nodo! campo de enlace y enlace"
Clase auto-referenciada: una clase con al menos un campo cuyo tipo de referencia es el nombre de
la clase#
class Employee {
private int empno;
private String name;
private double salary;
public Employee next;

// Other members
}
Employee
es una clase auto-referenciada por$ue su campo
next
tiene el tipo
Employee
"
Nodo: un ob%eto creado desde una clase auto-referenciada"
Campo de enlace: un campo cuyo tipo de referencia es el nombre de la clase" En el fragmento de
cdigo anterior!
next
es un campo de enlace" &or el contrario!
empno
!
name
! y
salary
son campos
no de enlace"
Enlace: la referencia a un campo de enlace" En el fragmento de cdigo anterior! la referencia
next
a
un nodo
Employee
es un enlace"
Los cuatro conceptos de arriba nos llevan a la siguiente definicin# una lista enlazada es una secuencia de
nodos que se interconectan mediante sus campos de enlace" En ciencia de la computacin se utiliza una
notacin especial para ilustrar las listas enlazadas" En la siguiente imagen aparece una variante de esta
notacin $ue utilizar' a lo largo de esta seccin#
1
Estructura de datos Unidad 3.- Listas enlazadas
La figura anterior presenta tres nodos# A! ( y C" Cada nodo se divide en reas de contenido )en naran%a* y
una o ms reas de enlace )en verde*" Las reas de contenido representan todos los campos $ue no son
enlaces! y cada rea de enlace representa un campo de enlace" Las reas de enlace de A y C tienen unas
flec+as para indicar $ue referencian a otro nodo del mismo tipo )o subtipo*" La ,nica rea de enlace de (
incorpora una - para indicar una referencia nula" En otras palabras! ( no est conectado a ning,n otro
nodo"
Aun$ue se pueden crear muc+os tipos de listas enlazadas! las tres variantes ms populares son la lista de
enlace simple! la lista doblemente enlazada y la lista enlazada circular" E.ploremos esas variantes!
empezando con la lista enlazada"
Lista de Enlace Simple
/na lista de enlace simple es una lista enlazada de nodos! donde cada nodo tiene un ,nico campo de
enlace" /na variable de referencia contiene una referencia al primer nodo! cada nodo )e.cepto el ,ltimo*
enlaza con el nodo siguiente! y el enlace del ,ltimo nodo contiene
null
para indicar el final de la lista"
Aun$ue normalmente a la variable de referencia se la suele llamar
top
! usted puede elegir el nombre $ue
$uiera" La siguiente figura presenta una lista de enlace simple de tres nodos! donde
top
referencia al nodo
A! A conecta con ( y ( conecta con C y C es el nodo final#
/n algoritmo com,n de las listas de enlace simple es la insercin de nodos" Este algoritmo est implicado
de alguna forma por$ue tiene muc+o $ue ver con cuatro casos# cuando el nodo se debe insertar antes
del primer nodo; cuando el nodo se debe insertar despus del ltimo nodo; cuando el nodo se debe
insertar entre dos nodos; y cuando la lista de enlace simple no existe" Antes de estudiar cada caso
consideremos el siguiente pseudocdigo#
DECL!E CLSS "ode
DECL!E S#!$"% name
DECL!E "ode next
E"D DECL!E
DECL!E "ode top & "'LL
Este pseudocdigo declara una clase auto-referenciada llamada
"ode
con un campo llamado
name
y un
campo de enlace llamado
next
" 0ambi'n declara una variable de referencia
top
)del tipo
"ode
* $ue
contiene una referencia al primer
"ode
de una lista de enlace simple" Como la lista todav1a no e.iste! el
valor inicial de
top
es
"'LL
" Cada uno de los siguientes cuatro casos asume las declaraciones de
"ode
y
top
#
La lista de enlace simple no existe:
Este es el caso ms simple" Se crea un
"ode
! se asigna su referencia a
top
! se inicializa su campo no
de enlace! y se asigna
"'LL
a su campo de enlace" El siguiente pseudocdigo realiza estas tareas#
top & "E( "ode
top)name & **
top)next & "'LL
2
Estructura de datos Unidad 3.- Listas enlazadas
En la siguiente imagen se puede ver la lista de enlace simple $ue emerge del pseudocdigo anterior#
El nodo debe insertarse antes del primer nodo:
Se crea un
"ode
! se inicialia su campo no de enlace! se asigna la referencia de
top
al campo de enlace
next
! y se asigna la referencia del
"ode
recien creado a
top
" El siguiente pseudocdigo )$ue asume
$ue se +a e%ecutado el pseudocdigo anterior* realiza estas tareas#
DECL!E "ode temp
temp & "E( "ode
temp)name & *+*
temp)next & top
top & temp
El resultado del listado anterior aparece en la siguiente imagen#
El nodo debe insertarse detrs del ltimo nodo:
Se crea un
"ode
! se inicializa su campo no de enlace! se asigna
"'LL
al campo de enlace! se atraviesa
la lista de enlace simple +asta el ,ltimo
"ode
! y se asigna la referencia del
"ode
recien creado al campo
next
del ,ltimo nodo" El siguiente pseudocdigo realiza estas tareas#
temp & "E( "ode
temp)name & *C*
temp)next & "'LL
DECL!E "ode temp,
temp, & top
// (e assume top -and temp,. are not "'LL
// because o/ the previous pseudocode
(0$LE temp,)next $S "O# "'LL
temp, & temp,)next
E"D (0$LE
// temp, no1 re/erences the last node
temp,)next & temp
3
Estructura de datos Unidad 3.- Listas enlazadas
La siguiente imagen revela la lista despu's de la insercin del nodo
C
despu's del nodo

"
El nodo se debe insertar entre dos nodos:
Este es el caso ms comple%o" Se crea un
"ode
! se inicializa su campo no de enlace! se atraviesa la
lista +asta encontrar el
"ode
$ue aparece antes del nuevo
"ode
! se asigna el campo de enlace del
"ode
anterior al campo de enlace del
"ode
recien creado! y se asigna la referencia del
"ode
recien
creado al campo del enlace del
"ode
anterior" El siguiente pseudocdigo realiza estas tareas#
temp & "E( "ode
temp)name & *D*
temp, & top
// (e assume that the ne1ly created "ode is inserted a/ter "ode
// and that "ode exists) $n the real 1orld2 there is no
// guarantee that any "ode exists2 so 1e 1ould need to chec3
// /or temp, containing "'LL in both the (0$LE loop4s header
// and a/ter the (0$LE loop completes)
(0$LE temp,)name $S "O# **
temp, & temp,)next
E"D (0$LE
// temp, no1 re/erences "ode )
temp)next & temp,)next
temp,)next & temp
La siguiente imagen muestra la insercin del nodo
D
entre los nodos

y
C
"
El siguiente listado presenta el e$uivalente 2ava de los e%emplos de pseudocdigo de inserccin anteriores#
// SLL$nsDemo)5ava
class SLL$nsDemo {
static class "ode {
String name;
"ode next;
}
4
Estructura de datos Unidad 3.- Listas enlazadas
public static void main -String 67 args. {
"ode top & null;
// 8) #he singly lin3ed list does not exist
top & ne1 "ode -.;
top)name & **;
top)next & null;
dump -*Case 8*2 top.;
// ,) #he singly lin3ed list exists2 and the node must be inserted
// be/ore the /irst node
"ode temp;
temp & ne1 "ode -.;
temp)name & *+*;
temp)next & top;
top & temp;
dump -*Case ,*2 top.;
// 9) #he singly lin3ed list exists2 and the node must be inserted
// a/ter the last node
temp & ne1 "ode -.;
temp)name & *C*;
temp)next & null;
"ode temp,;
temp, & top;
1hile -temp,)next :& null.
temp, & temp,)next;
temp,)next & temp;
dump -*Case 9*2 top.;
// ;) #he singly lin3ed list exists2 and the node must be inserted
// bet1een t1o nodes
temp & ne1 "ode -.;
temp)name & *D*;
temp, & top;
1hile -temp,)name)e<uals -**. && /alse.
temp, & temp,)next;
temp)next & temp,)next;
5
Estructura de datos Unidad 3.- Listas enlazadas
temp,)next & temp;
dump -*Case ;*2 top.;
}
static void dump -String msg2 "ode top"ode. {
System)out)print -msg = * *.;
1hile -top"ode :& null. {
System)out)print -top"ode)name = * *.;
top"ode & top"ode)next;
}
System)out)println -.;
}
}
El m'todo
static void dump-String msg2 "ode top"ode.
itera sobre la lista e imprime su
contenido" Cuando se e%ecuta
SLL$nsDemo
! las repetidas llamadas a este m'todo dan como resultado la
siguiente salida! lo $ue coincide con las imgenes anteriores#
Case 8
Case , +
Case 9 + C
Case ; + D C
Nota:
SLL$nsDemo y los e%emplos de pseudocdigo anteriores empleaban un algoritmo de b,s$ueda lineal
orientado a listas enlazadas para encontrar un "ode espec1fico" Indudablemente usted utilizar este otro
algoritmo en sus propios programas#
Bsqueda del ultimo Node:
// ssume top re/erences a singly lin3ed list o/ at least one "ode)
"ode temp & top // (e use temp and not top) $/ top 1ere used2 1e
// couldn4t access the singly lin3ed list a/ter
// the search /inished because top 1ould re/er
// to the /inal "ode)
(0$LE temp)next $S "O# "'LL
temp & temp)next
E"D (0$LE
// temp no1 re/erences the last "ode)
Bsqueda de un Node especfico:
// ssume top re/erences a singly lin3ed list o/ at least one "ode)
"ode temp & top
(0$LE temp $S "O# "'LL "D temp)name $S "O# ** // Search /or **)
6
Estructura de datos Unidad 3.- Listas enlazadas
temp & temp)next
E"D (0$LE
// temp either re/erences "ode or contains "'LL i/ "ode not /ound)
Otro algoritmo com,n de las listas de enlace simples es el borrado de nodos" Al contrario $ue la insercin de
nodos! slo +ay dos casos a considerar#
Borrar el rimer nodo:
Asigna el enlace del campo
next
del nodo referenciado por
top
a
top
#
top & top)next; // !e/erence the second "ode -or "'LL i/ there is only one
"ode.
La siguiente imagen presenta las vistas anterior y posterior de una lista donde se +a borrado el
primer nodo" En esta figura! el nodo
+
desaparece y el nodo

se convierte en el primer nodo"


Borrar cualquier nodo que no sea el primero:
Localiza el nodo $ue precede al nodo a borrar y le asigna el enlace $ue +ay en el campo
next
del nodo
a borrar al campo
next
del nodo $ue le precede" El siguiente pseudocdigo borra el nodo
D
#
temp & top
(0$LE temp)name $S "O# **
temp & temp)next
E"D (0$LE
// (e assume that temp re/erences "ode
temp)next & temp)next)next
// "ode D no longer exists
La siguiente figura presenta las vistas anterior y posterior de una lista donde se +a borrado un nodo
intermedio" En esa figura el nodo
D
desaparece"
7
Estructura de datos Unidad 3.- Listas enlazadas
El siguiente listado representa el e$uivalente 2ava a los pseudocdigos de borrado anteriores#
// SLLDelDemo)5ava
class SLLDelDemo {
static class "ode {
String name;
"ode next;
}
public static void main -String 67 args. {
// +uild >igure ?4s singly lin3ed list -i)e)2 + D C.
"ode top & ne1 "ode -.;
top)name & *C*;
top)next & null;
"ode temp & ne1 "ode -.;
temp)name & *D*;
temp)next & top;
top & temp;
temp & ne1 "ode -.;
temp)name & **;
temp)next & top;
top & temp;
temp & ne1 "ode -.;
temp)name & *+*;
temp)next & top;
top & temp;
dump -*$nitial singly@lin3ed list*2 top.;
8
Estructura de datos Unidad 3.- Listas enlazadas
// 8) Delete the /irst node
top & top)next;
dump -*/ter /irst node deletion*2 top.;
// Aut bac3 +
temp & ne1 "ode -.;
temp)name & *+*;
temp)next & top;
top & temp;
// ,) Delete any node but the /irst node
temp & top;
1hile -temp)name)e<uals -**. && /alse.
temp & temp)next;
temp)next & temp)next)next;
dump -*/ter D node deletion*2 top.;
}
static void dump -String msg2 "ode top"ode. {
System)out)print -msg = * *.;
1hile -top"ode :& null. {
System)out)print -top"ode)name = * *.;
top"ode & top"ode)next;
}
System)out)println -.;
}
}
Cuando e%ecute
SLLDelDemo
! observar la siguiente salida#
$nitial singly lin3ed list + D C
/ter /irst node deletion D C
/ter D node deletion + C
Cuidado:
Como %ava inicializa los campos de referencias de un ob%eto a null durante la construccin del ob%eto! no
es necesario asignar e.pl1citamente null a un campo de enlace" 3o olvide estas asignaciones de null en
su cdigo fuente4 su ausencia reduce la claridad del cdigo"
Despu's de estudiar
SLLDelDemo
! podr1a preguntarse $u' sucede si asigna
null
al nodo referenciado por
top
# 5El recolector de basura recoger toda la lista6 &ara responder a esta cuestin! compile y e%ecute el
cdigo del siguiente listado#
9
Estructura de datos Unidad 3.- Listas enlazadas
// %CDemo)5ava
class %CDemo {
static class "ode {
String name;
"ode next;
protected void /inaliBe -. thro1s #hro1able {
System)out)println -*>inaliBing * = name.;
super)/inaliBe -.;
}
}
public static void main -String 67 args. {
// +uild >igure ?4s singly lin3ed list -i)e)2 + D C.
"ode top & ne1 "ode -.;
top)name & *C*;
top)next & null;
"ode temp & ne1 "ode -.;
temp)name & *D*;
temp)next & top;
top & temp;
temp & ne1 "ode -.;
temp)name & **;
temp)next & top;
top & temp;
temp & ne1 "ode -.;
temp)name & *+*;
temp)next & top;
top & temp;
dump -*$nitial singly@lin3ed list*2 top.;
top & null;
temp & null;
/or -int i & C; i D 8CC; i==.
System)gc -.;
}
static void dump -String msg2 "ode top"ode. {
System)out)print -msg = * *.;
1hile -top"ode :& null.{
System)out)print -top"ode)name = * *.;
top"ode & top"ode)next;
}
System)out)println -.;
}
}
10
Estructura de datos Unidad 3.- Listas enlazadas
%CDemo
crea la misma lista de cuatro nodos $ue
SLLDelDemo
" Despu's de volcar los nodos a la salida
estndar!
%CDemo
asigna
null
a
top
y a
temp
" Luego!
%CDemo
e%ecuta
System)gc -.;
+asta 788 veces"
59u' sucede despu's6 :ire la salida )$ue +e observado en mi plataforma ;indo<s*#
$nitial singly@lin3ed list + D C
>inaliBing C
>inaliBing D
>inaliBing
>inaliBing +
La salida revela $ue todos los nodos de la lista de enlace simple +an sido finalizados )y recolectados*" Como
resultado! no tiene $ue preocuparse de poner a
null
todos los enlaces de una lista de enlace simple
cuando se $uiera des+acer de ella" )&odr1a necesitar tener $ue incrementar el n,mero de e%ecuciones de
System)gc -.;
si su salida no incluye los mensa%es de finalizacin"*
Los !l"oritmos de Concatenaci#n e $n%ersi#n
E.isten muc+os algoritmos ,tiles para listas de enlace simple" /no de ellos es la concatenacin! $ue implica
$ue puede a=adir una lista de enlace simple al final de otra lista"
Otro algoritmo ,til es la inversin" Este algoritmo invierte los enlaces de una lista de enlace simple
permitiendo atravesar los nodos en direccin opuesta" El siguiente cdigo e.tiende la clase anterior para
invertir los enlaces de la lista referenciada por
top8
#
// C$Demo5ava
class C$Demo {

static class DictEntry {
String 1ord;
String meaning;
DictEntry next;
}
// List$n/o is necessary because buildList-. must return t1o pieces
// o/ in/ormation
static class List$n/o {
DictEntry top;
DictEntry last;
}
public static void main -String 67 args. {
String 67 1ordsEaster & { *aardvar3*2 *anxious*2 *asterism* };
List$n/o liEaster & ne1 List$n/o -.;
buildList -liEaster2 1ordsEaster.;
dump -*Easter list &*2 liEaster)top.;
String 67 1ords(or3ing & { *carbuncle*2 *cat/ish*2 *color* };
List$n/o li(or3ing & ne1 List$n/o -.;
buildList -li(or3ing2 1ords(or3ing.;
11
Estructura de datos Unidad 3.- Listas enlazadas
dump -*(or3ing list &*2 li(or3ing)top.;
// Aer/orm the concatenation
liEaster)last)next & li(or3ing)top;
dump -*"e1 master list &*2 liEaster)top.;
invert -liEaster.;
dump -*$nverted ne1 master list &*2 liEaster)top.;
}
static void buildList -List$n/o li2 String 67 1ords. {
i/ -1ords)length && C.
return;

// Create a node /or /irst 1ord/meaning
li)top & ne1 DictEntry -.;
li)top)1ord & 1ords 6C7;
li)top)meaning & null;
// $nitialiBe last re/erence variable to
// simpli/y append and ma3e concatenation possible)
li)last & li)top;
/or -int i & 8; i D 1ords)length; i==. {
// Create -and append. a ne1 node /or next 1ord/meaning
li)last)next & ne1 DictEntry -.;
li)last)next)1ord & 1ords 6i7;
li)last)next)meaning & null;
// dvance last re/erence variable to simpli/y
// append and ma3e concatenation possible
li)last & li)last)next;
}
li)last)next & null;
}
static void dump -String msg2 DictEntry topEntry. {
System)out)print -msg = * *.;
1hile -topEntry :& null. {
System)out)print -topEntry)1ord = * *.;
topEntry & topEntry)next;
}
System)out)println -.;
}
static void invert -List$n/o li. {
DictEntry p & li)top2 < & null2 r;
12
Estructura de datos Unidad 3.- Listas enlazadas
1hile -p :& null. {
r & <;
< & p;
p & p)next;
<)next & r;
}
li)top & <;
}
}
C$Demo
declara un
DictEntry
anidado en la clase de ms alto nivel cuyos ob%etos contienen palabras y
significados" )&ara mentener el programa lo ms sencillo posible! +e evitado los significados" /sted puede
a=adirlos si lo desea*"
C$Demo
tambi'n declara
List$n/o
para seguir las referencias el primero y ,ltimo
DictEntry
de una lista de enlace simple"
El t+read principal e%ecuta el m'todo
public static void main-String 67 args.
de
C$Demo
" Este
t+read llama dos veces al m'todo
static void buildList -List$n/o li2 String 67 1ords.

para crear dos listas de enlace simple# una lista maestra )cuyos nodos se rellenan con palabras del array
1ordsEaster
*! y una lista de traba%o )cuyos nodos se rellenan con palabras del array
1ords(or3ing
*"
Antes de cada llamada al m'todo
buildList -List$n/o li2 String 67 1ords.
! el t+read principal
crea y pasa un ob%eto
List$n/o
" este ob%eto devuelve las referencias al primero y ,ltimo nodo" )/na
llamada a m'todo devuelve directamente un slo dato*" Despu's de construir una lista de enlace simple! el
t+read principal llama a
static void dump -String msg2 DictEntry topEntry.
para volcar un
mensa%e y las palabras de los nodos de una lista en el dispositivo de salida estndar"
Se podr1a estar preguntando sobre la necesidad del campo
last
de
List$n/o
" Este campo sirve a un
doble propsito# primero! simplifica la creacin de cada lista! donde se a=aden los nodos" Segundo! este
campo simplifica la concatenacin! $ue se $ueda slo en la e%ecucin de la siguiente l1nea de cdigo#
liEaster)last)next & li(or3ing)top;
" /na vez $ue se completa la concatenacin! y el t+read
principal vuelva los resultados de la lista maestra en la salida estndar! el t+read llama al m'todo
static
void invert -List$n/o li.
para invertir la lista maestra y luego muestra la lista maestra invertida por
la salida estndar"
Cuando e%ecute
C$Demo
ver la siguiente salida#
Easter list & aardvar3 anxious asterism
(or3ing list & carbuncle cat/ish color
"e1 master list & aardvar3 anxious asterism carbuncle cat/ish color
$nverted ne1 master list & color cat/ish carbuncle asterism anxious aardvar3
Lista &oblemente Enlazada
Las listas de enlace simple restringen el movimiento por lo nodos a una sola direccin# no puede atravesar
una lista de enlace simple en direccin opuesta a menos $ue primero utilice el algoritmo de inversin para
invertir los enlaces de los nodos! lo $ue lleva tiempo" Despu's de atravesarlos en direccin opuesta!
probablemente necesitar repetir la inversin para restaurar el orden original! lo $ue lleva a,n ms tiempo"
/n segundo problema implica el borrado de nodos# no puede borrar un nodo arbitrario sin acceder al
predecesor del nodo" Estos problemas desaparecen cuando se utiliza una lista doblemente enlazada"
/na lista doblemente enlazada es una lista enlazada de nodos! donde cada nodo tiene un par de campos de
enlace" /n campo de enlace permite atravesar la lista +acia adelante! mientras $ue el otro permite atravesar
la lista +acia atrs" &ara la direccin +acia adelante! una variable de referencia contiene una referencia al
13
Estructura de datos Unidad 3.- Listas enlazadas
primer nodo" Cada nodo se enlaza con el siguiente mediante el campo de enlace
next
! e.cepto el ,ltimo
nodo! cuyo campo de enlace
next
contiene
null
para indicar el final de la lista )en direccin +acia
adelante*" De forma similar! para la direccin contraria! una variable de referencia contiene una referencia al
,ltimo nodo de la direccin normal )+acia adelante*! lo $ue se interpreta como el primer nodo" Cada nodo se
enlaza con el anterior mediante el campo de enlace
previous
! y el primer nodo de la direccin +acia
adelante! contiene
null
en su campo
previous
para indicar el fin de la lista" La siguiente figura representa
una lista doblemente enlazada de tres nodos! donde
top>or1ard
referencia el primer nodo en la direccin
+acia adelante! y
top+ac31ard
referencia el primero nodo la direccin inversa"
'ruco:
&iense en una lista doblemente enlazada como una pare%a de listas de enlace simple $ue interconectan los
mismos nodos"
La insercin y borrado de nodos en una lista doblemente enlazada son operaciones comunes" Estas
operaciones se realizan mediante algoritmos $ue se basan en los algoritmos de insercin y borrado de las
listas de enlace simple )por$ue las listas doblemente enlazadas slo son una pare%a de listas de enlace
simple $ue interconectan los mismos nodos*"
El siguiente listado muestra la insercin de nodos para crear la lista de la figura anterior! el borrado de nodos
ya $ue elimina el nodo
+
de la lista! y el movimiento por la lista en ambas direcciones#
// DLLDemo)5ava
class DLLDemo {
static class "ode {
String name;
"ode next;
"ode prev;
}
public static void main -String 67 args. {
// +uild a doubly lin3ed list
"ode top>or1ard & ne1 "ode -.;
14
Estructura de datos Unidad 3.- Listas enlazadas
top>or1ard)name & **;
"ode temp & ne1 "ode -.;
temp)name & *+*;
"ode top+ac31ard & ne1 "ode -.;
top+ac31ard)name & *C*;
top>or1ard)next & temp;
temp)next & top+ac31ard;
top+ac31ard)next & null;
top+ac31ard)prev & temp;
temp)prev & top>or1ard;
top>or1ard)prev & null;
// Dump /or1ard singly lin3ed list
System)out)print -*>or1ard singly@lin3ed listF *.;
temp & top>or1ard;
1hile -temp :& null.{
System)out)print -temp)name.;
temp & temp)next;
}
System)out)println -.;
// Dump bac31ard singly lin3ed list
System)out)print -*+ac31ard singly@lin3ed listF *.;
temp & top+ac31ard;
1hile -temp :& null.{
System)out)print -temp)name.;
temp & temp)prev;
}
System)out)println -.;
// !e/erence node +
temp & top>or1ard)next;
// Delete node +
temp)prev)next & temp)next;
temp)next)prev & temp)prev;
// Dump /or1ard singly lin3ed list
System)out)print -*>or1ard singly@lin3ed list -a/ter deletion.F *.;
15
Estructura de datos Unidad 3.- Listas enlazadas
temp & top>or1ard;
1hile -temp :& null.{
System)out)print -temp)name.;
temp & temp)next;
}
System)out)println -.;
// Dump bac31ard singly lin3ed list
System)out)print -*+ac31ard singly@lin3ed list -a/ter deletion.F *.;
temp & top+ac31ard;
1hile -temp :& null.{
System)out)print -temp)name.;
temp & temp)prev;
}
System)out)println -.;
}
}
Cuando se e%ecuta!
DLLDemo
produce la siguiente salida#
>or1ard singly@lin3ed listF +C
+ac31ard singly@lin3ed listF C+
>or1ard singly@lin3ed list -a/ter deletion.F C
+ac31ard singly@lin3ed list -a/ter deletion.F C
!l"oritmo de $nserci#n-(rdenada
Algunas veces $uerr crear una lista doblemente enlazada $ue organice el orden de sus nodos basndose
en un campo no de enlace" Atravesar la lista doblemente enlazada en una direccin presenta esos nodos en
orden ascendente! y atravesarla en direccin contraria los presenta ordenados descendentemente" El
algoritmo de ordenacin de burbu%a es inapropiado en este caso por$ue re$uiere 1ndices de array" &or el
contrario! insercin-ordenada construye una lista de enlace simple o una lista doblemente enlazada
ordenadas por un campo no de enlace para identificar el punto de insercin de cada nuevo nodo" El
siguiente litado demuestra el algoritmo de insercin-ordenada#
// $nsSortDemo)5ava
class $nsSortDemo {
// "oteF #o 3eep Employee simple2 $4ve omitted various constructor and
// nonconstructor methods) $n practice2 such methods 1ould be present)
static class Employee {
int empno;
String name;

Employee next;
Employee prev;
}
16
Estructura de datos Unidad 3.- Listas enlazadas
public static void main -String 67 args. {
// Data /or a doubly lin3ed list o/ Employee ob5ects) #he lengths o/
// the empnos and names arrays must agree)
int 67 empnos & { ?GH2 9,I2 I?H2 8CC2 JGH2 ?I;2 ,9; };
String 67 names & { *pril*2 *Koan*2 *Kac3*2 *%eorge*2 *+rian*2 *Sam*2
*lice* };
Employee top>or1ard & null;
Employee top+ac31ard & null;
// Arime the doubly lin3ed list by creating the /irst node)
top>or1ard & ne1 Employee -.;
top>or1ard)empno & empnos 6C7;
top>or1ard)name & names 6C7;
top>or1ard)next & null;
top>or1ard)prev & null;
top+ac31ard & top>or1ard;
// $nsert remaining Employee nodes -in ascending order @@ via empno.
// into the doubly lin3ed list)
/or -int i & 8; i D empnos)length; i==. {
// Create and initialiBe a ne1 Employee node)
Employee e & ne1 Employee -.;
e)empno & empnos 6i7;
e)name & names 6i7;
e)next & null;
e)prev & null;
// Locate the /irst Employee node 1hose empno is greater than
// the empno o/ the Employee node to be inserted)
Employee temp & top>or1ard;
1hile -temp :& null LL temp)empno D& e)empno.
temp & temp)next;
// temp is either null -meaning that the Employee node must be
// appended. or not null -meaning that the Employee node must
// be inserted prior to the temp@re/erenced Employee node.)
i/ -temp && null. {

top+ac31ard)next & e; // ppend ne1 Employee node to
// /or1ard singly lin3ed list)

e)prev & top+ac31ard; // 'pdate bac31ard singly lin3ed
top+ac31ard & e; // list as 1ell)
}
else{
i/ -temp)prev && null. {
17
Estructura de datos Unidad 3.- Listas enlazadas
e)next & top>or1ard; // $nsert ne1 Employee node at
top>or1ard & e; // head o/ /or1ard singly lin3ed
// list)
temp)prev & e; // 'pdate bac31ard singly lin3ed
// list as 1ell)
}
else {
e)next & temp)prev)next; // $nsert ne1 Employee node
temp)prev)next & e; // a/ter last Employee node
// 1hose empno is smaller in
// /or1ard singly lin3ed list)
e)prev & temp)prev; // 'pdate bac31ard
temp)prev & e; //singly lin3ed list as 1ell)
}
}
}
// Dump /or1ard singly lin3ed list -ascending order.)
System)out)println -*scending orderFMn*.;
Employee temp & top>or1ard;
1hile -temp :& null. {
System)out)println -*6* = temp)empno = *2 * = temp)name = *7 *.;
temp & temp)next;
}
System)out)println -.;
// Dump bac31ard singly lin3ed list -descending order.)
System)out)println -*Descending orderFMn*.;

temp & top+ac31ard;
1hile -temp :& null. {
System)out)println -*6* = temp)empno = *2 * = temp)name = *7 *.;
temp & temp)prev;
}
System)out)println -.;
}
}
$nsSortDemo
simplifica su operacin creando primero un nodo
Employee
primario" &ara el resto de nodos
Employee
!
$nsSortDemo
localiza la posicin de insercin apropiada basndose en el campo no de enlace
empno
! y luego inserta el
Employee
en esa posicin" Cuando e%ecute
$nsSortDemo
! podr observar la
siguiente salida#
scending orderF
68CC2 %eorge7
6,9;2 lice7
69,I2 Koan7
6I?H2 Kac37
6?I;2 Sam7
18
Estructura de datos Unidad 3.- Listas enlazadas
6?GH2 pril7
6JGH2 +rian7
Descending orderF
6JGH2 +rian7
6?GH2 pril7
6?I;2 Sam7
6I?H2 Kac37
69,I2 Koan7
6,9;2 lice7
68CC2 %eorge7
0anto la insercin-ordenada como la ordenacin de burbu%a e.+iben prcticamente el mismo rendimiento"
Lista de Enlace Circular
El campo de enlace del ,ltimo nodo de una lista de enlace simple contiene un enlace nulo! ocurre lo mismo
en los campos de enlace del primer y ,ltimo elemento en ambas direcciones en las listas doblemente
enlazadas" Supongamos $ue en vez de esto los ,ltimos nodos contiene un enlace a los primeros nodos" En
esta situacin! usted terminar con una lista de enlace circular! como se ve en la siguiente figura#
Las listas de enlace circular se utilizan con frecuencia en procesamiento repetitivo de nodos en un orden
espec1fico" Dic+os nodos podr1an representar cone.iones de servidor! procesadores esperando una seccin
cr1tica! etc" Esta estructura de datos tambi'n sirve como base para una variante de una estructura de datos
ms comple%a# la cola"
Listas Enlazadas frente a !rra)s
Las listas enlazadas tienen las siguientes venta%as sobre los arrays#
3o re$uieren memoria e.tra para soportar la e.pansin" &or el contrario! los arrays re$uieren
memoria e.tra si se necesita e.pandirlo )una vez $ue todos los elementos tienen datos no se pueden
a=adir datos nuevos a un array*"
Ofrecen una insercin>borrado de elementos ms rpida $ue sus operaciones e$uivalentes en los
arrays" Slo se tienen $ue actualizar los enlaces despu's de identificar la posicin de
insercin>borrado" Desde la perspectiva de los arrays! la insercin de datos re$uiere el movimiento
de todos los otros datos del array para crear un elemento vac1o" De forma similar! el borrado de un
dato e.istente re$uiere el movimiento de todos los otros datos para eliminar el elemento vac1o"
En contraste! los arrays ofrecen las siguientes venta%as sobre las listas enlazadas#
Los elementos de los arrays ocupan menos memoria $ue los nodos por$ue no re$uieren campos de
enlace"
19
Estructura de datos Unidad 3.- Listas enlazadas
Los arrays ofrecen un acceso ms rpido a los datos! mediante 1ndices basados en enteros"
Las listas enlazadas son ms apropiadas cuando se traba%a con datos dinmicos" En otras palabras!
inserciones y borrados con frecuencia" &or el contrario! los arrays son ms apropiados cuando los datos son
estticos )las inserciones y borrados son raras*" De todas formas! no olvide $ue si se $ueda sin espacio
cuando a=ade 1tems a un array! debe crear un array ms grande! copiar los datos del array original el nuevo
array mayor y eliminar el original" Esto cuesta tiempo! lo $ue afecta especialmente al rendimiento si se +ace
repetidamente"
:ezclando una lista de enlace simple con un array uni-dimensional para acceder a los nodos mediante los
1ndices del array no se consigue nada" ?astar ms memoria! por$ue necesitar los elementos del array
ms los nodos! y tiempo! por$ue necesitar mover los 1tems del array siempre $ue inserte o borre un nodo"
Sin embargo! si es posible integrar el array con una lista enlazada para crear una estructura de datos ,til
)por e%emplo! las tablas hash*"
20

También podría gustarte