Estructuras en Memoria PDF

Estructuras de datos en memoria principal
Franco Guidi Polanco

Escuela de Ingeniería Industrial
Pontificia Universidad Católica de Valparaíso, Chile
fguidi@ucv.cl
Estructuras de datos
v Estructuras básicas
§  Arreglo
§  Lista enlazada
•  Simplemente enlazada
•  Doblemente enlazada
v Colecciones implementadas sobre las estructuras básicas:

§  Lista, Lista con iterador
§  Lista circular
§  Pila
§  Cola
§  Hashtable
§  Vector (Java)
§  (Otras)
Franco Guidi Polanco (PUCV-EII) 25-05-14 2

Arreglo
v Es una colección ordenada de elementos del

mismo tipo.
v Es de largo fijo, definido al momento de
instanciarlo.
v El acceso a los elementos se hace a través de un
subíndice.
v Fácil de recorrer en ambos sentidos.
v Estudiado en cursos anteriores

Listas enlazadas
v Son estructuras dinámicas: se asigna memoria

para los elementos de la lista en la medida que es
necesario.
v Cada elemento se almacena en una variable
dinámica denominada nodo.
v En la lista simplemente enlazada, cada nodo
apunta al nodo que contiene el elemento siguiente

Esquema tentativo de una lista simplemente
enlazada
Nodos
data data data data

head
null
ListaEnlazada

Datos contenidos en la lista
v Los nodos de una lista contendrán datos del tipo

declarado en la estructura del nodo. Por ejemplo:
§  Tipos primitivos (byte, int, boolean, char, etc.)
§  Referencias a objetos
v En los siguientes ejemplos consideraremos el uso
de listas de enteros, aunque las técnicas que serán
descritas son aplicables a cualquier otro “tipo” de
lista.

Diagrama de clases de una lista simplemente
enlazada
v Diagrama de clases (lista de enteros):
next
Lista Nodo
1..1
data:int
agregarAlFinal(d:Data) head
estáContenido(d:Data):boolean getData():int
eliminar(d:Data):boolean setNext(n:Nodo)
imprimirContenido() getNext():Nodo
Nodo(d:Data,n:Nodo)
v Diagrama de objetos:
head:Nodo :Nodo :Nodo
:Lista
data = 1 data = 20 data = -1

Una lista simplemente enlazada (versión
preliminar)
v Declaración de la Lista:
public class Lista{
Nodo head = null;
public void agregarAlFinal(int data){
...
}
public void imprimirContenido(){
...
}
public boolean estaContenido(int data){
...
}
public boolean eliminar(int data){
...
}
}
Nodos en una lista simplemente enlazada
public class Nodo{

private int data;
private Nodo next;
public Nodo(int d, Nodo n){
data = d;
next = n;
}
public int getData(){
return data;
}
public Nodo getNext(){
return next;
}
public void setNext(Nodo n){
next = n;
}
}

Inserción en la lista simplemente enlazada
v Insertar elementos: Ejemplo: [ 25, 1, 14, 4 ]

§  Al final de la lista
25 1 14 4
head
null
§  Manteniendo un orden
1 4 14 25
head
null
§  Al inicio de la lista
4 14 1 25
head
null

Inserción de elementos al final de la lista
v Caso 1: la lista está vacía (variable head contiene

null)
25
head head
null null
public Lista{
...
public void agregarAlFinal(int dato){
...
head = new Nodo( dato, null );
...
}
...
}

v Caso 2 (general): la lista tiene al menos un

elemento
1. ubicar último nodo de la lista
(aquél cuya variable next
25 1 contiene null)
head 2. Instanciar el nuevo nodo
null con el contenido indicado
aux 3. Asignar el nuevo nodo a la
variable next del último
nodo (asegurándose de que
la variable next del nuevo
nodo sea igual a null)
25 1 14
head
null
aux aux.setNext(new Nodo(dato, null));
v Caso general:
public class Lista{
...
public void agregarAlFinal(int dato){
Nodo nuevo = new Nodo(dato, null);
if( head == null )
head = nuevo;
else{
Nodo aux = head;
while( aux.getNext() != null)
aux = aux.getNext();
aux.setNext( nuevo );
}
}
...
}

