GUIAPICOLI

Regional Distrito Capital
Centro de Gestión de Mercados, Logística y Tecnología de la información Fecha:

Sistema de PROGRAMA DE FORMACION :
Gestión de la TECNICO EN PROGRAMACION DE SOFTWARE
Calidad PROYECTO:
SIMULADOR DE PAGOS EN CAJAS Y UTILIZACION DE CARROS EN UN
SUPERMERCADO
GUIA No. 6
COLAS, PILAS Y LISTAS
Fase l – Definición de la idea del proyecto: Realizar un simulador en el lenguaje C++ que permita ver
el comportamiento de los pagos en las cajas y la utilización de los carros en un supermercado aplicando
colas y pilas.
INTRODUCCIÓN
Las estructuras dinámicas son colecciones de elementos con un tamaño que puede variar cuando se
ejecuta el programa, las colas y pilas están dentro de la clasificación de estructuras dinámicas, que se
diferencian en el mecanismo con el que se insertan y extraen los elementos de la estructura dinámica.
Un ejemplo practico para representar el comportamiento de las colas y las pilas es un supermercado, las
colas se aplican en las cajas para realizar los pagos donde el primer cliente que llega a la caja es el
primero que se atiende y las pilas se aplican en los carros del supermercado donde el ultimo carro que se
deja en la pila es el primero que utiliza el cliente.
El aprendiz debe realizar una simulación en el lenguaje C++ de dicho ejemplo donde se asignan unos
códigos a los carros y un Id a los clientes en lo que se refleja el comportamiento de la fila de los carros
del supermercado y las cajas para pagos. Se debe tener en cuenta que todos los clientes que ingresan al
supermercado utilizan un carro y que el orden en que ingresan al supermercado no es el mismo al llegar a
las cajas.
Resultados de Aprendizaje:
Realizar un simulador en el lenguaje C++ que permita ver el comportamiento de los pagos en las cajas y
la utilización de los carros en un supermercado aplicando colas y pilas.
Evidencia de aprendizaje a entregar:

Taller planteado en la guía donde identifica como funciona una pila y una cola y cuáles son sus
operaciones básicas, así como saber como utilizarlas para resolver un problema computacional.
Software que simule el comportamiento de los pagos en las cajas y la utilización de los carros en un
supermercado.
Prerrequisitos Forma de entrega

Ejecución de cada programa y publicación del
Resolver algoritmos y realizar programas código fuente en su respectivo blog.
implementando las operaciones básicas de colas y
pilas.
Orientación de las estrategias para desarrollar las actividades de enseñanza aprendizaje

evaluación : (acompañamiento al aprendiz/ trabajo autónomo)
Se dará una breve orientación para el desarrollo de la guía y se realizara la explicación teórica por parte
del instructor sobre el tema de colas, pilas y listas, se realizaran ejemplos de programas en el lenguaje C+
+. El aprendiz desarrollara la guía resolviendo los ejemplos que se dan para luego realizar los programas
Calidad PROYECTO:
SUPERMERCADO
planteados, ejecutarlos y publicar en el blog los códigos fuente.
Evaluación del aprendizaje: Se recibirán los programas y se realizar pruebas para verificar el correcto
funcionamiento de los mismos, al final cada aprendiz dará a conocer el trabajo realizado a sus
compañeros.
COLAS, PILAS Y LISTAS
COLAS
Las colas son listas lineales de información a las cuales se accede de un modo
determinado siendo del tipo (FIFO) lo que quiere decir que el primer dato en entrar es
también el primer dato en salir, en las colas no se permite el acceso aleatorio a ningún
elemento concreto (como ejemplo podemos imaginar la cola de un supermercado), las
inserciones para las colas se hacen al final de la lista.
Hay que tener en cuenta que las operaciones de recuperación son destructivas, elimina
el elemento de la cola, si no es almacenado en otro lugar se destruye. Las colas se
utilizan principalmente en las simulaciones, planificación de sucesos, y los procesos de
entrada y salida con buffer.
Las colas circulares

