Carátula para entrega de prácticas

Facultad de Ingeniería Laboratorio de docencia

Laboratorios de computación
salas A y B
Profesor: Ing. Jonathan Roberto Torres Castillo

Asignatura: Estructura De Datos Y Algoritmos I

Grupo: 9

No de Práctica(s): 4

Integrante(s): VALDERRBANO VEGA ABRAHAM

Semestre: 2018-II

Fecha de entrega:

Observaciones:

CALIFICACIÓN: _________

1
 PRACTICA 4
ALMACENAMIENTO EN TIEMPO DE EJECUCIÓN
ESTRUCTURA DE DATOS Y ALGORITMOS I
UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO

Profesor: Ing. Jonathan Roberto Torres Castillo

Número de lista: #40

Correo Electrónico: abraham171270@gmail.com

1. Reglas de las Prácticas de Laboratorio

 Deberá respetar la estructura general del documento proporcionado para la respectiva
práctica y llenar cada una de las secciones que aparecen en él.
 El desarrollo de la práctica deberá ser autentico. Aquellos alumnos que presenten los
mismos cálculos, código fuente, etcétera, se les será anulada inapelablemente la
práctica correspondiente con una calificación de 0.
 Deberá subir el informe y los scripts al link de DropBox correspondiente a la práctica
que se encuentra en la carpeta del curso. Los archivos deberán tener las características
descritas en el archivo “Reglas_Laboratorio.pdf” o se anularan son calificación de 0.
 El día de entrega establecido deberá ser respetado por todos los alumnos, la práctica
debe ser terminada parcialmente al finalizar la clase y completada máximo a los 7 días
siguientes a la sesión de laboratorio tiempo en el cual debe subir la practica al link
correspondiente.
 No se recibirán informes ni actividades si no asiste a la sesión de laboratorio y no
presenta justificación médica, por lo cual no tendrá derecho a la calificación de dicha
práctica y la nota será de 0.
 La inasistencia a 3 sesiones de laboratorio en el semestre será causal de reprobación
de las prácticas y del curso.

2. Objetivos
 Utilizarás funciones en lenguaje C que permiten reservar y almacenar información de
manera dinámica (en tiempo de ejecución).

3. Introducción
La memoria dinámica se refiere al espacio de almacenamiento que se reserva en tiempo de
ejecución, debido a que su tamaño puede variar durante la ejecución del programa.
El uso de memoria dinámica es necesario cuando a priori no se conoce el número de datos y/o
elementos que se van a manejar.

2
Licencia GPL de GNU
El software presente en esta guía práctica es libre bajo la licencia GPL de
GNU, es decir, se puede modificar y distribuir mientras se mantenga la
licencia GPL. /*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see
<http://www.gnu.org/licenses/>.
*
* Author: Jorge A. Solano
*/

4. Planteamiento del Problema y Desarrollo

A continuación, se describen las actividades a realizar para la presente práctica, en cada
apartado debe colocar la descripción, los análisis numéricos y/o los resultados de cada
actividad. El código fuente del programa que permitió solucionar cada actividad debe
colocarse en la sección 5.

4.1. Actividad 1

Transcriba y compile el código que se encuentra en el anexo 1. Luego comente cada una de
las líneas de código. Describa brevemente en este apartado lo que realizar el programa.
El programa te pide el número de puntos del polígono y reserva una cantidad de datos
principal a la memoria con la función malloc, posteriormente te pide ingresar las
coordenadas de cada punto en 2d, una en x y otra en y así como te muestra la dirección
de memoria de cada uno de estos puntos, al final libera la memoria asignada con la
función free()

3
4.2. Actividad 2

Tomando como referencia el código anterior modifique el código que desarrolló en la tarea
1, para que en lugar de usar vectores tipo ‘point’ emplee memoria dinámica a partir de las
estructuras ‘point’.

El programa debe pedirle al usuario la cantidad de puntos del polígono (cuadrado, rectángulo,
triangulo, etc), dato que servirá para separar el espacio de memoria exacto en donde van a
ser almacenados. Luego debe pedir la coordenada ‘x’ e ‘y’ de cada punto (pueden tener
decimales) y guardarlos usando el apuntador de la memoria asignada.
Como resultado el programa identificara si el polígono a evaluar corresponde a un cuadrado,
un triángulo, un rectángulo o no corresponden a ninguno de estos.

