3.

Estructuras Lineales Estticas

y Dinmicas
1. Pilas
2. Colas
3. Listas enlazadas
1. Simples
2. Dobles
 Estructuras de Datos

Almacenamiento
Contiguo
Lineales
Estructuras Almacenamiento
de Datos No Contiguo
No lineales
 Operaciones Bsicas en Estructuras
Lineales
1. Recorrido: Procesa c/elemento de la estructura.
2. Bsqueda: Recupera la posicin de un elemento especfico.
3. Insercin: Adiciona un nuevo elemento a la estructura.
4. Borrado: Elimina un elemento de la estructura.
5. Ordenacin: Ordena los elementos de la estructura de
acuerdo a los valores que contiene.
6. Mezcla: Combina 2 estructuras en una sola.
 PILAS
Definicin:
Estructura de datos lineal donde los elementos
pueden ser aadidos o removidos solo por un
extremo.
Trabajan con filosofa LIFO (Last In- First Out ).

Ejemplos:
Pila de platos
Pila de discos
Pila de llamadas a funciones
Pila de recursion
Pila de resultados parciales de formulas aritmticas, etc.
 OPERACIONES BASICAS CON
PILAS
-PUSH (insertar).- Agrega un elementos a la pila en el
extremo llamado tope.
-POP (remover).- Remueve el elemento de la pila que se
encuentra en el extremo llamado tope.
-VACIA.- Indica si la pila contiene o no contiene
elementos.
-LLENA.- Indica si es posible o no agregar nuevos
elementos a la pila.
 REPRESENTACIN DE PILAS:
Usando arreglos: Define un arreglo de una dimensin
(vector) donde se almacenan los elementos.

0 1 2 3 4 5

TOPE: Apunta hacia el elemento que se

encuentra en el extremo de la pila.
(inicialmente es -1).
 Ejemplo
Insertar Insertar Insertar Eliminar

Inicio: A: B: C: elemento

C
B B B

A A A A

Tope -1 Tope Tope Tope

Tope
Interface para una pila de datos enteros:

interface IPila {
public boolean llena();
public boolean vacia();
public void push (int elem);
public int pop();
}
 Implementacin usando un arreglo:
class Pila implements IPila {
int tope = -1; public boolean vacia(){
private int [] pila = new int [10]; return (tope == -1);
final int MAX = 9; }
public boolean llena(){
return ( tope == MAX ); public int pop(){
} if (this.vacia()) then
public void push (int elem){ // ERROR
if (this.llena()) then else{
// ERROR int x = pila[tope];
else{ tope --;
tope ++; return x;
pila [ tope ] = elem; }
} }
} }
public class Stack {
private Vector items; Implementacin usando un Vector
public Stack() {
items = new Vector(10);
}
public Object push(Object item){
items.addElement(item);
return item;
}
public synchronized Object pop(){
int len = items.size();
Object obj = null;
if (len == 0) throw new EmptryStackException();
obj = items.elementAt(len-1);
items.removeElementAt(len 1);
return obj;
}
public boolean isEmpty() {
if (items.size == 0) return true;
else return false;
}
}
 Aplicaciones de Pilas
EXPRESIONES ARITMETICAS:
Una expresin aritmtica contiene constantes, variables
y operaciones con distintos niveles de precedencia.

OPERACIONES :
^ potencia
*/ multiplicacin, divisin
+,- suma, resta
 NOTACIONES:

NOTACION INFIJA:
Los operadores aparecen en medio de los operandos.
A + B, A 1, E/F, A * C , A ^ B , A + B + C, A+B-C

NOTACION PREFIJA:
El operador aparece antes de los operandos.
+ AB, - A1, /EF, *AC, ^AB, +AB+C, +AB-C

NOTACION POSTFIJA:
El operador aparece al final de los operandos.
AB+, A1-, EF/, AC*, AB^, AB+C+, AB+C-
 PASOS PARA EVALUAR UNA
