***************************
El autor de este artículo es Noah Lazy Yangyang, un compañero de clase de MF22, HKUST, para brindarle una idea de tarea, ¡no copie directamente! ! ! Aprendamos juntos~
****************************
Tabla de contenido
2.1 Descripción de la estructura de datos
2.2 Descripción de la estructura del programa
4. Análisis espacio-temporal del algoritmo
5. Resultados de las pruebas y análisis
6. Experiencia experimental y cosecha
1. Descripción del problema
1.1 Funciones básicas
- Utilice el conocimiento adquirido de las tablas lineales para construir una estructura de datos polinómicos univariada y realizar funciones como creación, visualización, suma, diferenciación e integral indefinida.
- Con respecto a las funciones de creación y visualización, no se requiere el formato de entrada y el formato de salida es el siguiente: X^3–X^2+2X-2.
- Con respecto a la función de suma, se requiere usar la función de creación para crear dos polinomios primero, luego suma y salida (serigrafía), por ejemplo, entrada X3+3X2+2X+6 y X3-X2+2X-2, la salida es 2X3+2X2 +4X+4.
- Con respecto a la función diferencial, primero se requiere ingresar un polinomio y luego calcular el diferencial de orden N. Por ejemplo, cuando N=1: X3+3X2+2X+6→3X2+6X+2, cuando N=2: X3+3X2+2X+6 →6X+6.
- Con respecto a la función de calcular la integral indefinida, primero se requiere ingresar un polinomio y luego calcular su integral indefinida, por ejemplo
- Además, se requiere todo el programa para construir un buen modo de interacción humano-computadora, con una interfaz de menú y varias interfaces funcionales, y la lógica de cambio de interfaz debe ser correcta.
1.2 Robustez
- Al ingresar X3-X2+2X-2, si los resultados mostrados son los mismos cuando se ingresan en el orden de X3, -X2, +2X, -2 y en el orden de -2, X3, -X2, +2X.
- Sumatoria: Se eliminará el coeficiente de 0: (X3+3X2+2X+6) + (X3-3X2+2X+6)=2X3+4X+12.
- Derivación N=4: X3+3X2+2X+6→0.
- La lógica de conmutación de la interfaz de menú y cada interfaz de función es correcta.
1.3 Normativa
- comentario de código
- modularización del programa
- Interacción amigable entre humanos y computadoras
2. Descripción del algoritmo
2.1 Descripción de la estructura de datos
La estructura de lista enlazada única se usa para el almacenamiento, y el nodo usa la estructura para definir cada elemento del polinomio.Cada nodo contiene tres elementos, que son el coeficiente, el índice y el puntero del siguiente nodo. La estructura lógica de los datos se muestra en la siguiente figura.
En la memoria, los nodos no se almacenan en espacios de almacenamiento adyacentes, pero se accede al siguiente nodo a través del puntero *siguiente en cada nodo, y todos los nodos se pueden encontrar a través del nodo principal.
Explicación de las principales variables:
| variable |
tipo |
ilustrar |
| nodo_polinomio |
estructura |
Estructuras de nodos de un término en polinomios |
| * polilista |
puntero del cuerpo |
Se utiliza para acceder a la estructura y almacenar la ubicación de memoria de la estructura |
| coef |
flotar |
Uno de los elementos en polynomial_Node, el coeficiente en el monomio |
| Exp |
En t |
Uno de los elementos en polynomial_Node, el índice en el monomio |
| *próximo |
puntero de estructura |
Uno de los elementos en polynomial_Node, utilizado para acceder a la estructura y almacenar la ubicación de memoria de la estructura. |
| pre_nodo |
puntero de estructura |
Aparece en varias funciones importantes y se utiliza para almacenar temporalmente el puntero del nodo anterior al construir una estructura de datos polinómicos. |
| resultado / result_return |
puntero de estructura |
Aparece como un parámetro en múltiples funciones importantes, generalmente como la salida de la función, y almacena el resultado de salida de la operación de la función. |
2.2 Descripción de la estructura del programa
El programa incluye principalmente el archivo de encabezado noah_exp1.h y el archivo principal main.cpp. El archivo noah_exp1.h es una colección de códigos para realizar la estructura de datos polinomial. El main.cpp realiza principalmente la interacción entre el menú y la interfaz de funciones. y la llamada de función en el archivo de encabezado. Su estructura específica es la siguiente,
La descripción específica del módulo en noah_exp1.h:
(1) typedef struct polynomial_Node{
/***********************
Nombre: polynomial_Node; * polilista
Descripción: definición de estructura para nodos polinómicos
Parámetros de entrada: -
Parámetros de salida: -
Devolver: -
Suplemento: -
***********************/
(2) void Creatpolyn(polylist &poly, int listsize){
/***********************
Nombre: Creatpolyn()
Descripción: ingrese el coeficiente y el exponente del elemento listsize+1 para crear una lista enlazada ordenada que represente un polinomio
Parámetros de entrada: -poly, el primer nodo de la lista vinculada que se inicializará (nodo sin cabeza en esta estructura de datos)
-listsize, la longitud de la lista enlazada que se inicializará
Parámetros de salida: -poly, parámetros de referencia, guarde el nodo principal de la lista vinculada inicializada como una salida
Devolver: -
Suplemento: -La lista enlazada no tiene nodo principal
***********************/
(3)int get_polylen(polilista p){
/***********************
Nombre: get_polylen()
Descripción: Devuelve la longitud de la lista enlazada (la mayor potencia del polinomio + 1)
Parámetros de entrada: -p, el primer nodo de la lista enlazada de la longitud requerida
Parámetros de salida: -
Devuelve: -len, tipo de datos int, es la longitud de la lista enlazada
Suplemento: -La lista enlazada no tiene nodo principal
***********************/
(4) void Copy_polylist (polilista original, polilista y resultado){
/***********************
Nombre: Copy_polylist()
Descripción: clone la lista vinculada, copie la lista vinculada p a la lista vinculada de resultados, las direcciones de memoria de las dos tablas son diferentes
Parámetros de entrada: -original, el primer nodo de la lista enlazada que se copiará
-resultado, el nodo principal de la lista enlazada clonada
Parámetros de salida: -resultado, parámetro de referencia, guarda el primer nodo de la lista enlazada clonada como la salida de la función
Devolver: -
Suplemento: -La lista enlazada no tiene nodo principal
***********************/
(5) polilista revers_Llist (polilista L){
/***********************
Nombre: revers_Llist()
Descripción: la lista enlazada se invierte y se devuelve el primer nodo después del inverso
Parámetros de entrada: -L, el primer nodo de la lista vinculada que debe invertirse
Parámetros de salida: -
Devuelve: - el primer nodo después de la inversión
Suplemento: -La lista enlazada no tiene nodo principal
***********************/
(6) void Displaypolinomial(polilista poli){
/***********************
Nombre: Mostrar polinomio ()
Descripción: Imprime polinomios en un formato común
Parámetros de entrada: -poly, el primer nodo de la lista enlazada que se imprimirá
Parámetros de salida: -
Devolver: -
Suplemento: -La lista enlazada no tiene nodo principal, por lo que también se debe imprimir el primer nodo,
Al generar el primer elemento, si el coeficiente es positivo, no se requiere el signo más, si es un elemento constante, X no se emite y si la potencia es 1, la potencia no se muestra.
El coeficiente no es igual a 0, X^n no se muestra cuando el exponente es igual a 0,
El coeficiente no es igual a 0, y ^n no se muestra cuando el exponente es igual a 1,
Cuando el coeficiente es igual a 0, se omite este ítem.
***********************/
(7) void addpoly(polilista a, polilista b, polilista &resultado){
/***********************
Nombre: addpoly()
Descripción: agregue dos polinomios y almacene el resultado en la lista vinculada de resultado
Parámetros de entrada: -a, el primer nodo de una de las listas vinculadas que debe agregarse
-b, el primer nodo de la segunda lista enlazada que se agregará
-resultado, nodo vacío para entrada
Parámetros de salida: -resultado, como salida de función, la lista enlazada con resultado como primer nodo guarda el polinomio agregado
Devolver: -
Suplemento: -
***********************/
(8) void diferencial poli(polilista a,int N, polilista &result_return){
/***********************
Nombre: diferencial poli ()
Descripción: Deriva el polinomio de orden N y almacena el resultado en la lista enlazada de resultado
Parámetros de entrada: -a, el puntero del primer nodo del polinomio que necesita ser diferenciado
-result_return, nodo vacío para entrada
Parámetros de salida: -result_return, como salida de función, la lista enlazada con result_return como primer nodo guarda el polinomio después de la diferenciación de orden N
Devolver: -
Suplemento: -Consulte la idea recursiva, cada vez que ingrese a la función N-1, cuando N = 0, gire a la función de salida
***********************/
(9) void indefiniteintegralpoly(polilista a, polilista &resultado){
/***********************
Nombre: indefiniteintegralpoly()
Descripción: Calcule la integral indefinida del polinomio y almacene el resultado en la lista vinculada de resultado
Parámetros de entrada: -a, el puntero del primer nodo del polinomio que debe ser integral indefinido
-resultado, nodo vacío para entrada
Parámetros de salida: -resultado, como salida de función, la lista enlazada con resultado como primer nodo guarda el polinomio después de calcular la integral indefinida
Devolver: -
Suplemento: -
***********************/
3. Análisis de depuración
Función de depuración 1: crea un polinomio e imprímelo en la pantalla
Al inicializar, primero ingrese el grado más alto del polinomio y luego ingrese los coeficientes de menor a mayor orden.
Selección de datos de prueba:
- 3- 1.2, 2, 2.2 ,22
- 1-1,2
- 0-2
- 5-0, 1, 1, 0, 1, 1
Problemas y soluciones:
(1) Problema de precisión flotante, porque es necesario comparar el tamaño del coeficiente de juicio (especialmente == juicio), pero debido a la precisión del tipo de datos flotante, use fabs(p->coef-0.000) > FLOAT_PRECISON en su lugar.
(2) Otros detalles de impresión, como omitir cuando el coeficiente es igual a 0 y no mostrar el número de veces que el índice es 1, utilizan diferentes declaraciones de juicio para manejar diferentes situaciones.
Función de depuración 2: agregue 2 polinomios e imprima el resultado en la pantalla
Selección de datos de prueba:
- 3- 1.2, 2, 2.2, 22; 1-1,2
- 0-2; 5-0, 1, 1, 0, 1, 1
Problemas y soluciones:
ninguno
Función de depuración tres: obtenga el diferencial de un polinomio e imprima el resultado en la pantalla
Selección de datos de prueba:
- 3- 1.2, 2, 2.2, 22; 1
- 3- 1.2, 2, 2.2, 22; 2
- 1-1,2; 1
- 1-1,2;2
- 0-2; 1
- 0-2; 2
- 5-0, 1, 1, 0, 1, 1; 1
- 5-0, 1, 1, 0, 1, 1; 2
Problemas y soluciones:
ninguno
Función de depuración cuatro: Obtenga la integral indefinida de un polinomio e imprima el resultado en la pantalla
Selección de datos de prueba:
- 3- 1.2, 2, 2.2 ,22
- 1-1,2
- 0-2
- 5-0, 1, 1, 0, 1, 1
Problemas y soluciones:
ninguno
4. Análisis espacio-temporal del algoritmo
(1) void Creatpolyn(polylist &poly, int listsize)
Complejidad temporal: O(n)
Complejidad espacial: O(n)
(2) int get_polylen (polilista p)
Complejidad temporal: O(n)
Complejidad espacial: O(n)
(3) void Copy_polylist (polilista original, polilista y resultado)
Complejidad temporal: O(n)
Complejidad espacial: O(n)
(4) polilista revers_Llist (polilista L)
Complejidad temporal: O(n)
Complejidad espacial: O(n)
(5) void Mostrar polinomio (polilista poli)
Complejidad temporal: O(n)
Complejidad espacial: O(n)
(6) void addpoly (polilista a, polilista b, polilista &resultado)
Complejidad temporal: O(n)
Complejidad espacial: O(n)
(6) void differentpoly (polilista a,int N, polilista &result_return)
Complejidad temporal: O(n)
Complejidad espacial: O(n)
(6) void indefiniteintegralpoly(polilista a, polilista &resultado)
Complejidad temporal: O(n)
Complejidad espacial: O(n)
5. Resultados de las pruebas y análisis
Función de prueba uno: cree un polinomio e imprímalo en la pantalla
| caso de prueba |
resultado |
analizar |
| 3- 1.2, 2, 2.2 ,22 |
|
√, el artículo principal no emite solo la energía |
| 1-0,2 |
|
√, el elemento constante es 0 para omitir la salida |
| 0-2 |
|
√, solo una salida normal |
| 5-0, 1, 1, 0, 1, 1 |
|
√, la salida del polinomio escaso es correcta |
Función de depuración 2: agregue 2 polinomios e imprima el resultado en la pantalla
| caso de prueba |
resultado |
analizar |
| 3- 1,2, 2, 2,2, 22; 1-0,2 |
|
√, la adición de potencia correspondiente es correcta |
| 0-2; 5-0, 1, 1, 0, 1, 1 |
|
√ |
Problemas y soluciones:
ninguno
Función de prueba tres: obtenga el diferencial de un polinomio e imprima el resultado en la pantalla
| caso de prueba |
resultado |
analizar |
| 3- 1.2, 2, 2.2, 22; 1 |
|
√, salida normal diferencial de primer orden |
| 3- 1.2, 2, 2.2, 22; 2 |
|
√, salida normal diferencial de segundo orden |
| 1-1,2;2 |
|
√, el orden diferencial es mayor que la salida de potencia más alta es 0 |
| 0-2 ; 3 |
|
√, el orden diferencial es mayor que la salida de potencia más alta es 0 |
Función de depuración cuatro: obtenga la integral indefinida de un polinomio e imprima el resultado en la pantalla
| caso de prueba |
resultado |
analizar |
| 3- 1.2, 2, 2.2 ,22 |
|
√ |
| 1-1,2 |
|
|
| 5-0, 1, 1, 0, 1, 1 |
|
6.实验体会和收获
- 学会了灵活运用链表这种数据结构；
- 对指针、引用参数、函数返回值的认识更加深刻；
- 对递归的思想理解更加深刻，并且能够用于实战；
- 学会了如何更快地定位程序BUG并进行调试；
- 学会了如何更科学地设计测试用例来对程序进行功能测试。
代码
Noah_exp1.h
/**************************************************************************
Copyright Copyright 2022 Noah Zhan.* File Name: noah_exp1.h* Description: 实现一元稀疏多项式数据机构及相关功能** Version: V1.0* Author: Noah Zhan* Create Time: 2022-10-20
**************************************************************************/
#ifndef NOAH_EXP1_H_INCLUDED
#define NOAH_EXP1_H_INCLUDED
#define FLOAT_PRECISON 0.0000001//用于浮点数的大小比较
#include<cmath>
//定义多项式结点结构体
typedef struct polynomial_Node{
/***********************
Name: polynomial_Node; *polylist
Description: 多项式结点的结构体定义
Input Parameters: -
Output Parameters: -
Return: -
Supplement: -
***********************/
float coef;
int expn;
struct polynomial_Node *next;
}polynomial_Node,*polylist;
//初始化多项式
void Creatpolyn(polylist &poly, int listsize){
/***********************
Name: Creatpolyn()
Description: 输入listsize+1项的系数和指数，建立表示多项式的有序链表
Input Parameters: -poly, 所需初始化的链表的第一个结点（该数据结构中无头结点）
-listsize，所需初始化的链表的长度
Output Parameters: -poly，引用参数，作为出口保存了初始化后的链表的头结点
Return: -
Supplement: -该链表没有头结点
***********************/
poly = (polylist)malloc(sizeof(polynomial_Node));
poly->next = nullptr;
printf("Input constant coefficient:(float)");
scanf("%f",&poly->coef);
poly->expn = 0;
//初始化剩下的listsize-1个结点
polylist pre_node = poly;
for(int i = 1; i<listsize;i++){
polylist p = (polylist)malloc(sizeof(polynomial_Node));
printf("Input X^%d coefficient:(float)",i);
scanf("%f",&p->coef);
p->next = nullptr;
p->expn = i;
pre_node->next = p;
pre_node = p;
}
}
//返回链表的长度（多项式的最高次幂+1）
int get_polylen(polylist p){
/***********************
Name: get_polylen()
Description: 返回链表的长度（多项式的最高次幂+1）
Input Parameters: -p，所需求长度的链表的第一个结点
Output Parameters: -
Return: -len，int数据类型，为链表的长度
Supplement: -该链表没有头结点
***********************/
int len = 1;
while(p->next!=nullptr){
len++;
p = p->next;
}
return len;
}
//链表的克隆,将p链表复制给result链表，两表的内存地址不同
void Copy_polylist(polylist original,polylist &result){
/***********************
Name: Copy_polylist()
Description: 链表的克隆,将p链表复制给result链表，两表的内存地址不同
Input Parameters: -original，被复制的链表的第一个结点
-result，克隆后的链表的头结点
Output Parameters: -result，引用参数，作为函数的出口保存了克隆后的链表的第一个结点
Return: -
Supplement: -该链表没有头结点
***********************/
//克隆头结点
result = (polylist)malloc(sizeof(polynomial_Node));
result->coef = original->coef;
result->expn = original->expn;
result->next = nullptr;
polylist pre_node = result;
int len = get_polylen(original);
//克隆剩下的结点
for(int i = 1; i<len;i++){
original = original->next;
//printf("%f %d %f %d",original->coef,original->expn,original->next->coef,original->next->expn);
polylist p = (polylist)malloc(sizeof(polynomial_Node));
p->coef = original->coef;
p->expn = original->expn;
p->next = nullptr;
pre_node->next = p;
pre_node = p;
}
}
//链表逆置，并返回逆置后的第一个结点
polylist revers_Llist(polylist L){
/***********************
Name: revers_Llist()
Description: 链表逆置，并返回逆置后的第一个结点
Input Parameters: -L，需要逆置的链表的第一个结点
Output Parameters: -
Return: -逆置后的第一个结点
Supplement: -该链表没有头结点
***********************/
if(L->next==nullptr)//如果长度为1，则不必逆置
return L;
polylist p = L->next;
L->next = nullptr;
while(p){
polylist temp = p->next;
p->next = L;
L = p;
p = temp;
}
return L;
}
//打印多项式
void Displaypolynomial(polylist poly){
/***********************
Name: Displaypolynomial()
Description: 以常见的格式打印多项式
Input Parameters: -poly，需要打印的链表的第一个结点
Output Parameters: -
Return: -
Supplement: -该链表没有头结点,因此第一个结点也需要打印，
输出第一项时如果系数为正则不需要输出加号,如果是常数项则不输出X,如果幂为1则不显示次幂，
系数不等于0，指数等于0时不显示X^n，
系数不等不等于0，指数等于1时不显示^n，
系数等于0时，省略该项。
***********************/
polylist p = poly;
//输出第一项（如果系数为正则不需要输出加号,如果是常数项则不输出X,如果幂为1则不显示次幂）
if(fabs(p->coef-0.000) > FLOAT_PRECISON && p->expn==0)//系数不等于零，指数等于零时
printf("%.2f",p->coef);
else if(fabs(p->coef-0.000) > FLOAT_PRECISON && p->expn==1)//系数不等于零，指数等于1时
printf("%.2fX",p->coef);
else{
while(fabs(p->coef-0.000) < FLOAT_PRECISON){//系数等于零时，p = p->next
if(p->next==nullptr){//如果多项式只有一项且系数为0
printf("0"); return;}
p = p->next;
}
if(fabs(p->coef-1.000) < FLOAT_PRECISON && p->expn!=0)
printf("X^%d",p->expn);
else if(fabs(p->coef-(-1.000)) < FLOAT_PRECISON && p->expn!=0)
printf("-X^%d",p->expn);
else
printf("%.2fX^%d",p->coef,p->expn);
}
p = p->next;
//输出剩下的项
while(p!=nullptr){
if(fabs(p->coef-0.000) < FLOAT_PRECISON){//如果系数为0则该项不打印
p = p->next;
continue;
}
else if(p->coef<0.000 && p->expn!=0 && p->expn !=1){//系数小于零直接打印，自带减号
if(fabs(p->coef-(-1.000)) < FLOAT_PRECISON)//系数为-1
printf("-X^%d",p->expn);
else//系数不为-1
printf("%.2fX^%d",p->coef,p->expn);
}
else if(p->coef>0.000 && p->expn!=0 && p->expn !=1){ //系数大于零打印时要加“+”
if(fabs(p->coef-1.000) < FLOAT_PRECISON)//系数为1
printf("+X^%d",p->expn);
else//系数不为1
printf("+%.2fX^%d",p->coef,p->expn);
}
else if(p->expn==0){//指数为零的时候不打印X和次幂
if(p->coef>0)
printf("+%.2f",p->coef);
else if(p->coef<0)
printf("%.2f",p->coef);
}
else if(p->expn==1){//指数为1的时候不打印次幂
if(p->coef>0){
if(fabs(p->coef-1.000) < FLOAT_PRECISON)//系数为1
printf("+X");
else
printf("+%.2fX",p->coef);}
else if(p->coef<0){
if(fabs(p->coef-(-1.000)) < FLOAT_PRECISON)//系数为-1
printf("-X");
else
printf("%.2fX",p->coef);}
}
p = p->next;
}
}
//两个多项式相加
void addpoly(polylist a, polylist b, polylist &result){
/***********************
Name: addpoly()
Description: 将两个多项式相加并将结果存储在result的链表中
Input Parameters: -a，需要相加的其中一个链表的第一个结点
-b，需要相加的第二个链表的第一个结点
-result，输入的空结点
Output Parameters: -result，作为函数出口，以result为第一个结点的链表保存了相加后的的多项式
Return: -
Supplement: -
***********************/
result = (polylist)malloc(sizeof(polynomial_Node));
polylist pre_node;
int head_state = 1;//用于在生成第一个结点时的控制
if(a->expn!=0){//当a头结点次幂不为0时进行逆置操作，方便后续相加运算
a = revers_Llist(a);
}
if(b->expn!=0){//当b头结点次幂不为0时进行逆置操作，方便后续相加运算
b = revers_Llist(b);
}
while(a!=nullptr || b!=nullptr){
float coef_a,coef_b;//暂存
int expn_a,expn_b;//暂存
//计算新的coef和expt
if(a==nullptr && b != nullptr){
coef_a = 0.000;
expn_a = 0;
}
else{
coef_a = a->coef;
expn_a = a->expn;
}
if(b==nullptr && a != nullptr){
coef_b = 0.000;
expn_b = 0;
}
else{
coef_b = b->coef;
expn_b = b->expn;
}
float coef = coef_a + coef_b;
int expn = expn_a|expn_b;
//如果是头结点
if(head_state){
result->coef = coef;
result->expn = expn;
result->next = nullptr;
pre_node = result;
//printf("%f %d",result->coef,result->expn);
if(a!=nullptr)
a = a->next;
if(b!=nullptr)
b = b->next;
head_state = 0;
continue;
}
//如果不是头结点
polylist temp = (polylist)malloc(sizeof(polynomial_Node));
temp->coef = coef;
temp->expn = expn;
temp->next = nullptr;
pre_node->next = temp;
pre_node = temp;
if(a!=nullptr)
a = a->next;
if(b!=nullptr)
b = b->next;
}
result = revers_Llist(result);
}
//多项式求N阶微分
void differentialpoly(polylist a,int N, polylist &result_return){
/***********************
Name: differentialpoly()
Description: 将多项式微分N阶并将结果存储在result的链表中
Input Parameters: -a，需要进行微分的多项式的第一个结点指针
-result_return，输入的空结点
Output Parameters: -result_return，作为函数出口，以result_return为第一个结点的链表保存了N阶微分后的的多项式
Return: -
Supplement: -参考了递归思路，每次进入函数N-1,当N=0时转向函数出口
***********************/
if(get_polylen(a)<=N){//微分阶数过高时进行控制
result_return = (polylist)malloc(sizeof(polynomial_Node));
result_return->coef = 0.000;
result_return->expn = 0;
result_return->next = nullptr;
return ;
}
else if(N>0){//此时还要继续微分
polylist result;
result = (polylist)malloc(sizeof(polynomial_Node));
polylist pre_node;
int head_state = 1;//用于在生成第一个结点时的控制
while(a!=nullptr){
//如果expn为0则这项微分后不存在了，直接跳过这个node
if(a->expn==0){
a = a->next;
continue;
}
//计算微分后新的coef和expt
float coef = a->coef * a->expn;
int expn = a->expn - 1;
//如果是头结点
if(head_state){
result->coef = coef;
result->expn = expn;
result->next = nullptr;
pre_node = result;
a = a->next;
head_state = 0;
continue;
}
//如果不是头结点
polylist temp = (polylist)malloc(sizeof(polynomial_Node));
temp->coef = coef;
temp->expn = expn;
temp->next = nullptr;
pre_node->next = temp;
pre_node = temp;
a = a->next;
}
differentialpoly(result,N-1,result_return);//进入下一阶微分
free(result);//释放内存
}
else if(N==0)//出口，将最终结果复制给result_return
Copy_polylist(a,result_return);
}
//多项式不定积分
void indefiniteintegralpoly(polylist a, polylist &result){
/***********************
Name: indefiniteintegralpoly()
Description: 求多项式不定积分并将结果存储在result的链表中
Input Parameters: -a，需要求不定积分的多项式的第一个结点指针
-result，输入的空结点
Output Parameters: -result，作为函数出口，以result为第一个结点的链表保存了求不定积分后的的多项式
Return: -
Supplement: -
***********************/
result = (polylist)malloc(sizeof(polynomial_Node));
result->coef=0.000;result ->expn=0;result->next=nullptr;
polylist pre_node = result;
while(a!=nullptr){
polylist temp = (polylist)malloc(sizeof(polynomial_Node));
temp->coef = float(a->coef / (float(a->expn) + 1.00));
temp->expn = a->expn + 1;
temp->next = nullptr;
pre_node->next = temp;
pre_node = temp;
a = a->next;
}
}
#endif // NOAH_EXP1_H_INCLUDED
Main.cpp
#include <iostream>
#include "noah_exp1.h"
#include <stdlib.h>
#include <stdio.h>
using namespace std;
void Menue_gui();
void createandprintpoly();
void addandprint();
void differentialandprint();
void integralandprint();
int main()
{
while(1){
Menue_gui();
int func;
scanf("%d",&func);
switch(func){
case 0:
exit(0);
case 1:
createandprintpoly();break;
case 2:
addandprint();break;
case 3:
differentialandprint();break;
case 4:
integralandprint();break;
default:
printf("Input error! Please try again!");
}
printf("\n");
system("pause");
}
return 0;
}
//菜单界面
void Menue_gui(){
system("cls");//清屏
printf("********************This is Sparse unary polynomial arithmetic unit**************************\n");
printf("*********************************************************************************************\n");
printf("Menue:\n");
printf("\nExit this program------------------------------------------------------0.\n");
printf("\nCreate a polynomial and print it to screen-----------------------------1.\n");
printf("\nAdd 2 polynomial and print result to screen----------------------------2.\n");
printf("\nGet differential of a polynomial and print result to screen------------3.\n");
printf("\nGet indefinite integral of a polynomial and print result to screen-----4.\n");
printf("\n**********************************************************************************************\n");
printf("Choose the function you want to use(input number):\n");
}
//功能1界面
void createandprintpoly(){
system("cls");//清屏
printf("ENTER FUNCTION : Create a polynomial and print it to screen--1.\n");
polylist poly_1;
printf("Please input highest exponential(integer) and a number series of coefficient to initialize the polynomial.\n");
printf("highest exponential:\n");
int Initsize;
scanf("%d",&Initsize);
Initsize=Initsize+1;
//printf("The number series of coefficient:(input)\n");
Creatpolyn(poly_1,Initsize);
printf("Now the polynomial is:\n");
//Displaypolynomial(poly_1);//这是从低次幂到高次幂进行打印
//将正向链表逆置，得到从高次降到低次的链表
polylist poly_1_reverse;
Copy_polylist(poly_1,poly_1_reverse);//复制一个原链表到别的内存空间
poly_1_reverse = revers_Llist(poly_1_reverse);//逆置
Displaypolynomial(poly_1_reverse);
}
//功能2界面
void addandprint(){
system("cls");//清屏
printf("ENTER FUNCTION : Add 2 polynomial and print result to screen----------------------------2.\n");
//初始化多项式A
printf("Initialize polynomial A.\n");
polylist poly_2;
printf("Please input highest exponential(integer) and a number series of coefficient to initialize the polynomial.\n");
printf("highest exponential:\n");
int Initsize;
scanf("%d",&Initsize);
Initsize=Initsize+1;
//printf("The number series of coefficient:(input)\n");
Creatpolyn(poly_2,Initsize);
//初始化多项式B
printf("Initialize polynomial B.\n");
polylist poly_3;
printf("Please input highest exponential(integer) and a number series of coefficient to initialize the polynomial.\n");
printf("highest exponential:\n");
//int Initsize;
scanf("%d",&Initsize);
Initsize=Initsize+1;
//printf("The number series of coefficient:(input)\n");
Creatpolyn(poly_3,Initsize);
//展示多项式A
printf("\nNow the polynomial A is:\n");
polylist poly_2_reverse;
Copy_polylist(poly_2,poly_2_reverse);//复制一个原链表到别的内存空间
poly_2_reverse = revers_Llist(poly_2_reverse);//逆置
Displaypolynomial(poly_2_reverse);
//展示多项式B
printf("\nNow the polynomial B is:\n");
polylist poly_3_reverse;
Copy_polylist(poly_3,poly_3_reverse);//复制一个原链表到别的内存空间
poly_3_reverse = revers_Llist(poly_3_reverse);//逆置
Displaypolynomial(poly_3_reverse);
//多项式A\B相加并打印
printf("\nAdd A and B, the result is:\n");
polylist add_result;
addpoly(poly_2_reverse,poly_3_reverse,add_result);
Displaypolynomial(add_result);
}
//功能3界面
void differentialandprint(){
system("cls");//清屏
printf("ENTER FUNCTION: Get differential of a polynomial and print result to screen------------3.\n");
//初始化多项式C
printf("Initialize polynomial.\n");
polylist poly_5;
printf("Please input highest exponential(integer) and a number series of coefficient to initialize the polynomial.\n");
printf("highest exponential:\n");
int Initsize;
scanf("%d",&Initsize);
Initsize=Initsize+1;
//printf("The number series of coefficient:(input)\n");
Creatpolyn(poly_5,Initsize);
//展示多项式C
printf("\nNow the polynomial is:\n");
polylist poly_5_reverse;
Copy_polylist(poly_5,poly_5_reverse);//复制一个原链表到别的内存空间
poly_5_reverse = revers_Llist(poly_5_reverse);//逆置
Displaypolynomial(poly_5_reverse);
printf("\nInput the differential order:\n");
int N;
scanf("%d",&N);
//一阶微分阶数
printf("\n %d order differential of polynomial is:\n",N);
polylist differential_result_1st;
differentialpoly(poly_5_reverse,N,differential_result_1st);
Displaypolynomial(differential_result_1st);
}
//功能4界面
void integralandprint(){
system("cls");//清屏
//初始化多项式D
printf("Initialize polynomial.\n");
polylist poly_6;
printf("Please input highest exponential(integer) and a number series of coefficient to initialize the polynomial.\n");
printf("highest exponential:\n");
int Initsize;
scanf("%d",&Initsize);
Initsize=Initsize+1;
//printf("The number series of coefficient:(input)\n");
Creatpolyn(poly_6,Initsize);
//展示多项式D
printf("\nNow the polynomial is:\n");
polylist poly_6_reverse;
Copy_polylist(poly_6,poly_6_reverse);//复制一个原链表到别的内存空间
poly_6_reverse = revers_Llist(poly_6_reverse);//逆置
Displaypolynomial(poly_6_reverse);
//不定积分
printf("\n Indefinite integral of polynomial is:\n");
polylist integeral_result;
indefiniteintegralpoly(poly_6_reverse,integeral_result);
Displaypolynomial(integeral_result);
}