Carátula para entrega de prácticas

Facultad de Ingeniería Laboratorio de docencia

Laboratorios de computación
salas A y B
Profesor: Elba Karen Sáenz Garcia

Asignatura: Estructura de Datos y algoritmos

Grupo: 4

No de Práctica(s): Practica 7 y 8

Integrante(s): Garcia Cruz Brandon Manuel

Hernandez Hernandez Brayan Giovani

Semestre: 2022-2

Fecha de entrega: 18 abril 2022

Observaciones:

CALIFICACIÓN: __________
Objetivo;

● .Revisarás las definiciones, características, procedimientos y ejemplos de las

estructuras lineales Lista circulares y listas doblemente ligada con la finalidad de que
comprendas sus estructuras y puedas implementarlas.

DESARROLLO:

Actividad 1
Realizar un programa en ANSI C que permita implementar una ruleta.
1-Primero se debe crear y llenar una lista ligada circular con los números del 0 al 36 de forma no contigua.
2-Una vez formada la lista circular el usuario debe introducir un número entre 0 y 36 y girar la ruleta.Se
comparará el dato introducido con el dato obtenido
al girar la ruleta, para girar la ruleta se recorrerá la lista n lugares donde n es un numero aleatorio de entre 0 y
5*36
3-Al final se debe mostrar si la ruleta llegó al número solicitado.

CODIGO;

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include<time.h>

struct node
{
int dato;
struct node *sig;
struct node *ant;
};

typedef struct node nodo;

struct clista
{
nodo *ini,*fin;
int ne,pos;
};
typedef struct clista lista;

void inilista (lista *lis);

char vacia (lista *lis);
char insFin(lista *lis, int dato);
nodo *creaNodo (int dato);
void mostrar(lista *lis);
int girarRuleta(lista *lis,int valor);

int main ()
{
int i,a,dato=0;
int n;
int resultado;
lista ruleta;
inilista(&ruleta);
 for(i=0;i<36;i++)
{
dato=(dato+5)%36;
insFin(&ruleta,dato);
}

mostrar(&ruleta);
do{
printf("\nIngrese numero para Jugar\n");
scanf("%d",&n);
if(n<36)
{
resultado=girarRuleta(&ruleta,n);

if(resultado==0)
{
printf("GANASTE\n");
}
else
{
printf("FALLASTE\n");
}
}
else
{
printf("NUMERO INVALIDO");
}
printf("\nQuieres volver a intentarlo? 1)Si 2)No\n");
scanf("%d",&a);
}while(a!=2);
}

void inilista (lista *lis)

{
lis->ini=NULL;
lis->fin=NULL;
lis->ne=0;
}

char vacia (lista *lis)

{
if (lis->ini==NULL && lis->fin==NULL && lis->ne==0)
return 0;
else
return 1;
}

nodo *creaNodo (int dato)

{
nodo *n;

n=(nodo *)malloc(sizeof(nodo));
if (n!=NULL)
{
n->dato=dato;
n->sig=NULL;
}
return n;
}
char insFin(lista *lis, int dato)
{
nodo *Nnodo;
Nnodo=creaNodo(dato);

if (Nnodo==NULL)
{
return 1;
}
if (!vacia(lis))
{
lis->fin=Nnodo;
lis->ini=Nnodo;
}
else
{
lis->fin->sig=Nnodo;
lis->fin=Nnodo;
}
Nnodo->sig=lis->ini;
lis->ne++;
return 0;
}

void mostrar(lista *lis){

nodo *tmp;
int nvueltas=0;
tmp=lis->ini;
while(nvueltas != 1*lis->ne){
printf("\nDato = %d",tmp->dato);
tmp=tmp->sig;
nvueltas++;
}
}

int girarRuleta(lista *lis,int valor)

