PRESENTACIÓN

3ER CORTE
PILAS COLAS Y LISTAS
WILLDERS CARVAJAL
C.I. 27.362.966
EXTENSIÓN VALENCIA
 PILAS
Las pilas son un tipo de estructura de dato bastante frecuente y es
utilizada para almacenar cierta cantidad de datos en un orden en
concreto. En el caso de las pilas la forma en la que se almacenan
dichos datos es llamado LIFO ( Last in First Out) esto debido a
que el ultimo dato ingresado siempre será el primero en salir. El
ejemplo mas común para explicar como funciona esta estructura es
un pila de platos siempre colocas un plato encima del anterior y
cuando quieres sacar un plato sacas el de la cima es decir el ultimo
que colocaste en la pila
 CONCEPTO
Una pila es una lista ordenada o estructura de datos que permite almacenar y recuperar datos,
siendo el modo de acceso a sus elementos de tipo LIFO (del inglés Last In, First Out, «último
en entrar, primero en salir»). Esta estructura se aplica en multitud de supuestos en el área de
informática debido a su simplicidad y capacidad de dar respuesta a numerosos procesos.
 ORGANIZACIÓN Y ACCESO A DATOS

El modo de acceso a sus elementos de tipo LIFO (del inglés Last In,
First Out, «último en entrar, primero en salir») .
Para el manejo de los datos cuenta con dos operaciones básicas:
apilar (push), que coloca un objeto en la pila, y su operación inversa,
retirar (o desapilar, pop), que retira el último elemento apilado.
En cada momento solamente se tiene acceso a la parte superior de la
pila, es decir, al último objeto apilado (denominado TOS, Top of
Stack en inglés). La operación retirar permite la obtención de este
elemento, que es retirado de la pila permitiendo el acceso al anterior
(apilado con anterioridad), que pasa a ser el último, el nuevo TOS.
 OPERACIONES PRIMITIVAS
Habitualmente, junto a las dos operaciones básicas de apilar y desapilar (push, pop), las
pilas puede implementar otra serie de funciones:
• Crear (constructor): crea la pila vacía.
• Tamaño (size): regresa el número de elementos de la pila.
• Apilar (push): añade un elemento a la pila.
• Desapilar (pop): lee y retira el elemento superior de la pila.
• Leer último (top o peek): lee el elemento superior de la pila sin retirarlo.
• Vacía (empty): devuelve cierto si la pila está sin elementos o falso en caso de que contenga
alguno.
 IMPLEMENTACIÓN
package pilas;
public class Pila {
Las pilas suelen emplearse en los siguientes contextos: Nodo tos;//Top Of Stack
public void apilar(char dato) {
Nodo nuevo = new Nodo(dato);
• Evaluación de expresiones en notación postfija if (tos == null) {
tos = nuevo;
(notación polaca inversa). } else {
nuevo.setSiguiente(tos);
tos = nuevo;
• Reconocedores sintácticos de lenguajes }
}
independientes del contexto. public char desapilar() {
Nodo temp = tos;
tos = tos.getSiguiente();
• Implementación de recursividad. return temp.getDato();
}
public void imprimir() {
Nodo temp = tos;
while (temp != null) {
System.out.print(temp.getDato() + "\n");
temp = temp.getSiguiente();
}
}
}
 EXPRESIONES ARITMÉTICAS
Se calcula empleando la notación polaca Por ejemplo, el cálculo:
inversa utilizando una estructura de pila para ((1 + 2) * 4) + 3
almacenar temporalmente los valores. Las se traduciría o notación postfija
expresiones pueden ser representadas en con la ventaja de no tener que
prefijo, infijo, postfijo. La conversión de una atender a la jerarquía de
forma de expresión a otra forma, necesita de prioridades:
una pila. Muchos compiladores utilizan una
En notación postfija: 1 2 + 4 * 3 +
pila para analizar la sintaxis de las
expresiones, bloques de programa, etc.
 ENTRADA OPERACIÓN PILA
La expresión es evaluada de izquierda a 1 Apilar operando 1
derecha utilizando una pila: 2 Apilar operando 1, 2
+ Sumar operandos* 3
• Diagrama de flujo para resolver una
4 Apilar operando 3, 4
expresión en notación postfija * Multiplicar operandos* 12
• Apilar cuando el dato sea un operando 3 Apilar operando 12, 3
+ Sumar operandos* 15
• Desapilar dos operandos y evaluar el valor
cuando el dato sea un operador. El resultado final, 15, se encuentra en la pila, y el puntero
apuntado a su dirección. Se lee haciendo pop y la pila
• Apilar el resultado de la operación. vuelve a quedar vacía.
 IMPLEMENTACIÓN BASADO EN