EXPRESION:

1.-CONVERTIR A POSTFIJO: convertir la

expresin en notacin infijo a notacin postfijo

2.-EVALUAR LA EXPRESION POSTFIJA: usar

una pila para mantener los resultados intermedios
cuando se evala la expresin en notacin posfijo.
 REGLAS PARA CONVERTIR EXPRESION
INFIJA A POSTFIJA
Se crea un string resultado donde se almacena la expresin en postfijo.
1.- Los operandos se agregan directamente al resultado
2.- Un parntesis izquierdo se mete a la pila y tiene prioridad o precedencia
cero (0).
3.- Un parntesis derecho saca los elementos de la pila y los agrega al
resultado hasta sacar un parntesis izquierdo.
4.- Los operadores se insertan en la pila si:
a) La pila esta vaca.
b) El operador en el tope de la pila tiene menor precedencia.
c) Si el operador en el tope tiene mayor precedencia se saca y agrega al
resultado (repetir esta operacin hasta encontrar un operador con menor
precedencia o la pila este vaca).
5.- Cuando se termina de procesar la cadena que contiene la expresin infijo se
vaca la pila pasando los elementos al resultado.
 Ejemplos
Convertir las siguientes expresiones infijas
a posfijo
A +B*C-D
A * ((B-C) / 2))
((X-Z)*(Y+W))/X+Y
 REGLAS PARA EVALUAR UNA
EXPRESION POSTFIJA

Recorrer la expresion de izquierda a derecha

1. Si es un operando
1. almacenar el valor en la pila de valores
2. Si es un operador:
1. Obtener dos operandos de la pila de valores
2. Aplicar el operador
3. Almacenar el resultado en la pila de valores

Al finalizar el recorrido, el resultado estar en la pila de valores

 Aplicaciones de Pilas
Funciones Recursivas
Las pilas pueden ser usadas para implementar la
recursin en programas.
Una funcin o procedimiento recursivo es aquel
que se llama a si mismo.
Ejemplos:
Factorial
Nmeros de Fibonacci
Torres de Hanoi
Algoritmos de Ordenamiento de datos
Etc.
Aplicaciones de Pilas
Recursion
// Funcion factorial
public static int factorial(int n) {
if (n<=1) return 1;
else return n*factorial(n-1);
}

// Funcion fibonacci
public static int fib(int n) {
if (n==1) return 0;
else if (n==2) return 1;
else return fib(n-1)+fib(n-2);
}
 Aplicaciones de Pilas
Control de secuencia de programas.
Las pilas son requeridas para implementar
el control de flujo de ejecucin de un
programa con subprogramas (funciones,
procedimientos o mtodos).
Subprogramas recursivos o no recursivos
Existen llamadas a ejecucin de subprogramas.
Un subprograma se ejecuta completamente
antes de retornar al punto donde fue llamado.
 Aplicaciones de Pilas
Control de secuencia de programas.
// Programa Principal
class Principal{ Cual es la
public static void proceso1(){ salida de este
System.out.println(proceso1); programa?
proceso2();

}
public static void proceso2(){
System.out.println(proceso2);

}
public static void main(String[] args){
proceso1();
proceso2();

}
}
 Clase Stack en Java
La clase Stack representa una pila de objetos donde el ltimo
en entrar es el primero en salir (LIFO). Extiende la clase
Vector con 5 operaciones bsicas.

java.util
Class Stack<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.Vector<E>
java.util.Stack<E>
All Implemented Interfaces:
Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess
Method Summary

boole empty()
an Tests if this stack is empty.
E peek()
Looks at the object at the top of this stack without removing it
from the stack.
E pop()
Removes the object at the top of this stack and returns that
object as the value of this function.
E push(E item)
Pushes an item onto the top of this stack.
int search(Object o)
Returns the 1-based position where an object is on this stack.
 COLAS
