3.

Estructuras Lineales Estticas y Dinmicas

1. Pilas 2. Colas 3. Listas enlazadas
1. Simples 2. Dobles

Estructuras de Datos
Almacenamiento Contiguo Lineales Estructuras de Datos No lineales Almacenamiento No Contiguo

Operaciones Bsicas en Estructuras Lineales

1. 2. 3. 4. 5. 6. Recorrido: Procesa c/elemento de la estructura. Bsqueda: Recupera la posicin de un elemento especfico. Insercin: Adiciona un nuevo elemento a la estructura. Borrado: Elimina un elemento de la estructura. Ordenacin: Ordena los elementos de la estructura de acuerdo a los valores que contiene. 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.

TOPE: Apunta hacia el elemento que se encuentra en el extremo de la pila. (inicialmente es -1).

Ejemplo
Insertar Inicio: A: Insertar B: Insertar C: Eliminar elemento

C B A
Tope -1 Tope

B A
Tope

B A
Tope

A
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; private int [] pila = new int [10]; final int MAX = 9; public boolean llena(){ return ( tope == MAX ); } public void push (int elem){ if (this.llena()) then // ERROR else{ tope ++; pila [ tope ] = elem; } } public boolean vacia(){ return (tope == -1); } public int pop(){ if (this.vacia()) then // ERROR else{ int x = pila[tope]; tope --; return x; } } }

public class Stack { private Vector items; 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; } }

Implementacin usando un Vector

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{ public static void proceso1(){ System.out.println( proceso1 ); proceso2(); } public static void proceso2(){ System.out.println( proceso2 ); } public static void main(String[] args){ proceso1(); proceso2(); } }

Cual es la salida de este programa?

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

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:
1.- Insertar A 2.- Insertar B 2.3.- Insertar C 4.- Remover Elemento 5.- Insertar D 6.- Remover Elemento

Estado de la cola: Inicio: Cola Vaca

A

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 A 1 F 2 S 3 D 4 Z 5

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 B Final C

B C Frente fijo

Frente movible

Frente

Final

Frente B

Final C

B C

Insertar elemento D:
Frente Final Frente B Final C D

B C D

Frente

Insertar elemento E: Final Frente B

Final C D E

B C D E

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

Insertar elemento G:

Error: Cola llena!!!!

Frente

Final

Cola Circular
Es una representacin lgica de la cola en un arreglo. El frente y final son movibles. Cuando el frente o final llegan al extremo se regresan a la primera posicin del arreglo.

Cola inicial

B C D Frente Final

Remover C D Frente Insertar E C D Final Insertar F F C D E Frente E Final

Representacin de colas:
Usando memoria esttica: arreglos con tamao fijo y frente fijo o movible o represntacin circular.
Final Frente B C D
0 1 2

E
3

F
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 Object
class Cola implements ICola { private Object[] cola; Object[] private int frente = -1; private int fin = -1; private int size; public Cola(int s){ size = s-1; scola = new Object[s]; Object[s]; } public boolean vacia(){ return (frente == -1); } public boolean llena(){ return ( fin == size ); } public void insertar( Object elem) { if ( frente == -1 ) frente ++; else if ( fin == size) ERROR Cola Llena! fin ++; cola[fin]=elem; }

Implementacion usando parametros de tipo

class Cola<T> implements ICola<T> { private T[] cola; private int frente = -1; private int fin = -1; private int size; public Cola(int s){ size = s-1; cola = new T[s]; } public boolean vacia(){ return (frente == -1); } public boolean llena(){ return ( fin == size ); } public void insertar( T elem) { ... } public T eliminar(){ } }

} public Object eliminar(){ 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. Con tamao variable.

Desplazamiento de elementos cuando el final llegue al lmite del arreglo y existan elementos vacos al frente. 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 aPriorityQueue 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 void Comparator <? super E> add(E o) Adds the specified element to this queue. clear() Removes all elements from the priority queue. 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() Returns an iterator over the elements in this queue. offer(E o) Inserts the specified element into this priority queue. peek() Retrieves, but does not remove, the head of this queue, returning null if this queue is empty. poll() Retrieves and removes the head of this queue, or null if this queue is empty. boolean int remove(Object o) Removes a single instance of the specified element from this queue, if it is present. size() Returns the number of elements in this collection.

Iterator<E> boolean E

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
0 1

enlace

Pan Galletas Jamn

-1 4 7

inicio

2 3 4 5 6 7

El arreglo contiene dos campos: uno para la informacin y otro para relacionar al siguiente elemento. La lista se recorre desde el inicio y hasta encontrar un elemento que contenga un enlace vaco.

Leche

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. informacin enlace
public class Nodo{ // atributos public String informacion; public Nodo enlace; // el constructor de nodos Nodo (String n){ informacion = n; enlace = null; } }

Nodo

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{ class Nodo{ public String dato; public Nodo enlace; Nodo (String n){ dato = n; enlace = null; } } Nodo inicio; public Lista(){ inicio = null; } public boolean vaca(){ return (inicio == null); } public int tamao(){ int n=0; Nodo temporal=inicio; while (temporal != null) { n++; temporal = temporal.enlace; } return n; } public boolean buscar(String elemento){ Nodo temporal = inicio; while (temporal != null) { if (elemento.equals(temporal.dato)) return true; else temporal= temporal.enlace; } return false; } public String recorrer(){ . } public void insertar(String elemento){ Nodo n = new Nodo(elemento); // donde se inserta??? // al frente? // al final? // en el medio? } public boolean eliminar(String elemento){ // elimina a un elemento especifico } public String eliminar(){ // elimina el primer elemento String temporal = inicio.dato; inicio = inicio.enlace; return temporal; } }

Tarea individual. Fecha de entrega Lunes 26 de marzo

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 { class Nodo{ String nombre; Nodo enlace; Nodo (String n){ nombre = n; enlace = null; } } Nodo frente; Nodo fin; Cola_Lista(){ frente=null; fin=null; } public boolean vacia(){ return (frente == null); } public boolean llena(){ return false; } public void insertar (String e ){ Nodo n = new Nodo(e); if (this.vacia() ) { frente = n; fin = n; } else { fin.enlace= n; fin = n; } } public String eliminar(){ Nodo n = frente; if (frente != null) { frente = n.enlace; if (frente==null) fin = null; return n.nombre; } 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 { class Nodo{ Integer dato; Nodo enlace; Nodo (Integer n){ dato = n; enlace = null; } } Nodo tope; Pila_Lista(){ tope=null; } public boolean vacia(){ return (tope == null); } public boolean llena(){ return false; } public Integer pop(){ if (tope != null) { Nodo n = tope; tope = tope.enlace; return n.dato; } else ERROR; } public void push(Integer elem){ Nodo n = new Nodo(elem); n.enlace = tope; tope = n; } }

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 public class Nodo{ elemento siguiente.

Estructura del Nodo:

Anterior Informacin Siguiente

// atributos Object informacion; Nodo anterior; Nodo siguiente; // el constructor de nodos Nodo (Object n){ informacion = n; anterior = null; siguiente = null; }

Lista Vaca inicio = fin =

Ejemplos:

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