Carátula para entrega de prácticas

Facultad de Ingeniería Laboratorio de docencia

Laboratorios de computación
salas A y B
Profesor: Manuel Castañeda Castañeda

Asignatura: Estructuras de Datos y Algoritmos I

Grupo: 18

No de Práctica(s): 06

Integrante(s): Jesús Vázquez Romero

No. de Equipo de cómputo

empleado:

No. de Lista o Brigada:

Semestre: 2020-2

Fecha de entrega:

CALIFICACIÓN: _________
 Practica 6.
Estructuras de datos lineales: Cola circular y cola doble.

Objetivo: Revisarás las definiciones, características, procedimientos y ejemplos de las

estructuras lineales Cola circular y Cola doble, con la finalidad de que comprendas sus
estructuras y puedas implementarlas.
Definiciones:
Cola Circular: Es una mejora de la cola simple, debido a que es una estructura de datos lineal
en la cual el siguiente elemento del último es, en realidad, el primero. La cola circular utiliza de
manera más eficiente la memoria que una cola simple. Debido a que una cola circular es una
mejora de la cola simple, maneja las mimas operaciones para INSERTAR y ELIMINAR.
Cola Doble: Es una estructura de datos tipo cola simple en la cual las operaciones ENCOLAR y
DESENCOLAR se pueden realizar por ambos extremos de la estructura, es decir, en una cola
doble se pueden realizar las operaciones: - ENCOLAR POR HEAD - DESENCOLAR POR HEAD -
ENCOLAR POR TAIL -- DESENCOLAR POR TAIL.

1. Cola Circular:
Análisis de Resultado:
Se podría decir que se podría considerar que el inicio y el final se pueden mover, así
mismo el inicio y final, al llegar al extremo se regresan a la primera posición.

#include <stdio.h>
#include <stdlib.h>

struct queue{
int fin, in;
int arre[5];
};
void crear(queue &cola){
cola.fin=-1;
cola.in=1;
}
bool Vacia(queue cola){
if(cola.fin==1)
return true;
 return false;
}
int (obt_element(queue cola)){
if(cola.fin<cola.fin)

return cola.fin-cola.in+1;
return 5-cola.in+cola.fin+1; }

bool Es_llena(queue cola){

if(obt_element(cola)==5)
return true;
return false;
}
void ingre_dat(queue &cola,int dato){
if(!Es_llena(cola)){
if(Vacia(cola))
cola.in++;

if(cola.fin==5-1){
cola.fin=0;
}
else
cola.fin++;

cola.arre[cola.fin]=dato;
printf("\nSe añadio el elemento: %d", dato);
printf("\n El elemento inicial es %d y el
elemento final es %d", cola.in, cola.fin);
}
else
printf("\nLa cola esta llena");
}
void borrar(queue &cola){
if(!Vacia(cola)){
printf("\nSe ha borrado el
elemento");

if(obt_element(cola)==1)
crear(cola);
else
cola.in++;
}
else
printf("\nLa cola esta vacia, no se pueda borrar");
}
void Mos_cola(queue &cola){
if(!Vacia(cola)){
if(cola.in<cola.fin)
for(int i=0;i<=cola.fin;i++)
printf("\n%d", cola.arre[i]);
else
for(int i=0;i<=cola.fin;i++)
printf("\n%d",cola.arre[i]);
}
}

int main(){
queue cola;
crear(cola);
ingre_dat(cola,10);
ingre_dat(cola,20);
ingre_dat(cola,30);
Mos_cola(cola);
}

2. Cola Circular Doble

Análisis del Resultado:

Entender cómo se maneja una Cola Circular Doble es importante ya que es más útil que
una Cola Simple, ya que podemos eliminar e insertar elementos desde cualquier punto
de la Cola.

#include <stdio.h>
#include <stdlib.h>
#define max 10

struct queue{
int i;
int A[max];
};
void agregar();
void eliminar();
void mostrar();
queue Cola;
int main(){
int op;
Cola.i=-1;
do{
printf("\nQue deseas hacer: \n");
printf("\n1. agregar");
 printf("\n2. eliminar");
printf("\n3. mostrar");
printf("\n4. salir\n")
scanf("%d",&op);

switch(op){
case 1: agregar(); break;
case 2: eliminar(); break;
case 3: mostrar(); break;
case 4: printf("hasta la vista");
default: break;
}
}while(op<4);
}

void agregar(){
printf("\n en donde \n");
printf("\n1. inicio\n");
printf("\n2. fin\n");
int op;
scanf("%d",&op);
switch (op){
case 1:
Cola.i++;
for(int j=Cola.i; j>=0; j--)
Cola.A[j+1]=Cola.A[j];
printf("Que dato deseas agregar\n");
scanf("%d", &Cola.A[0]);
break;
case 2:
Cola.i++;
printf("Que dato deseas agregar\n");
scanf("%d",&Cola.A[Cola.i]);
break;
}
}

void eliminar(){
for(int j=0; j<Cola.i;j++)
Cola.A[j]=Cola.A[j+1];
Cola.A[Cola.i]=NULL;
Cola.i--;
}

void mostrar (){

for(int j=0; j<=Cola.i; j++)
printf("\n%d",Cola.A[j]);
}

Conclusión
Visto Cola Circular y Circular Doble, queda claro que es ineficiente una Cola Simple ya que
algunas veces necesitamos que los elementos se muevan en los espacios vacíos, utilizar una
Cola Simple también implica que se utilice más memoria, porque una Cola simple aunque al
eliminar elementos vacía los espacios, al agregar nuevos elementos utiliza nuevos espacios,
entonces ocupa más memoria, Esto es todo lo contrario con una cola Doble.
Entonces suele ser más útil utilizar Cola Circular o Doble, por las funciones.