Son una variante de las anteriores y su diferencia es que mientras que en las colas
lineales es necesario parar el programa cuando se alcanza el limite del arreglo, en las
circulares, la cola está llena solo cuando el índice de almacenamiento y el índice de
Calidad PROYECTO:
SUPERMERCADO
recuperación son iguales, en otro caso la cola aun tiene espacio para almacenar más
datos. Su utilización más común es en los sistemas operativos en los que la cola circular
mantiene la información que se lee de archivo y que se escribe en archivo, aplicaciones
de tiempo real, etc.
EJEMPLO
/* Colas Dinamicas */
#include <iostream>
#include <stdlib.h>
using namespace std;
struct nodo {
int info;
struct nodo *sig;
};
void crear(struct nodo **, struct nodo **);

void poner(struct nodo **, struct nodo **, int);
int sacar(struct nodo **, struct nodo **);
int vacia(struct nodo **);
int ver(struct nodo **);
void recorrer(struct nodo **, struct nodo **);
int main(void) {
struct nodo *ent, *sal;

crear(&ent, &sal);
int dato;
cout << "\nIngrese dato: ";
cin >> dato;
while(dato!=0) {
poner(&ent, &sal, dato);
cout << "\nIngrese dato: ";
cin >> dato;
}
if(vacia(&ent)==0) {
dato=sacar(&sal,&ent);
Calidad PROYECTO:
SUPERMERCADO
cout<<dato<<" ";
}
recorrer(&ent, &sal);
getchar();
getchar();
return 0;
}
void crear(struct nodo **ent, struct nodo **sal) {

*ent=NULL;
*sal=NULL;
}
void poner(struct nodo **ent, struct nodo **sal, int dato) {

struct nodo *aux; //creo puntero auxiliar apuntando a nodo
aux=new nodo; //pido memoria para un nodo
if (aux==NULL) {
cout << "Memoria insuficiente..." << endl;
exit(1);
}
aux->info=dato;
aux->sig=NULL;
if(*ent==NULL)
*sal=aux;
else
(*ent)->sig=aux;
*ent=aux;
}
int sacar(struct nodo **sal, struct nodo **ent) {

struct nodo *aux;
int dato;
aux=*sal; // apunto aux al nodo que quiero sacar
dato=(*sal)->info;
*sal=(*sal)->sig; // cambio *sal al siguiente nodo
if(*sal==NULL)
*ent=NULL;
delete aux;
Calidad PROYECTO:
SUPERMERCADO
return dato;
}
int vacia(struct nodo **ent) {

if(*ent==NULL)
return 1;
else
return 0;
}
int ver(struct nodo **sal) {

return (*sal)->info;
}
void recorrer(struct nodo **ent, struct nodo **sal) {

int dato, marca;
if (vacia(ent)==1)
cout<<"Cola vacia...";
else
dato=sacar(sal,ent); // asigno nodo a variable aux dato
cout << dato; // muestro elementos
marca=dato; // asigno a marca dato

poner(ent ,sal, dato); // vuelvo a poner el dato al final de la cola
dato=ver(sal); // miro si llegue al dato de la marca
while (dato!=marca) {
dato=sacar(sal, ent);
cout << dato << " ";
poner(ent, sal, dato);
dato=ver(sal);
}
}
Calidad PROYECTO:
SUPERMERCADO
PILAS
Una pila es lo contrario de una cola, ya que su acceso es de tipo LIFO, el último que
entra es el primero que sale, imaginar un montón de libros unos encima de otros y que
para acceder al segundo por arriba primero es necesario coger el primero, su utilización
principal es para el software de sistemas, compiladores, interpretes.
Las dos operaciones básicas, son las de almacenamiento y la de recuperación, que se

llaman push (la de almacenamiento) y pop (la de recuperación), para implementar una
pila se necesitan las dos operaciones mencionadas con anterioridad y una zona de
memoria para utilizarla como pila, se puede utilizar un arreglo, o una zona asignada
mediante asignación dinámica de memoria. Al igual que en las colas, la función de
recuperación elimina el valor de la lista, y si este no se almacena en algún lugar, este se
destruye.
La variable top es el índice de la siguiente posición libre de la pila. Cuando se
implementan estas funciones, lo más importante es evitar el desbordamiento de la pila
por los dos extremos, si top =0 la pila esta vacía y si top >que la ultima posición de
almacenamiento la pila está llena.
EJEMPLO
/* Pilas Dinamicas */
#include <iostream>
#include <stdlib.h>
struct nodo {
int info;
struct nodo *sig;
Calidad PROYECTO:
SUPERMERCADO
};
void crear(struct nodo **);

