Está en la página 1de 24

Lenguaje de Programacin Estructurado

TIPOS DE DATOS ABSTRACTOS: PILAS Y COLAS

21/11/2015 1
Qu es una Pila?
Tambin conocida como Stack, es un tipo de datos abstracto que
acta como coleccin de elementos y soporta las siguientes
operaciones:

- Apilar (push): Agregar un elemento a la coleccin (pila)

- Tope (top): Obtener el ltimo elemento agregado

- Desapilar (pop): Remover el ltimo elemento agregado

Adicionalmente es posible considerar las siguientes operaciones:

- Vaco (empty): Indicar si la coleccin esta vaca

- Tamao (size): Indicar la cantidad de elementos de la coleccin

21/11/2015 2
Qu es una Cola?
Tambin conocida como Queue, es un tipo de datos abstracto que
acta como coleccin de elementos y soporta las siguientes
operaciones:

- Encolar (enqueue): Agregar un elemento a la coleccin (cola)

- Frente (front): Obtener el primer elemento de la cola

- Desencolar (dequeue): Remover el primer elemento de la cola

Adicionalmente es posible considerar las siguientes operaciones:

- Vaco (empty): Indicar si la coleccin esta vaca

- Tamao (size): Indicar la cantidad de elementos de la coleccin

21/11/2015 3
Pila vs Cola

Pila LIFO: Last-in, First-out (ltimo en entrar, primero en salir)

Cola FIFO: First-in, First-out (primero en entrar, primero en salir)

21/11/2015 4
Implementacin de Pila: Usando arreglos

Se mantiene una variable, size, que indica el tamao de la pila y


Pila basada en arreglo al mismo tiempo la posicin en la que se agregar el prximo
elemento.

Apilar (push):
v= v0 v1
- Guardar el nuevo elemento en la posicin size
- Incrementar variable de tamao size: size = size + 1
0 1 2
Tope (top):
size - Retornar el elemento en la posicin size - 1

Desapilar (pop):
- Reducir variable de tamao size: size = size - 1

21/11/2015 5
Implementacin de Pila: Usando arreglos
#include <iostream>

using namespace std;

#define MAX_SIZE 1000

struct Stack {
int v[MAX_SIZE];
int size;
v= v0 v1

Stack() { int main() {


Stack pila;
0 1 2
size = 0;
}
bool empty() { if(pila.empty()) {
return size == 0; cout<<"Pila vacia"<<endl; size
} }
int top() {
return v[size - 1]; pila.push(5);
} pila.push(4); Desventaja: El tamao mximo se ve
void push(int value) { cout<<pila.top()<<endl; // 4
limitado por el tamao del arreglo utilizado
v[size] = value;
size++; pila.pop();
} cout<<pila.top()<<endl; // 5
void pop() {
size--; return 0;
} }
};

21/11/2015 6
Implementacin de Cola: Usando arreglos
Se mantienen dos variables: front, que indica el ndice del
primer elemento de la cola (ms antiguo), y back, que indica la
posicin en la que se agregar el prximo elemento.
Cola basada en arreglo
Inicialmente front = 0 y back = 0

v= v2 v3 Encolar (enqueue):
- Guardar el nuevo elemento en la posicin back
0 1 2 3 4 - Incrementar variable back: back = back + 1

Frente (front):
front back - Retornar el elemento en la posicin front

Desencolar (dequeue):
- Incrementar la variable front: front = front + 1

Tamao (size):
- Retornar size = back - front
21/11/2015 7
Implementacin de Cola: Usando arreglos
#include <iostream>
using namespace std;

#define MAX_SIZE 1000

struct Queue {
int v[MAX_SIZE];
int _front, _back; v= v3
Queue() {
v2
_front = 0;
_back = 0; 0 1 2 3 4
} int main() {
bool empty() { Queue cola;
int size = _back - _front;
return size == 0; if(cola.empty()) { front back
} cout<<"Cola vacia"<<endl;
int front() { }
return v[_front];
} cola.enqueue(5); Desventaja: El tamao mximo se ve
void enqueue(int value) { cola.enqueue(4); limitado por el tamao del arreglo utilizado
v[_back] = value; cout<<cola.front()<<endl; // 5
_back++;
} cola.dequeue();
void dequeue() { cout<<cola.front()<<endl; // 4
_front++;
} return 0;
}; }

