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): 7

Integrante(s): Dionicio Juárez Agustín

Reyes Castillo Christian

Palacios Cacique Esteffany Abigail

No. de Equipo de
cómputo empleado:

Semestre: 2 semestre

Fecha de entrega: 20 de agosto 2018

Observaciones:
 CALIFICACIÓN: ________________

Objetivo:

Revisarás las definiciones, características, procedimientos y ejemplos de las estructuras lineales, Lista simple
y Lista circular, con la finalidad de que comprendas sus estructuras y puedas implementarlas.

Introducción;

Las listas son un tipo de estructura de datos lineal y dinámica. Es lineal porque cada elemento tiene un único
predecesor y un único sucesor, y es dinámica porque su tamaño no es fijo y se puede definir conforme se
requiera. Las operaciones básicas dentro de una lista son BUSCAR, INSERTAR Y ELIMINAR

En una lista podemos almacenar datos del mismo tipo, con la característica que puede contener un número
indeterminado de elementos y que, mantienen un orden explícito, porque cada elemento, se une a otro
mediante un puntero, como ya se ha dicho anteriormente, los elementos constitutivos de las listas se
denominan nodos.

Las listas son estructuras de datos dinámicos, por tanto, pueden cambiar de tamaño durante la ejecución del
programa, aumentando o disminuyendo el número de nodos.

Un aspecto importante de las listas es que las inserciones, las podemos hacer por el frente, al final, en medio,
después de..., etc., etc., etc.; es decir que, no existen reglamentos que nos restringían añadir datos a una
lista, en la posición que nosotros queramos.
De igual manera, para las eliminaciones de nodos, podemos hacerlo como nosotros lo queramos, sin
embargo, se acostumbra ingresando el campo de información o dato que se desea eliminar.

La lista circular es una especie de lista enlazada simple o doblemente enlazada, pero que posee una
característica adicional para el desplazamiento dentro de la lista: esta no tiene fin.
Para que la lista sea sin fin, el puntero siguiente del último elemento apuntará hacia el primer elemento de la
lista en lugar de apuntar al valor NULL, como hemos visto en el caso de listas enlazadas simples o
doblemente enlazadas.

En las listas circulares, nunca se llega a una posición en la que ya no sea posible desplazarse. Cuando se
llegue al último elemento, el desplazamiento volverá a comenzar desde el primer elemento.
Desarrollo:

Actividad 1:

Lista (Vista en laboratorio):

#include<stdio.h>

#include<stdlib.h>

struct node{

float dato;

struct node *sig;

};

typedef struct node nodo;

struct tipoLista

nodo *ini;

nodo *fin;

int tam;

};

typedef struct tipoLista lista;

 void creaLista(lista *lis);

int insertarInicio (lista *lis, float dato);

int incertarFinal(lista *list, float dato);

int insertarPos(lista *lis,float dato, int pos);

int vacia(lista *lis);

float eliminarpos(lista *lis, int pos);

float eliminarInicio(lista *lis);

void Mostrar(lista *lis);

int main()

lista list;

int opc,p;

float datos,d;

creaLista(&list);

do

printf("Menu\n");

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

printf("2) Meter Elemento del final\n");

printf("3) Meter Elemento del Pos\n");

printf("4) Sacar Elemento pos\n");

printf("5) Sacar Elemento inicio\n");

printf("6) Mostrar\n");

printf("7) Salida\n");

scanf("%d",&opc);
 switch(opc)

case 1:

printf("Ingrese dato nuevo: ");

scanf("%f",&datos);

insertarInicio(&list,datos);

if(!insertarInicio(&list,datos))

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

else

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

break;

case 2:

printf("Ingrese dato nuevo: ");

scanf("%f",&datos);

incertarFinal(&list,datos);

if(!incertarFinal(&list,datos))

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

else

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

break;
 case 3:

printf("Ingrese dato nuevo: ");

scanf("%f",&datos);

printf("\nIngrese pocisión: ");

scanf("%d",&p);

insertarPos(&list,datos,p);

if(!insertarPos(&list,datos,p))

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

else

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

break;

case 4:

printf("\nIngrese pocisión: ");

scanf("%d",&p);

d=eliminarpos(&list,p);

printf("El dato eliminado es: %.2f",d);

break;

case 5:

d=eliminarInicio(&list);

printf("El dato eliminado es: %.2f",d);

case 6:

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

 Mostrar(&list);

break;

case 7:

printf("\nAdios\n");

break;

default:

break;

} while (opc !=7);

void creaLista(lista *lis)

lis->ini=NULL;

lis->fin=NULL;

lis->tam=0;

int vacia(lista *lis)

if(lis->ini==NULL && lis->fin==NULL && lis->tam==0)

return 0;

else

