Carátula para entrega de prácticas

Facultad de Ingeniería Laboratorios de docencia

Laboratorio de Computación
Salas A y B

Profesor: Sáenz García Elba Karen

Asignatura: Estructura de Datos Y Algoritmos 1

Grupo: 4

No de Práctica(s): 6

Integrante(s): Dionicio Juárez Agustín Cambrón Ramírez Ricardo Daniel

Reyes Castillo Christian

Palacios Cacique Esteffany Abigail

Ávila Sánchez Eduardo Benjamín

No. de Equipo de
cómputo empleado:

Semestre: 2 semestre

Fecha de entrega: 20 de agosto 2018

Observaciones:
 CALIFICACIÓN: ________________

Introducción:

La bicola o doble cola es un tipo de cola especial que permiten la inserción y eliminación de elementos de
ambos extremos de la cola. Puede representarse a partir de un vector y dos índices, siendo su representación
más frecuente una lista circular doblemente enlazada.

Esta estructura es una cola bidimensional en que las inserciones y eliminaciones se pueden realizar en
cualquiera de los dos extremos de la bicola. Gráficamente representamos una bicola de la siguiente manera:

Existen dos variantes de la doble cola:

 Doble cola de entrada restringida.

 Doble cola de salida restringida.

Las operaciones que nosotros podemos realizar sobre una cola son las siguientes:

        Inserción.
        Extracción.
Las inserciones en la cola se llevarán a cabo por atrás de la cola, mientras que las eliminaciones se realizarán
por el frente de la cola (hay que recordar que el primero en entrar es el primero en salir).

Existen dos variantes de la doble cola:

Doble cola de entrada restringida.-

Este tipo de doble cola acepta solamente la inserción de elementos por un extremo; mientras que puede
eliminar por ambos.

Doble cola de salida restringida.-

Este tipo de doble cola acepta solamente la eliminación de elementos por un extremo; mientras que puede
insertar por ambos.

Una cola circular o anillo es una estructura de datos en la que los elementos están de forma circular y cada
elemento tiene un sucesor y un predecesor. Los elementos pueden consultarse, añadirse y eliminarse
únicamente desde la cabeza del anillo que es una posición distinguida. Existen dos operaciones de
rotaciones, una en cada sentido, de manera que la cabeza del anillo pasa a ser el elemento sucesor, o el
predecesor, respectivamente, de la cabeza actual.
Para solucionar el problema de desperdicio de memoria se implementaron las colas circulares, en las cuales
existe un apuntador desde el último elemento al primero de la cola.
La representación gráfica de esta estructura es la siguiente:

Objetivo:

Utilizar las definiciones, características, procedimientos y ejemplos de las estructuras lineales de pila, colas
con datos ligados, con la finalidad de comprenderlas e implementarlas

Revisar las definiciones, características y operaciones básicas de una cola circular y cola doble con la
finalidad de comprender las estructuras de datos y poder implementarlas.

Actividad 1:

Implementar un programa en ANSI C que tenga las opciones para realizar las operaciones push, pop, mostrar
y eliminar todos los elementos de una pila con datos ligados mediante un menú, utilizar las funciones vistas en
clase.

Código:

#include<stdio.h>

#include<stdlib.h>

struct Nodo

long dato;

struct Nodo *siguiente;

};

struct Pila{

struct Nodo *tope;

int tam;

};

int Push(struct Pila *inicio, long dato1);

int Pop(struct Pila *objeto);

void Limpiar(struct Pila *objeto);

void Mostrar(struct Pila objeto);