{
nodo *tmp;
int n=0,i,a;

printf("\nEn que sentido quiere girar la ruleta? 1)Izq 2)Der \n");

scanf("%d",&a);
tmp=lis->ini;

srand(time(NULL));
n=rand()%(5*36);
for(i=0;i<n;i++)//girar la ruleta
{
tmp=tmp->sig;
printf(" %d ",tmp->dato );
sleep(0.9);

}
printf("\nla ruleta gira a la derecha\n");
printf("\nEl valor de la ruleta: %d ",tmp->dato);
if(tmp->dato==valor)
{
return 0;
}}
 CAPTURA DE EJECUCIÓN

Actividad 2
Modificar el programa anterior para que se pueda indicar si se mueve la ruleta a la izquierda o a la derecha.

CODIGO;

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include<time.h>
struct node
{
int dato;
struct node *sig;
struct node *ant;
};

typedef struct node nodo;

struct clista
{
nodo *ini,*fin;
int ne,pos;
};
typedef struct clista lista;

void inilista (lista *lis);

char vacia (lista *lis);
char insFin(lista *lis, int dato);
nodo *creaNodo (int dato);
void mostrar(lista *lis);
int girarRuleta(lista *lis,int valor);

int main ()
{
int i,a,dato=0;
int n;
int resultado;
lista ruleta;
inilista(&ruleta);

for(i=0;i<36;i++)
{
dato=(dato+5)%36;
insFin(&ruleta,dato);
}

mostrar(&ruleta);
do{
printf("\nIngrese numero para Jugar\n");
scanf("%d",&n);
if(n<36)
{
resultado=girarRuleta(&ruleta,n);

if(resultado==0)
{
printf("GANASTE\n");
}
else
{
printf("FALLASTE\n");
}
}
else
{
printf("NUMERO INVALIDO");
}
printf("\nQuieres volver a intentarlo? 1)Si 2)No\n");
scanf("%d",&a);
 }while(a!=2);
}

void inilista (lista *lis)

{
lis->ini=NULL;
lis->fin=NULL;
lis->ne=0;
}

char vacia (lista *lis)

{
if (lis->ini==NULL && lis->fin==NULL && lis->ne==0)
return 0;
else
return 1;
}

nodo *creaNodo (int dato)

{
nodo *n;

n=(nodo *)malloc(sizeof(nodo));
if (n!=NULL)
{
n->dato=dato;
n->sig=NULL;
}
return n;
}

char insFin(lista *lis, int dato)

{
nodo *Nnodo;
Nnodo=creaNodo(dato);

if (Nnodo==NULL)
{
return 1;
}
if (!vacia(lis))
{
lis->fin=Nnodo;
lis->ini=Nnodo;
}
else
{
lis->fin->sig=Nnodo;
lis->fin=Nnodo;
}
Nnodo->sig=lis->ini;
lis->ne++;
return 0;
}

void mostrar(lista *lis){

nodo *tmp;
int nvueltas=0;
tmp=lis->ini;
while(nvueltas != 1*lis->ne){
 printf("\nDato = %d",tmp->dato);
tmp=tmp->sig;
nvueltas++;
}
}

int girarRuleta(lista *lis,int valor)