return -1;

}
 int insertarInicio (lista *lis, float dato)

nodo *nuevoNodo;

nuevoNodo=(nodo*)malloc(sizeof (nodo));

if(nuevoNodo==NULL)

return(1);

nuevoNodo->dato=dato;

nuevoNodo->sig=NULL;

if (!vacia(lis))

lis->fin=nuevoNodo;

lis->ini=nuevoNodo;

else

nuevoNodo->sig=lis->ini;

lis->ini=nuevoNodo;

lis->tam++;

return (0);

int incertarFinal(lista *lis, float dato)

nodo *nuevoNodo;

nuevoNodo=(nodo*)malloc(sizeof (nodo));

if(nuevoNodo==NULL)
 return(1);

nuevoNodo->dato=dato;

nuevoNodo->sig=NULL;

if (!vacia(lis))

lis->fin=nuevoNodo;

lis->ini=nuevoNodo;

else

lis->fin->sig=nuevoNodo;

lis->fin=nuevoNodo;

lis->tam++;

return 0;

int insertarPos(lista *lis,float dato, int pos)

int i;

nodo *actual,*nuevoNodo;

if (pos<0 || pos>lis->tam)

return -1;

nuevoNodo=(nodo*)malloc(sizeof (nodo));

if(nuevoNodo==NULL)

return(-2);

nuevoNodo->dato=dato;

actual=lis->ini;

for (i=0;i<pos;i++)
 actual=actual->sig;

if(actual->sig==NULL)

printf("Usar insertar inicio o fin");

return -1;

nuevoNodo->sig=actual->sig;

actual->sig=nuevoNodo;

lis->tam++;

return 0;

float eliminarpos(lista *lis, int pos)

nodo *tmp,*actual;

float dato;

int i;

if (!vacia(lis))

return -1.0;

if (pos <0 || pos>lis->tam)

printf("La posicion no es valida");

return -2;

tmp=lis->ini;

if (lis->ini==lis->fin)

creaLista(lis);

else