Definicion. Es una lista lineal de elementos en la que las
operaciones de insertar y eliminar se realizan en diferentes
extremos de la cola.
Trabajan con filosofa FIFO ( First In - First out), el primer
elemento en entrar es el primer elemento en salir.

Ejemplos:

Cola de automviles esperando servicio en una gasolinera

Cola de clientes en una ventanilla del banco para pagar un servicio
Cola de programas en espera de ser ejecutados por una computadora.
 TIPOS DE COLAS:

Cola simple: Estructura lineal donde los elementos salen en

el mismo orden en que llegan.

Cola circular: Representacin lgica de una cola simple en un

arreglo.

Cola de Prioridades: Estructura lineal en la cual los

elementos se insertan en cualquier posicin de la cola y se
remueven solamente por el frente.

Cola Doble (Bicola): Estructura lineal en la que los elementos

se pueden aadir o quitar por cualquier extremo de la cola
(cola bidireccional).
Operaciones bsicas en Colas Simples
Insertar.- Almacena al final de la cola el elemento que se
recibe como paramtro.
Eliminar.- Saca de la cola el elemento que se encuentra al
frente.
Vaca.- Regresa un valor booleano indicando si la cola tiene o
no elementos (true si la cola esta vacia, false si la cola
tiene al menos un elemento).
Llena.- Regresa un valor booleano indicando si la cola tiene
espacio disponible para insertar nuevos elementos ( true
si esta llena y false si existen espacios disponibles).
Operaciones: Estado de la cola:
Inicio: Cola Vaca

1.- Insertar A A

2.- Insertar B A B

3.- Insertar C A B C

4.- Remover Elemento B C

5.- Insertar D
B C D

6.- Remover Elemento

C D
 Implementacin de Colas
Arreglo
con frente fijo.
con frente movible.
circular.
Listas ligadas
 Representacin usando arreglos

Las colas pueden ser representadas en arreglos de

una dimensin (vector) manteniendo dos variables
que indiquen el FRENTE y FINAL de los elementos
de la cola.

0 1 2 3 4 5

A F S D Z

Frente Final
 Cuando la cola esta vaca las variables frente y final son
nulos y no es posible remover elementos.

Cuando la cola esta llena ( frente = 0 y final = n-1) no

es posible insertar elementos nuevos a la cola.

Cuando se remueven elementos el frente puede

incrementarse para apuntar al siguiente elemento de la
cola (implementacion con frente movil) o los elementos
en la cola pueden desplazarse una posicion adelante
(implementacin con frente fijo)

Recuperacin de espacio: Cuando no hay espacios libres

al final del arreglo los elementos pueden ser desplazados
para desocupar posiciones en un extremo del arreglo o
se puede manejar una estructura circular.
Ejemplo: Suponer que usamos un arreglo de 5
posiciones. Usando la representacin de frente fijo y
frente movible.
Frente A B C

Final
Al remover un elemento:
Frente Final Frente Final

B C B C

Frente fijo Frente movible

Frente Final Frente Final

B C B C

Insertar elemento D:
Frente Final Frente Final

B C D B C D
 Insertar elemento E:
Frente Final Frente Final

B C D E B C D E

Insertar elemento F:
Frente Final Frente Final

B C D E F B C D E F

Insertar elemento G: Error: Cola llena!!!!

 Frente Final
Cola
B C D
Cola Circular inicial

Frente Final
Es una representacin Remover
lgica de la cola en C D
un arreglo.
El frente y final son Frente Final
movibles. Insertar E
Cuando el frente o C D E
final llegan al Final Frente
extremo se regresan
Insertar F
a la primera posicin
del arreglo. F C D E
 Representacin de colas:
Usando memoria esttica: arreglos con tamao fijo y
frente fijo o movible o represntacin circular.
Final

Frente B C D E F

0 1 2 3 4

Usando memoria dinmica: Listas ligadas.

