1. 3. Estructuras Lineales Estáticas
y Dinámicas
1. Pilas
2. Colas
3. Listas enlazadas
1. Simples
2. Dobles

2. Estructuras de Datos
Almacenamiento
Contiguo
Lineales
Estructura Almacenamiento
s de Datos No Contiguo
No lineales

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

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

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

6. 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).

7. Ejemplo
Insertar Insertar Insertar Eliminar
Inicio: A: B: C: elemento
C
B B B
A A A A
Tope -1 Tope Tope Tope
Tope

8. Interface para una pila de datos enteros:
interface IPila {
public boolean llena();
public boolean vacia();
public void push (int elem);
public int pop();
}

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

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

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

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

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

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

15. Ejemplos
• Convertir las siguientes expresiones infijas
a posfijo
A +B*C-D
A * ((B-C) / 2))
((X-Z)*(Y+W))/X+Y

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

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

18. 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);
}

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

20. 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();
…
}
}

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

22. Method Summary
bool empty()
ean 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.

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

24. 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).

25. 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).

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

27. Implementación de Colas
• Arreglo
– con frente fijo.
– con frente movible.
– circular.
• Listas ligadas

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

29. • 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.

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

31. Frente Final Frente Final
B C B C
Insertar elemento D:
Frente Final Frente Final
B C D B C D

32. 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 B C D E
F F
Insertar elemento G: Error: Cola llena!!!!

33. 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 C D
final llegan al E
Final Frente
extremo se regresan
Insertar F
a la primera posición
F C D
del arreglo.
E

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

35. Interfase de un TDA llamado ICola:
interface ICola{
public boolean llena();
public boolean vacia();
public void insertar (Object elem);
public Object eliminar();
}

36. 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(){
…
}
}

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

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

39. Colas en Java
public interface Queue<E> extends
Collection<E> {
E element();
boolean offer(E o);
E peek();
E poll();
E remove();
}

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

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

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

43. Method Summary
boolean add(E o)
Adds the specified element to this queue.
void clear()
Removes all elements from the priority queue.
Comparator
comparator()
<? super E>
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.

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

45. 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);
}
}

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

47. 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)

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

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

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

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

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

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

54. 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();
}

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

56. Tarea individual.
Fecha de entrega Lunes 26 de marzo
• 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.

57. Puntos Extras!!
• Escribe un método llamado copia que
obtenga una copia de la lista y la regrese
como resultado.

58. Ejercicio
Implementar una cola usando una lista ligada.
La cola contiene alumnos.
Que elementos (datos) se requieren?
Que métodos se implementan?
o1 frente Alumno 2 Alumno 3 Alumno 4
fin

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

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

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

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

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

64. Ejemplos:
Lista Vacía
inicio = fin =
Lista de un solo elemento
inicio A
fin
Lista de tres elementos
inicio A B C
fin

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

66. 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();
}

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

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

69. Métodos de la clase LinkedList

70. 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).

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

72. Representación:
1.- Lista simple c/cabecera y tierra:
Inicio
Nodo cabecera
2.- Lista circular c/cabecera:
Nodo cabecera
Inicio