Programación para suma y resta de números grandes
# incluir & ltmalloc.h & gt
# incluir & ltmath.h & gt
# incluir & ltstring. h & gt
# include & ltctype.h & gt
#Definición M 40
/*Pila de definiciones*/
typedef Estructura {
Datos dobles [M];
int top
} pila
/*Pila de inicialización*/
InitStack(pila*s)
{
s->top = 0;
}
/* Determinar si la pila está vacía*/
int system type (stack)
{
if(s-& gt;top==0)
{
Devuelve 1;
}
Otros
{
Devuelve 0 ;
}
}
/*Operación de pila*/
StPush (pila *s, doble x)
{
if(s-& gt;top==M)
{
printf("¡Desbordamiento de pila!");
}
Otro
{
s-& gt;top = s-& gt;top+1;
s->data[s->top]= x;
}
}
/*Operación de apilamiento*/
Doble StPop(pila)
{
Doble t;
if (!StEmpty(s))
{
t = s->datos[s->top];
s->top = s->top-1;
}
Otros
{
printf("StPop: ¡La pila está vacía!");
t = NULL
}
return t;
}
/*Obtener el elemento superior de la pila*/
Double StGetTop(stack)
{
Doble t;
if (!StEmpty(s))
{
t = s->data[s->top];
}
Otro
{
printf("StGeTop: El ¡La pila está vacía! ");
t = NULL
}
return t;
}
/*Cambiar el número Convertir caracteres a números enteros*/
int ChrTransferint(char c)
{
int n;
Switch (c)
p>
{
Caso "0": n = 0 roto;
Caso "1": n = 1; p>
Caso "2": n = 2;
Caso "3": n = 3;
Caso "4": n = 4; roto;
Caso "5": n = 5;
Caso "6": n = 6;
Caso "7": n = 7; romper ;
Caso "8": n = 8;
Caso "9": n = 9;
Devolver n;
}
/*Obtiene el número de caracteres numéricos entre dos operadores y devuelve la posición del último carácter numérico*/
int GetNumsize(char str[], int n1)
{
int N2 = n 1;
while(is digit(str[N2])| |(str[N2])= = 46)/* is digit() determina si Para numérico caracteres*/
{
N2 = N2+1;
}
Devuelve N2;
}
/* Determina si la cadena numérica obtenida en la última función contiene un punto decimal y devuelve su posición, si no, devuelve -1*/
int IsIncludepoint(char str [] , int n1, int n2)
{
int n3 =-1;
int I
for(I = n; 1;i<= n2i++)
{
if(str[i]== ' . ')
{
n3 = Yo;
Romper
}
}
Regresar n3; p>/*Convertir caracteres numéricos en valores numéricos*/
double Transfer(char str[], int n1, int n2, int n3)
{
dato doble = 0;
int i, CT;
if (n3 & lt0)
{
for(I = N2;i>= n 1;i-)
{
CT = ChrTransferint(str[I]);
datos= datos+ct*pow( 10, N2-I); /*pow(x, y) calcula el valor de potencia y-ésimo de x*/
}
}
Otro
{
for(I = n3-1;I>= n 1;I-)
{
CT = ChrTransferint( str[I]);
data=data+ct*pow(10,n3-1-I);/*pow(x,y) calcula la potencia yésima del valor x*/
}
for(I = n3+1;i<= n2i++)
{
CT = ChrTransferint (str[I]);
data=data+ct*pow(0.1, I-n3); /*pow(x, y) calcula el valor de potencia y-ésimo de x*/
}
}
Datos devueltos;
}
/*Programa principal*/
main()
{
char str[M], c;
char a;
int n, p1, p2, P3; la longitud de la cadena, P1, P2 y P3 son la posición inicial, la posición final y la posición del punto decimal de los caracteres numéricos*/
Datos dobles /*Valor convertido de almacenamiento*/
<; p>int I = 0;Pila * so =(Pila *)malloc(sizeof(Pila));/*Operador de almacenamiento "(':1,'+': 2, '-': 3, ' *': 4, '/': 5 caracteres'), = 'Sin pila*/
Pila * SD =(Pila *)malloc(sizeof(Pila )); */
pila de inicio(así);
pila de inicio(SD);
>printf("Ingrese la fórmula (formato: (1+2)* 1.2/4 =):\ n ";
n =
mientras((a; = getchar())! ='\n ')
{
str[n]= a;
n++;
}
mientras(i<n)
{
char c;
c = str[I];
if(c== '(')
{/*c if '('poner directamente en la pila entonces, i++*/
StPush(so, 1);
i++;
}
si no(isdigit(c))
{
p 1 = I Si /*c es un carácter numérico, convierta los siguientes caracteres numéricos consecutivos en valores numéricos y apílelos en sd, y configure I de la siguiente manera */
p2=GetNumsize(str, p 1) ;
p3=IsIncludepoint(str, p1, p2-1); /*La posición del primer carácter no numérico*/
data=Transfer(str, p1, p2); -1, P3);
StPush(sd, datos);
i = p2
}
si no (c= ='+ ')
{
StPush(so, 2); /*cSi '+' va directamente a la pila, entonces I++*/
i++;
p>}
si no(c=='-')
{
StPush(entonces, 3) ; /*cif' -'Directamente a la pila, luego I++*/
i++;
}
else if(c=='* ')
{
If(str[i+1]=='(') /*c Si' * ' es el carácter que sigue (', Si' * ' es un pila directa, entonces, */
{
StPush(so, 4)
i++;
Otros
{
Double t1, t2, T3 /*Si no, es un carácter numérico y los caracteres numéricos consecutivos posteriores se convierten en valores numéricos. t2, sd se envía a t1, t3=t2*t1 se envía a sd*/
t 1 = StPop(SD); /*El operador "*" no se apila, por lo que */
p 1 = I+1;
p2=GetNumsize(cadena, p 1);
p3=IsIncludepoint(cadena, p1, p2-1);
t2=Transferir(str, p1, p2-1 , P3
T3 = t 1 * T2
StPush(sd, T3); p>
i = p2
}
}
si no(c=='/')
{
if(str[i+1]== '(')
{
StPush(entonces, 5);
i++
}
Otros
{
Doble t1, t2, T3
t 1 = StPop; (SD); /*c es con ' *' */ /'
p 1 = I+1
p2=GetNumsize(str, p 1); >
p3=IsIncludepoint(cadena, p1, p2- 1);
t2=Transfer(cadena, p1, p2-1, P3);
T3 = t 1 /T2;
S
tPush(sd, T3);
i = p2
}
}
else if(c== ')')
{
Doble t1, t2, T3;
int p;
mientras((p=StPop(so))! =1.
& amperio! Si está vacío (so))/* c es ')', apílelo, determine si es '+' o '-', apile sd dos operandos, suma y resta */
{/* Hasta StPop =='('*/
t 1 = StPop(SD);
t2=StPop(SD);
Si (p==2 )
{
T3 = T2+t 1;
StPush(sd, T3
}
<); p >else if(p==3){
T3 = T2-t 1;
StPush(sd, T3);
}
}
If(StGetTop(so)==4) /*Luego determine si la parte superior de la pila so es ' * ' o '/'*/
{
ST pop(so);
t 1 = StPop(SD);/* es ' *' extraído, por lo que el sd extraído obtiene dos operandos , multiplicación de dos operandos*/
t2=StPop(SD);
T3 = T2 * t 1;
StPush(sd, T3);
p>
}
else if(StGetTop(so)==5)
{
ST pop(so);
t 1 = StPop(SD);/* se'/'explota, por lo que la sd extraída obtiene dos operandos y realiza la operación de división*/
t2=StPop(SD);
T3 = T2/t 1;
StPush(sd, T3);
}
i++;
}
else if(c=='= ')
{
Doble t1, t2, T3 /*c Si' = ', solo; en modo más y menos, entonces a p, sd a t1, t2*/
int p;
y (!StEmpty(so))
{
t 1 = StPop(SD);
t2=StPop(SD);
p = ST pop(entonces); >Si (p==2)
{
T3 = T2+t 1; /*p=='+', suma, resultado de la pila t3 sd*/
StPush(sd, T3);
}
si no(p==3)
{
T3 = T2-t 1;
StPush(sd, T3);/* p ='-', resta, resultado de superposición t3 sd*/
}
}
i++;
}
}
si (! StEmpty(so)||StEmpty(sd))
{
printf("¡Error de entrada, atrás!\n "); Si está vacío y solo hay un elemento en sd, la fórmula de entrada es incorrecta*/
}
Otros
{
Double-ended;
int I; /* De lo contrario, los datos en sd son el resultado final del cálculo, que se imprimirá*/
end = StGetTop(SD) ;
printf("El valor de esta fórmula:\ n ");
for(I = 0;i<n;i++)
{
printf ("%c ", str[I]);
}
printf("%f\n ", fin);