Recorrido de la lista
v Método que imprime el contenido de la lista:
public class Lista{

...
public void imprimirContenido(){
Nodo aux = head;
while( aux != null ){
System.out.print( aux.getData() + "; " );
}
System.out.println();
...
}

Búsqueda en la lista
v Retorna true si el elemento está contenido en la

lista
public class Lista{
...
public boolean estaContenido(int data){
Nodo aux = head;
while( aux != null ){
if( data == aux.getData() )
return true;
}
return false;
}
...
}

Eliminación de un elemento
v Requiere identificar el nodo a borrar.

v Caso 1: es el primer nodo de la lista
25 1 14 4
head
null
head = head.getNext();
25 1 14 4
head
Sin otras referencias: candidato a eliminación null
(recolector de basura de Java)
1 14 4
head
null
v Caso 2 (general): no es el primer nodo de la lista
25 1 14 4
head null
aux.setNext(aux.getNext().getNext());
aux
25 1 14 4
head
Sin otras referencias: candidato a eliminación null
25 1 4
head
null
public class Lista{
...
if( head != null)
if( head.getData() == data ){
head = head.getNext();
return true;
}else{
Nodo aux = head;
while( aux.getNext() != null ){
if( aux.getNext().getData() == data ){
aux.setNext( aux.getNext().getNext() );
return true;
}
}
}
return false;
}
...
}
Simplificación del esquema propuesto: uso de un
nodo “fantasma”
v En el esquema propuesto se deben hacer
excepciones al insertar y eliminar el nodo del
comienzo de la lista.
v El manejo se simplifica si se utiliza un nodo

“fantasma”:
§  Es un nodo siempre presente en la lista
§  Su contenido es irrelevante (el valor u
objeto contenido no forma parte de la lista).

Lista simplemente enlazada con nodo fantasma
v Lista vacía: public class Lista{

Nodo head;
public Lista(){
head = new Nodo(0, null);
}
head ...
null
v Lista con elementos: }
Valor irrelevante
25 1 4
head
null
Primer elemento de la lista

Operación de inserción en la lista con nodo fantasma
v La inserción del primer elemento de la lista entra

en el caso general:
1
head null
aux aux.setNext(new Nodo(dato, null));
Clase public void agregarAlFinal(int dato){

Lista Nodo aux = head;
while( aux.getNext() != null)
aux.setNext( new Nodo(dato, null) );
}
}

Eliminación del primer elemento en la lista con nodo
fantasma
v La eliminación del primer elemento de la lista entra

en el caso general:
aux.setNext(aux.getNext().getNext());
aux
14 1 4
head
null
Sin otras referencias: candidato a eliminación

Eliminación del primer elemento en la lista con nodo
fantasma (cont.)

Nodo aux = head;
while( aux.getNext() != null ){
if( aux.getNext().getData() == data ){
aux.setNext( aux.getNext().getNext() );
return true;
}
}
return false;
}

Mejora al procedimiento de inserción de elementos al final
de la lista
v El procedimiento descrito anteriormente requiere que todas

las veces sea encontrado el último elemento de la lista.
v Más conveniente: tener una variable de instancia que

siempre referencie al último elemento de la lista.
v Esto aplica a listas con o sin nodo fantasma (con pequeños

cambios).

Mejora al procedimiento de inserción de
elementos al final de la lista (cont.)
v Diagrama de clases:
Lista Nodo
1..1
data: int
agregarAlFinal(d:Data) head
estáContenido(d:Data) getData():Data
eliminar(d:Data):boolean 1..1 1..1 setNext(n:Nodo)
imprimirContenido() getNext():Nodo
tail Nodo(d:Data,n:Nodo)
v Diagrama de objetos:
head ghost:Nodo 1stNode:Nodo 2ndNode:Nodo
Lista
data = 20 data = -1
tail

de la lista (cont.)
v La variable de instancia tail mantiene siempre la

referencia al último elemento:
public class Lista{
Nodo head, tail;
public Lista(){
head head = new Nodo(0, null);
null tail = head;
tail }
...
}
25 1 4
head
null
tail

de la lista (cont.)
v El método agregarAlFinal ya no requiere recorrer la
lista para ubicar el último nodo:
public void agregarAlFinal(int dato){ Versión con

Nodo aux = new Nodo(dato, null) ; nodo fantasma
tail.setNext( aux );
tail = aux;
}
v La varaible tail es actualizada después de la inserción.

v Notar que el procedimiento de eliminación debe actualizar
la referencia tail si se remueve el último nodo de la lista.

Inserción en orden/al inicio
v Ejercicio 1: implemente el método:

agregarEnOrden(int dato)
que recibe un entero y lo agrega en orden
ascendente a la lista.
v Ejercicio 2: implemente el método

agregarAlInicio(int dato)
que recibe un entero y lo agrega como
primer elemento.