ARRAYS
public class ArrayStack implements
Stack {
public static final int CAP=1000;
private int capacity;
private Object S[];
private int top=-1;
public ArrayStack(){this(CAP);}
public ArrayStack(int cap){
capacity=cap;
S=new Object[capacity];}
public int size()
{return (top+1);}
public boolean isEmpty()
{return (top<0);}
public Object top()
throws StackEmptyException {
if (isEmpty())
throw new StackEmptyException("vacio"};
return S[top];}
public void push(Object o)
throws StackFullException {
if (size()==capacity)
throw new StackFullException("lleno");
S[++top]=o;}
public Object pop()
throws StackEmptyException {
Object el;
if (isEmpty())
throw new StackEmptyException("vacio"};
el=S[top]; S[top--]=null; return el;}
 COLAS
Una cola es una estructura de datos de las mas comunes por su versatilidad y su capacidad
para almacenar una cantidad variada de datos en un orden especifico, en este caso este
orden es llama FIFO, debido a que cuando se almacenan los datos en una cola estos se van
apilando uno detrás del otro siendo el primero en ser ingresado también el primero en salir o
ser mostrado. Un ejemplo bastante sencillo de comprender es el de la cola de un banco, en
este caso la primera persona en llegar será la primera en ser atendida y asi sucesivamente.
 CONCEPTO
Una cola es una estructura de datos, caracterizada por ser una secuencia de elementos en la
que la operación de inserción push se realiza por un extremo y la operación de extracción
pull por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a
que el primer elemento en entrar será también el primero en salir.
En caso de estar vacía, borrar un elemento sería imposible hasta que no se añade un nuevo
elemento. A la hora de añadir un elemento podríamos darle una mayor importancia a unos
elementos que a otros (un cargo VIP) y para ello se crea un tipo de cola especial que es la
cola de prioridad.
 ORGANIZACIÓN Y ACCESO A DATOS

Es un tipo de estructura FIFO (del inglés First In First Out), debido a que el primer
elemento en entrar será también el primero en salir.
La particularidad de una estructura de datos de cola es el hecho de que solo podemos
acceder al primer y al último elemento de la estructura. Así mismo, los elementos solo se
pueden eliminar por el principio y solo se pueden añadir por el final de la cola.
 OPERACIONES PRIMITIVAS
• Crear: se crea la cola vacía.
• Encolar: se añade un elemento a la cola. Se añade al final de esta.
• Desencolar: (sacar, salir, eliminar): se elimina el elemento frontal de la cola, es decir, el
primer elemento que entró.
• Frente: (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primer
elemento que entró.
 IMPLEMENTACIÓN
Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación
(entre otros), donde los objetos, personas o eventos son tomados como datos que se
almacenan y se guardan mediante colas para su posterior procesamiento. Este tipo de
estructura de datos abstracta se implementa en lenguajes orientados a objetos mediante
clases, en forma de listas enlazadas.
#ifndef COLA IMPLEMENTACIÓN DE COLA EN C++
#define COLA // Define la cola
using namespace std;
void push(const T& elem){
Nodo* aux = new Nodo;
template <class T> aux->elemento = elem;
class Cola{ if (elementos == 0)
struct Nodo{ primero = aux;
T elemento; else ultimo->siguiente =
struct Nodo* siguiente; // coloca el aux;
ultimo = aux;
nodo en la segunda posición
++elementos;
}; }
Nodo* primero;
Nodo* ultimo; void pop(){
unsigned int elementos; Nodo* aux = primero;
primero = primero-
>siguiente;
public:
if (ultimo == aux){
Cola(): ultimo = primero;
primero(0), }
ultimo(0), delete aux;
elementos(0) --elementos;
{} }

T consultar() const{
~Cola(){ return primero->elemento;
while (elementos != 0) pop(); }
} bool vaci
 IMPLEMENTACIÓN DE COLAS
BASADAS EN ARRAYS
Array de elementos y dos cursores que indican el frente y el final
• “array circular”: cuando un cursor sobrepasa la última posición
del array, vuelve a la primera elementos : Elemento[N] frente,
final : Entero
Ejemplo. Dos configuraciones de cola válidas:
 DETECCIÓN DE COLAS
VACÍA / LLENA
• Hay dos opciones: Son soluciones equivalentes:
Llevando un contador con el número de elementos • no hay un acuerdo general sobre cual es mejor
• Necesidad de una variable extra (el contador) • unas implementaciones/libros eligen una y otros otra
• Se puede llenar el array totalmente

Utilizando la posición relativa de los cursores

• No hace falta ninguna variable extra
• Siempre debe quedar, al menos, una posición libre en el
array
 APLICACIONES DE LAS COLAS
Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación
(entre otros), dónde los objetos, personas o eventos son tomados como datos que se
almacenan y se guardan mediante colas para su posterior procesamiento. Este tipo de
estructura de datos abstracta se implementa en lenguajes orientados a objetos mediante
clases, en forma de listas enlazadas.
 LISTAS
Las listas son un tipo de abstracto bastante dinámico esto debido a que existen una gran
variedad de listas, esto lo hace una de las mas utilizadas y versátiles. Gracias a esto se
podría decir que hay un tipo de lista para cada situación. Las listas a diferencia de la cola y
la pila esta puede ser recorrida y extraer e insertar datos en cualquier sitio de la lista.
Ejemplos de listas hay muchos, cuando apilamos una cantidad “x” de datos estamos
creando una lista, como los números del 1 al 10 o el abecedario.
 CONCEPTO
Una lista enlazada es una de las estructuras de datos fundamentales, y
puede ser usada para implementar otras estructuras de datos. Consiste
en una secuencia de nodos, en los que se guardan campos de datos
arbitrarios y una o dos referencias, enlaces o punteros al nodo anterior
o posterior. Existen diferentes tipos de listas enlazadas: listas enlazadas
simples, listas doblemente enlazadas, listas enlazadas circulares y listas
enlazadas doblemente circulares. Las listas enlazadas pueden ser
implementadas en muchos lenguajes. Lenguajes tales como Lisp,
Scheme y Haskell tienen estructuras de datos ya construidas, junto con
operaciones para acceder a las listas enlazadas. Lenguajes imperativos
u orientados a objetos tales como C o C++ y Java, respectivamente,
disponen de referencias para crear listas enlazadas.
ORGANIZACIÓN Y ACCESO A DATOS

El principal beneficio de las listas enlazadas respecto a los vectores convencionales es que
el orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la
memoria o el disco, permitiendo que el orden de recorrido de la lista sea diferente al de
almacenamiento. Una lista enlazada es un tipo de dato autorreferenciado porque contienen
un puntero o enlace a otro dato del mismo tipo. Las listas enlazadas permiten inserciones y
eliminación de nodos en cualquier punto de la lista en tiempo constante, pero no permiten
un acceso aleatorio.
 OPERACIONES BÁSICAS
Las operaciones básicas de las listas van ligadas a los nodos que la conforman
• Crear un nuevo nodo
• Eliminar un nodo
• Buscar un nodo
• Mostrar un dato específico o todos
• Vaciar la lista
 IMPLEMENTACIÓN
record Node { Singly linked list delete after.png
data // El dato almacenado en el nodo function removeAfter(Node node) {
next // Una referencia al nodo siguiente, nulo para obsoleteNode := node.next
el último nodo node.next := node.next.next
} destroy obsoleteNode
record List { }
Node firstNodo // Apunta al primer nodo de la function removeBeginning(List list) {
lista; nulo para la lista vacía obsoleteNode := list.firstNode
} list.firstNode :=
node := list.firstNodo list.firstNode.next
while node not null { destroy obsoleteNode
node := node.next }
}
Singly linked list insert after.png
function insertAfter(Node node, Node newNode) {
newNode.next := node.next
node.next := newNode
}
function insertBeginning(List list, Node newNode) {
newNode.next := list.firstNode
list.firstNode := newNode
}
 LISTAS CIRCULARES
En una lista enlazada circular, el primer y el último nodo están unidos juntos. Esto se puede
hacer tanto para listas enlazadas simples como para las doblemente enlazadas. Para recorrer
una lista enlazada circular podemos empezar por cualquier nodo y seguir la lista en
cualquier dirección hasta que se regrese hasta el nodo original. Desde otro punto de vista,
las listas enlazadas circulares pueden ser vistas como listas sin comienzo ni fin. Este tipo de
listas es el más usado para dirigir buffers para “ingerir” datos, y para visitar todos los nodos
de una lista a partir de uno dado.
LISTAS DOBLEMENTE ENLAZADAS
• Un tipo de lista enlazada más sofisticado es la lista doblemente enlazada o lista enlazadas de dos vías.
Cada nodo tiene dos enlaces: uno apunta al nodo anterior, o apunta al valor NULL si es el primer nodo;
y otro que apunta al nodo siguiente, o apunta al valor NULL si es el último nodo.
• En una lista enlazada doblemente circular, cada nodo tiene dos enlaces, similares a los de la lista
doblemente enlazada, excepto que el enlace anterior del primer nodo apunta al último y el enlace
siguiente del último nodo, apunta al primero. Como en una lista doblemente enlazada, las inserciones y
eliminaciones pueden ser hechas desde cualquier punto con acceso a algún nodo cercano. Aunque
estructuralmente una lista circular doblemente enlazada no tiene ni principio ni fin, un puntero de
acceso externo puede establecer el nodo apuntado que está en la cabeza o al nodo cola, y así mantener el
orden tan bien como en una lista doblemente enlazada.
 PILAS SOBRE LISTAS ENLAZADAS
Una pila puede ser creada utilizando la misma
estructura utilizadas en las listas enlazadas, esto
quiere decir que mediante la utilización de
punteros y nodos podríamos crear una pila. De
esto modo es mucho mas sencillo de estructurar e
implementar una pila, otra de sus ventajas es que
gracias a los punteros siempre tenemos
identificados de mejor formas cosas tales como
el inicio o el final de la cola.
COLAS SOBRE LISTAS ENLAZADAS
Al igual que las pilas, las colas también pueden ser creadas a partir de estructuras de nodos y punteros
del mismo modo que se haría con un lista enlazada, esto con el propósito de simplificar el código
utilizando estructuras predefinidas que muchas veces vienen integradas en el propio lenguaje de
programación que se este utilizando. De esta forma la cola se puede dividir en varias funciones que
trabajan de mejor forma y de manera mas sencilla de comprender e implementar. Gracias a los
punteros las operaciones de los punteros se hacen mas dinámicas.