{
nodo *tmp;
int n=0,i,a;

printf("\nEn que sentido quiere girar la ruleta? 1)Izq 2)Der \n");

scanf("%d",&a);
if(a!=1){
tmp=lis->ini;

srand(time(NULL));
n=rand()%(5*36);
for(i=0;i<n;i++)//girar la ruleta
{
tmp=tmp->sig;
printf(" %d ",tmp->dato );
sleep(0.9);

}
printf("\nla ruleta gira a la derecha\n");
printf("\nEl valor de la ruleta: %d ",tmp->dato);
if(tmp->dato==valor)
{
return 0;
}
else
{
return 1;
}
}else{
tmp=lis->fin;

srand(time(NULL));
n=rand()%(5*36);
for(i=0;i<n;i++)//girar la ruleta
{
tmp=tmp->sig;
printf(" %d ",tmp->dato );
sleep(0.9);

}
printf("\nla ruleta gira a la izquierda\n");
printf("\nEl valor de la ruleta: %d ",tmp->dato);
if(tmp->dato==valor)
{
return 0;
}
else
{
return 1;
}}

CAPTURA DE EJECUCIÓN;
Actividad 3

Realizar un programa en ANSI C que permita simular un elevador utilizando una lista doblemente ligada donde
en cada elemento se tenga un dato entero que represente el piso. Los pisos va de 0 a n , n es PH y 0 PB.
El programa debe llenar una lista (doblemente enlazada) con enteros de 0 a n y una vez llena se debe solicitar
el piso al ir, y la lista se debe recorrer hacia arriba o hacia abajo dependiendo de en qué piso nos encontremos.
Cuando se llegue al piso solicitado se debe imprimir el número de piso (el contenido de la lista en esa posición).
Se debe tomar en cuenta que: El piso dado no debe ser menor 0 ni mayor n

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

struct node{
int numero;
struct node *next;
struct node *past;
};

struct list{
struct node *inicio;
struct node *fin;
int size;
};

int begining(struct list *edificio,int p);

int moving(struct list *edificio, struct node *cliente,int p, int posicion);

int main(){
struct list edificio;
struct node cliente;
int posicion,high;
cliente.numero=0;
printf("¿CUANTOS PISOS TIENE TU EDIFICIO?\n\n");
scanf("%d",&high);
if(begining(&edificio,high))
{
printf("Error al iniciar\n");
return 0;
}
cliente.next=edificio.inicio;
printf("Bienvenido \n\nSe encuentra en PB (piso 0) en un edificio de %i pisos\n",high);
do{
printf("¿A que piso desea ir? \n\n(para salir escriba un valor negativo)\n\n");
scanf("%i",&posicion);

if(moving(&edificio,&cliente,high,posicion))
printf("El piso no existe\n");

}while(posicion >= 0);

printf("Gracias \n");
return 1;
}

int begining(struct list *edificio,int p){

int x;
struct node *piso;
piso = (struct node*)malloc(sizeof(struct node));
if(piso == NULL)
return 1;

piso->numero = 0;
piso->past = NULL;
edificio->inicio = piso;

for(x=1;x<p+1;x++)
{
edificio->fin = piso;
piso = (struct node*)malloc(sizeof(struct node));

if(piso == NULL)
return 1;

piso->numero = x;
piso->past = edificio->fin;
edificio->fin->next = piso;
 }

piso->next = NULL;
edificio->size = p;
return 0;
}

int moving(struct list *edificio, struct node *cliente, int p,int posicion){
int x = 0;
if(posicion < 0 || posicion > p)
return 1;

struct node *piso;

piso = cliente->next;

if((posicion - cliente->numero)>0)
for(x=0;x<(posicion - cliente->numero);x++)
cliente->next = cliente->next->next;
else
for(x=0;x>(posicion - cliente->numero);x--)
cliente->next = cliente->next->past;
cliente->numero = cliente->next->numero;
printf("Ahora estas en el piso %i\n",cliente->numero);
return 0;
}

CAPTURA DE EJECUCION

CONCLUSIONES:
Garcia Cruz Brandon Manuel:

Para esta práctica el uso de las listas ayudó a realizar un juego de ruleta y un simulador para
emplear números aleatorios y llenado de estos, de tal manera que al momento de realizar los
códigos quedarán como refuerzo el uso de estas listas y para lograrlo hubo dificultades sin
embargo fue una manera interesante de realizar esto.

Hernandez Hernandez Brayan Giovani:

El concepto de estructuras doblemente ligadas fue algo complicado de entender, debido a esto
hubieron algunas dificultades, a la hora de realizar los códigos nos tuvimos que guiar con la
ayuda de nuestros apuntes, eso nos permitió aclarar un poco más el tema, por eso en lo personal
creo que el tema quedó un poco más claro y solo falta seguir practicando.