Resumen listas simplemente enlazadas
v Útiles para guardar un número no predefinido de

elementos.
v Distintas disciplinas para mantener los datos
ordenados (y para removerlos).
v El acceso a los nodos es secuencial; el recorrido es
en una sola dirección (Ejercicio: confrontar con
arreglos)

Listas doblemente enlazadas
v Están diseñadas para un acceso fácil al nodo siguiente y al

anterior.
v Cada nodo contiene dos referencias: una apuntando al nodo
siguiente, y otra apuntando al nodo anterior.
v El acceso a los nodos sigue siendo secuencial.
v La técnica del nodo fantasma puede ser útil también en este
tipo de lista.
1 14 4
head
null
null

Comentarios finales sobre estructuras elementales
v Estar abierto a definir y utilizar otras estructuras.

v Ejemplo: Lista simplemente enlazada y circular
25 1 14 4
head

Colecciones implementadas sobre estructuras
básicas
Franco Guidi Polanco

Escuela de Ingeniería Industrial
Pontificia Universidad Católica de Valparaíso, Chile
fguidi@ucv.cl
Interfaces versus implementación
v En la sección anterior estudiamos estructuras elementales

para implementar colecciones.
v En esta sección estudiaremos colecciones clásicas, desde
dos perspectivas:
§  La interfaz de la colección (cómo se utiliza)
§  La implementación de la colección (cómo se construye)
v Una misma interfaz puede ser soportada por múltiples
implementaciones
v La eficiencia en la operación de una colección va a
depender de su implementación

Listas
v  Representa una colección conformada por una secuencia finita y

ordenada de datos denominados elementos.
v  Ordenada implica que cada elemento tiene una posición.
v  Los elementos corresponden a un tipo de dato.
v  La lista está vacía cuando no contiene elementos.
v  El número de elementos se denomina largo de la lista.
v  El comienzo de la lista es llamado cabeza (head), y el final cola
(tail).
v  Notación: (a1, a2, ..., an).

Lista: versión clásica
v Además de los datos, el estado de la lista contiene

una identificación (referencia) al “dato actual”.
(12, 22, 50, 30).
v La lista provee operaciones para:
§  Cambiar (modificar la referencia) del dato actual
§  Retornar el dato actual
§  Eliminar el dato actual
§  Modificar el dato actual
§  Insertar un dato en la posición del dato actual
§  Borrar toda la lista, buscar elementos en la lista, contar
sus elementos

Interfaces para la versión clásica de la lista
v No hay una única definición formal de interfaz.
v Estudiaremos dos extremos:

§  Interfaz elemental
§  Interfaz extendida

Interfaz elemental para la lista clásica
public interface List {

public void clear(); // Elimina todos los elem.
public void insert(Object item); // Inserta elem. en act.
public Object remove(); // Saca/retorna elem.
public void setFirst(); // Setea act. en 1ra pos.
public void next(); // Mueve act. a sig. pos.
public int length(); // Retorna largo
public void setValue(Object val);// Setea elemento
public Object currValue(); // Retorna elemento
public boolean isEmpty(); // True: lista vacía
public boolean eol(); // True: act en end of list
public String toString(); // Retorna lista de elem.
}
Nota: pos.=posición; act.=posición actual; sig.:siguiente; prev.:previa

Ejemplo de uso de una lista (versión clásica)
v Sea la siguiente lista:
miLista=(12, 22, 50, 30)

Dato actual
v Operaciones:
§  miLista.insert(99) :
miLista=(12, 99, 22, 50, 30)

Dato actual
§  miLista.next():
miLista=(12, 99, 22, 50, 30)

Dato actual
Ejemplo de uso de una lista (versión clásica)
§  miLista.currValue():
miLista=(12, 99, 22, 50, 30)

Dato actual 22
§  miLista.remove():
miLista=(12, 99, 50, 30)

(Nuevo) dato actual 22
§  miLista.setFirst():
miLista=(12, 99, 50, 30)

Dato actual

Interfaz extendida para la lista clásica
public interface ExtendedList {

public void clear(); // Elimina todos los elem.
public void insert(Object item); // Inserta elem. en act.
public void append(Object item); // Agrega elem. al final
public Object remove(); // Saca/retorna elem.
public void setFirst(); // Setea act. en 1ra pos.
public void next(); // Mueve act. a sig. pos.
public void prev(); // Mueve act. a pos. prev.
public int length(); // Retorna largo
public void setPos(int pos); // Setea act. a pos
public void setValue(Object val);// Setea elemento
public Object currValue(); // Retorna elemento
public boolean isEmpty(); // True: lista vacía
public boolean eol(); // True: act en end of list
public String toString(); // Retorna lista de elem.
}
Nota: pos.=posición; act.=posición actual; sig.:siguiente; prev.:previa