void poner(struct nodo **, int);
int sacar(struct nodo **);
int ver(struct nodo **); //veo pero NO elimino
int vacia(struct nodo **); //vacia? booleano 0-1
void recorrer(struct nodo **); //muestro lo que hay ... uso una pila aux
int main(void) {
struct nodo *tope;
int dato;
crear(&tope);
cout<<"\nIngrese un valor: ";
cin>>dato;
//cargo la pila
while(dato != 0) {
poner(&tope, dato);
cout<<"\nIngrese un valor: ";
cin>>dato;
}
//saco un elemento
if(vacia(&tope) != 0) {
dato = sacar(&tope);
cout<<"\nTOPE de la pila: "<<dato<<endl;
}
//recorro la píla
recorrer(&tope);
//vacio la pila
while(vacia(&tope) != 0) sacar(&tope);
//confirmo que esta vacia
if(vacia(&tope) == 0)
cout<<"Pila VACIA "<<endl;
else
cout<<"Pila NO VACIA"<<endl;
getchar();
getchar();
return 0;
}
void crear(struct nodo **tope) {

*tope = NULL;
}
Calidad PROYECTO:
SUPERMERCADO
void poner(struct nodo **tope, int dato) {

struct nodo *aux;
aux = new nodo; //new() devuelve un puntero
if(aux == NULL) {
cout<<"Memoria insuficiente..."<<endl;
exit(1);
}
aux->info = dato;
aux->sig = *tope;
*tope = aux;
}
int sacar(struct nodo **tope) {

struct nodo *aux;
int dato;
aux = *tope;
dato = (*tope)->info; //podria ser: dato = aux->info;
*tope = (*tope)->sig; //podria ser: *tope = aux->sig;
delete aux; //libero memoria
return dato;
}
int ver(struct nodo **tope){

return (*tope)->info;
}
int vacia(struct nodo **tope) {

if(*tope == NULL)
return 0;
else
return 1;
}
void recorrer(struct nodo **tope) {

struct nodo *tope_aux;
int dato;
crear(&tope_aux); //pila AUXILIAR, es LOCAL
while(vacia(tope) != 0) { //vacia(tope) = &(*tope)
dato = sacar(tope);
cout<<dato<<endl;
poner(&tope_aux, dato);
}
//armoa nuevamente la pila:
Calidad PROYECTO:
SUPERMERCADO
//quedo al reves y tope no apunta a nada ...

while(vacia(&tope_aux) != 0) {
poner(tope, sacar(&tope_aux));
}
}
LISTAS ENLAZADAS
Al contrario que las pilas y las colas las listas enlazadas pueden acceder a una zona de
memoria de forma aleatoria, ya que cada trozo de información lleva un enlace al
siguiente elemento de la cadena. Una lista enlazada requiere una estructura de datos
compleja, al contrario que las colas o las pilas, que pueden operar con elementos
simples o complejos, además una operación de recuperación en una lista enlazada no
elimina ni destruye el elemento de la lista. Para poder eliminar un elemento de una lista
es necesario utilizar una operación especifica de eliminación.
Las listas enlazadas se utilizan principalmente para dos propósitos, crear arreglos de un
tamaño desconocido en memoria, y los archivos de almacenamiento en disco para bases
de datos, las listas enlazadas permiten insertar y eliminar nuevos elementos.
Las listas pueden ser simplemente enlazadas o doblemente enlazadas, las simplemente
enlazadas contienen un enlace al elemento siguiente, las doblemente enlazadas tanto al
siguiente elemento como al elemento anterior del la lista.
Listas simplemente enlazadas
Una lista simplemente enlazada necesita que cada elemento contenga un enlace con el
siguiente elemento, cada elemento consiste en una estructura de campos de información
a punteros de enlace.
Calidad PROYECTO:
SUPERMERCADO
Existen dos formas de construir una lista simplemente enlazada, la primera es añadir un
nuevo elemento al principio o al final de la lista, la otra añade los elementos en un punto
específico de la lista.
Si la lista ya esta ordenada, es conveniente mantenerla así, insertando los nuevos