Final
B C D E F

Frente
 Interfase de un TDA llamado ICola:

interface ICola{
public boolean llena();
public boolean vacia();
public void insertar (Object elem);
public Object eliminar();
}
 Implementacin de una cola:
Implementacion usando Implementacion usando
Object parametros de tipo
class Cola implements ICola { class Cola<T> implements ICola<T> {
private Object[] cola; private T[] cola;
private int frente = -1; private int frente = -1;
private int fin = -1; private int fin = -1;
private int size; private int size;
public Cola(int s){ public Cola(int s){
size = s-1; size = s-1;
cola = new Object[s]; cola = new T[s];
} }
public boolean vacia(){ public boolean vacia(){
return (frente == -1); return (frente == -1);
} }
public boolean llena(){ public boolean llena(){
return ( fin == size ); return ( fin == size );
} }
public void insertar( Object elem) { public void insertar( T elem) {
if ( frente == -1 ) ...
frente ++; }
else public T eliminar(){
if ( fin == size)
ERROR Cola Llena! }
fin ++;
cola[fin]=elem; }
}
}
public Object eliminar(){

}
}
 Ejercicio.
Definir una clase Cola con las operaciones
bsicas en 3 implementaciones diferentes:
Con tamao fijo y frente fijo. Desplazamiento de
elementos cada vez que se remueve un elemento.
Con tamao fijo y frente movible.
Desplazamiento de elementos cuando el final llegue al
lmite del arreglo y existan elementos vacos al frente.
Con tamao variable.
Incrementar el tamao del arreglo cuando la cola
este llena.
 Colas en Java
Java contiene la definicin de interfaces y
clases para el manejo de colas.
Las colas son una coleccin de elementos
diseadas para almacenar elementos que
esperan ser procesados.
Java contiene una interfase parametrizada
Queue<E> y varias clases que que la
implementan, entre ellas PriorityQueue<E>
 Colas en Java
public interface Queue<E> extends Collection<E> {
E element();
boolean offer(E o);
E peek();
E poll();
E remove();
}
Method Summary
E element()
Retrieves, but does not remove, the head of this queue, it throws an exception if this
queue is empty..
bool offer(E o)
ean Inserts the specified element into this queue, if possible.
E
peek()
Retrieves, but does not remove, the head of this queue, returning null if this queue is
empty.

E
poll()
Retrieves and removes the head of this queue, or null if this queue is empty.

E remove()
Retrieves and removes the head of this queue.
 Cola de Prioridad en Java
java.util
Class PriorityQueue<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractQueue<E>
java.util.PriorityQueue<E>

Type Parameters:
E - the type of elements held in this collection
All Implemented Interfaces:
Serializable, Iterable<E>, Collection<E>, Queue<E>
Constructor Summary
PriorityQueue()
Creates a PriorityQueue with the default initial capacity (11) that orders its elements according to
their natural ordering (using Comparable).

PriorityQueue(Collection<? extends E> c)

Creates a PriorityQueue containing the elements in the specified collection.

PriorityQueue(int initialCapacity)
Creates a PriorityQueue with the specified initial capacity that orders its elements according to
their natural ordering (using Comparable).

PriorityQueue(int initialCapacity, Comparator<? super E> comparator)

Creates a PriorityQueue with the specified initial capacity that orders its elements according to the
specified comparator.

PriorityQueue(PriorityQueue<? extends E> c)

Creates a PriorityQueue containing the elements in the specified collection.
PriorityQueue(SortedSet<? extends E> c)
Creates a PriorityQueue containing the elements in the specified collection.
Method Summary
boolean add(E o)
Adds the specified element to this queue.
void clear()
Removes all elements from the priority queue.
Comparator
<? super E> comparator()
Returns the comparator used to order this collection, or null if this collection is sorted according
to its elements natural ordering (using Comparable).