Implementación de la lista clásica
v La conveniencia de una u otra implementación depende de

las operaciones definidas en la interfaz.
v Interfaz elemental:
§  Implementación basada en lista simplemente enlazada
§  Implementación basada en arreglos
§  Implementación basada en lista doblemente enlazada
(sobredimensionada)
v Interfaz extendida:
§  Implementación basada en arreglos
§  Implementación basada en lista doblemente enlazada
§  Implementación basada en lista simplemente enlazada

Implementación de la lista clásica basada en
arreglos
v Usa un arreglo para almacenar los elementos de la
lista.
v Los elementos son almacenados en posiciones
contiguas en el arreglo.
v El elemento “i” de la lista se almacena en la celda
“i-1” del arreglo.
v La cabeza de la lista siempre está en la primera
posición del arreglo (0).
v El máximo número de elementos en la lista se
define al crear el arreglo.

Inserción en lista basada en arreglos
Insertar 23
13 12 20 8 3 13 12 20 8 3
0 1 2 3 4 5 0 1 2 3 4 5
(a) (b)
23 13 12 20 8 3
0 1 2 3 4 5
(c)

Comparación entre implementaciones de listas
v Las listas basadas en arreglos tienen la desventaja

de que su número de elementos debe ser
predeterminado.
v Cuando estas listas tienen pocos elementos, se
desperdicia espacio.
v Las listas enlazadas no tienen límite de número
máximo de elementos (mientras la memoria lo
permita).

Comparación entre implementaciones de listas
v Las listas basadas en arreglos son más rápidas que

aquellas basadas en listas enlazadas para el
acceso aleatorio por posición.
v Las operaciones de inserción y eliminación son
más rápidas en las listas enlazadas.
v En general, si el número de elementos que
contendrá una lista es muy variable o desconocido,
es mejor usar listas enlazadas.

Uso de listas
v Supongamos las siguientes implementaciones de la lista:
§  LList, implementa List mediante una lista
simplemente enlazada
§  AList, implementa List mediante un arreglo
v Referenciamos la lista por medio de su interfaz:
...
List lista = new LList(); // Implementación seleccionada
lista.insert( “Hola” );
lista.insert( “chao” );
lista.setFirst();
while( !lista.eol() ){
System.out.println( (Sring)lista.currValue());
lista.next();
}
lista.setFirst();
String eliminado = (String) lista.remove()
...
Uso de listas (cont.)
v Si en el programa anterior ahora se desea utilizar otra

implementación de lista, sólo debe cambiarse la clase a
instanciar.
...
List lista = new AList(); // Implementación seleccionada
lista.insert( “Hola” );
lista.insert( “chao” );
lista.setFirst();
while( !lista.eol() ){
System.out.println( (Sring)lista.currValue());
lista.next();
}
lista.setFirst();
String eliminado = (String) lista.remove()
...
Pilas
v Es un tipo restringido de lista, en donde los

elementos sólo pueden ser insertados o removidos
desde un extremo, llamado top.
v Se le llama también Stack o Lista LIFO (Last In,
First Out).
v La operación para insertar un nuevo elemento se
denomina push.
v La operación para remover un elemento se denomina
pop.

Interfaz para la Pila
public interface Stack {

public void clear(); // Remueve todos los objetos
public void push(Object it); // Agrega objeto al tope
public Object pop(); // Saca objeto del tope
public Object topValue();// Retorna objeto en el tope
public boolean isEmpty(); // True: pila vacía
}

Ejemplo de uso de una pila
v  pila.push(4):
v pila.push(14):
14 top
4 top 4
v pila.push(1): v pila.pop():
1
1 top
14 14 top
4 4 (nuevo)

Implementación de una pila mediante lista
simplemente enlazada
top null Se inserta y remueve

siempre el primer
pila.push(4) elemento:
no se requiere nodo
4
top fantasma
null
pila.push(14)
14 4
top
null
pila.pop()
4
top null
Implementación de una pila mediante un arreglo
top=4
3 5 8 2
0 1 2 3 4 5
v En esta clase, por conveniencia, se usa una

variable top, que siempre está 1 posición más
adelante del elemento “superior” de la pila.

Ejercicio pilas
v Proponga implementaciones de la pila:

