Red de conocimiento informático - Material del sitio web - Cómo escribir un programa de operaciones cuadráticas con números grandes en C

Cómo escribir un programa de operaciones cuadráticas con números grandes en C

Este es el código. Si desea usarlo, debe depurarlo usted mismo antes de poder usarlo.

/*----------------------------------------- ----------------------------------

* Nombre de la función: Suma de números grandes

*Proceso: 1 Compara dos números cuál es más largo

* 2 Usa el número más largo como número de bucles

* 3 Agrega los elementos correspondientes y almacena en la memoria hasta la siguiente suma superior

* 4 hasta el final del ciclo

* 5 !!!!!! La suma negativa no está diseñada

*Parámetros de entrada: numa, entumecido, cadena de resultado

*Parámetros de salida: Ninguno

*Entorno de edición: winSP2 VC2003 C

*----- -------------------------------------------- -------------- ---- ------------------*/

void add(char *numa, char *numb, char *result) // Calcular el suma de dos números grandes

{

char *pna = findend(numa); // Puntero a numa. pna apunta al bit más bajo del multiplicando,

char *pnb = findend(num); //Un puntero a entumecido//pnb apunta al bit más bajo del multiplicando,

int together=(int)strlen( numa);

int together=(int)strlen( numa); // Marca la longitud del número a; (int )strlen(num); // Marca la longitud del número b;

int times = 0; // Marca el número de veces a contar.

int carry=0, temp_result; // Almacena transporte y temp_result

Nodo *head, // Se utiliza para almacenar el puntero principal

*pstart, / / Se usa para almacenar el primer puntero en el cálculo

*pnew; // Se usa para solicitar un nuevo nodo

head = pstart = new Node // Inicializa el primer nodo y el nodo principal; .

pstart -gt; datos = 0;

pstart -gt; siguiente = NULL

pstart -gt; p>if (abigerb(numa,numb)gt;=1)

times = (int)strlen(numa); //Compara las longitudes de las dos cadenas y usa la más grande como recuento de bucles.

else

{

times = (int)strlen(numb);

pna = findend(numb); punteros

pnb = findend(numa);

along = (int)strlen(numb); //marca la longitud del número a;

blong = (int)strlen(numa); //marca la longitud del número b;

}

while ((times-- amp;amp; (timesgt;=0) )|| carry ! = 0)

{

if (!pstart-gt; next) //si el nodo está actualmente vacío, solicita un nuevo nodo

{

pnew = nuevo Nodo;

pnew -gt; datos = 0;

pnew -gt; siguiente = NULL; -gt; adelante = pstart;

pstart -gt; siguiente = pnew;

}

else temp_result = (pstart-gt;data (*pna- 48) (*pnb-48) llevar); //valor propio nuevo valor llevar como nuevo valor actual

pstart -gt; data = temp_result10; //almacenar bits

carry = temp_result/10; //almacenar transporte

pstart = pstart -gt.next; //movimiento de nodo

blong--;

if(blonggt; 0 )pnb--; //el puntero se mueve al máximo del número agregado

else *pnb=48; //después de eso, la resta se convierte en 0 sin ninguna operación;

pna-- ; //agregar movimiento del puntero,

}

pstart =head; //buscar el punto final de la tabla de cadenas

while(pstart-gt; next! = 0)

{

pstart-gt;data = 48; //! lt;lt;lt;Porque nuestra salida son caracteres.

Entonces agregue 48 gt;gt;gt;gt;salida inversa

pstart = pstart-gt;next;

}

int tip = 0; convertir a cadena

pstart = pstart-gt; //buscar palabras válidas

//coutlt;lt;"\n el resultado es: ";

while(pstart ! = 0) // genera el resultado en orden positivo

{

resultado[tip] = pstart-gt;data;

//coutlt; datos;

pstart = pstart-gt;

}

resultado[tip] = '\0';

p>

pstart = head; //espacio libre

while(pstart-gt; next != 0)

{

pnew = pstart- gt; siguiente; eliminar pstart;

pnew;

}

regresar; // Función para comparar los tamaños de dos cadenas numéricas

// Descripción del valor de retorno: 0 es largoblong; 2 es largo=blong

int abigerb(char *numa, char *numb ) //Compara el que tiene el dígito más alto de los dos números

{

int together=(int)strlen(numa); //Marca la longitud del número a; ;

p>

int blong=(int)strlen(numb); //Marca la longitud del número b;

char *pna = numa;

char *pna = numa ; // Apunta al bit más alto del número A;

char *pnb = nub; // Apunta al bit más alto del número B

if ( togethergt; blong) devuelve 1;

p>

if (along==blong)

{

while(*pna) //Compara dos números cuál es más grande

{

si (*pnagt; *pnb) devuelve 1;

si no (*pnalt; *pnb) devuelve 0

;

else if(*pna==* pnb){pna;pnb;}//1111 y 1112

}

return 2;

Esto muestra que encontrar el punto final sigue siendo congruente;

p>

}

Esto muestra que encontrar el punto final sigue siendo congruente.

p>devuelve 0;

}

/*---------------------- --------------------------------------------------

*Nombre de la función: Resta de números grandes

*Proceso 1 Compara los dos números cuál es más largo

* 2 Usa el más largo como el número de loops

* 3 Si los dos números tienen la misma longitud, comienza la comparación desde la posición más alta hasta descubrir cuál es mayor,

* 4 Resta el elemento correspondiente y almacena en la siguiente posición superior hasta la siguiente Suma de una posición superior

* 5 Al restar el elemento correspondiente en cada posición, hay tres situaciones posibles a tratar: a=b, ab;

* 5 cuando Al restar el valor correspondiente a cada posición se procesan tres situaciones posibles, a= b, ab;

* 6 Cuando a=b, calcular, 11-12, 111- 112, considere tomar prestado

* 7 hasta el final del ciclo

*Parámetros de entrada: numa, entumecido, cadena de resultado

*Parámetros de salida: Ninguno

* -------------------------------------------- ------- ------------------------*/

resta vacía(char *numa, char *numb , char *resultado)// Calcular la resta

{ char *pna = findend(numa); //un puntero a numa. pna apunta al bit más bajo del minuendo,

char *pnb = findend(numb); //un puntero a entumecido //pnb apunta al bit más bajo del minuendo,

int together=(int) strlen(numa);

int together=(int) strlen(numa);

int blong=; (int) strlen(numb); // Marca la longitud del número b;

int times = 0; // Marca el número de veces a contar.

int carry = 0; // Guarda los bits prestados

int clear0 = 0 // Elimina el impacto del "0" inútil en la parte superior 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

p> p>

*pstart, // usado para almacenar el primer puntero en el cálculo

*pnew; // usado para solicitar un nuevo nodo

head = pstart = new Nodo; // Inicializa el primer nodo y el nodo principal.

pstart -gt; datos = 0;

pstart -gt; siguiente = NULL

pstart -gt; p>if (abigerb(numa,numb))

times = strlen (numa);

else //intercambia posiciones para hacerlo menos difícil

{

times = strlen(numb); //Deja que el número más largo (cadena) reste el número más corto (cadena)

pna = findend(numb); p>

pnb = findend(numa);

along=(int)strlen(numb); //marca la longitud del número a;

blong=(int); )strlen(numa); // Marca la longitud del número b;

isnegative=1 // Marca el final con un signo negativo

}

while ((times-- amp; amp; (timesgt;=0))||carry != 0)//carry ! = 0 significa que no hay préstamos

{

if (!pstart-gt; next) // Si el nodo actual está vacío, solicita un nuevo nodo

{

pnew = new Node;

pnew - gt; datos = 0;

pnew -gt.next = NULL;

pnew -gt; adelante = pstart; ;

}

if(timeslt;0)//Si después del cálculo, el bit prestado es igual a 1, significa que debe ser negativo;

{ pstart -gt; data = -3; // deja que sea igual al signo negativo '-'// -3 proviene del hecho de que el signo negativo difiere de 0 en 3.

break ; }

else

{

if ( *pna == *pnb )// Cuando el minuendo es igual al minuendo.

El resultado es igual al resultado de la resta directa; y establece el débito en 0

{

if (carry == 0) pstart -gt data = (*pna-48). )-(* pnb-48); // 111-11

else

{

pstart -gt; datos = (*pna-48)- (*pnb- 48); // situación 111-11

else

{

pstart-gt; datos = (*pna-48)-( *pnb- 48) 10 -llevar; //1121-1112 llevar=1;

}

}

if( *pna gt; *pnb ) // cuando Cuando el minuendo es mayor que el sustraendo. El resultado es igual al resultado de la resta directa y el bit de préstamo se establece en 0

{

pstart -gt; -48)- carry; //Almacena los bits

carry=0;

}

else if( *pna lt; *pnb )//Indica que el minuendo es mayor que Restar, suma 10 al resultado, lo que equivale a tomar prestado (llevar) 1

{ if(timesgt; 0)

part-gt; (*pna-48) -(*pnb-48) 10 -carry;//el caso 13-5 como nuevo valor

else

pstart -gt; data = ( *pnb-48)- (*pna-48) -carry; //3-5 como el nuevo valor actual

carry=1;

}

}

pstart = pstart -gt; next;

/Movimiento del nodo

blong--;

if(blonggt; 0 )pnb--;/ / El puntero se mueve al bit alto del minuendo

else *pnb=48; // Luego la resta se vuelve 0 sin ninguna operación, lo que en realidad se puede optimizar. ¡Pero el código será muy largo! Y es necesario reabrir el nodo. Así que ríndete; pna--; // Calculando el movimiento del puntero,

}