Iterator<E> iterator()
Returns an iterator over the elements in this queue.
boolean offer(E o)
Inserts the specified element into this priority queue.
E peek()
Retrieves, but does not remove, the head of this queue, returning null if this queue is empty.

E poll()
Retrieves and removes the head of this queue, or null if this queue is empty.

boolean remove(Object o)
Removes a single instance of the specified element from this queue, if it is present.
int size()
Returns the number of elements in this collection.
 Tablas Hash
java.util
Class Hashtable<K,V>
java.lang.Object
java.util.Dictionary<K,V>
java.util.Hashtable<K,V>

All Implemented Interfaces:

Serializable, Cloneable, Map<K,V>
 Este ejemplo crea un tabla hash con
llave de tipo String y datos de tipo Integer.

import java.util.Hashtable;
public class Tabla{
public static void main (String[] arg){
Hashtable<String, Integer> numeros = new Hashtable<String,
Integer>();
numeros.put("uno",1);
numeros.put("dos", new Integer(2));
Integer n = numeros.get("dos");
if (n != null) System.out.println(n);
}
}
 Constructores de Tablas hash
Constructor Summary

Hashtable()
Constructs a new, empty hashtable with a default initial capacity (11) and load factor, which is 0.75.

Hashtable(int initialCapacity)
Constructs a new, empty hashtable with the specified initial capacity and default load factor, which is 0.75.

Hashtable(int initialCapacity, float loadFactor)

Constructs a new, empty hashtable with the specified initial capacity and the specified load factor.

Hashtable(Map<? extends K,? extends V> t)

Constructs a new hashtable with the same mappings as the given Map.
 LISTAS ENLAZADAS

1. Simples (con enlace simple)

2. Dobles (doblemente enlazadas)

Existe diversas implementaciones de estas

estructuras.
Las variaciones mas comunes implementan
listas circulares y listas con cabecera en sus dos
variaciones (simples y dobles)
 En lenguajes donde no se cuenta con memoria
dinmica, las listas se implementan usando
arreglos.
informacin enlace El arreglo contiene dos
0 Pan -1 campos: uno para la
1 informacin y otro para
relacionar al siguiente
inicio 2 Galletas 4 elemento.
3

4
Jamn 7 La lista se recorre desde el
5 inicio y hasta encontrar un
6 elemento que contenga un
enlace vaco.
7
Leche 0
 LISTAS
Una lista es una coleccin lineal de elementos llamados nodos
donde el orden de los mismos se establece mediante punteros o
referencias y existe un puntero/referencia especial llamado inicio
para localizar al primer elemento.

Ejemplos:

inicio *Lista enlazada de 0 elementos

Informacin enlace

inicio
* Lista enlazada de 4 elementos
 Los nodos de las listas
Un nodo se divide en 2 partes:
Informacin: Contiene la informacin del elemento.
Enlace: Contiene la direccin del siguiente nodo de la
lista.
public class Nodo{
informacin enlace // atributos
public String informacion;
Nodo public Nodo enlace;
// el constructor de nodos
Nodo (String n){
informacion = n;
enlace = null;
}
}
 Almacenamiento de datos:

1. Arreglos: La relacin lineal esta implcita en la

relacin fsica de los elementos. Desventaja:
Almacenamiento esttico y tamao fijo.

2. Elementos enlazados: Agrega a cada elemento un

campo de enlace, no requieren almacenamiento
contiguo en memoria, se pueden aadir y borrar
elementos fcilmente.
 Listas Simples

Coleccin lineal de elementos llamados nodos.

Existe un elemento llamado inicio que apunta al
primer elemento de la lista.
Cada nodo contiene un campo de enlace que apunta
al siguiente elemento.
El ltimo elemento de la lista en su campo enlace
apunta a nulo.
Al principio el apuntador inicio apunta a nulo.
 Operaciones con listas simples