elementos en su lugar apropiado para lo cual se explora la lista de forma secuencial
hasta encontrar el lugar apropiado, la nueva dirección se inserta en ese punto y los
enlaces se vuelven a colocar como sea necesario.
Se pueden dar tres posibles situaciones al insertar un elemento en una lista enlazada.
Primero: El elemento se puede convertir en el primer elemento.
Segundo: Puede ser insertado entre otros dos elementos.
Tercero: Se puede convertir en el último elemento de la lista.
Tener en cuenta que al cambiar el primer elemento hay que actualizar el punto de
entrada en alguna parte del programa, también se puede utilizar un centinela, que es
el primer elemento que no cambia nunca con un valor especial, con lo que siempre será
el primer elemento de la lista pero se necesita una posición más de memoria. Para
recuperar un elemento de la lista es como seguir una cadena, una rutina basada en el
campo nombre. Para borrar un elemento al igual que para insertar un elemento se
pueden dar los mismos tres casos, si se borra el primer elemento de la lista el puntero
previo ha de hacerse nulo, y la función tiene que devolver un puntero al comienzo de la
lista para que cuando se borre el primer elemento de la lista, el programa conozca la
dirección del nuevo primer elemento de la lista. Las listas simplemente enlazadas solo
se pueden recorrer en sentido ascendente y no en sentido descendente, para lo cual se
pueden utilizar las listas doblemente enlazadas.
EJEMPLO
/* Lista Dinámica */
/* Simplemente enlazada */
#include <iostream>
#include <stdlib.h>

struct nodo {
int info;
struct nodo *sig;
};
Calidad PROYECTO:
SUPERMERCADO
void crear(struct nodo **);

void insertar(struct nodo **, int);
void eliminar(struct nodo **, int);
void recorrer(struct nodo **);
int buscar(struct nodo **, int); //true or false
int main() {
struct nodo *ent;
int dato;
crear(&ent);
cout<<"Ingrese valores enteros, cero para terminar: ";
cin>>dato;
while(dato != 0)
{
insertar(&ent, dato);
cout<<"Ingrese valores enteros, cero para terminar: ";
cin>>dato;
}
recorrer(&ent);
cout<<"Ingrese dato a eliminar: ";
cin>>dato;
eliminar(&ent, dato);
recorrer(&ent);
cout<<"Ingrese dato a buscar: ";
cin>>dato;
if(buscar(&ent,dato) == 1)
cout<<"numero "<<dato<<" encontrado";
getchar();
getchar();
return 0;
}
/******** funciones de listas simplemente enlazadas *********/

void crear(struct nodo **ent)
{
*ent = NULL;
}
void insertar(struct nodo **ent, int dato)

{
struct nodo *aux, *p, *ant;
Calidad PROYECTO:
SUPERMERCADO
aux = new nodo;

if(!aux) { cout<<"error:memoria insuficiente"<<endl; exit(1);}
aux->info = dato;
ant = NULL;
p = *ent; //p es el ptro aux que recorre la lista para insertar ORDENADO
while((p != NULL) && (p->info < dato))
{
ant = p;
p = p->sig;
}
if(ant == NULL)
{
aux->sig = *ent;
*ent = aux;
}
else
{
ant->sig = aux;
aux->sig = p;
}
}
void eliminar(struct nodo **ent, int dato)

{
struct nodo *p, *ant;
p = *ent;
ant = NULL;
while((p != NULL) && (p->info < dato))
//si pregunto p->info != dato recorro toda la lista sin sentido
{
ant = p;
p = p->sig;
}
if(p->info != dato) cout<<"dato no existe "<<endl;
else
{
if(ant == NULL) //1er nodo
*ent = (*ent)->sig;
else
ant->sig = p->sig;
delete p;
}
}
Calidad PROYECTO:
SUPERMERCADO
void recorrer(struct nodo **ent)