21/11/2015 8
Lenguaje de Programacin Estructurado
TIPOS DE DATOS ABSTRACTOS: PILAS Y COLAS
BASADAS EN LISTAS ENLAZADAS

21/11/2015 9
Implementacin de Pila: Usando lista enlazada
Pila basada en lista

Se hace uso de 2 estructuras:


3 19
<<nodo>> - Pila (Stack): Contiene la cantidad de elementos y un puntero
<<pila>> al nodo tope de la pila.

Cantidad de Puntero a - Nodo (Node): Contiene el valor o valores propios del nodo y
elementos nodo siguiente un puntero al nodo siguiente.
99
<<nodo>> Apilar: Insertar un nuevo nodo en el tope
Puntero a
nodo tope Tope: Retornar el elemento del nodo tope

47 Desapilar: Remover el nodo tope y actualizar puntero de la pila


<<nodo>> hacia el nodo siguiente
Puntero nulo

21/11/2015 10
Implementacin de Pila: Usando lista enlazada
Pila basada en lista

Constructor:
Apilar(push):
<<pila>>
2 _top 54 Node* nodo = new Node();
size=0 Puntero nulo nodo->value = 54;
<<pila>> nodo->next = _top;
_top = nodo;
size++;
Tope(top): 19

1 _top 19
<<nodo>>
<<pila>>

return _top->value;

21/11/2015 11
Implementacin de Pila: Usando lista enlazada
Pila basada en lista

Apilar(push):
Desapilar(pop):

2 _top 54 top 54 Node* top = _top;


1 _top _top = _top->next;
<<pila>> delete(top);
<<pila>>

19
19

21/11/2015 12
Implementacin de Pila: Usando lista enlazada
#include <iostream> struct Stack {
Node* _top;
using namespace std; int size;
Stack() {
struct Node { _top = NULL;
int value; size = 0;
Node* next; }
}; bool empty() {
return size == 0;
}
int top() {
return _top->value;
}
int main() {
void push(int value) {
Stack pila;
Node* nodo = new Node();
nodo->value = value;
if(pila.empty()) {
nodo->next = _top;
cout<<"Pila vacia"<<endl;
_top = nodo;
}
size++;
}
pila.push(5);
void pop() {
pila.push(4);
Node* top = _top;
cout<<pila.top()<<endl; // 4
if(size > 0) {
_top = _top->next;
pila.pop();
delete(top);
cout<<pila.top()<<endl; // 5
size--;
}
return 0;
}
21/11/2015 } 13
};
Ejemplo 1: Convertir de base 10 a base 2
19 = 9 * 2 + 1
9=4*2+1 Algoritmo:
4=2*2+0
2=1*2+0 1. Mientras n > 0
1=0*2+1 1. digitos.push(n mod 2)
2. n = n / 2
19 = 100112 2. Mientras pila.empty() == false
1. imprimir(pila.top())
2. pila.pop()

21/11/2015 14
Ejemplo 2: Notacin Polaca Inversa
Inventada en 1954 para evaluar expresiones de manera rpida minimizando el uso de
memoria del computador. Implementada en mltiples calculadoras de la poca. No requiere
el uso de parntesis.

54+ 9
54+3* 27
54+32** 54 Equivalente a (5 + 4) * (3 * 2)

Algoritmo:

1. Mientras hay tokens en el input


1. Leer token
2. Si el token es un numero
1. Agregarlo a la pila
3. En caso contrario, si es un operador
21/11/2015 15
Ejemplo 2: Notacin Polaca Inversa
Algoritmo:

1. Mientras hay tokens en el input


1. Leer token
2. Si el token es un numero
1. Agregarlo a la pila
3. En caso contrario, el token es un operador
1. Se sabe que el operador necesita n operandos
2. Si hay menos de n valores en la pila
1. (Error) El usuario no ha ingresado suficientes valores
3. En caso contrario, extraer n valores de la pila
4. Evaluar el operador con los n operandos
5. Agregar el resultado a la pila
2. Si solo queda un valor en la pila
1. Ese valor es el resultado de la expresin
3. En caso contrario, si hay mas valores en la pila
1. (Error) El usuario ha ingresado demasiados valores