Insertar: Agrega un elemento a la lista.
Eliminar: Retira un elemento de la lista.
Buscar: Busca un elemento en la lista.
Recorrer: Visita todos los elementos de la lista.
Vaca: Indica si la lista contiene o no elementos.
Tamao: Indica el nmero de elementos de la lista.

Con las operaciones anteriores, define una interfase

para una lista simple que contiene datos de tipo
String.
public interface ILista{
public void insertar(String elemento);
public boolean eliminar(String elemento);
public String eliminar();
public boolean buscar(String elemento);
public String recorrer();
public boolean vaca();
public int tamao();
}
Implementacin de la interfase ILista
public class Lista implements ILista{ public boolean buscar(String elemento){
class Nodo{ Nodo temporal = inicio;
public String dato; while (temporal != null) {
public Nodo enlace; if (elemento.equals(temporal.dato))
Nodo (String n){ return true;
dato = n; else
enlace = null; temporal= temporal.enlace;
} }
} return false;
Nodo inicio; }
public Lista(){ public String recorrer(){ . }
inicio = null; public void insertar(String elemento){
} Nodo n = new Nodo(elemento);
public boolean vaca(){ // donde se inserta???
return (inicio == null); // al frente?
} // al final?
public int tamao(){ // en el medio?
int n=0; }
Nodo temporal=inicio; public boolean eliminar(String elemento){
while (temporal != null) { // elimina a un elemento especifico
n++; }
temporal = temporal.enlace; public String eliminar(){ // elimina el primer elemento
} String temporal = inicio.dato;
return n; inicio = inicio.enlace;
} return temporal;
}
}
 Tarea individual.
Fecha de entrega:
Escribe el mtodo insertar para una lista que contiene datos
ordenados ascendentemente.
Escribe el mtodo eliminar un elemento especfico para la
clase Lista.
Escribe el mtodo recorrer donde el String de resultado
contiene a todos los elementos de la lista y cada elemento
esta separado por un return.

Prueba la clase Lista con un programa Java que lea de

teclado 10 nombre y los inserte en la lista. Imprime la lista
y su tamao despus de cada operacin de insercin.
 Puntos Extras!!
Escribe un mtodo llamado copia que
obtenga una copia de la lista y la regrese
como resultado.
 Ejercicio
Implementar una cola usando una lista ligada.
La cola contiene alumnos.

Que elementos (datos) se requieren?

Que mtodos se implementan?

frente Alumno 1 Alumno 2 Alumno 3 Alumno 4

fin
 Ejemplo
Implementacin de una cola de datos String usando una lista
class Cola_Lista { public void insertar (String e ){
class Nodo{ Nodo n = new Nodo(e);
String nombre; if (this.vacia() ) {
Nodo enlace; frente = n;
Nodo (String n){ fin = n;
nombre = n; }
enlace = null; else {
} fin.enlace= n;
} fin = n;
Nodo frente; }
Nodo fin; }
Cola_Lista(){ public String eliminar(){
frente=null; Nodo n = frente;
fin=null; if (frente != null) {
} frente = n.enlace;
public boolean vacia(){ if (frente==null)
return (frente == null); fin = null;
} return n.nombre;
public boolean llena(){ }
return false; else ERROR; //return null; // excepcin
} }
} // final de la clase
 Ejercicio
Implementar una pila usando una lista ligada.
La pila contiene nmeros enteros.

Que elementos (datos) se requieren?

Que mtodos se implementan?

tope 10 7 4 2
Implementacin de una pila de datos Integer usando una lista
class Pila_Lista { public Integer pop(){
class Nodo{ if (tope != null) {
Integer dato; Nodo n = tope;
Nodo enlace; tope = tope.enlace;
Nodo (Integer n){ return n.dato;
dato = n; }
enlace = null; else ERROR;
} }
} public void push(Integer elem){
Nodo tope; Nodo n = new Nodo(elem);
Pila_Lista(){ n.enlace = tope;
tope=null; tope = n;
} }
public boolean vacia(){ }
return (tope == null);
}
public boolean llena(){
return false;
}
 Tipos parametrizados
