Sei sulla pagina 1di 8

EDA I

Definición de pila

EDA I Definición de pila Una pila es una colección lineal de elementos en la que

Una pila es una colección lineal de elementos en la que sólo se pueden añadir y retirar elementos por uno de sus extremos. Se procesa con una estrategia LIFO (Last In First Out)

EDA I Pilas tercero top 1. push “primero” 2. push “segundo” segundo 3. push “tercero”
EDA I
Pilas
tercero
top
1. push “primero”
2. push “segundo”
segundo
3. push “tercero”
primero
4. pop
Pilas
2
EDA I
EDA I

tipo pila(T) usa bool operaciones pvacia: pila(T) apilar: T × pila(T) pila(T) cima: pila(T) T desapilar: pila(T) pila(T) es_vacia: pila(T) bool

ecuaciones (1) cima(pvacia) = error (2) cima(apilar(x, p)) = x (3) desapilar(pvacia) = error (4) desapilar(apilar(x, p)) = p (5) es_vacia(pvacia) = True

(Recuérdese: Metodología de la programación)

(6) es_vacia(apilar(x, p))

= False

Pilas

3

Operaciones en una pila

Operación

Descripción

push

Añade un elemento a la parte superior de la pila

pop

Elimina y devuelve un elemento de la parte superior de la pila (supone que la pila no está vacía)

peek

Da acceso al elemento situado en la parte superior de la pila (supone que la pila no está vacía)

isEmpty

Determina si la pila está vacía

size

Determina el número de elementos de la pila

Pilas

4

EDA I

Pila genérica de elementos T

Pila(T)

// El identificador T es un parámetro genérico de clase

// crea una pila de elementos de clase T vacía crear: Pila(T)

// añade un elemento de clase T a la cima de una pila

push: Pila(T) × T

// devuelve y retira el elemento de la cima de una pila // (supone que la pila no está vacía)

pop: Pila(T)

// devuelve el elemento de la cima de una pila // (supone que la pila no está vacía)

peek: Pila(T)

// true si la pila está vacía y false en el caso contrario

isEmpty: Pila(T)

// devuelve el número de elementos que hay en la pila

size: Pila(T)

Pila(T)

T ×Pila(T)

T

boolean

natural

Pilas

5

EDA I

Interfaz del TAD Pila

public interface PilaTAD<T> {

//Añade un elemento a la cima de la pila public void push (T element);

//Elimina y devuelve el elemento de la cima de la pila //(supone que la pila no está vacía) public T pop ();

//Devuelve, sin eliminarlo, el elemento de la cima de la pila //(supone que la pila no está vacía) public T peek ();

//Devuelve true si esta pila no contiene ningún elemento, //y false en caso contrario public boolean isEmpty ();

//Devuelve el número de elementos de la pila public int size();

}

Pilas

6

EDA I

Problemas a resolver

public int size(); } Pilas 6 EDA I Problemas a resolver Cada tarea que llega, interrumpe
public int size(); } Pilas 6 EDA I Problemas a resolver Cada tarea que llega, interrumpe
public int size(); } Pilas 6 EDA I Problemas a resolver Cada tarea que llega, interrumpe

Cada tarea que llega, interrumpe la que se esté haciendo y debe ser atendida. Luego debe continuarse con la última tarea que se estuviera haciendo.

Implementación con una pila de tareas

Pilas

7

Invertir una palabra

EDA I

algoritmo omtirogla o m t Apilando según i construyendo según vamos desapilando vamos leyendo r
algoritmo
omtirogla
o
m
t
Apilando según
i
construyendo según
vamos desapilando
vamos leyendo
r
o
g
l
(Véase Reverser)
a

Pilas

8

Problema:

EDA I

Determinar si los delimitadores {, }, [, ], (, ), están bien emparejados en una cadena de caracteres dada.

están bien emparejados en una cadena de caracteres dada. EDA I Uso de una pila para

EDA I

Uso de una pila para la solución

Para la entrada A{B(C[D]E)F}

de una pila para la solución Para la entrada A{B(C[D]E)F} Pilas 9 Pilas 1 0  
de una pila para la solución Para la entrada A{B(C[D]E)F} Pilas 9 Pilas 1 0  
de una pila para la solución Para la entrada A{B(C[D]E)F} Pilas 9 Pilas 1 0  

