Your SlideShare is downloading. ×
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Estructura datos pilas y colas
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Estructura datos pilas y colas

33,805

Published on

0 Comments
8 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
33,805
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
884
Comments
0
Likes
8
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. 3. Estructuras Lineales Estáticas y Dinámicas1. Pilas2. Colas3. Listas enlazadas 1. Simples 2. Dobles
  • 2. Estructuras de Datos Almacenamiento Contiguo LinealesEstructura Almacenamientos de Datos No Contiguo No lineales
  • 3. Operaciones Básicas en Estructuras Lineales1. 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. PILASDefinición:Estructura de datos lineal donde los elementospueden ser añadidos o removidos solo por unextremo.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 ATope -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, variablesy 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-CNOTACION PREFIJA:El operador aparece antes de los operandos. + AB, - A1, /EF, *AC, ^AB, +AB+C, +AB-CNOTACION 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 postfijo2.-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 POSTFIJASe crea un string resultado donde se almacena la expresión en postfijo.1.- Los operandos se agregan directamente al resultado2.- 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 POSTFIJARecorrer la expresion de izquierda a derecha1. Si es un operando 1. almacenar el valor en la pila de valores2. 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 valoresAl 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 Principalclass 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.utilClass 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. COLASDefinicion. Es una lista lineal de elementos en la que lasoperaciones de insertar y eliminar se realizan en diferentesextremos de la cola.Trabajan con filosofía FIFO ( First In - First out), el primerelemento 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 SimplesInsertar.- 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ía1.- Insertar A A2.- Insertar B A B3.- Insertar C A B C4.- Remover Elemento B C5.- Insertar D B C D6.- Remover Elemento C D
  • 27. Implementación de Colas• Arreglo – con frente fijo. – con frente movible. – circular.• Listas ligadas
  • 28. Representación usando arreglosLas colas pueden ser representadas en arreglos deuna dimensión (vector) manteniendo dos variablesque indiquen el FRENTE y FINAL de los elementosde 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 5posiciones. Usando la representación de frente fijo yfrente 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 FInsertar elemento G: Error: Cola llena!!!!
  • 33. Frente Final Cola B C DCola Circular inicial Frente FinalEs una representación Remover lógica de la cola en C D un arreglo.El frente y final son Frente Final movibles. Insertar ECuando 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 yfrente 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 usandoObject 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 Javapublic 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 Javajava.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 collectionAll Implemented Interfaces: Serializable, Iterable<E>, Collection<E>, Queue<E>
  • 42. Constructor SummaryPriorityQueue () Creates a PriorityQueue with the default initial capacity (11) that orders its elements according totheir 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 totheir 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 thespecified 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 Hashjava.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 hashConstructor SummaryHashtable() 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 ENLAZADAS1. 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 siguienteinicio 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. LISTASUna lista es una colección lineal de elementos llamados nodosdonde el orden de los mismos se establece mediante punteros oreferencias y existe un puntero/referencia especial llamado iniciopara localizar al primer elemento.Ejemplos:inicio *Lista enlazada de 0 elementos Información enlaceinicio * Lista enlazada de 4 elementos
  • 50. Los nodos de las listasUn 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 IListapublic 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 listaclass 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. EjercicioImplementar 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 listaclass 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 DOBLESUna lista doble es una estructura lineal de elementos llamadosnodos los cuales contienen dos campos de enlace: uno alelemento anterior y otro al elemento siguiente de la lista.El primer nodo de la lista contiene nulo en su enlace al elementoanterior y el último nodo de la lista contiene nulo en su enlace alelemento siguiente. public class Nodo{ // atributosEstructura 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íainicio = fin =Lista de un solo elementoinicio A finLista de tres elementosinicio 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 Javajava.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 Javajava.utilClass 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 collectionAll Implemented Interfaces: Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, Queue<E>
  • 69. Métodos de la clase LinkedList
  • 70. LISTAS ENLAZADAS CON CABECERAEs una lista enlazada que contiene un nodo especial llamadonodo cabecera que se encuentra al inicio de la misma.NODO CABECERA.- Es un nodo especial que no contieneinformación, solo se utiliza para indicar el inicio de los elementos de lalista.La utilización de un nodo cabecera en listas enlazadaspermiten que la implementación de los métodos de insercióny eliminación sea mas sencilla, ya que evitan tratar de formaexplícita los casos especiales (insertar al inicio o eliminar elprimer elemento). Sin embargo, requieren de un nodo extraen 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 cabecera2.- Lista circular c/cabecera: Nodo cabecera Inicio

×