Nota: No se debe emplear ningún tipo de vector y las funciones deben usar únicamente
parámetros por referencia.

Muestre en este apartado los resultados ingresando los siguientes puntos.

Polígono 1 (cuadrado): Polígono 2 (rectángulo): Polígono 3 (Rombo):

4
 (0.00, 0.00) (0.00, 0.00) (0.00, 0.00)
(0.50, 0.00) (10.00, 0.00) (5.00, 2.50)
(0.50, 0.50) (10.00, 5.00) (0.00, 5.00)
(0.00, 0.50) (0.00, 5.00) (-5.00, 2.50)

Polígono 4 (cuadrilátero): Polígono 5 (triangulo): Polígono 6 (pentagono):

(0.00, 0.00) (0.00, 0.00) (0.00, 0.00)

(5.00, 1.50) (5.00, 2.50) (5.50, 2.50)
(0.50, 5.00) (0.00, 5.00) (0.00, 5.60)
(-3.40, 2.50) (-5.00, 2.50)
(-5.40, 2.50)

En esta sección se presenta el código fuente del programa que permitió cumplir los
objetivos propuestos. El programa debe estar comentado en cada una de sus líneas de código
y/o en sus ciclos iterativos.

4.3. Código Actividad 1

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

typedef struct //define una estructura

{
/** X coordinate */
float x;

/** Y coordinate */
float y;

}Point;//crea una variable a partir de la estructura llamada point

/**
* Prints the point
*/
void print(Point *p);//crea un puntero point

// --------------------------------------------------------------------------
// -------------------------------- Main ----------------------------------
// --------------------------------------------------------------------------
int main()
{

5
 unsigned short num_puntos, cont;//define un dato tipo entero unsigned short
Point *P;

printf("%cCu%cntos puntos tiene el poligono?\n",168,160);//imprime cuantos pulyos

tiene el poligono
scanf("%d",&num_puntos);
P = (Point *)malloc (num_puntos * sizeof(Point));//declara una funcion malloc para
reservar memoria en la computadora

// Imprime la direccion donde empieza la memoria solicitada dinamicamente.

printf("\nLa direccion inicial de la memoria reservada es: %p",P);

// verifica si se asigno satisfactoriamente la memoria.

if (P!=NULL) {//verifica si existe el espacio disponible

// Solicita las coordenadas de cada punto del poligono y lo almacena por medio de
apuntadores
printf("\n\tIngrese las coordenadas de cada punto:\n\t");
for (cont=0 ; cont<num_puntos ; cont++){
printf("\n\tCual es la coordenada x del punto %d?\n\t",cont+1);//pide una
cooordenada en x
scanf("%f",&(P+cont)->x);//guarda en el apuntador x la variable
printf("\n\tCual es la coordenada y del punto %d?\n\t",cont+1);//pide una
coordenada en y
scanf("%f",&(P+cont)->y);//guarda en el apuntador y la variable
}

// Accede a la memoria separada por medio de apuntadores para obtener los puntos
almacenados
// Se imprime en pantalla las coordenadas de cada punto y la direccion donde se
encuentra almacenado
for (cont=0 ; cont<num_puntos ; cont++){ //con el cilo iterativo repite la instruccion
para el num de puntos
printf("\n\n\tEl punto %d es: ",cont+1);
printf(&((P+cont)->x));//nos dice el punto que es en cada iteracion
printf("\testa almacenado en la direccion %p.",(P+cont));//nos manda la dirreccion
del punto
printf("\n\tLa coordenada x del punto %d es: ",cont+1);//imprime la coordenada del
punto x
printf("%f \n\ty esta almacenado en la direccion %p.",((P+cont)->x),&(P+cont)-
>x);//imptime la direeccion del punto x en la memoria
printf("\n\tLa coordenada y del punto %d es: ",cont+1);//imprime la coordenada del
punto y
printf("%f \n\ty esta almacenado en la direccion %p.",((P+cont)->y),&(P+cont)-
>y);//imprime la direccion de la memoria
}

6
 printf("\n\nSe libera el espacio reservado.\n");
free(P);//con esta funcion se libera el espacio para ser reutilizado
}

return 0;//retorna 0

// --------------------------------------------------------------------------
void print(Point *p)//crea la funcion imprimir
{
printf("(%0.2f, %0.2f) \n", p->x, p->y);
}

4.4. Código Actividad 2

/**

* Implentar un TDA para un paralelogramo el cual queda definido

* por el numero de puntos y un arreglo de Puntos donde el orden define la conectividad

* de los mismos.

* Crear las funciones es_cuadrado, es_rectangulo, es_triangulo.

* Hint: implemente el TDA para definir un Punto en 2D

*/

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <string.h>

typedef struct

/** X coordinate */

float x;

7
 /** Y coordinate */

float y;

}Point;