Pilas

9

Pilas

10

 

EDA I

EDA I

Comprobador de delimitadores

 

Arrays en Java

Variable de estado String input

 

public void check() {

Crear pila theStack del tamaño de input para cada ch de input hacer

{

 

Los arrays en java son objetos

int[ ] miTabla; miTabla = new int[100];

// define una referencia a un objeto array de enteros

 

si ch es '{‘, '[‘ o ‘(‘ entonces theStack.push(ch); (*Apilar ch*) si no si ch es ‘}‘, ‘]‘ o ‘)‘ entonces si ( !theStack.isEmpty() ) (*Pila no vacía*) entonces

{

 

// crea un objeto array de tamaño 100 y // hace que miTabla lo referencie

El primer índice de un array es el 0 El atributo length, indica el número de posiciones del array Véase EjemArray.java (análisis de sus fragmentos de búsqueda y eliminación)

 
 

chx = theStack.pop(); (*Desapilar*) si (chx y ch no emparejan bien) Comunicar el error y terminar

}

si no // la pila está vacía prematuramente

 

}

Comunicar el error y terminar // fin del para

// Todos los caracteres de input se han procesado

 

si ( !theStack.isEmpty() ) (*Pila no vacía*) Comunicar el error } // end check()

(Véase BracketChecker)

 

Pilas

11

Pilas

12

EDA I

Implementación de Pila con Array

(0)

EDA I

Implementación de Pila con Array

(1)

import pilaTAD.PilaTAD;

public class PilaArray<T> implements PilaTAD<T> { A B C D private int maxSize; private T[]
public class PilaArray<T> implements PilaTAD<T> {
A
B C
D
private int maxSize;
private T[] stackArray;
private int top;
// size of stack array
// top of stack
0
1 2
3
4
5
6
7
8
9
//--------------------------------------------------------------
public PilaArray(int alturaMax)
// constructor
{
maxSize = alturaMax;
// set array size
top
stackArray = (T[])(new Object[maxSize]); // create array
top = -1;
// no items yet
}
//--------------------------------------------------------------
stackArray
top = 3
maxSize = 10
public void push(T elemento)
// put item on top of stack
{
stackArray[++top] = elemento;
// increment top, insert item
}
//--------------------------------------------------------------

Pilas

13

public T pop()

// take item from top of stack

{

return stackArray[top--]; // access item, decrement top

}

Pilas

14

EDA I

Implementación de Pila con Array

(2)

//--------------------------------------------------------------

public T peek()

// peek at top of stack

{

return stackArray[top];

}

//--------------------------------------------------------------

public boolean isEmpty()

{

return (top == -1);

}

// true if stack is empty

//--------------------------------------------------------------

public int size() //Número de elementos que hay en esta pila

{

return (1+top);

}

//--------------------------------------------------------------

}

public boolean isFull()

// true if stack is full

{

return (top == maxSize-1);

}

Todas las operaciones son O(1)

Pilas

15

EDA I

Diseño de una estructura ligada

Generalmente, una estructura ligada bien diseñada constará de la clase de nodos y de una clase con una o más referencias a nodos distinguidos

Un nodo incluirá:

Campos de datos y

Una o más referencias de la clase del nodo (la clase de los nodos es auto-referencial )

Pilas

16

EDA I

Definición de un nodo

class Link

{

public int iData; public double dData; public Link next;

}

// datos en el nodo // datos en el nodo // siguiente nodo en la estructura

Link

Link

Link

Data Data Data next next next
Data
Data
Data
next
next
next

Denominamos NODO a un objeto de la estructura ligada (en esta figura hay tres nodos de la clase Link)

EDA I

Definición de una estructura ligada

class LinkedList

{

private Link first; // referencia a nodo distinguido

public LinkedList() { first = null;

// constructor

}

public boolean isEmpty() {…….} public void insertFirst(int id, double dd) {…….} public Link deleteFirst() {…….} public void displayList() {…….} public Link find(int key) {…….} public Link delete(int key) {…….}

LinkedList first
LinkedList
first

}

Link

Link

Link

Link

Data Data Data Data next next next next
Data
Data
Data
Data
next
next
next
next

null

Pilas

17

Pilas

18

 

EDA I

EDA I

 

Insertar al principio

 

Retirar el primero

Linked List

Link

Link

Link

Linked List

Data next
Data
next
Data next
Data
next
Data next
Data
next

null

Link Link Link Link Data Data Data Data first next next next next temp
Link
Link
Link
Link
Data
Data
Data
Data
first
next
next
next
next
temp

public Link deleteFirst ( ) { Link temp = first; first = first.next; return temp;

null

Link Data first next Data next
Link
Data
first
next
Data
next

newLink

public void insertFirst (int id, double dd) { Link newLink = new Link(id, dd); newLink.next = first; first = newLink;

 

}

}

 

Coste: O(1)

 

Coste: O(1)

Pilas

19

Pilas

20

EDA I

Imprimir los datos de la estructura

public void displayList()

{

System.out.print("List (first-->last): ");

Link current = first;

while(current != null)

// start at beginning of list // until end of list,

{

current.displayLink();

current = current.next; // move to next link

}

// print data

System.out.println("");

}

Véanse LinkList.java

y

LinkList2.java

Coste: O(n)

EDA I

Implementación de Pila con estructura ligada (0)

first D length = 4 C B A
first
D
length = 4
C
B
A

Pilas

21

Pilas

22

 

EDA I

EDA I

Implementación de Pila con estructura ligada (1)

Implementación de Pila con estructura ligada (2)

import pilaTAD.PilaTAD;

//Elimina y devuelve el elemento de la cima de la pila public T pop (){ LinkG<T> temp = first; first = first.next;

length--; return temp.data;

public class PilaLigada<T> implements PilaTAD<T>{ private LinkG<T> first; private int length;

public PilaLigada(){ first = null; length = 0;

}

 

}

//Devuelve, sin eliminarlo, el elemento de la cima de la pila

 

public T peek (){ return (first.data);

}

 
 

//Añade un elemento a la cima de la pila public void push (T element){ LinkG<T> newLink = new LinkG<T>(element); newLink.next = first; first = newLink; length++;

 

//Devuelve true si esta pila no contiene ningún elemento, y false en caso contrario public boolean isEmpty (){ return (first==null);

 

}

}

