Urgente, urgente, urgente. Encuentre el código C para las cuatro operaciones aritméticas de números grandes. Utilice tablas lineales para implementar la suma, resta, multiplicación y división de números grandes.
struct Node // Definir una lista doblemente enlazada para almacenar resultados
{
char data; // La razón por la cual los datos * se definen como caracteres: a se mostrará signo negativo
Nodo *siguiente; // Puntero de cola
Nodo *adelante; // Puntero de cabeza
};
/* ------------------------------------------------ -- --------------------------
*Nombre de función: Suma de números grandes
* Proceso de función: 1 Compara los dos números cuál es más largo
* 2 Usa el más largo como número de ciclos
* 3 Agrega los elementos correspondientes y guárdalos hasta el siguiente máximo se agrega un bit
* 4 hasta el final del ciclo
* 5!!!!!! No hay diseño para agregar números negativos
*Entrada parámetros: numa, entumecido, cadena de resultados
*Parámetros de exportación: Ninguno
*Entorno de edición: winSP2 + VC2003 + C++
*------ -------------------- ------------------------------ -------------------- ----*/
void add(char *numa, char *numb,char *resultado) // Calcula la suma de dos números grandes
{
char *pna = findend(numa); // Un puntero a numa. point numa pna apunta al bit más bajo del multiplicando,
char *pnb = findend(numb); //Un puntero a entumecido//pnb apunta al bit más bajo del multiplicando,
int together=(int)strlen(numa); //Marca la longitud del número a;
int blong=(int)strlen(numb); //Marca la longitud del número b;
int times = 0; // Cuántas veces necesita calcular Peugeot.
int carry=0,temp_result; //Transporte de almacenamiento y resultados temporales
Nodo *head, // Se utiliza para almacenar el puntero principal
* pstart, / / usado para almacenar el primer puntero durante el cálculo
*pnew; //usado para solicitar un nuevo nodo
head = pstart =new Node; //inicializa el primer nodo Point y nodo principal.
pstart -> datos = 0;
pstart -> siguiente = NULL;
pstart -> adelante = NULL
if; (abigerb(numa,numb)>=1)
times = (int)strlen(numa); //Compara las longitudes de las dos cadenas y usa la más grande como número de bucles
else
{
times = (int)strlen(numb);
pna = findend(numb); //Intercambiar punteros
pnb = findend(numa);
together=(int)strlen(numb); //Marca la longitud del número a;
blong=( int)strlen(numa); //Marca la longitud del número b;
}
while ((times-- && (times>=0))|| carry != 0)
{
if(!pstart->next) //Si el nodo actual está vacío, solicita un nuevo nodo
{
pnew = nuevo Nodo ;
pnew -> datos = 0;
pnew -> siguiente = NULL;
pnew -> forward = pstart ;
pstart -> next = pnew;
}
else temp_result =(pstart->data +(*pna-48)+(*pnb- 48)+carry) ; // Su propio valor + nuevo valor + carry se utiliza como el nuevo valor actual
pstart -> data = temp_result%10 //Almacenando el dígito de las unidades
<; p> carry = temp_result/10; // Almacenar carrypstart = pstart -> next; //Movimiento del nodo
blong--;
if( blong>0)pnb--; //El puntero se mueve al bit alto del sumando
else *pnb=48; //Después, la resta se vuelve 0 sin ninguna operación;
pna--; // Addend El puntero se mueve,
}
pstart =head // Encuentra el punto final de la lista vinculada
while; (pstart->siguiente != 0)
{
pstart->data += 48; //!!<< Entonces agregue 48>>>> salida inversa pstart = pstart->next; } int tip = 0 //Transferir uso para cadenas pstart = pstart->ahead; //Buscar palabras válidas //cout<<"\nEl resultado es: "; while(pstart != 0) // Genera resultados de secuencia positiva; { result[tip++] = pstart->data //cout < data; pstart = pstart->ahead ; } resultado[tip] = '\0'; pstart =head; espacio while(pstart->siguiente != 0) { pnew = pstart->siguiente ;eliminar pstart; pstart =pnew; } return ; } //Compara dos cadenas numéricas Función de tamaño //Descripción del valor de retorno: 0 es largoblong; 2 es largo=blong int abigerb(char *numa, char *numb) //Compara los dos números más altos ¿Cuál es más grande? { int together=(int)strlen(numa); //Marca la longitud del número a; int blong=(int )strlen(numb); // Marca la longitud del número b; char *pna = numa; // Señala el bit más alto del número A, char *pnb = numb; el bit más alto del número B, if (along>blong) devuelve 1; if (along==blong) { while(*pna) //Compara los dos números cuál es mayor { if(*pna>*pnb)return 1; else if(*pna<*pnb)return 0; else if(*pna==*pnb){pna++;pnb++;} //1111 y 1112 } return 2; //Esto demuestra que al final todos son iguales; } return 0; } /*-------------------------------------------- ----- ---------------------------- *Nombre de función: Resta de números grandes * Proceso de función: 1. Compara los dos números cuál es más largo * 2. Usa el más largo como número de bucles * 3. Si el las longitudes de los dos números son iguales, comience a comparar desde el bit más alto hasta encontrar el número. Si un número es mayor, reste el término pequeño del término grande * 4 El término correspondiente se resta y se almacena. hasta que se agregue el siguiente bit de orden superior * 5 El término correspondiente se resta de cada bit Cuando, maneja tres situaciones posibles, a=b,ab; * 6 Cuando a =b, calcular, 1 1-12, 111-112, se debe considerar el préstamo * 7 hasta el final del ciclo *Parámetros de entrada: numa, entumecido, cadena de resultado *Parámetros de salida: Ninguno *------------------------------------ ---- ----------------------------------*/ resta nula( char *numa, char *numb,char *result)//Calcular resta { char *pna = findend(numa);//Un puntero a numa. point numa pna apunta al bit más bajo del sustraendo, char *pnb = findend(numb);//un puntero a entumecido//pnb apunta al bit más bajo del minuendo, int together=(int)strlen(numa);//Marca la longitud del número a; int blong=(int)strlen(numb);//Marca la longitud del número b; int times = 0; // Cuántas veces se debe calcular la marca. int carry=0; // Préstamo de almacenamiento int clear0=0; // ¡Elimina el '0' inútil al frente del resultado 13-5 = 08! ! int isnegative=0; //Se usa para agregar el último signo negativo cuando el minuendo es mayor que el sustraendo Nodo *head, // Se usa para almacenar el puntero del encabezado *pstart, // Se utiliza para almacenar el primer puntero durante el cálculo *pnew; // Se utiliza para solicitar un nuevo nodo head = pstart = new Node ;//Inicializa el primer nodo y el nodo principal. pstart -> datos = 0 pstart -> siguiente = NULL; pstart -> adelante = NULL si (abigerb(numa,numb)) times = strlen(numa);//Compara las longitudes de las dos cadenas y usa la más grande como número de ciclos else //Intercambia posiciones con Reducir dificultad { times = strlen(numb);//Deja que el número largo (cadena) reste el número corto (cadena) pna = findend(numb);// Intercambiar punteros pnb = findend(numa together=(int)strlen(numb);//Marcar la longitud de number a; blong=(int)strlen(numa);//Marcar la longitud del número b isnegative=1;//Marcar con un signo negativo en el end } while ((times-- && (times>=0))|| carry != 0)//carry != 0 cuando no hay préstamo { if(!pstart->next)//Si el nodo actual está vacío, solicite un nuevo nodo { pnew = nuevo Nodo; pnew -> datos = 0; pnew -> siguiente = NULL pnew -> adelante = pstart; > pstart - > next = pnew; } if(times<0)//Si después del cálculo, el bit de préstamo es igual a 1, significa que debe ser un valor negativo; { pstart -> data = -3;//Que sea igual al signo negativo '-'//-3 proviene de la diferencia entre el signo negativo y 0 por 3. . break; } else { if ( *pna == *pnb )//El sustraendo es igual al hora minuendo. El resultado es igual al resultado de la resta directa; el bit de préstamo se establece en 0 { if(carry==0)pstart -> data = (*pna-48). )-(* pnb-48); //La situación del 111-11 else { pstart->data = (*pna-48) )-(*pnb -48)+10 -carry;//1121-1112 llevar=1; } } if( *pna > *pnb )// Cuando el sustraendo es mayor que el minuendo. El resultado es igual al resultado de la resta directa; el bit de préstamo concatenado es 0 { pstart -> data = (*pna-48)-(*pnb-48) -carry; //Almacenando el dígito de las unidades carry=0; } else if( *pna < *pnb )//Indica que el minuendo es mayor que el minuendo, suma 10 al resultado, lo que equivale a llevar 1 { if(times>0) pstart->data = (*pna-48) -(* pnb-48)+10 -carry;//La situación de 13-5 se utiliza como nuevo valor else pstart->data = (*pnb- 48)-(*pna- 48) -carry; //3-5 como el nuevo valor actual carry=1 } } <; /p> pstart = pstart -> next; //Movimiento del nodo blong-- if(blong>0)pnb-; -;//Movimiento del puntero Muévete al bit alto del minuendo else *pnb=48;//Después de eso, la resta se vuelve 0 sin ninguna operación, lo que en realidad se puede optimizar. ¡Pero el código será largo! Y es necesario reabrir el nodo. Así que ríndete; pna--;//Mueve el puntero contado, } if(isnegative==1)////Agrega un signo negativo. Agregue una longitud y configúrela con un signo negativo { pnew = new Node pnew -> data = 0
pnew -> adelante = pstart;
pstart -> siguiente = pnew
pstart->data=-3; ;/ /Porque al buscar el punto final de la lista vinculada, se debe agregar 48 de manera uniforme. Y porque '-' es 45. Entonces igual a '-3'
}
pstart =head;//Encuentra el punto final de la lista enlazada
while(pstart->next ! = 0)
{
pstart->data += 48;//!!<< Entonces agregue 48>>>> salida inversa pstart = pstart->next; } int tip = 0;//turn Usar para cadenas clear0=0;//Elimina el '0' inútil al frente del resultado 13-5 = 08..>>Modifica el primer puntero de la cadena pstart = pstart ->ahead ;//Buscar palabras válidas while(pstart != 0)//Resultados de secuencia positiva { if(clear0==0 && ( (int)pstart; ->data)==48&&pstart->ahead!=0)//Elimina el '0' inútil al frente del resultado; //No genera nada más resultado[tip++] = pstart->datos; if(((int)pstart->datos)!=48&&((int)pstart->datos)!= 45 )clear0=1;//'-' número pstart = pstart->ahead } resultado[tip] = '\0' ; pstart =head; //Liberar espacio while(pstart->next != 0) { pnew = pstart ->siguiente ; eliminar pstart pstart =pnuevo } regresar ; } /*---------------------------------------- - --------------------------------- *Nombre de función: Multiplicación de números grandes p> *Proceso de función: 1. Ingrese dos números grandes como cadenas * 2. Haga una lista doblemente enlazada * 3. Dos punteros apuntan al más bajo valor de la cadena numérica. Bit * 4 Multiplica el bit más bajo del primer número por todos los elementos del segundo número y guárdalos en la lista enlazada * 5 Mueve el primer puntero de la lista enlazada * 6 Repita 4 y 5 desde el bit más bajo hasta el bit más alto en secuencia * 7 Después de multiplicar, porque el bit más bajo es la cabeza de la lista enlazada, el último bit es la cola de la lista enlazada. Entonces, la lista vinculada se genera en orden inverso. * 4 hasta el final del bucle *Parámetros de entrada: numa, entumecido, cadena de resultado *Parámetros de salida: Ninguno * ------------------------------------------------ ------------------------*/ void multiplicar(char *numa, char *numb,char *resultado) // Usado para almacenar resultados)//Calcular el producto { char *pna = findend(numa);//Un puntero a numa. point numa pna apunta al bit más bajo del multiplicador, char *pnb = findend(numb);//Un puntero a entumecido //pnb apunta al bit más bajo de el multiplicando, int together=(int)strlen(numa);//Marca la longitud del número a int blong=(int)strlen(numb);// Número de marca b La longitud de p>*pstart, //Se usa para almacenar el primer puntero durante el cálculo *pnew, //Se usa para solicitar un nuevo nodo *pgo; //A medida que se completa cada cálculo Cuando hay una fila, use el desplazamiento Peugeot para regresar al nodo inicial de la siguiente fila head = pstart =new Node //Inicializa el nodo principal y el nodo principal; . pstart -> datos = 0 pstart -> siguiente = NULL; pstart -> adelante = NULL mientras; (a lo largo--) { pgo = pstart;//Guardar el punto de transporte blong = (int)strlen(numb);//Inicializar la longitud pnb = findend(numb); //Inicializar puntero mientras ((blong-- && (blong>=0))|| carry != 0) { if(!pstart->next)//Si el nodo actual está vacío, solicite un nuevo nodo { pnew = new Node pnew - > datos = 0; pnew -> siguiente = NULL; pnew -> adelante = pstart pstart -> siguiente = pnew; > } if(blong<0)temp_result = carry ;//Manejar solo la situación de transporte else temp_result =(pstart->data+(*pna-48)* ( *pnb-48)+carry); //Valor propio + nuevo valor + llevar como nuevo valor pstart -> data = temp_result%10 //Almacenando los dígitos carry = temp_result/10; //Almacenamiento carry pstart = pstart -> next; //Movimiento del nodo pnb-- //El puntero se mueve al bit alto del multiplicand } pstart = pgo->next; //Avanzar una posición pna-- //El puntero se mueve al bit alto; del multiplicador } pstart =head;//Encuentra el punto final de la lista enlazada while(pstart->next != 0) { pstart- >data += 48;//!!<< Entonces agregue 48 >>>> salida inversa pstart = pstart->next; } int tip = 0; //convertir a cadena pstart = pstart->ahead ;//Encontrar palabras válidas while(pstart != 0)//Resultados de secuencia positiva { result[tip++] = pstart->data; /p> pstart = pstart->ahead } resultado[tip] = '\0'; pstart =head; while(pstart->siguiente != 0) { pnew = pstart->siguiente ; eliminar pstart pstart =pnew; /p> } return ; } /*---------- ------- ------------------------------------- ------- -------- *Nombre de la función: División de números grandes 2-- *Idea de función: 1 Use un puntero para señalar el bit más alto del divisor, guarda la cadena temporal; tempstr[a++] = pna * 2 Si la cadena temporal es mayor que el dividendo, se resta. El resultado es igual al resto * if(tempstr>numb)tempstr = tempstr - numb * 3 Si es menor que el dividendo y el puntero llega al final, el el resto es igual a la cadena temporal * if(tempstr * *Parámetros de entrada: numa, entumecido, resultado, cadena restante *Parámetros de salida: Ninguno *----- ------------------------------- ------------- ------------------*/ void divide2( char *numa, char *numb ,char *resultado,char *resto)//División de cálculo 2 { char one[]="1";//Cadena temporal.... char one2[] ="1";// char zero[]="0";// char numb2[6048];// char tempstr[ 6018]="";//Cadena temporal i nt ia=0,ia2=0;//indicador tempstr bool moveon=false;//voltear la tarjeta char *pna = numa;//Un puntero al punto numa numa pna //Apunta al bit más bajo del sustraendo, char *pnb = findend(numb);//A puntero a entumecido//pnb apunta al restado El bit más bajo del número, Nodo *head, // usado para almacenar el puntero principal *pstart, // usado para almacena el primer puntero durante el cálculo *pnew; // Solicita un nuevo nodo head = pstart =new Node // Inicializa el nodo principal y el nodo principal. pstart -> datos = 0 pstart -> siguiente = NULL pstart -> adelante = NULL moveron; = false; while(*pna) { if(!pstart->next)//Si el nodo actual está vacío, solicita un nuevo nodo { pnew = new Node ; pnew -> datos = 0 pnew -> siguiente = NULL; pnew -> adelante = pstart; pstart -> next = pnew; } ia=(int)strlen(tempstr);//La longitud a tomar tempstr[ia++] = *(pna++); p > tempstr[ia] ='\0'; //Convertir a cadena if(tempstr[0]=='0')//Procesar el tipo donde también está el bit alto 0, como 00 { ia2=0 while(tempstr[ia2]=='0')++ia2; > while (ia2>=1)//Borrar 0 inútiles { ia=ia2-1 tempstr[ia]=tempstr; [ia2]; --ia2; } tempstr[++ia2]='\0'; while(abigerb(tempstr,numb)>0)//Si tempstr es mayor o igual que entumecido { if(tempstr[0] =='0')// El bit de orden superior también es 0, como 00----este es un código redundante, reservado para la memoria { ia2= 0; while (tempstr[ia2]=='0')++ia2 if(ia==ia2 ) { moveon = true ; romper; } } strcpy(numb2,numb); restar(tempstr, entumecido,tempstr);//A-B strcpy(entumecido, entumecido2) ); if (tempstr[0]=='-')// Si el juicio es inexacto y se convierte en un número negativo, agregue B. . { strcpy(numb2,numb); add(tempstr, entumecido,tempstr);//A-B strcpy( entumecido, entumecido2); ia2=0; //La longitud corregida. Porque no hay ninguna operación negativa adicional ia=0; // Para eliminar el último signo negativo, todo avanza. while(tempstr[ia2]!='\0')++ia2; while(ia2>=1)//Borrar inútil 0 { tempstr[ia]=tempstr[ia+1]; ++ia --ia2 } tempstr[ia]=' \ 0'; moveon = true; break; pstart->data++ ; //El resultado se incrementa moveon = true; } if(moveon) pstart = pstart -> next; //Movimiento del nodo } strcpy(remainder,tempstr);/ / Resto de almacenamiento int tip = 0;// Convertir a cadena pstart =head;//Encontrar el punto final de la lista vinculada while( pstart ->siguiente != 0) { pstart->data += 48;//!!<< result[tip++] = pstart->data pstart = pstart->next } result[; tip] = '\0';//Almacenando el resultado pstart =head; //Liberar espacio while(pstart->next != 0) { pnew = pstart->siguiente ;eliminar pstart; pstart =pnew } return ; }