int main(){

struct Pila inicio;

inicio.tope = NULL;

inicio.tam = 0;

int opc, dato1;

do{

printf("\tMenu\n");

printf("\n1.Push\n");

printf("2.-Pop\n");

printf("3.-Liberar\n");

printf("4.-Mostrar\n");

printf("5.-Salir\n");

scanf("%i", &opc);

switch(opc){

case 1:

printf("\nDame un numero\n");

scanf("\n%i", &dato1);

Push(&inicio,dato1);

break;

case 2:

Pop(&inicio);

break;

case 3:

Limpiar(&inicio);

break;
case 4:

Mostrar(inicio);

break;

case 5:

printf("Adios\n");

break;

default:

printf("Error, no es una opcion.\n");

}while(opc != 5);

int Push(struct Pila *inicio,long dato1){

struct Nodo apoyo;

apoyo.siguiente = inicio->tope;

inicio->tope = (struct Nodo*)malloc(sizeof(struct Nodo));

if(inicio->tope == NULL)

return 0;

inicio->tope ->dato = dato1;

inicio->tope ->siguiente = apoyo.siguiente;

inicio->tam++;

return 1;

int Pop(struct Pila *objeto){

if(objeto->tam == 0){

printf("Pila vacia\n");

return 0;
 }

struct Nodo apoyo;

apoyo.siguiente = objeto->tope;

objeto->tope = apoyo.siguiente ->siguiente;

free(apoyo.siguiente);

objeto->tam--;

printf("\nEl elemento eliminado:\n %li", apoyo.siguiente->dato);

return 1;

void Limpiar(struct Pila *objeto){

struct Nodo apoyo;

while(objeto->tam != 0){

apoyo.siguiente = objeto->tope;

objeto->tope = apoyo.siguiente ->siguiente;

free(apoyo.siguiente);

objeto->tam--;

void Mostrar(struct Pila objeto){

struct Pila apoyo;

apoyo = objeto;

printf("\nLos elementos de la pila son:\n");

while(apoyo.tam != 0){

printf("Elemento %i:\t%li\n",apoyo.tam,apoyo.tope->dato);
 apoyo.tope = apoyo.tope ->siguiente;

apoyo.tam--;

Actividad 1.2

Realizar un programa que revise si una palabra es un palíndromo utilizando una pila con datos ligados.

Código:

Código:

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#define _Nodoc_H_

struct Nodo{

char Dato;

struct Nodo* Sig;

};

struct Nodo* inicNodoD(char Dato){

struct Nodo*init;

init = (struct Nodo*) malloc (sizeof(struct Nodo));

 init->Dato = Dato;

init->Sig = NULL;

return init;

};

struct Nodo* inicNodoDN(char Dato, struct Nodo* Sig){

struct Nodo* init;

init = (struct Nodo*) malloc (sizeof(struct Nodo));

init->Dato=Dato;

init->Sig=Sig;

return init;

};

struct Pila{

struct Nodo* H;

struct Nodo* T;

int size;

};

struct Pila* initPila(){

struct Pila*init;

init =(struct Pila*) malloc (sizeof(struct Pila));

init->H=NULL;

init->T=NULL;

init->size=0;

return init;

};

void imprimirPila(struct Pila *p){

struct Nodo * aux =p->H;

while(aux!=NULL){

printf(" %c ", aux->Dato);

 aux=aux->Sig;

};

};

void push(struct Pila* p, char Dato){

struct Nodo *aux;

aux = inicNodoDN(Dato,p->H);

p->H=aux;

p->size++;

if(p->size==1)

p->T=aux;

};

char pop(struct Pila*p){

if(p->size==0){

printf("\n\t La pila no tiene elementos \n");

return ' ';

char aux=p->H->Dato;

struct Nodo* borrame=p->H;

p->H=p->H->Sig;

borrame->Sig=NULL;

if(p->size==1)

p->T=NULL;

free(borrame);

p->size--;

return aux;

};

void main(){

struct Pila* act;

act=initPila();

struct Nodo* itp;

struct Nodo* itc;

char* ingr;

ingr=(char*)malloc(256*sizeof(char));

unsigned int i=0, aux;

printf("\n\t Palindromos \n Este programa verifica si tu cadena es un palindromo\n");

printf(" Ingresa una cadena \n");

gets(ingr);

printf("\n Tu cadena sera diferente si no cuidas las mayusculas \n");

aux=strlen(ingr);

while(i<=aux){

if(*(ingr+i)==' '){

i++;

else{

push(act, *(ingr+i));

i++;

};

imprimirPila(act);

itp=act->H;

i=i;

while(i<=aux){

if((itp->Dato)==(itc->Dato)){

itp=itp->Sig;

itc=itc->Sig;
 i++;

printf(".");

else{

printf("\n Tu cadena no es un palindromo\n");

exit(0);

};

printf("\n Tu cadena, es un palindromo\n");

while(act->size!=0){

pop(act);

};

free(act);

free(ingr);

Actividad 2

Implementar una cola con datos ligados en ANSI C, utilizando lo visto en clase, asesoría del profesor

Código:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

struct Nodo

char *dato;
struct Nodo *sig;

};

struct Cola{

struct Nodo *Inicio;

struct Nodo *Fin;

int tam;

};

void Inicializar(struct Cola *s);

int Push(struct Cola *s, char *dato);

int Pop(struct Cola *s);

void Mostrar(struct Cola *s);

int main()

struct Cola c;

int opc;

char d[50];

Inicializar(&c);

do

printf("Menu\n");

printf("1) Meter Elemento\n");

printf("2) Sacar Elemento\n");

printf("3)Tamano Cola, Elemento del Inicio y del Fin\n");

printf("4) Salida\n");

scanf("%d",&opc);

switch(opc)

case 1:

printf("Ingrese dato nuevo: ");

scanf("%s",d);

Push(&c,d);

if(!Push(&c,d))

printf("\nDato ingresado correctamente.\n");

else

printf("\nError al crear cola.\n");

break;

case 2:

Pop(&c);

if(!Pop(&c))

printf("\nElemento eliminado correctamente.\n");

else

printf("\nCola vacia.\n");

break;
case 3:

printf("\nDatos de la Cola: \n");

Mostrar(&c);

break;

case4:

printf("\nAdios\n");

break;

default:

break;

} while (opc != 4);

void Inicializar(struct Cola *s)

s->Inicio=NULL;

s->Fin=NULL;

s->tam=0;

int Push(struct Cola *s, char *dato){

struct Nodo *nuevoNodo;

nuevoNodo=(struct Nodo*)malloc(1*sizeof(struct Nodo));

if(nuevoNodo == NULL){

return -1;
 }

nuevoNodo->dato=(char*)malloc(50*sizeof(char));

if(nuevoNodo->dato == NULL){

return -1;

strcpy(nuevoNodo->dato,dato);

if(s->Inicio == NULL&& s->Fin == NULL)

s->Fin=nuevoNodo;

nuevoNodo->sig=s->Inicio;

s->Inicio=nuevoNodo;

else

if(s->Fin->sig == NULL)

s->Fin->sig=nuevoNodo;

nuevoNodo->sig=NULL;

s->Fin=nuevoNodo;

return 0;

}
int Pop(struct Cola *s){

struct Nodo *tmp;

if(s->tam == 0&& s->Inicio == NULL){

return -1;

tmp=s->Inicio;

s->Inicio=s->Inicio->sig;

s->tam--;

free(tmp->dato);

free(tmp);

return 0;

void Mostrar(struct Cola *s){

struct Nodo *tmp;

tmp=s->Inicio;

if(tmp == NULL){

printf("Sin elementos");

} else {

printf("Inicio: %s\n",tmp->dato);

tmp=s->Fin;

printf("Fin: %s",tmp->dato);
printf("\n\nElementos:\n");

tmp=s->Inicio->sig;

while(tmp != NULL){

printf("%s \t",tmp->dato);

tmp=tmp->sig;

printf("\n");

Actividad 3:

Implementar una cola circular en ANSI C.

Código:

#include <stdlib.h>

#include <stdio.h>

#define N 5
struct colaC{

int *datos;

int inicio, fin;

int nelem;

};

int ColaVaciarcir(struct colaC *Q);

int ColaLlenacir(struct colaC *cc);

void creaCola(struct colaC *Q);

int insertarColacir(struct colaC *Q, int valor);

int removerColacir(struct colaC *Q);

int mostrarColacir(struct colaC *Q);

int siguiente(int r);

int main()

int opc, num,a;

struct colaC Q;

creaCola(&Q);

if(Q.datos==NULL)

return -1;

do {

printf("\t\tMenu\n");

printf("\t1.-Introducir Elemento\n");

printf("\t2.-Eliminar Elemento\n");

printf("\t3.- Mostrar\n");

printf("\t4.-Salida\n");

printf("\nELIGE UNA OPCION\n");

scanf("%i",&opc);

switch(opc)

case 1:

printf("\nIngresa el dato a introducir:\n ");

scanf("%d", &num);

insertarColacir(&Q,num);

break;

case 2:

a=removerColacir(&Q);

printf("El dato eliminado es %d", a);

break;

case 3:

mostrarColacir(&Q);

break;

case 4:

printf("Adios\n");

break;

default:

printf("ESTA OPCION NO ES VALIDA");

break;

} while (opc!=4);

int ColaVaciarcir(struct colaC *Q){

if (Q->inicio==Q->fin&& Q->nelem==0){

return 1;

else{

return 0;

int ColaLlenacir(struct colaC *cc){

if(cc->inicio==cc->fin&& cc->nelem==N){

return 1;

else{

return 0;

void creaCola(struct colaC *Q){

Q->inicio=0;

Q->fin=0;

Q->datos=(int*)malloc(N*sizeof(int));

Q->nelem=0;

int insertarColacir(struct colaC *Q, int valor){

if (!ColaLlenacir(Q))

Q->datos[Q->fin]=valor;
 Q->nelem++;

Q->fin=(Q->fin+1)%N;

return 0;

else{

printf("\nCola circular llena\n");

return -1;

int removerColacir(struct colaC *Q){

int x;

if (!ColaVaciarcir(Q)){

x=Q->datos[Q->inicio];

Q->inicio=(Q->inicio+1)%N;

Q->nelem--;

return (x);

else{

printf("\nCola circular vacia\n");

return -1;

int siguiente(int r)

return (r+1)%N;

}
int mostrarColacir(struct colaC *Q)

int indice=Q->inicio,x;

for(x=0;x<Q->nelem;x++ )

printf("Tu dato[%d]=%d\n",indice,Q->datos[indice]);

indice=siguiente(indice);

return 0;

}
Actividad 4:

Implementación de un programa que realice las operaciones de una cola doble. El programa debe mostrar
primero un menú con las opciones

a) Entrada restringida

b) Salida Restringida

Código:

#include <stdio.h>

#include <stdlib.h>

struct dato

int num;

};

struct NODO

struct dato elemento;

struct NODO *p_anterior;

struct NODO *p_siguiente;

};

struct ColaDob{

int nodos;

struct NODO *primero;

struct NODO *ultimo;

};

void inicializarBicola(struct ColaDob **coladob);

void insertIzqBicola(struct ColaDob **coladob,int dato);

void insertDerBicola(struct ColaDob **coladob,int dato);

void eliminaIzqBicola(struct ColaDob **coladob);

void eliminaDerBicola(struct ColaDob **coladob);

void imprimeBicola(struct ColaDob **coladob);

int main()

struct ColaDob *coladob;

int nuevoDato;

inicializarBicola(&coladob);

int opc;

char op;

do{

printf("\n\n");

printf("Menu:\n\n");

printf("a)Entrada Restringida.\n");

printf("b)Salida Restringida.\n");

scanf("%c", &op);

switch(op)

case'a':

do{

printf("\n\n");

printf("Menu:\n\n");

printf("1.Insertar solo por inicio\n");

printf("2.Desencolar por inicio\n");

printf("3.Desencolar por final\n");

printf("4.Mostrar elementos\n");

printf("5.Salir del programa.\n");

scanf("%i", &opc);

switch(opc)

case 1:
 printf("\nIntroduzca un número:\n");

scanf("%i", &nuevoDato );

insertIzqBicola(&coladob, nuevoDato );

break;

case 2:

eliminaIzqBicola(&coladob);

break;

case 3:

eliminaDerBicola(&coladob);

break;

case 4:

imprimeBicola(&coladob);

break;

case 5:

printf("Adios\n");

break;

default:

break;

} while(opc != 5);

break;

case'b':

do{

printf("\n\n");

printf("Menu:\n\n");

printf("1.Insertar por inicio\n");

printf("2.Insertar por final\n");

printf("3.Desencolar por inicio\n");

printf("4.Mostrar elementos\n");

printf("5.Salir del programa.\n");

scanf("%i", &opc);

switch(opc)

case 1:

printf("\nIntroduzca un número:\n");

scanf("%i", &nuevoDato );

insertIzqBicola(&coladob, nuevoDato );

break;

case2:

printf("\nIntroduzca un número:\n");

scanf( "%i", &nuevoDato);

insertDerBicola(&coladob, nuevoDato);

break;

case3:

eliminaIzqBicola(&coladob);

break;

case4:

imprimeBicola(&coladob);

break;

case5:

printf("Adios\n");

break;

};

} while(opc != 5);

}
break;

};

} while(op != 'a'&& op != 'b');

void inicializarBicola( struct ColaDob **coladob){

struct ColaDob *temp = (struct ColaDob *) malloc(sizeof(struct ColaDob));

temp->nodos = 0;

temp->primero = NULL;

temp->ultimo = NULL;

(*coladob) = temp;

};

void insertIzqBicola( struct ColaDob **coladob, int dato ){

struct NODO *temp = (struct NODO *) malloc(sizeof(struct NODO));

if( (*coladob)->primero == NULL){

temp->elemento.num = dato;

temp->p_anterior = NULL;

temp->p_siguiente = NULL;

(*coladob)->primero = temp;

(*coladob)->ultimo = temp;

else{

temp->elemento.num = dato;

temp->p_anterior = NULL;

temp->p_siguiente = (*coladob)->primero;

(*coladob)->primero->p_anterior = temp;

(*coladob)->primero = temp;
 };

(*coladob)->nodos += 1;

};

void insertDerBicola(struct ColaDob **coladob, int dato){

struct NODO *temp = (struct NODO *) malloc(sizeof(struct NODO));

if( (*coladob)->primero == NULL ){

temp->elemento.num = dato;

temp->p_anterior = NULL;

temp->p_siguiente = NULL;

(*coladob)->primero = temp;

(*coladob)->ultimo = temp;

else{

temp->elemento.num = dato;

temp->p_anterior = (*coladob)->ultimo;

temp->p_siguiente = NULL;

(*coladob)->ultimo->p_siguiente = temp;

(*coladob)->ultimo = temp;

};

(*coladob)->nodos += 1;

};

void eliminaIzqBicola(struct ColaDob **coladob){

struct NODO *aBorrar;

if( (*coladob)->primero == NULL ){

printf( "No puede eliminar elementos de una Bicola vacía." );

else

if( (*coladob)->nodos == 1 ){
free(*coladob);

inicializarBicola(coladob);

else

if( (*coladob)->nodos>1 ){

aBorrar = (*coladob)->primero;

(*coladob)->primero->p_siguiente->p_anterior = NULL;

(*coladob)->primero = (*coladob)->primero->p_siguiente;

free(aBorrar);

(*coladob)->nodos -= 1;

};

};

void eliminaDerBicola(struct ColaDob **coladob){

struct NODO *aBorrar;

if( (*coladob)->primero == NULL ){

printf( "No puede eliminar elementos de una Bicola vacía." );

else

if( (*coladob)->nodos == 1 ){

free(*coladob);

inicializarBicola(coladob);

else if( (*coladob)->nodos>1 ){

aBorrar = (*coladob)->ultimo;

(*coladob)->ultimo->p_anterior->p_siguiente = NULL;

(*coladob)->ultimo = (*coladob)->ultimo->p_anterior;

free(aBorrar);

(*coladob)->nodos -= 1;
 };

};

void imprimeBicola( struct ColaDob **coladob ){

struct NODO *bic = (*coladob)->primero;

if( bic == NULL )

printf("La Bicola no contiene elementos.\n" );

else{

printf("Los elementos de la Cola Doble son:\n");

while(bic != NULL)

printf("%i\n",bic->elemento.num);

bic = bic->p_siguiente;

};

printf( "\n\n" );

};

};
Conclusiones:

Reyes Castillo Christian: A través de esta práctica donde utilizamos nuevamente pilas y colas, pero ahora
estas aun nivel más complejo viendo las colas circulares utilizándolas ya de mejor manera y más eficaz,
también en la cola utilizando datos ligados para a través de estos hacer menús para mostrar que se pueden
hacer con estas colas como introducir, eliminar elemento, pilas ahora con datos ligados, esta para
nuevamente un palíndromo pero ahora con esos nuevos datos ligados, fue una práctica muy laboriosa, pero
todas las actividades se realizaron bien y se reafirmó más el tema de pilas y colas y se añadieron
conocimientos acerca de esos temas, una buena practica

Dionicio Juárez Agustín:

Al realizar la práctica tuvimos muchas dificultades, principalmente en el problema del palíndromo debido a que se tenían
que utilizar datos ligados, lo de las colas y colas circulares estuvo igual complicado pero el equipo logro resolverlo, lo
bueno fue que al final pudimos interpretar un poco mejor los términos, tal vez todavía no los manejamos adecuadamente
pero el concepto se comprende más, lo primordial es practicar para que podamos cumplir a cien los objetivos de la
práctica.

Palacios Cacique Esteffany Abigail:

ATRAVES DE LA IMPLEMENTACION DE PILAS Y COLAS LIGAS PODEMOS TRABAJAR DE MANERA

MAS EFICAZ YA QUE PUDES ASIGNAR VALOR EN TIEMPO DE EJECUCION, MIENTRAS QUE LAS
COLAS CIRCULARES SON DE GRAN AYUDA YA QUE EN ESTE ES POSIBLE OCUPAR EL LUGAR DE
ALMACENAMIENTO DEL PRIMER LUGAR SI ESTE SE ENCUENTRA VACIO Y TODOS LOS DEMAS
COMPONETES DE LA COLA HACIENDO MAS EFICAZ Y EFICIENTE EL PROGRAMA.

Ávila Sánchez Eduardo Benjamín:

Durante la práctica, tuvimos varios inconvenientes en cuanto la comunicación en el equipo, y que varios
tenemos clases muy diferidas durante la semana y no podíamos ponernos de acuerdo en el día para hacer el
trabajo.

En cuanto a los objetivos tuvimos un par de problemas al realizarlos, pero lo pudimos arreglar con tiempo y
ajustar las actividades para que el programa sea correcto con las características pedidas.

Finalmente tenemos problemas al entrar a la página que la profesora solicitó ya que 3 integrantes del equipo
intentaron entrar pero finalmente logramos juntar el trabajo en equipo y poder enviarlo a tiempo, pero con un
poco de prisas.

En conclusión, tuvimos varias dificultades en comunicación y organización, pero las actividades y objetivos de
la práctica fueron logrados y hechos con suma delicadeza.