{
 actual= lis ->ini;

for (i=1;i<pos;i++)

actual=actual->sig;

if(actual->sig==NULL)

return 1;

tmp=actual->sig;

actual->sig=actual->sig->sig;

lis->tam--;

dato=tmp->dato;

free(tmp);

return dato;

float eliminarInicio(lista *lis)

nodo *tmp;

float dato;

if(!vacia(lis))

return -1.0;

tmp=lis->ini;

if(lis->ini==lis->fin)

creaLista(lis);

else {

lis->ini=lis->ini->sig;
 lis->tam--;

lis->tam--;

dato=tmp->dato;

free(tmp);

return dato;

void Mostrar(lista *s)

nodo *tmp;

tmp=s->ini;

if(tmp == NULL){

printf("Sin elementos");

} else {

tmp=s->ini;

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

tmp=s->fin;

printf("Fin: %f",tmp->dato);

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

tmp=s->ini->sig;

while(tmp != NULL){

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

tmp=tmp->sig;

}
 }

printf("\n");

Actividad 2: Lista circular:

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

typedef struct ElementoLista{

char * dato;
struct ElementoLista *siguiente;
}Elemento;

typedef struct ListaIdentificar{

Elemento *inicio;
Elemento *fin;
int tamano;
}Lista;

void crear(Lista *lista);

int InsertarEnListaVacia(Lista *lista, char *dato);
int InsertarInicio(Lista *lista, char *dato);
int InsertarFinal(Lista *lista, Elemento *actual, char *dato);
int Insertar (Lista *lista, char *dato, int pos);
int EliminarInicio(Lista *lista);
int EliminarEnLista(Lista *lista, int pos);
void visualizacion(Lista *lista);
void destruir(Lista * lista);
int menu(Lista *lista,int *k);

int main()
{
char eleccion;
char *nom;
Lista *lista;
Elemento *actual;

if ((lista = (Lista *) malloc (sizeof (Lista))) == NULL)

return -1;
if ((nom = (char *) malloc (50)) == NULL)
return -1;
actual = NULL;
eleccion = 'o';

crear(lista);
int k = 0, pos;
do{
printf("MENU\n");
if (lista ->tamano == 0){
printf ("1. Agregar el primer elemento\n");
printf ("2. Quitar\n");
}
else if(lista ->tamano == 1 || k == 1){
printf ("1. Agregar al inicio de la lista\n");
printf ("2. Agregar al final de la lista\n");
printf ("4. Agregar al inicio de la lista\n");
printf ("6. Destruir la lista\n");
printf ("7. Quitar\n");
}
else {
printf ("1. Agregar elemento al inicio de la lista\n");
printf ("2. Agregar elemento al final de la lista\n");
printf ("3. Agregar elemento después de la posición indicada\n");
printf ("4. Eliminar el elemento del inicio de la lista\n");
printf ("5. Eliminar el elemento después de la posición indicada\n");
printf ("6. Mostrar la lista\n");
printf ("7. Destruir la lista\n");
printf ("8. Quitar\n");
}
printf ("\n\nElegir: ");
scanf ("%s", &eleccion);
getchar();
switch (eleccion){
case '1':
printf ("Ingrese un elemento : ");
scanf ("%s", nom);
getchar ();
if (lista->tamano == 0)
InsertarEnListaVacia(lista, nom);
else
InsertarInicio(lista, nom);
visualizacion(lista);
break;
case '2':
printf ("Ingrese un elemento: ");
scanf ("%s", nom);
getchar ();
InsertarFinal (lista, lista->fin, nom);
visualizacion(lista);
printf("\n");
break;
case '3':
printf ("Ingrese un elemento: ");
scanf ("%s", nom);
getchar ();
do{
printf ("Ingrese la posicion: ");
scanf ("%d", &pos);
}
while (pos < 1 || pos > lista->tamano);
getchar ();
if (lista->tamano == 1 || pos == lista->tamano){
k = 1;
 printf("Error\n");
break;
}
Insertar(lista, nom, pos);
visualizacion(lista);
break;
case '4':
EliminarInicio (lista);
if (lista->tamano != 0)
printf ("%d elementos: ini = %s,fin = %s\n", lista->tamano,
lista->inicio->dato, lista->fin->dato);
else
printf ("lista vacia\n");
visualizacion (lista);
break;
case '5':
do{
printf ("Ingrese la posicion : ");
scanf ("%d", &pos);
}
while (pos < 1 || pos > lista->tamano);
getchar ();
EliminarEnLista (lista, pos);
if (lista->tamano != 0)
printf ("%d elementos:ini=%s,fin=%s\n", lista->tamano,
lista->inicio->dato, lista->fin->dato);
else
printf ("lista vacia\n");
visualizacion (lista);
break;
case '6':
 visualizacion(lista);
break;

case '7':
destruir (lista);
printf ("la lista ha sido destruida: %d elementos\n", lista->tamano);
break;
}

}while (eleccion != '7');

if(lista->tamano == 0 && eleccion == '2')
eleccion = '7';
return eleccion;
}

void crear(Lista *lista){

lista->inicio = NULL;
lista->fin= NULL;
lista->tamano = 0;
}

int InsertarEnListaVacia(Lista *lista, char *dato){

Elemento *nuevo_elemento;
if((nuevo_elemento = (Elemento *)malloc(sizeof(Elemento)))==NULL)
return -1;
if((nuevo_elemento->dato = (char *)malloc(50*sizeof(char)))==NULL)
return -1;
strcpy(nuevo_elemento->dato, dato);

nuevo_elemento->siguiente = NULL;
lista->inicio = nuevo_elemento;
 lista->fin = nuevo_elemento;
lista->tamano++;
return 0;
}

int InsertarInicio(Lista *lista, char *dato){

Elemento *nuevo_elemento;
if((nuevo_elemento = (Elemento *)malloc(sizeof(Elemento)))==NULL)
return -1;
if((nuevo_elemento->dato = (char *)malloc(50*sizeof(char)))==NULL)
return -1;
strcpy(nuevo_elemento->dato, dato);

nuevo_elemento->siguiente = lista->inicio;
lista->inicio=nuevo_elemento;
lista->tamano++;
return 0;
}

int InsertarFinal(Lista *lista, Elemento *actual, char *dato){

Elemento *nuevo_elemento;
if((nuevo_elemento = (Elemento *)malloc(sizeof(Elemento)))==NULL)
return -1;
if((nuevo_elemento->dato = (char *)malloc(50*sizeof(char)))==NULL)
return -1;
strcpy(nuevo_elemento->dato,dato);

actual->siguiente = nuevo_elemento;
nuevo_elemento->siguiente = NULL;

lista->fin = nuevo_elemento;
 lista->tamano++;
return 0;
}

int Insertar(Lista *lista, char *dato, int pos){

if(lista->tamano <2)
return -1;
if(pos<(1) || pos>=1)
return -1;
Elemento *actual;
Elemento *nuevo_elemento;
int i;

if((nuevo_elemento=(Elemento *)malloc(sizeof(Elemento)))==NULL)
return -1;
if((nuevo_elemento->dato=(char *)malloc(50*sizeof(char)))==NULL)
return -1;

actual = actual->siguiente;
for(i = 1; i<pos; ++i )
actual=actual->siguiente;
if(actual->siguiente == NULL)
return -1;
strcpy(nuevo_elemento->dato, dato);

nuevo_elemento->siguiente=actual->siguiente;
actual->siguiente = nuevo_elemento;
lista->tamano++;
return 0;
}
int EliminarInicio(Lista *lista){
if(lista->tamano == 0)
return -1;
Elemento *sup_elemento;
sup_elemento = lista->inicio;
lista->inicio=lista->inicio->siguiente;
if(lista->tamano==1)
lista->fin = NULL;
free(sup_elemento->dato);
free(sup_elemento);
lista->tamano--;
return 0;
}

int EliminarEnLista(Lista *lista, int pos){

if(lista->tamano <= 1 || pos < 1 || pos >= lista->tamano)
return -1;
int i;
Elemento *actual;
Elemento *sup_elemento;
actual = lista->inicio;
for(i=1;i<pos;++i)
actual = actual ->siguiente;
sup_elemento = actual->siguiente;
actual->siguiente = actual->siguiente->siguiente;
if(actual->siguiente==NULL)
lista->fin = actual;
free(sup_elemento->dato);
free(sup_elemento);
lista->tamano--;
return 0;
}

void visualizacion(Lista *lista){

Elemento *actual;
actual = lista->inicio;
while(actual != NULL){
printf("%p - %s\n",actual,actual->dato);
actual = actual->siguiente;
}
}

void destruir (Lista * lista){

while (lista->tamano > 0)
EliminarInicio (lista);
}
Actividad 3:

Realizar una ruleta:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define n 40
struct elemento{
int valor;
struct elemento *siguiente;
struct elemento *anterior;
};
typedef struct elemento casilla;
struct ruleta{
casilla *inicio;
int tam;
};
typedef struct ruleta ruleta;
void inicializar(ruleta *rul);
int nodos(ruleta *rul, int i);
int jugar(ruleta *rul, int apuesta);
int main(){
ruleta *rul;
int i, a;
inicializar(rul);
for(i=0;i<n;i++){
nodos(rul, i);
}
do{
printf("Elige un valor entre 0 y 40 (si quieres salir ingresa 100)\n");
 scanf("%d", &a);
jugar(rul, a);
}while(a=!100);
}
void inicializar(ruleta *rul){
rul=(ruleta *)malloc(sizeof(ruleta));
rul->inicio=NULL;
rul->tam=0;
}
int nodos(ruleta *rul, int i){
casilla *nuevo, *tmp;
int random, j;
int((nuevo=(casilla *)malloc(sizeof(casilla)))==NULL);
return 1;
nuevo->valor=i;
if(rul->tam==0){
rul->inicio=nuevo;
nuevo->siguiente=nuevo;
nuevo->anterior=nuevo;
rul->tam++;
}
else{
random=rand() %(n+1);
tmp=rul->inicio;
for(j=0;j<random;j++){
tmp=tmp->siguiente;
}
nuevo->anterior=tmp;
nuevo->siguiente=tmp->siguiente;
tmp->siguiente=nuevo;
nuevo->siguiente->anterior=nuevo;
 rul->tam++;
}
}
int jugar(ruleta *rul, int apuesta){
int i, vueltas;
vueltas=rand() % 40;
casilla *tmp;
tmp=rul->inicio;
printf("%d", vueltas);
for(i=0;i<vueltas;i++){
tmp=tmp->siguiente;
}
if(tmp->valor==apuesta){
printf("Ganaste!\n");
return 0;
}
else{
printf("Perdiste, tu valor fue %d y el valor de la ruleta fue %d\n", apuesta, tmp->valor);
return 0;
}
}
Conclusiones:

Reyes Castillo Christian:

Al realizar la práctica nos ayudó a darnos cuenta que con esta, vimos mucho de las practicas anteriores,
primero es una práctica muy densa por el contenido de la lista añadiéndole a sus funciones un menú para sus
características y aun mas con la lista circular que es un poco más compleja y con aun mas y diferentes
funciones , nos ayudó el concepto de las pilas y colas para hacer las listas, fue un poco complejo la parte de
la ruleta, ya que era algo nuevo para mí, en general con la ayuda de la profesora, pudo salir bien la práctica,
una buena práctica, densa un poco confusa en algo, pero buena.

Dionicio Juárez Agustín:

Al ver las definiciones de listas y colas circulares pudimos hacer el procedimiento para armar el código así, lo
más complicado a mi parecer fue lo de las funciones, eso es principalmente lo que nos sucedió en la práctica,
aunque el tema no ha quedado comprendido al cien por ciento, se tiene una idea más clara, lo que único que
nos falta es poder practicar más, las listas circulares si es algo que debe quedar comprendido al finalizar el
curso.

Palacios Cacique Esteffany Abigail:

Con esta práctica nos dimos cuenta que una pila nos ayuda a tener un mejor tratamiento de datos los cuales
podemos manipular a nuestra conveniencia, teniendo muchas posibilidades a la hora de programar