Descripción del problema
Programación para implementar el cálculo de la suma de polinomios de una variable.
Requisitos básicos
Ser capaz de utilizar listas enlazadas para realizar cálculos de suma de polinomios de una variable y poder imprimir los resultados del cálculo.
Conocimientos requeridos
(1) Métodos básicos de programación y conocimientos de programación.
(2) Comprensión, funcionamiento y aplicación de listas enlazadas.
Algoritmos utilizados
Algoritmo transversal y algoritmo recursivo.
Plataforma operativa
Visual C++
#include
#include
#define MAX 100
typedef struct polinodo
{ float coef;
int expn;
struct polinodo *next;
}nodo;
nodo * create(void) /*Función de puntero, devuelve el tipo de puntero que utiliza interpolación de cola para crear una lista vinculada de polinomios de una variable*/
{
nodo *h,*r,*s;
float c;
int e;
h=( node *)malloc(sizeof(node)); /*Crea el nodo principal del polinomio y asigna espacio de almacenamiento para el nodo principal*/
r=h; siempre apunta dinámicamente al punto actual de la lista vinculada. Al final de la tabla, para facilitar la inserción de la cola, su valor inicial apunta al nodo principal*/
printf("coef:");
scanf("%f",&c); /*Coeficiente de entrada*/
printf("expn: ");
scanf("%d", &e); /*Exponente de entrada*/
while(c!=0.0) /*Cuando el coeficiente de entrada es 0, indica el final de la entrada polinómica*/
{
s=(node *)malloc(sizeof(node) ); /*Aplicar para nuevo nodo*/
s->coef=c; for new node*/
s->expn=e; /* Asignar valor después de solicitar un nuevo nodo*/
r->next=s /*Hacer inserción de cola y insert new node*/
r=s; /*r siempre apunta al final de la lista enlazada individualmente*/
printf("coef:");
scanf("%f",&c);
printf("expn : ");
scanf("%d",&e);
}
r->next=NULL; /*Cambiar el último en la tabla Establecer el siguiente del nodo en NULL para indicar el final de la tabla*/
return(h );
}
void polyadd(node *pa, node *pb ) /*Función de suma de polinomios de una variable, utilizada para sumar dos polinomios,
luego almacena el polinomio de suma en el polinomio pa y elimina el polinomio pb*/
{
nodo *p,*q,*pre,*temp;
int sum;
p=pa->next; /*Dejemos que p y q apunten al primer nodo en las listas enlazadas de polinomios pa y pb respectivamente*/
q=pb->next;
pre=pa; /*Puntero de posición, apuntando al polinomio de suma pa */
while(p!=NULL&&q!=NULL) /* Cuando ambos polinomios no hayan sido escaneados, ejecute lo siguiente
Siguiente operación*/
{
if(p->expn
{
pre->next=p; /*Agregar nodo p al polinomio de suma*/
pre=pre->next;
p=p->next;
}
if(p->expn==q->expn) /*Si los exponentes son iguales, los coeficientes correspondientes se suman* /
{
sum=p->coef+q->coef;
if(sum!=0)
{
p->coef=sum;
pre->siguiente=p;pre=pre->siguiente;p=p->siguiente;
temp =q;q=q->next;free(temp);
}
else /*Si la suma de los coeficientes es cero, elimina los nodos p y q, y reemplace los punteros Apunte al siguiente nodo*/
{
temp=p->next;free(p);p=temp;
temp =q-> siguiente;libre(q);q=temp;
}
}
si (q->expn
{
pre->next=q; /*Agregar el nodo q al polinomio de suma*/
pre=pre->next;
q=q->next;
}
}
if(p!=NULL) /*Hay resto en el polinomio A, luego Los nodos restantes se suman al polinomio de suma*/
pre->next=p;
else /*De lo contrario, los nodos de B se suman al polinomio de suma*/
pre->next=q;
}
void print(node * p) /*Función de salida, imprime el polinomio de una variable */
{
while(p->siguiente!=NULL)
{
p=p->siguiente;
imprimirf (" %f*
x^%d",p->coef,p->expn);
}
}
void calcular() /*Asignar un valor a el polinomio y Cálculo*/
{ float cal=1.0, mid=0.0,las;
int j;
float num, x;
int i=0;
float later=0.0;
int e[MAX];float c[MAX];
printf(" Por favor ingrese num :"); /*Ingrese el valor de la constante*/
scanf("%f",&num);
printf("Por favor ingrese x:") ; /*Ingrese el valor del número desconocido de X*/
scanf("%f",&x);
printf("Por favor, ingrese e[0]:"); *El valor inicial de la matriz de entrada determina si se realiza el bucle*/
scanf("%d",&e[0]);
printf("Por favor, ingrese c[0] :");
scanf("%f",&c[0]);
while(e[i]!=0 && c[i]!=0.0 ) / *Este bucle se utiliza para cálculos polinomiales* /
{ cal=1;
for(j=0;j { cal=cal*x; } i++; mid= cal*c[i-1 ]; /*Indicar elemento único*/ later+=mid; printf("Ingrese e[%d] y c[%d] :",i,i) ; scanf("%d%f",&e[i],&c[i]); } las=later+num; / *Representa el polinomio completo*/ printf("El resultado es :\n"); printf("%f",las); /*El resultado final del cálculo */ sleep(3); } void main() { nodo * pa,* pb,*pc,*p,*q,*pre; int driver=VGA,mode=VGAHI; initgraph(&driver, &modo,"c:\ \tc "); setbkcolor(AZUL); setcolor( RED); printf("Bienvenido, ¡vamos!\n"); printf("¡A continuación, verá el proceso de cálculo!"); printf("\nIngrese el coef y la expn de pa:\n"); pa=create() /*Llame a la función de lista vinculada para crear el polinomio A*/ print(pa); printf("\nPor favor, ingrese el coef y expn de pb:\n"); pb=create() /*De manera similar; , create B*/ print(pb); p=pa->next; /*El siguiente código se utiliza para ordenar*/ pa -> siguiente=NULL; mientras(p!=NULL) { si(pa->siguiente==NULL) { pa->siguiente=p;p=p->siguiente; pa->siguiente->siguiente=NULL; } else { pre=pa;q=pre->siguiente; while(q!=NULL && p->expn>q->expn) { pre=q;q=q->siguiente; } q=p->siguiente; p->siguiente=pre->siguiente; pre->siguiente=p; p=q; } } printf("\nel primero ordenado:\n");print(pa /*Salida del pa ordenado*/ p=pb); - >next; /*El siguiente código se utiliza para ordenar pb*/ pb->next=NULL; while(p!=NULL) { if(pb->siguiente==NULL) { pb->siguiente=p;p=p->siguiente; pb->siguiente->siguiente=NULL; } else { pre=pb;q=pre->siguiente; while(q!=NULL && p->expn>q->expn) { pre=q;q=q->next; } q=p->siguiente; p->siguiente=pre->siguiente; pre->siguiente=p; p=q; } } printf("\nel segundo pedido:\n");print(pb); *Generar el pb ordenado*/ printf("\nLa suma de los polis es:\n"); polyadd(pa,pb); fase polinómica Agregar función*/ print(pa) /*Llamar a la función de salida e imprimir el resultado*/ printf("\n"); setbkcolor( RED); calculate() /*Llamar a la función que calcula el valor del polinomio*/ } Resumen de post-edición Esto Durante las etapas de diseño lógico, diseño detallado, codificación del programa y depuración del programa, el programa diseñó originalmente la función save() y la función de descarga load(), que se utilizan para guardar los polinomios creados y descargar otros. datos polinomiales que deben calcularse, para que este sistema pueda ser más práctico. El prototipo de función original de void createadj() es arcnode. La función *createdj() utiliza una estructura de lista vinculada para guardar los datos de adjmatrix[][] En él, los datos se pueden guardar, pero luego es necesario convertir la adjmatrix [][] en Dijkstra en un puntero de arcnode, porque solo de esta manera se pueden usar los datos descargados. Pero en la etapa final de depuración, se descubrió que dijkstra no se podía ejecutar, pero era difícil guardar adjmatrix[][] con la función save(). Al final, solo abandonó save() y load(). funciones y lo inicializó en la función main() Fórmula de cálculo. A partir de esta programación, vi mis propias deficiencias y trabajaré más duro para aprender y dominar el conocimiento de la programación de estructuras de datos en el futuro.