Pregrado

ESTRUCTURAS LIFO - FIFO

PILAS o STACKS Y COLAS
ESTRUCTURAS LIFO : PILAS o STACKS
Definición
● Lista ordenada de elementos a la cual se puede
insertar o eliminar elementos sólo por uno de los
extremos.

● Estructura de datos de acceso restrictivo a sus

elementos.
Ejemplos reales.
● Pila de libros.
● Pila de funciones.
● Pila de protocolos.
● Navegadores.
● Procesadores de texto
(rehacer deshacer)
Características
● Los elementos se eliminan en
orden inverso al que se insertaron.
● El último elementos que se inserta
en la pila es el primero en salir.
● A diferencia de las colas, en las
pilas los ítems se añaden y se
eliminan en el mismo extremo.
● Estructura LIFO: Last In First Out
(último en entrar, primero en
salir)
Caracteristicas
● La representación gráfica típica:
● El elementos superior se llama TOPE
● No se pueden extraer los elementos C, B y A sin antes extraer D.

● El uso de las pilas es independiente de la implementación interna

Operaciones Básicas
● La pila tiene cinco operaciones básicas, que se definen en su clase
abstracta:
1. clear, que modifica la pila haciendo que sea vacía.
2. empty, que retorna cierto si la pila es vacía.
3. top, que retorna el elemento que está en el tope de la pila.
4. pop, que suprime el elemento que está en el tope de la pila.
5. push, que añade un valor en el tope de la pila.
Operaciones Basicas

● PUSH: Insertar o agregar un elemento a la Pila

○ También se puede decir poner o apilar
● NO existe limite o restricción para agregar
elementos (crece indefinidamente)
● POP : Quitar un elemento de la Pila:
○ Sacar o desempilar
Operaciones Básicas
● EMPTY: Comprobar si la pila está vacía.
Operación necesaria para saber si se pueden eliminar
elementos
NO se puede eliminar de una pila vacía.

● TOP: Ver el elemento en el tope de la pila sin

removerlo

● Otras:
○ Obtener un elemento de la pila
○ Imprimir los elementos de la pila
Aplicaciones de las Pilas
● Proporcionan un medio ordenado de demorar la realización de las
tareas secundarias que aparecen durante la ejecución del programa.
Llamas a procedimientos y métodos.
● Suelen ir asociadas a algoritmos recursivos.
● Tipos derivados:
○ pilas de programas,
○ pila del analizador sintáctico (parser).
Representación en memoria
● Las pilas no son estructuras de datos
fundamentales, es decir, no están definidas como
tales en los lenguajes de programación.
● Las pilas pueden representarse mediante el uso
de :
○ Arreglos.
○ Listas enlazadas.
Representación mediante arreglos
● Limitación: espacio de memoria reservada. Una vez
establecido un máximo de capacidad para la pila, ya
no es posible insertar más elementos.
● Definir el tamaño máximo de la pila.
● Un apuntador al último elemento insertado en la pila
SP.
 Operaciones

Inserción (Push) Eliminación (Pop)

si sp=máximo entonces si sp=0 entonces
mensaje mensaje (underflow)
(overflow) sino
sino
sp sp+1 xpila[sp]
spsp-1
pila[sp] valor
13

PILAS DINAMICAS

Operaciones
Creapila (nodo inicio)
Quitar (nodo inicio) = pop
Agregar (nodo inicio, int dato) =
push
Vacia (nodo inicio)
 Método Push() public class Nodo
{ int dato;
Nodo sig;
2 public Nodo(int num)
{ dato=num;
Dato Dato Dato sig=null;
}
1 }
3 null
Dato

private void push(int num)

{ Nodo nuevo=new Nodo(num);
//Realizando los enlaces correspondientes
if(tope==null)
nuevo.sig=null;
else
nuevo.sig=tope;
tope=nuevo;
}
 public class Nodo
{ int dato;
Método Pop() Nodo sig;
public Nodo(int num)
{ dato=num;
sig=null;
}
}

private void pop()

{ Nodo aux=tope;
tope=tope.sig;
aux.sig=null;
}
 BUSCAR UN NODO CON ALGUNA