21/11/2015 16
Ejemplo 2: Notacin Polaca Inversa

21/11/2015 17
Implementacin de Cola: Usando lista enlazada
Cola basada en lista

Se hace uso de 2 estructuras:


3 19
<<nodo>> - Cola (Queue): Contiene la cantidad de elementos, un
<<cola>> puntero al nodo frente (primer nodo), y un puntero al
ultimo nodo de la cola.
Puntero a
Cantidad de
nodo siguiente - Nodo (Node): Contiene el valor o valores propios del nodo y
elementos
99 un puntero al nodo siguiente.
<<nodo>>
Puntero a Encolar (enqueue) : Insertar un nuevo nodo al final de la cola
nodo frente
Frente (front): Retornar el nodo del frente (primer nodo)
Puntero a
47
ltimo nodo <<nodo>> Desencolar (dequeue): Remover el nodo del frente y actualizar
Puntero nulo puntero de la cola hacia el nodo siguiente

21/11/2015 18
Lenguaje de Programacin Estructurado
TIPOS DE DATOS ABSTRACTOS:
ARREGLOS DINMICOS

21/11/2015 19
Arreglos Dinmicos
Podemos crear arreglos cuyo numero de elementos no sea constante?
S, utilizando gestin dinmica de memoria! (dynamic memory allocation)
0
get(1) Podemos crear una estructura con las siguientes operaciones:
1
- Agregar (.add(x)): Agregar un elemento al final de la estructura
2

3 - Obtener i-simo elemento (.get(i))

add(x) x - Tamao (.size()): Indicar la cantidad de elementos

21/11/2015 20
Operador new[]
Reservar un bloque de memoria

El operador new[], usado del modo new tipo[n], reserva un bloque de memoria con espacio para n
elementos de determinado tipo de datos. Retorna un puntero hacia el primer elemento del bloque.

int* ptr1 = new int[n]; // El puntero ptr1 apunta a un bloque de n enteros


Alumno* ptr2 = new Alumno[n]; // El puntero ptr2 apunta a un bloque de n Alumnos

Acceder a un elemento del bloque de memoria

Podemos acceder a los elementos usando aritmtica de punteros:

*(ptr1 + 5) = 1234; // Asignando el valor 1234 al elemento 5


cout << *(ptr1 + 5) << endl; // Obteniendo el valor del elemento 5

Adicionalmente, podemos acceder al bloque como si se tratara de un arreglo:


ptr1[0] = 4321; // Asignando el valor 4321 al elemento 0
cout << ptr1[0] << endl; // Obteniendo el valor del elemento 0
21/11/2015 21
Arreglo Dinmico

1. Constructor: 2. Agregar elemento:

ptr ptr

Usando new[], crear 123 Si el nmero actual de


size = 0 0
un bloque inicial con elementos es menor a la
cierta capacidad pero capacidad, almacenar el
1 sin ningn valor size = 1
nuevo elemento en la
almacenado siguiente posicin
2 2 disponible del bloque.
3 3
En caso contrario, es
necesario incrementar la
capacity = 4 capacity = 4
capacidad!

21/11/2015 22
Arreglo Dinmico
3.3. Eliminamos el
bloque antiguo y
3. Incrementar capacidad:
actualizamos referencias

ptr ptrNuevo ptr ptrNuevo ptr

123 123 123 123 0 123


0
37 37 37 37 1 37
1
56 56 56 56 2 56
2

3 99 99 99 99 3 99

size = capacity = 4 size = 4

3.1. Creamos un nuevo 3.2. Copiamos todos


bloque con el doble de los valores hacia el
capacidad nuevo bloque

21/11/2015 23
capacity = 8
Operador delete[]
Liberar un bloque de memoria

El operador delete[], usado del modo delete[] ptr, libera el bloque de memoria apuntado por el
puntero ptr. La memoria liberada, ya no debe ser utilizada por el puntero, puesto que puede ser utilizada
por otra variable o programa.

int* ptr1 = new int[n];


delete[] ptr1; // Liberar la memoria del bloque de n enteros

Alumno* ptr2 = new Alumno[n];


delete[] ptr2; // Liberar la memoria del bloque de n Alumnos

21/11/2015 24

También podría gustarte