{
struct nodo *p;
p = *ent;
while(p != NULL)
{
cout<<p->info<<endl;
p = p->sig;
}
}
int buscar(struct nodo **ent, int dato)

{
struct nodo *p;
p = *ent;
while((p != NULL) && (p->info < dato)) p = p->sig;
if(p->info == dato)
return 1;
else
return 0;
}
Listas doblemente enlazadas.
Las listas doblemente enlazadas consisten en datos y enlaces tanto al elemento siguiente
como al elemento anterior. Con lo que se consiguen dos grandes ventajas, primero la
lista se puede leer en cualquier dirección, la segunda es que se pueden leer los enlaces
hacia delante como hacia atrás, con lo que si un enlace resulta no valido se puede
reconstruir utilizando el otro enlace.
Como en las listas simplemente enlazadas, las doblemente enlazadas pueden contener
una función que almacene cada elemento en una posición específica de la lista a medida
que esta se construye, en lugar de colocar cada elemento al final de la lista.
Calidad PROYECTO:
SUPERMERCADO
TALLER
Realizar los siguientes programas:
1. Implementar una función que recibe una lista de enteros L y un número

entero n de forma que modifique la lista mediante el borrado de todos los
elementos de la lista que tengan este valor.
2. Construir una función que sume los elementos de una lista de enteros.
3. Construir una función imprimeInverso que imprima los elementos de una lista
enlazada de enteros en orden inverso.

GUIAPICOLI

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

GUIAPICOLI

Загружено:

Авторское право:

Доступные форматы

Regional Distrito Capital

Centro de Gestión de Mercados, Logística y Tecnología de la información Fecha:

Evidencia de aprendizaje a entregar:

Prerrequisitos Forma de entrega

Orientación de las estrategias para desarrollar las actividades de enseñanza aprendizaje

planteados, ejecutarlos y publicar en el blog los códigos fuente.

COLAS, PILAS Y LISTAS

Las colas circulares

using namespace std;

void crear(struct nodo **, struct nodo **);

struct nodo *ent, *sal;

void crear(struct nodo **ent, struct nodo **sal) {

void poner(struct nodo **ent, struct nodo **sal, int dato) {

int sacar(struct nodo **sal, struct nodo **ent) {

int vacia(struct nodo **ent) {

int ver(struct nodo **sal) {

void recorrer(struct nodo **ent, struct nodo **sal) {

cout << dato; // muestro elementos

marca=dato; // asigno a marca dato

Las dos operaciones básicas, son las de almacenamiento y la de recuperación, que se

using namespace std;

void crear(struct nodo **);

void crear(struct nodo **tope) {

void poner(struct nodo **tope, int dato) {

int sacar(struct nodo **tope) {

int ver(struct nodo **tope){

int vacia(struct nodo **tope) {

void recorrer(struct nodo **tope) {

//quedo al reves y tope no apunta a nada ...

Listas simplemente enlazadas

Si la lista ya esta ordenada, es conveniente mantenerla así, insertando los nuevos

Primero: El elemento se puede convertir en el primer elemento.

Segundo: Puede ser insertado entre otros dos elementos.

Tercero: Se puede convertir en el último elemento de la lista.

using namespace std;

void crear(struct nodo **);

/******** funciones de listas simplemente enlazadas *********/

void insertar(struct nodo **ent, int dato)

aux = new nodo;

void eliminar(struct nodo **ent, int dato)

void recorrer(struct nodo **ent)

int buscar(struct nodo **ent, int dato)

Listas doblemente enlazadas.

Realizar los siguientes programas:

1. Implementar una función que recibe una lista de enteros L y un número

Вам также может понравиться

void crear(struct nodo , struct nodo );

struct nodo ent, sal;

void crear(struct nodo ent, struct nodo sal) {

void poner(struct nodo ent, struct nodo sal, int dato) {

int sacar(struct nodo sal, struct nodo ent) {

void recorrer(struct nodo ent, struct nodo sal) {

/ funciones de listas simplemente enlazadas */