if(isnegative==1)//// Agrega un signo negativo.

Agregue una longitud y configúrela en signo negativo

{

pnew = new Node;

pnew -gt = 0;

pnew -gt; siguiente = NULL;

pnew -gt; pstart;

pstart -gt; siguiente =

pnew -gt; = pstart;

pstart -gt; next = pnew;

pstart -gt; //Porque para encontrar el final de la tabla de cadena necesitamos agregar de manera uniforme. 48. Debido a que '-' es 45, es igual a '-3'

}

pstart =head; //encuentra el punto final de la tabla de cadenas

mientras (pstart -gt; next ! = 0)

{

pstart -gt;data = 48; //! lt;

Entonces agregue 48gt;gt;gt;gt; para invertir la salida

pstart = pstart-gt;next;

}

int tip = 0;/ / conconvert to string

clear0=0; //elimina el inútil '0' 13-5 = 08 en la parte superior del resultado. gt;

pstart = pstart-gt; forward; // Encuentra palabras válidas

while (pstart ! = 0) // Muestra los resultados en orden positivo;

{ if(clear0==0 amp;amp; ((int)pstart-gt;data)==48amp;amp;pstart-gt;ahead!=0) //Elimina el "0" inútil en la parte superior del resultado ;

//No mostrar ningún contenido

else

resultado[tip] = pstart-gt;data;

if( ((int) pstart-gt; datos)! = 48amp; ((int) pstart-gt; datos)! = 45) clear0=1; //'-' símbolo

pstart = pstart-gt ; adelante ;

}