/**

* Computes the euclidean distance between two points

*/

float distance(Point p, Point q);

/**

* Computes the dot product between two points

*/

float dot_product(Point *p, Point *q);

/**

* Prints the point

*/

void print(Point *p);

// --------------------------------------------------------------------------

float distance(Point a, Point b)

float dx = a.x - b.x;

float dy = a.y - b.y;

return sqrt(dx*dx + dy*dy);

8
// --------------------------------------------------------------------------

// --------------------------------------------------------------------------

float dot_product(Point *p, Point *q)

float x = p->x * q->x;

float y = p->y * q->y;

return x + y;

// --------------------------------------------------------------------------

void print(Point *p)

printf("(%0.2f, %0.2f) \n", p->x, p->y);

// --------------------------------------------------------------------------

// --------------------------------------------------------------------------

typedef struct {

int num_points;

Point *vertex;

}polygon;

void is_triangle(polygon *p);

9
void is_square(polygon *p);

void is_rectangle(polygon *p);

void constructor(polygon *paral,Point *_vertex);

void constructor(polygon *paral,Point *_vertex)

paral->num_points = 4;

paral->vertex = _vertex;

// --------------------------------------------------------------------------

void is_triangle(polygon *p)

if(p->num_points == 3)

printf(" Es un triangulo \n");

} else {

printf(" No es un triangulo \n");

// --------------------------------------------------------------------------

void is_square(polygon *p)

if(p->num_points == 4)

float d1 = distance(*p->vertex, *(p->vertex+1));

float d2 = distance(*(p->vertex+1), *(p->vertex+2));

10
 float d3 = distance(*(p->vertex+2), *(p->vertex+3));

float d4 = distance(*(p->vertex+3), *p->vertex);

if(d1 == d2 && d2 == d3 && d3 ==d4)

float dot = dot_product(p->vertex+1, p->vertex+3);

if (dot == 0)

printf(" Es un cuadrado \n");

return;

printf(" No es un cuadrado \n");

// --------------------------------------------------------------------------

void is_rectangle( polygon *p)

if(p->num_points == 4)

float d1 = distance(*p->vertex, *(p->vertex+1));

float d2 = distance(*(p->vertex+1), *(p->vertex+2));

float d3 = distance(*(p->vertex+2), *(p->vertex+3));

float d4 = distance(*(p->vertex+3), *p->vertex);

float d5 = distance(*(p->vertex), *(p->vertex+2));

float d6 = distance(*(p->vertex+1), *(p->vertex+3));

11
 //printf("%0.1f, %0.1f \n", d5, d6);

if(d1 == d3 && d2 == d4 && d1 != d2 && d5 == d6)

printf(" Es un rectangulo \n");

return;

printf(" No es un rectangulo \n");

// --------------------------------------------------------------------------

// -------------------------------- Main ----------------------------------

// --------------------------------------------------------------------------

int main()

int i;

// the square

polygon *arreglo1=(polygon *)malloc(4 * sizeof(polygon));

arreglo1->vertex->x=0;

arreglo1->vertex->y = 0;

printf(" --- Poligono 1 - cuadrado --- \n");

for( i = 0; i < 4; i++)

print((arreglo1+i));

// the rectangle

Point r1; r1.x = 0; r1.y = 0;

Point r2; r2.x = 10; r2.y = 0;

Point r3; r3.x = 10; r3.y = 5;

12
Point r4; r4.x = 0; r4.y = 5;

Point R[] = {r1, r2, r3, r4};

printf(" --- Poligono 2 - rectangulo --- \n");

for( i = 0; i < 4; i++)

print(&(R[i]));

// the diamod

Point d1; d1.x = 0; d1.y = 0;

Point d2; d2.x = 5; d2.y = 2.5;

Point d3; d3.x = 0; d3.y = 5;

Point d4; d4.x = -5; d4.y = 2.5;

Point D[] = {d1, d2, d3, d4};

printf(" --- Poligono 3 - rombo --- \n");

for( i = 0; i < 4; i++)

print(&(D[i]));

printf(" --- ---- --- \n");

printf(" El poligono 1: \n");

polygon P01;

constructor(&P01, arreglo);

is_triangle(&P01);

is_square(&P01);

is_rectangle(&P01);

13
 printf(" --- ---- --- \n");

printf(" El poligono 2: \n");

polygon pr1,*prr;

prr=&pr1;

constructor(prr, &R[0]);

is_triangle(prr);

is_square(prr);

is_rectangle(prr);

printf(" --- ---- --- \n");

printf(" El poligono 3: \n");

int a=4;

polygon par, *para;

para=&par;

constructor(para,&D[0]);

is_triangle(para);

is_square(para);

is_rectangle(para);

return 0;

14
5.-Conclusiones
EN ESTA PRACTICA LO QUE ME FUE MAS DIFICIL REALIZAR FUE LA
ACTIDAD 2 QUE CONSISITIO EN CREAR DE LA TAREA EL MISMO
CODIGO OCUPANDO MEMORIA DINAMICA Y EN GENERAL PUDE
APRENDER A UTILIZAR LA ESTRUCTURAS DE MEMORIA DINAMIXA
MALLOC Y COMO UTILIZARLAS, ASI COMO TAMBIEN EL USO DE
MEMORIA DINAMICA PARA LA RESOLUCION DE PROBLEMAS Y
HACIENDO UN USO MAS EFICIENTE DE LA MEMORIA DEL
DISPOSITIVO.

6.-Referencias
[1] GARCÍA CANO, Edgar, SOLANO GÁLVEZ, Jorge, Guía práctica de estudio 4,
Almacenamiento en tiempo de ejecución, Facultad de ingeniería, UNAM.

[2] CORMEN, Thomas, LEISERSON, Charles, et al. Introduction to Algorithms 3rd

edition MA, USA The MIT Press, 2009

15
5. Anexo 1
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

typedef struct
{
/** X coordinate */
float x;

/** Y coordinate */
float y;

}Point;

/**
* Prints the point
*/
void print(Point *p);

// --------------------------------------------------------------------------
// -------------------------------- Main ----------------------------------
// --------------------------------------------------------------------------
int main()
{

unsigned short num_puntos, cont;

Point *P;

printf("%cCu%cntos puntos tiene el poligono?\n",168,160);

scanf("%d",&num_puntos);
P = (Point *)malloc (num_puntos * sizeof(Point));

// Imprime la direccion donde empieza la memoria solicitada dinamicamente.

printf("\nLa direccion inicial de la memoria reservada es: %p",P);

// verifica si se asigno satisfactoriamente la memoria.

if (P!=NULL) {

// Solicita las coordenadas de cada punto del poligono y lo almacena por medio de
apuntadores
printf("\n\tIngrese las coordenadas de cada punto:\n\t");
for (cont=0 ; cont<num_puntos ; cont++){
printf("\n\tCual es la coordenada x del punto %d?\n\t",cont+1);
scanf("%f",&(P+cont)->x);
printf("\n\tCual es la coordenada y del punto %d?\n\t",cont+1);
scanf("%f",&(P+cont)->y);

16
 }

// Accede a la memoria separada por medio de apuntadores para obtener los puntos
almacenados
// Se imprime en pantalla las coordenadas de cada punto y la direccion donde se encuentra
almacenado
for (cont=0 ; cont<num_puntos ; cont++){
printf("\n\n\tEl punto %d es: ",cont+1);
print(&((P+cont)->x));
printf("\testa almacenado en la direccion %p.",(P+cont));
printf("\n\tLa coordenada x del punto %d es: ",cont+1);
printf("%f \n\ty esta almacenado en la direccion %p.",((P+cont)->x),&(P+cont)->x);
printf("\n\tLa coordenada y del punto %d es: ",cont+1);
printf("%f \n\ty esta almacenado en la direccion %p.",((P+cont)->y),&(P+cont)->y);
}
printf("\n\nSe libera el espacio reservado.\n");
free(P);
}

return 0;

// --------------------------------------------------------------------------
void print(Point *p)
{
printf("(%0.2f, %0.2f) \n", p->x, p->y);
}

17