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

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

Introducción:

Las pilas, las colas, las colas dobles y las listas son ejemplos de colecciones de datos cuyos ítems se ordenan
dependiendo de cómo se agregan o eliminan. Una vez se agrega un ítem, éste se mantiene en la misma
posición relativa respecto a los otros ítems previos y posteriores a él. Colecciones como éstas se denominan a
menudo estructuras de datos lineales.

Las listas doblemente enlazadas son estructuras de datos semejantes a las listas enlazadas simples.
La asignación de memoria es hecha al momento de la ejecución.

En cambio, en relación a la listas enlazada simple el enlace entre los elementos se hace gracias a dos
punteros (uno que apunta hacia el elemento anterior y otro que apunta hacia el elemento siguiente).

El puntero anterior del primer elemento debe apuntar hacia NULL (el inicio de la lista).
El puntero siguiente del último elemento debe apuntar hacia NULL (el fin de la lista).

Para acceder a un elemento, la lista puede ser recorrida en ambos sentidos: comenzando por el inicio, el
puntero siguiente permite el desplazamiento hacia el próximo elemento; comenzando por el final, el puntero
anterior permite el desplazamiento hacia el elemento anterior.

Resumiendo, el desplazamiento se hace en ambas direcciones, del primer al último elemento y/o del último al
primer elemento.

Para definir un elemento de la lista será utilizado el tipo struct.

El elemento de la lista contendrá un campo dato, un puntero anterior y un puntero siguiente.

Los punteros anterior y siguiente deben ser del mismo tipo que el elemento, de lo contrario no va a poder
apuntar hacia un elemento de la lista.
El puntero anterior permitirá el acceso hacia el elemento anterior mientras que el puntero siguiente permitirá el
acceso hacia el próximo elemento.

Objetivo:
Revisaras las definiciones, características, procedimientos y ejemplos de las estructuras lineales Lista
doblemente ligada con la finalidad de que comprendas sus estructuras y puedas implementarlas

Desarrollo: Realizar las siguientes actividades:

Actividad 1: Realizar u programa que permita inicializar, agregar, eliminar y mostrar (de inicio a fin y de fin a
inicio) elementos en una lista doblemente ligada

Código:

#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. Eliminar 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)
{
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 2: Utilizando el aprendido en la actividad 1, implementar un programa en ANSI c que permita

simular un elevador utilizando una lista doblemente ligada donde cada elemento tenga almacenado un dato
entero que represente el piso de un edificio, el total de pisos es de 0 a n, n es PH y 0 es PB.
El programa debe llenar la lista doblemente ligada con los enteros de 0 a n y una vez llena se debe solicitar el
piso a ir, y la lista debe recorrer hacia arriba o hacia abajo dependiendo el piso donde se encuentre. 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 el piso proporcionado no puede ser menor a 0 ni mayor a n.

Código:

#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");
scanf("%d",&high);
if(begining(&edificio,high)){
printf("Error al iniciar\n");
return 0;
}
 cliente.next = edificio.inicio;
printf("Bienvenido a CorpLop\n\nSe encuentra en la planta baja (piso 0) en un edificio de %i pisos\n",high);
do{
printf("A que piso desea ir?\n(para terminar de un valor negativo)\n");
scanf("%i",&posicion);
if(moving(&edificio,&cliente,high,posicion))
printf("El piso no existe\n");
}while(posicion >= 0);
printf("Gracias por visitar CorpLop\n");
return 1;
}
int begining(struct list *edificio,int p){
int x;
struct node *piso;
piso = (struct node*)malloc(sizeof(struct node));//Planta baja
if(piso == NULL)
return 1;
piso->numero = 0;
piso->past = NULL;
edificio->inicio = piso;
for(x=1;x<p+1;x++){
edificio->fin = piso; //apunta al ˙ltimo elemento creado
//printf("Piso %i creado\tAnterior %p\tActual %p\tSiguiente %p\n",piso->numero,piso->past,piso,piso-
>next);
piso = (struct node*)malloc(sizeof(struct node)); //creando un nuevo piso
if(piso == NULL)
return 1;
piso->numero = x; //Asignando valor de la planta
piso->past = edificio->fin; //DirecciÛn del elemento anterior
edificio->fin->next = piso;
}
 piso->next = NULL;
//printf("Piso %i creado\tAnterior %p\tActual %p\tSiguiente %p\n",piso->numero,piso->past,piso,piso->next);
//printf("Inicio %p\tFin %p\n",edificio->inicio,edificio->fin);
edificio->size = p;
return 0;
}
int moving(struct list *edificio, struct node *cliente, int p,int posicion){
if(posicion < 0 || posicion > p)
return 1;
int x = 0;
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 está en el piso %i\n",cliente->numero);
return 0;
}
Conclusiones:
Reyes Castillo Christian:

Al realizar la práctica me di cuenta que al llegar a esta práctica con ayuda de los conocimientos de las
practicas anteriores fue bastante sencilla, un poco densa y larga, pero sencilla, ya que la profesora en la
actividad 1 nos ayudó mucho con la lista, en esta actividad como en las otras realizamos un menú con las
funciones de la lista ligada, añadiendo algunas más y con otras características, pero al final era casi lo mismo,
en la segunda actividad era con la lista hacer una especie de elevador para que te indicara el piso en el que
estas y prácticamente lo que hace un elevador, eso fue un poco de pensar, pero al final se logró, una buena
práctica, un poco larga, pero una buena práctica.

Dionicio Juárez Agustín:

El concepto de estructuras doblemente ligadas fue algo complicado de entender, debido a esto en el
laboratorio tuvimos algunas dificultades para poder implementar las estructuras, pero fue más sencillo cuando
la profesora empezó a preguntar si había dudas, esto nos permitió aclarar un poco más el tema, a la hora de
realizar los códigos nos tuvimos que guiar con la ayuda de nuestros apuntes, por eso en lo personal creo que
el tema quedó un poco más claro ya y solo falta practicar.

Palacios Cacique Esteffany Abigail:

A través de esta práctica entendimos la importancia de la implementación de listas ya que como vimos puede
resolver distintos problemas de la vida actual haciendo que la solución sea la más eficaz y eficiente posible.