§  Basada en un arreglo
§  Basada en una lista simplemente enlazada

Colas
v Es un tipo restringido de lista, en donde los

elementos sólo pueden ser agregados al final, y
removidos por el frente.
v Se le llama también Queue o Lista FIFO (First In,
First Out).
v La operación para agregar un nuevo elemento se
denomina enqueue.
v La operación para remover un elemento se denomina
dequeue.

Interfaz para la Cola
public interface Queue {

public void clear(); // Remueve todos los objetos
public void enqueue(Object it);// Agrega obj. al final
public Object dequeue(); // Saca objeto del frente
public Object firstValue(); // Retorna obj. del frente
public boolean isEmpty(); // Retorna V si cola vacía
}

Ejemplo de uso de una cola
v  cola.enqueue( 20 )
cola=(20)
cola=(20, 15)
cola=(20, 15, 40)

v  cola.dequeue()
cola=(15, 40)
20
v  cola.dequeue()
cola=(40)
15
Cola basada en lista simplemente enlazada
25 1 1 4
front null
rear
v Es conveniente mantener una referencia al último

elemento de la cola (facilita operación enqueue).

Cola basada en arreglos (cont.)
v Aproximación simple: almacenar los “n” elementos de

la cola en las “n” primeras posiciones del arreglo.
rear=3
3 5 8 2
Sacar del frente:

rear=2
5 8 2
Problema: lentitud de procedimiento dequeue (sacar

primer elemento).
Cola basada en arreglos (cont.)
v Aproximación mejorada: al hacer dequeue, no

desplazar elementos, sino asumir que el frente de la
cola se desplaza.
front=0 rear=3
3 5 8 2
Sacar del frente:

front=1 rear=3
5 8 2
Problema: Al sacar y agregar elementos, rear llega a la última
posición del arreglo y la cola no puede crecer, aun cuando existan
posiciones libres al comienzo.

Cola basada en arreglos* (cont.)
v Arreglo circular: Pretender que el arreglo es “circular”, y

permitir que la cola continúe directamente de la última
posición del arreglo a la primera.
front=0 Función de avance

7 0
3 Dados:
6 1
•  pos: posición actual
5
•  size: tamaño arreglo
8 pos=(pos+1);
5 2
if (pos>=size)
2 pos=0;
rear=3
4 3

v  Problema de arreglo circular:

§  Si front es igual a rear, implica que hay 1 elemento.
§  Luego, rear está una posición detrás de front implica que la cola
está vacía.
§  Pero si la cola está llena, rear también está una posición detrás de
front.
v  Problema: ¿Cómo reconocer cuando una cola está vacía o llena?
v  Solución: Usar un arreglo de n posiciones, para almacenar como
máximo n-1 elementos.

v Por conveniencia, se usa una variable front para

apuntar a la posición precedente al elemento
frontal.
v La cola está vacía cuando front=rear.
v La cola está llena cuando rear está justo detrás
de front, o sea cuando la función de avance
indica que de aumentar rear en 1, se llegaría a
front.

Estructuras en Memoria PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Estructuras en Memoria PDF

Cargado por

Copyright:

Formatos disponibles

Estructuras de datos en memoria principal

Franco Guidi Polanco

v Colecciones implementadas sobre las estructuras básicas:

Franco Guidi Polanco (PUCV-EII) 25-05-14 2

v Es una colección ordenada de elementos del

Franco Guidi Polanco (PUCV-EII) 25-05-14 3

v Son estructuras dinámicas: se asigna memoria

Franco Guidi Polanco (PUCV-EII) 25-05-14 4

data data data data

Franco Guidi Polanco (PUCV-EII) 25-05-14 5

v Los nodos de una lista contendrán datos del tipo

Franco Guidi Polanco (PUCV-EII) 25-05-14 6

Franco Guidi Polanco (PUCV-EII) 25-05-14 7

