Tecnologa de la Programacin

Junio 2014
Cuestin 1 (7 puntos)

Implementar en C el TDA Polinomio (en un fichero Polinomio.c) sujeto a la especificacin y fichero
cabecera (Polinomio.h) adjuntos, teniendo en cuenta las siguientes consideraciones:
Debe utilizarse una representacin enlazada con simple enlace ordenada decrecientemente segn
los grados. Se sugiere el uso de una celda de encabezamiento al inicio de la estructura enlazada.
Todas las operaciones deben ser O(n) excepto PolinomioCrea que es O(1).
La operacin PolinomioSuma debe suprimir un monomio, si al sumar, su coeficiente se hace cero.
La operacin PolinomioEvalua debe implementarse recursivamente; las dems operaciones se
implementarn todas de forma iterativa (no recursiva).
Puede utilizarse la operacin pow de la libera <math.h>:
double pow(double x,double y); // Devuelve el valor de x elevado a y


#ifndef __POLINOMIO_H
#define __POLINOMIO_H

/**
\file Polinomio.h
\brief Mdulo para representar polinomios con coeficientes reales y grados enteros.
*/

/**
\brief TDA Polinomio.
*/
typedef void * Polinomio;

/**
\brief Crea un nuevo polinomio vaco P(x) = 0
\return Un polinomio vaco.
*/
Polinomio PolinomioCrea();

/**
\brief Libera el polinomio p.
\param p El polinomio que se libera.
*/
void PolinomioLibera(Polinomio p);

/**
\brief Suma un monomio con el grado y coeficiente dados al polinomio p:
P(x) = P(x) + coeficiente * x ^ grado
\param p El polinomio al que se suma.
\param grado Grado del monomio que se suma.
\param coeficiente Coeficiente del monomio que se suma.
*/
void PolinomioSuma(Polinomio p, int grado, float coeficiente);

/**
\brief Imprime por pantalla el polinomio p decrecientemente segn los grados con el
siguiente formato: +2.0 x^3 +4.6 x^1 -3.2 x^0
\param p El polinomio que se imprime.
*/
void PolinomioImprime(Polinomio p);

/**
\brief Evala el polinomio p en el valor x.
\param p El polinomio que se evala.
\param x Valor en el que se evala el polinomio.
\return El resultado de evaluar el polinomio P en el valor x.
*/
float PolinomioEvalua(Polinomio p, double x);

#endif // __POLINOMIO_H



Cuestin 2 (3 puntos)

Implementar en C una funcin mezcla la cual, dados dos arrays de enteros, v1 y v2, de tamaos n1
y n2 respectivamente, ordenados crecientemente, crea y devuelve un nuevo array, de tamao n1+n2 que
contiene los elementos de v1 y v2 ordenados crecientemente, en un tiempo de ejecucin O(n).

Por ejemplo, dados los arrays de enteros:

v1 = {1,4,4}
v2 = {2,5}

Crea y devuelve el array de enteros:

{1,2,4,4,5}


La sintaxis de la funcin es la siguiente:


int * mezcla(int * v1, int n1, int * v2, int n2)




Tecnologa de la Programacin
Junio 2014
Resolucin


Cuestin 1 (7 puntos)

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

typedef struct Celda
{
int grado;
float coeficiente;
struct Celda * sig;
} CeldaRep;
typedef CeldaRep * CeldaAp;

Polinomio PolinomioCrea()
{
CeldaAp c = malloc(sizeof(CeldaRep));
c->sig = NULL;
return c;
}

void PolinomioLibera(Polinomio p)
{
CeldaAp c = p;
while(c!=NULL)
{
CeldaAp aux = c;
c = c->sig;
free(aux);
}
}

void PolinomioSuma(Polinomio p, int grado, float coeficiente)
{
CeldaAp c = p;
while ((c->sig!=NULL)&&(c->sig->grado>grado)) c = c->sig;
if ((c->sig!=NULL)&&(c->sig->grado==grado))
{
c->sig->coeficiente += coeficiente;
if (c->sig->coeficiente==0)
{
CeldaAp aux = c->sig;
c->sig = c->sig->sig;
free(aux);
}
}
else
{
CeldaAp aux = malloc(sizeof(CeldaRep));
aux->coeficiente = coeficiente;
aux->grado = grado;
aux->sig = c->sig;
c->sig = aux;
}
}

void PolinomioImprime(Polinomio p)
{
for(CeldaAp c = p; c->sig!=NULL; c = c->sig)
{
if (c->sig->coeficiente>0) printf("+");
printf("%f x^%i ",c->sig->coeficiente,c->sig->grado);
}
}

float PolinomioEvalua(Polinomio p, double x)
{
CeldaAp c = p;
if (c->sig==NULL) return 0;
return PolinomioEvalua(c->sig,x) + c->sig->coeficiente * pow(x,c->sig->grado);
}




Cuestin 2 (3 puntos)

int * mezcla(int * v1, int n1, int * v2, int n2)
{
int * v3 = malloc(sizeof(int)*(n1+n2));
int i1 = 0, i2 = 0, i3 = 0;
while((i1<n1)&&(i2<n2))
{
if (v1[i1]<v2[i2]) { v3[i3] = v1[i1]; i1++; }
else { v3[i3] = v2[i2]; i2++; }
i3++;
}
while(i1<n1) { v3[i3] = v1[i1]; i1++; i3++; }
while(i2<n2) { v3[i3] = v2[i2]; i2++; i3++; }
return v3;
}