CARACTERÍSTICA public class Nodo{
// atributos
public String codigo;
info sig // puntero al siguiente nodo
public Nodo sig ;
info(p)
sig(p) // el constructor de nodos
comienzo Nodo (String cod)
{ codigo=cod;
sig = null;
}
}
p
private Nodo Buscar(Nodo tope,String cod)
{ Nodo pos=tope;
//Recorriendo la lista para encontrar la información
while(pos!=null &&
!cod.equalsIgnoreCase(pos.codigo))
pos=pos.sig;
//Retorno de la posición del dato
return pos;
}
Notación PostFija - RPN
● Notación Infija : El operador se encuentra entre los dos
operandos.
a+b
● Prefija. El operador se ubica antes de los operandos:
+ab
● Postfija. El operador se ubica después de los operandos:
ab+
Por ejemplo, la siguiente expresión infija,
(((5+9)*2)+(6*5))
se puede escribir usando notación postfija de la siguiente
forma:
59+2*65*+
Notación PostFija
● La notación postfija (y prefija) no necesita de
paréntesis para expresar el orden de los operadores.
● Una expresión postfija se puede evaluar con la ayuda
de una pila usando el siguiente procedimiento:

Recorrer la expresión de izquierda a derecha y para

cada termino hacer:
1. Sí el término es un valor, introducirlo en una pila
2. Sí el término es un operador:
○ Sacar dos operandos de la pila.
○ Aplicar el operador.
○ Meter el resultado en la pila.
 Ejempl
o
Infija: 5+((1+2)*4)-3
Postfija: 5 1 2 + 4 * + 3 –
Se evalúa de izquierda a derecha según se muestra en la siguiente tabla.
La "Pila" es la lista de los valores que el algoritmo mantiene en su memoria
después de realizar la operación dada en la segunda columna.
Entrada Operación Pila Comentario
5 Introducir en la pila 5
1 Introducir en la pila 5, 1
2 Introducir en la pila 5, 1, 2
Tomar los dós últimos valores de la pila (1, 2) y
+ Suma 5, 3
sustituirlos por el resultado (3)
4 Introducir en la pila 5, 3, 4
Tomar los dos últimos valores de la pila (3, 4) y
* Multiplicación 5, 12
sustituirlos por el resultado (12)
Tomar los dós últimos valores de la pila (5, 12) y
+ Suma 17
sustituirlos por el resultado (17)
3 Introducir en la pila 17, 3
Tomar los dos últimos valores de la pila (17, 3) y
− Resta 14
sustituirlos por el resultado (14)
 Algoritmo.
1. Se lee la entrada, elemento a
elemento, x:
Si es un operando → se mete en
la pila: push(P, x)
Si es un operador → se sacan
los operandos, se realiza la
operación y se guarda el
resultado en la pila:
pop (P, op1);
pop(P, op2);
evaluar (x, op1, op2,
res);
push(P, res)
2. Al terminar de leer la entrada,
en el tope de la pila P debe
quedar el resultado de la
operación
ESTRUCTURAS FIFO : COLAS
 public class Nodo

frente Método EnColar() { int dato;

Nodo sig;
public Nodo(int num)
{ dato=num;
2 sig=null;
fincola
Dato Dato Dato }
}
1
3 null
Dato
private void EnColar(int num)
{ Nodo nuevo=new Nodo(num);
//Realizando los enlaces correspondientes
if(frente==null)
frente=nuevo;
else
fincola.sig=nuevo;
fincola=nuevo;
fincola.sig=null;
}
 public class Nodo
Método Frente() { int dato;
Nodo sig;
public Nodo(int num)
frente { dato=num;
fincola
sig=null;
}
}

private void frente()

{ Nodo aux=frente;
//Eliminando el primer elemento de la cola
frente=frente.sig;
aux.sig=null
}
 BUSCAR UN NODO CON ALGUNA
CARACTERÍSTICA public class Nodo{
// atributos
info sig public String codigo;
// puntero al siguiente nodo
info(p) public Nodo sig ;
sig(p)
// el constructor de nodos
comienzo Nodo (String cod)
{ codigo=cod;
sig = null;
}
p }

private Nodo Buscar(Nodo frente,String cod)

{ Nodo pos=frente;
//Recorriendo la lista para encontrar la información
while(pos!=null &&
!cod.equalsIgnoreCase(pos.codigo))
pos=pos.sig;
//Retorno de la posición del dato
return pos;
}