Estructuras Lineales Estáticas y

Dinámicas
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 Básicas en Estructuras
Lineales
1. Recorrido: Procesa c/elemento de la estructura.
2. Búsqueda: Recupera la posición de un elemento específico.
3. Inserción: Adiciona un nuevo elemento a la estructura.
4. Borrado: Elimina un elemento de la estructura.
5. Ordenación: Ordena los elementos de la estructura de
acuerdo a los valores que contiene.
6. Mezcla: Combina 2 estructuras en una sola.
 PILAS
Definición:
Estructura de datos lineal donde los elementos
pueden ser añadidos o removidos solo por un
extremo.
Trabajan con filosofía 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 aritméticas, 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.
 REPRESENTACIÓN DE PILAS:
• Usando arreglos: Define un arreglo de una dimensión
(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();
}
 Implementación 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; Implementación 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 expresión aritmética contiene constantes, variables
y operaciones con distintos niveles de precedencia.

OPERACIONES :
^ potencia
*/ multiplicación, división
+,- 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

expresión en notación infijo a notación postfijo

2.-EVALUAR LA EXPRESION POSTFIJA: usar

una pila para mantener los resultados intermedios
cuando se evalúa la expresión en notación posfijo.
 REGLAS PARA CONVERTIR EXPRESION
INFIJA A POSTFIJA
Se crea un string resultado donde se almacena la expresión en postfijo.
1.- Los operandos se agregan directamente al resultado
2.- Un paréntesis izquierdo se mete a la pila y tiene prioridad o precedencia
cero (0).
3.- Un paréntesis derecho saca los elementos de la pila y los agrega al
resultado hasta sacar un paréntesis izquierdo.
4.- Los operadores se insertan en la pila si:
a) La pila esta vacía.
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 operación hasta encontrar un operador con menor
precedencia o la pila este vacía).
5.- Cuando se termina de procesar la cadena que contiene la expresión infijo
se vacía 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
recursión en programas.
• Una función o procedimiento recursivo es aquel que
se llama a si mismo.
• Ejemplos:
– Factorial
– Números 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 ejecución de un
programa con subprogramas (funciones,
procedimientos o métodos).
– Subprogramas recursivos o no recursivos
– Existen llamadas a ejecución 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 básicas.

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 filosofía FIFO ( First In - First out), el primer
elemento en entrar es el primer elemento en salir.

Ejemplos:

•Cola de automóviles 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: Representación lógica de una cola simple en

un arreglo.

• Cola de Prioridades: Estructura lineal en la cual los

elementos se insertan en cualquier posición de la cola y se
remueven solamente por el frente.

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

se pueden añadir o quitar por cualquier extremo de la cola
(cola bidireccional).
Operaciones básicas en Colas Simples
Insertar.- Almacena al final de la cola el elemento que se
recibe como paramétro.
Eliminar.- Saca de la cola el elemento que se encuentra al
frente.
Vacía.- 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 Vacía

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
 Implementación de Colas
• Arreglo
– con frente fijo.
– con frente movible.
– circular.
• Listas ligadas
 Representación usando arreglos

Las colas pueden ser representadas en arreglos de

una dimensión (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 vacía 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
(implementación con frente fijo)

• Recuperación 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 representación 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 representación Remover
lógica de la cola en C D
un arreglo.
El frente y final son Frente Final
movibles. Insertar E
Cuando el frente o final C D E
llegan al extremo se
Final Frente
regresan a la primera
posición del arreglo. Insertar F
F C D E
 Representación de colas:
• Usando memoria estática: arreglos con tamaño fijo y
frente fijo o movible o represntación circular.
Final

Frente B C D E F

0 1 2 3 4

• Usando memoria dinámica: 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();
}
 Implementación 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
básicas en 3 implementaciones diferentes:
– Con tamaño fijo y frente fijo. Desplazamiento de
elementos cada vez que se remueve un elemento.
– Con tamaño fijo y frente movible.
Desplazamiento de elementos cuando el final llegue al
límite del arreglo y existan elementos vacíos al frente.
– Con tamaño variable.
• Incrementar el tamaño del arreglo cuando la cola
este llena.
 Colas en Java
• Java contiene la definición de interfaces y
clases para el manejo de colas.
• Las colas son una colección de elementos
diseñadas 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
dinámica, las listas se implementan usando
arreglos.
información enlace •El arreglo contiene dos
0 Pan -1 campos: uno para la
1 información y otro para
relacionar al siguiente
inicio 2 Galletas 4 elemento.
3

4
Jamón 7 •La lista se recorre desde el
5 inicio y hasta encontrar un
6 elemento que contenga un
7
enlace vacío.
Leche 0
 LISTAS
Una lista es una colección 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

Información enlace

inicio
* Lista enlazada de 4 elementos
 Los nodos de las listas
Un nodo se divide en 2 partes:
• Información: Contiene la información del elemento.
• Enlace: Contiene la dirección del siguiente nodo de la
lista.
public class Nodo{
información 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 relación lineal esta implícita en la

relación física de los elementos. Desventaja:
Almacenamiento estático y tamaño fijo.

2. Elementos enlazados: Agrega a cada elemento un

campo de enlace, no requieren almacenamiento
contiguo en memoria, se pueden añadir y borrar
elementos fácilmente.
 Listas Simples

• Colección 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.
• Vacía: Indica si la lista contiene o no elementos.
• Tamaño: Indica el número 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 vacía();
public int tamaño();
}
Implementación 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 vacía(){ // donde se inserta???
return (inicio == null); // al frente?
} // al final?
public int tamaño(){ // en el medio?
}
int n=0;
public boolean eliminar(String elemento){
Nodo temporal=inicio;
// elimina a un elemento especifico
while (temporal != null) {
}
n++;
public String eliminar(){ // elimina el primer elemento
temporal = temporal.enlace;
String temporal = inicio.dato;
}
inicio = inicio.enlace;
return n;
return temporal;
} }
}
 Tarea en equipos de 2.

• Escribe el método insertar para una lista que contiene

datos ordenados ascendentemente.
• Escribe el método eliminar un elemento específico para la
clase Lista.
• Escribe el método 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 tamaño después de cada operación de inserción.
 Puntos Extras!!
• Escribe un método 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 métodos se implementan?

frente Alumno 1 Alumno 2 Alumno 3 Alumno 4

fin
 Ejemplo
Implementación 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; // excepción
} }
} // final de la clase
 Ejercicio
Implementar una pila usando una lista ligada.
La pila contiene números enteros.

Que elementos (datos) se requieren?

Que métodos se implementan?

tope 10 7 4 2
Implementación 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
serán 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 Información Siguiente Nodo siguiente;
// el constructor de nodos
Nodo (Object n){
informacion = n;
anterior = null;
siguiente = null;
}
}
 Ejemplos:
Lista Vacía
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 atrás: Visita todos los elementos de la lista
desde el final hasta el inicio.
• Vacía: Indica si la lista contiene o no elementos.
• Tamaño: Indica el número 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 vacía();
public int tamaño();
}
 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>
Métodos 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

información, solo se utiliza para indicar el inicio de los elementos de la
lista.

La utilización de un nodo cabecera en listas enlazadas

permiten que la implementación de los métodos de inserción
y eliminación sea mas sencilla, ya que evitan tratar de forma
explícita 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.
 Representación:
1.- Lista simple c/cabecera y tierra:

Inicio

Nodo cabecera

2.- Lista circular c/cabecera:

Nodo cabecera
Inicio