resultado[tip] = '\0';

pstart = cabeza; //espacio libre

while( pstart-gt; siguiente ! = 0)

{

pnew = pstart-gt; siguiente;

eliminar pstart;

pstart = pnew;

}

retorno;

}

/*----------- -------------------------------------------------- -- -----------

* Nombre de la función: Multiplicación de números grandes

*Proceso: 1 Ingrese dos números grandes en forma de cadena

* 2 Haz una lista doblemente enlazada

* 3 Dos punteros apuntan al bit más bajo de la cadena numérica

* 4 Compara el bit más bajo del primer número con el más bajo bit almacenado en la lista enlazada Multiplica todos los elementos de los dos números

* 5 Mueve el primer puntero de la lista enlazada

* 6 Repite 4 y 5 y multiplica desde el bit más bajo hasta el bit más alto

* 7 Después de la multiplicación, porque el bit más bajo es el primer bit de la lista vinculada y el último bit es el final de la lista vinculada. Entonces genere la lista vinculada 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 el resultado)//calcular el producto

{ char *pna = findend(numa); //un puntero a 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 a lo largo =(int)strlen(numa ); //longitud del marcador número a ;

int blong=(int)strlen(numb); //longitud del marcador número b;

int carry=0, temp_result; // Almacena redondeo y resultados temporales

Nodo *head, // usado para almacenar el puntero principal

*pstart, // usado para almacenar el primero parte del cálculo.

*pnew, // Se usa para solicitar un nuevo nodo

*pgo; // Se usa para devolver el nodo inicial de la siguiente línea después de calcular cada línea y usar el desplazamiento

head = pstart =new Node; // Inicializa el primer nodo y el nodo principal.

pstart -gt; datos = 0;

pstart -gt; siguiente = NULL

pstart -gt; p> while (a lo largo de--)

{

pgo = pstart; // Guarda el punto de entrada

blong = (int)strlen(numb); // Inicializar longitud

pnb = findend(numb); // Inicializar puntero

while ((blong-- amp; amp; (blonggt;=0))|| carry ! = 0)

{ if (!pstart-gt; next)//si el nodo actualmente está vacío, solicita un nuevo nodo

{ pnew = new Node;

pnew -gt; datos = 0;

pnew -gt; siguiente = NULL;

pnew -gt; pststart-gt; > pnew -gt; siguiente = NULL;

pnew -gt; adelante = pstart;

pstart -gt; >

if(blonglt;0)temp_result = carry; //maneja el caso donde solo hay progresiones disponibles

else temp_result =( pstart -gt;data (*pna-48)*(*pnb- 48 ) carry); //valor propio nuevo valor feed como nuevo valor

pstart -gt; data = temp_result10; //almacenar dígitos

carry = temp_result/10; redondeo

pstart = pstart -gt; //movimiento del nodo

pnb--;

pstart = pstart-gt; una posición ;

pna--; //Puntero al punto más alto del multiplicador

}

pstart = head; //Encuentra el final del lista enlazada

mientras(pstart-gt;siguiente! = 0) {

pstart-gt;data = 48; //! lt;lt;lt;Porque nuestra salida son caracteres.

Entonces agregue 48 gt; gt; gt; salida inversa

pstart = pstart-gt; next; p>

pstart = pstart-gt; //busca palabras válidas

while(pstart != 0) //Envía los resultados en orden positivo;

{ resultado [tip] = pstart-gt;data;

pstart = pstart-gt;ahead;}

resultado[tip] = '\0';

pstart =head; //Liberar espacios

while(pstart-gt; next != 0) {

pnew = pstart-gt;

eliminar pstart;

pstart =pnew;

}

return;

}

/ *--- -------------------------------------------------- ----------------------

* Nombre de la función: División de números grandes 2 -

*Ideas de funciones: 1 Guarde la cadena temporal con un puntero que apunte al bit más alto del divisor; tempstr[a] = pna

* 2. Si la cadena temporal es mayor que el divisor, réstela.

El resultado es igual al resto

* if (tempstrgt; numb)tempstr = tempstr - numb

* 3 Si es menor que el divisor y el puntero apunta a la cabeza, el resto es igual a la cadena temporal

* if(tempstr *

* Parámetros de entrada: numa, numb.result, cadena restante

*argumentos de salida: ninguno

*--- -------------------------------------- ------------ ----------------------*

void divide2( char *numa, char * entumecido, char *resultado, char *resto)// calculando división2

{ 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 de tempstr

bool moveon=false; //Voltea la tarjeta

char *pna = numa; //un puntero al punto numa numa pna //apunta al bit más bajo del signo menos,

char *pnb = findend(numb); puntero a entumecido //pnb apunta al minuendo El bit más bajo

Nodo *head, // usado para almacenar el puntero principal

*pstart, // usado para almacenar el primer puntero en el cálculo

*pnew; // Se utiliza para solicitar un nuevo nodo

head = pstart =new Node; // Inicializa el primer nodo y el nodo principal. primer nodo y el nodo principal.

pstart -gt; datos = 0;

pstart -gt; siguiente = NULL

pstart -gt; p>moveon = false; while(*pna)

{ if(!pstart -gt; next)//Si el nodo actual está vacío, solicita un nuevo nodo

{ pnew = nuevo nodo;

pnew -gt; datos = 0;

pnew -gt; siguiente = NULL

pnew -gt; /p> p>

pstart -gt; next = pnew;}

ia=(int)strlen(tempstr); // longitud tomada

tempstr[ia] = *( pna );

tempstr[ia] = '\0'; //Convertir a cadena

if(tempstr[0]=='0')//Procesar el bits altos también El tipo de cadena que es 0, como g.00

{

ia2=0;

while(tempstr[ia2]= ='0') ia2;

while(ia2gt;=1)//Borrar 0's inútiles

{

ia=ia2-1;

tempstr[ia]=tempstr[ia2];

--ia2;

}

tempstr[ia2]='\0';

}

while (abigerb(tempstr,numb)gt;0)//Si tempstr es mayor o igual que entumecido

{

if(tempstr[ 0]=='0')//Los números de dígitos altos que se procesan también son 0, como 00----, este es un código redundante, guárdelo como memoria

{

ia2 = 0;

mientras(tempstr[ia2]=='0') ia2;

if(ia==ia2 )

{ moveon = true; break; }

}

strcpy(numb2, entumecido);

restar(tempstr, entumecido, tempstr); ///A-B strcpy( numb,numb2);

if(tempstr[0]=='-')//Si no se permite que el juicio se vuelva negativo, agregue B nuevamente.

{

strcpy(numb2, entumecido);

addition(tempstr, entumecido, tempstr); //A-B

strcpy(entumecido, numb2);

ia2=0; //Longitud corregida. Porque no hay operación negativa en la operación de suma

ia=0; // Para eliminar el último signo negativo, toda la operación avanza.

while(tempstr[ia2]!= '\0') ia2;

while(ia2gt;=1)//borrar 0 inútiles {

tempstr [ia]=tempstr[ia 1];

ia;

--ia2;}

tempstr[ia]='\0';

p>

moveon = true;

break; }

pstart -gt; //resultados selfadd

moveon = true;}

p>

if(moveon) pstart = pstart -gt; next; //movimiento de nodo

}

strcpy(remainder, tempstr); //almacenar el resto

int tip = 0; //convertir a cadena

pstart = head; //encontrar el punto final de la tabla de cadenas

mientras (pstart -gt; next ! = 0) {

pstart-gt;data = 48 //! lt;lt;lt;Porque nuestra salida son caracteres. Entonces agregue 48 gt;gt;gt;gt;salida inversa

resultado[tip] = pstart-gt;data;

pstart = pstart-gt;next }

resultado[tip] = '\0'; //almacenar resultado

pstart = head; //espacio libre

while(pstart-gt ; next ! = 0 ) {

pnew = pstart-gt; siguiente; eliminar pstart; pstart = pnew }

regresar;