Define una clase para implementar una Pila/Cola
usando una lista. Los datos que se almacenaran
sern tipo Object.
Que requiere un programa que use estas
estructuras?
Define una clase parametrizada para implementar
una Pila usando una lista.
Define una clase parametrizada para implementar
una Cola usando una lista.
 LISTAS DOBLES
Una lista doble es una estructura lineal de elementos llamados
nodos los cuales contienen dos campos de enlace: uno al
elemento anterior y otro al elemento siguiente de la lista.

El primer nodo de la lista contiene nulo en su enlace al elemento

anterior y el ltimo nodo de la lista contiene nulo en su enlace al
elemento siguiente. public class Nodo{
// atributos
Estructura del Nodo: Object informacion;
Nodo anterior;
Anterior Informacin Siguiente Nodo siguiente;
// el constructor de nodos
Nodo (Object n){
informacion = n;
anterior = null;
siguiente = null;
}
}
 Ejemplos:
Lista Vaca
inicio = fin =

Lista de un solo elemento

inicio A

fin
Lista de tres elementos

inicio A B C

fin
 Operaciones con listas dobles
Insertar: Agrega un elemento a la lista.
Eliminar: Retira un elemento de la lista.
Buscar: Busca un elemento en la lista.
Recorrer hacia adelante: Visita todos los elementos de la lista
desde el inicio hasta el final.
Recorrer hacia atrs: Visita todos los elementos de la lista
desde el final hasta el inicio.
Vaca: Indica si la lista contiene o no elementos.
Tamao: Indica el nmero de elementos de la lista.

Con las operaciones anteriores, define una interfase

para una lista doble que contiene datos de tipo
Integer.
public interface IListaDoble{
public void insertar(Integer elemento);
public boolean eliminar(Integer elemento);
public Integer eliminar();
public boolean buscar(Integer elemento);
public String recorrer();
public boolean vaca();
public int tamao();
}
 La interfase List de Java
java.util
Interface List<E>
All Superinterfaces:
Collection<E>, Iterable<E>
All Known Implementing Classes:
AbstractList, AbstractSequentialList, ArrayList,
AttributeList, CopyOnWriteArrayList, LinkedList,
RoleList, RoleUnresolvedList, Stack, Vector
 La clase LinkedList en Java
java.util
Class LinkedList<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.AbstractSequentialList<E>
java.util.LinkedList<E>
Type Parameters:
E - the type of elements held in this collection
All Implemented Interfaces:
Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, Queue<E>
Mtodos de la clase LinkedList
 LISTAS ENLAZADAS CON CABECERA
Es una lista enlazada que contiene un nodo especial llamado
nodo cabecera que se encuentra al inicio de la misma.

NODO CABECERA.- Es un nodo especial que no contiene

informacin, solo se utiliza para indicar el inicio de los elementos de la
lista.

La utilizacin de un nodo cabecera en listas enlazadas

permiten que la implementacin de los mtodos de insercin
y eliminacin sea mas sencilla, ya que evitan tratar de forma
explcita los casos especiales (insertar al inicio o eliminar el
primer elemento). Sin embargo, requieren de un nodo extra
en la lista (el nodo cabecera).
 TIPOS DE LISTA ENLAZADA CON
CABECERA:
1)LISTA CON CABECERA Y TIERRA:
Es una lista enlazada con cabecera, donde el apuntador
del ltimo nodo contiene nulo.

2)LISTA CIRCULAR CON CABECERA:

Es una lista enlazada con cabecera, donde el ltimo
nodo contiene un apuntador hacia la cabecera.
 Representacin:
1.- Lista simple c/cabecera y tierra:

Inicio

Nodo cabecera

2.- Lista circular c/cabecera:

Nodo cabecera
Inicio