public class Nodo{

Franco Guidi Polanco (PUCV-EII) 25-05-14 9

v Insertar elementos: Ejemplo: [ 25, 1, 14, 4 ]

Franco Guidi Polanco (PUCV-EII) 25-05-14 10

v Caso 1: la lista está vacía (variable head contiene

Franco Guidi Polanco (PUCV-EII) 25-05-14 11

v Caso 2 (general): la lista tiene al menos un

Franco Guidi Polanco (PUCV-EII) 25-05-14 13

v Método que imprime el contenido de la lista:

public class Lista{

Franco Guidi Polanco (PUCV-EII) 25-05-14 14

v Retorna true si el elemento está contenido en la

Franco Guidi Polanco (PUCV-EII) 25-05-14 15

v Requiere identificar el nodo a borrar.

v Caso 2 (general): no es el primer nodo de la lista

v El manejo se simplifica si se utiliza un nodo

Franco Guidi Polanco (PUCV-EII) 25-05-14 19

v Lista vacía: public class Lista{

Primer elemento de la lista

Franco Guidi Polanco (PUCV-EII) 25-05-14 20

v La inserción del primer elemento de la lista entra

Clase public void agregarAlFinal(int dato){

Franco Guidi Polanco (PUCV-EII) 25-05-14 21

v La eliminación del primer elemento de la lista entra

Franco Guidi Polanco (PUCV-EII) 25-05-14 22

public boolean eliminar(int data){

Franco Guidi Polanco (PUCV-EII) 25-05-14 23

v El procedimiento descrito anteriormente requiere que todas

v Más conveniente: tener una variable de instancia que

v Esto aplica a listas con o sin nodo fantasma (con pequeños

Franco Guidi Polanco (PUCV-EII) 25-05-14 24

Franco Guidi Polanco (PUCV-EII) 25-05-14 25

v La variable de instancia tail mantiene siempre la

Franco Guidi Polanco (PUCV-EII) 25-05-14 26

public void agregarAlFinal(int dato){ Versión con

v La varaible tail es actualizada después de la inserción.

Franco Guidi Polanco (PUCV-EII) 25-05-14 27

v Ejercicio 1: implemente el método:

v Ejercicio 2: implemente el método

Franco Guidi Polanco (PUCV-EII) 25-05-14 28

v Útiles para guardar un número no predefinido de

Franco Guidi Polanco (PUCV-EII) 25-05-14 29

v Están diseñadas para un acceso fácil al nodo siguiente y al

Franco Guidi Polanco (PUCV-EII) 25-05-14 30

v Estar abierto a definir y utilizar otras estructuras.

Franco Guidi Polanco (PUCV-EII) 25-05-14 31

Franco Guidi Polanco

v En la sección anterior estudiamos estructuras elementales

Franco Guidi Polanco (PUCV-EII) 25-05-14 33

v Representa una colección conformada por una secuencia finita y

v Colecciones implementadas sobre las estructuras básicas:

v Es una colección ordenada de elementos del

v Son estructuras dinámicas: se asigna memoria

v Los nodos de una lista contendrán datos del tipo

v Insertar elementos: Ejemplo: [ 25, 1, 14, 4 ]

v Caso 1: la lista está vacía (variable head contiene

v Caso 2 (general): la lista tiene al menos un

v Método que imprime el contenido de la lista:

v Retorna true si el elemento está contenido en la

v Requiere identificar el nodo a borrar.

v Caso 2 (general): no es el primer nodo de la lista

v El manejo se simplifica si se utiliza un nodo

v Lista vacía: public class Lista{

v La inserción del primer elemento de la lista entra

v La eliminación del primer elemento de la lista entra

v El procedimiento descrito anteriormente requiere que todas

v Más conveniente: tener una variable de instancia que

v Esto aplica a listas con o sin nodo fantasma (con pequeños

v La variable de instancia tail mantiene siempre la

v La varaible tail es actualizada después de la inserción.

v Ejercicio 1: implemente el método:

v Ejercicio 2: implemente el método

v Útiles para guardar un número no predefinido de

v Están diseñadas para un acceso fácil al nodo siguiente y al

v Estar abierto a definir y utilizar otras estructuras.

v En la sección anterior estudiamos estructuras elementales

v  Representa una colección conformada por una secuencia finita y

v Además de los datos, el estado de la lista contiene

v No hay una única definición formal de interfaz.

v Estudiaremos dos extremos:

v Sea la siguiente lista:

v La conveniencia de una u otra implementación depende de

v Las listas basadas en arreglos tienen la desventaja

v Las listas basadas en arreglos son más rápidas que

v Si en el programa anterior ahora se desea utilizar otra

v Es un tipo restringido de lista, en donde los

v En esta clase, por conveniencia, se usa una

v Proponga implementaciones de la pila:

v Es un tipo restringido de lista, en donde los

v Es conveniente mantener una referencia al último

v Aproximación simple: almacenar los “n” elementos de

v Aproximación mejorada: al hacer dequeue, no

v Arreglo circular: Pretender que el arreglo es “circular”, y

v  Problema de arreglo circular:

v Por conveniencia, se usa una variable front para