//Devuelve el número de elementos de la pila public int size(){ return length;

 

}

Todas las operaciones son O(1)

 
 

}

Pilas

23

Pilas

24

EDA I

Más ejemplos de uso

Evaluador de expresiones postfijas: Véase sección 6.2 de [Lewis, Chase]

(3 * 4 – (2 + 5)) * 4 / 2

3

4 * 2

5

+

4 * 2

/

-

en notación infija en notación postfija

Método evaluador

EDA I

// Se supone que expr es una expresión postfija bien formada // Devuelve el resultado de evaluar expr public int evaluate (String expr) { while “no se haya procesado toda la expr” { Tomar siguiente elemento de la expr if “elemento es operador” { op2 = extraer cima de la pila op1 = extraer cima de la pila resultado = operar (elemento, op1, op2) Poner resultado en la cima de la pila

}

else

Poner elemento en la pila (porque es un valor) //end if }//end while return “la cima de la pila”

}

Pilas

25

Pilas

26

 

EDA I

EDA I

Busca camino en un laberinto

Método de recorrido del laberinto

private int [ ] [ ] laberinto = { {1,1,1,0,0,1,0},

public boolean traverse (){ Poner posición inicial en la cima de la pila while “la posición no sea la salida” y “tenga esperanza de poder llegar a la salida” { posición = extraer la cima de la pila Marcar esa posición como visitada if “la posición es la salida” terminar el while

 

{1,1,0,1,0,1,0},

{0,1,0,1,1,1,1},

{1,1,1,0,1,0,0},

{0,0,1,1,1,0,1},

{1,0,0,0,1,0,1},

else {

{1,1,1,1,1,0,0},

para cada casilla posible de avance desde posición:

{1,0,0,0,0,1,1}

apilar esa casilla /* puede verse como una tarea que queda por hacer: intentar el camino desde esa casilla*/

}

 

{1,1,1,1,1,1,1} };

laberinto [fila] [columna] == 1 “esa casilla es pasillo” laberinto [fila] [columna] == 0 “esa casilla es pared”

}//end while if “la posición es la salida” return true else return false

}

Pilas

27

Pilas

28

Lectura

De [Lewis, Chase 2006]

Capítulo 6

EDA I

Pilas

29