两个最大数相加C语言程序_附完整源码

合集下载

c 高精度加法

c 高精度加法C语言中的高精度加法是一种处理大数运算的方法，它可以实现超出标准整数范围的加法运算。

在日常的编程中，我们经常会遇到需要处理大数运算的情况，例如计算两个很大的整数的和，传统的整数运算方法已经无法满足需求。

本文将详细介绍C语言中的高精度加法的实现方法。

在C语言中，整数的表示范围是有限的，一般为-2^31到2^31-1。

超出这个范围的整数运算会导致溢出错误，得到错误的结果。

为了解决这个问题，我们可以使用字符串来表示大数，并通过模拟手工计算的方式进行加法运算。

我们需要将输入的两个大数转化为字符串，并计算出两个字符串的长度。

然后，我们可以从最低位开始，逐位相加，并将结果保存在一个新的字符串中。

需要注意的是，相加时要考虑进位的情况。

如果当前位的和大于等于10，那么进位为1，否则进位为0。

计算完当前位的和和进位后，将和的个位数添加到结果字符串中，并将进位保存起来。

接下来，我们继续处理下一位，直到两个大数的所有位都相加完毕。

最后，我们需要将结果字符串进行翻转，得到最终的结果。

下面是一个使用C语言实现的高精度加法的示例代码：```#include <stdio.h>#include <string.h>void reverse(char *str) {int i, j;char temp;int len = strlen(str);for (i = 0, j = len - 1; i < j; i++, j--) {temp = str[i];str[i] = str[j];str[j] = temp;}}void bigAddition(char *num1, char *num2, char *result) { int len1 = strlen(num1);int len2 = strlen(num2);int maxLen = len1 > len2 ? len1 : len2;int carry = 0;int sum;int i;for (i = 0; i < maxLen; i++) {int digit1 = i < len1 ? num1[i] - '0' : 0;int digit2 = i < len2 ? num2[i] - '0' : 0; sum = digit1 + digit2 + carry;result[i] = sum % 10 + '0';carry = sum / 10;}if (carry > 0) {result[maxLen] = carry + '0';result[maxLen + 1] = '\0';} else {result[maxLen] = '\0';}reverse(result);}int main() {char num1[] = "123456789012345678901234567890"; char num2[] = "987654321098765432109876543210"; char result[1000];bigAddition(num1, num2, result);printf("The sum is: %s\n", result);return 0;}```在上面的示例代码中，我们定义了一个 `bigAddition` 函数来实现高精度加法。

c语言俩数求和

c语言俩数求和C语言是一门广泛应用于计算机编程的高级程序设计语言。

在C语言中，求两个数的和是一项基础操作。

本文将介绍C语言中实现两数求和的方法和相关知识点。

我们需要了解C语言中的变量和数据类型。

变量是程序中用来存储数据的一种容器，而数据类型则定义了变量中可以存储的数据类型和所占用的内存大小。

在C语言中，基本的数据类型包括整型、浮点型、字符型等。

在C语言中，我们可以用赋值语句将数据存储到变量中。

例如，我们可以定义两个整型变量a和b，并将它们的值分别赋为3和5：int a = 3;int b = 5;接下来，我们就可以使用加法运算符“+”将a和b相加，并将结果存储到一个新的变量sum中：int sum = a + b;这个语句的意思是将a和b的和赋值给sum变量。

注意，sum变量的数据类型也必须为整型，否则会出现类型不匹配的错误。

除了使用变量和运算符，C语言中还有一些常用的库函数可以用来实现两数求和。

例如，我们可以使用scanf函数从用户输入中读取两个数，然后使用printf函数将它们的和输出到屏幕上：#include <stdio.h>int main(){int a, b, sum;printf("Enter two numbers: ");scanf("%d %d", &a, &b);sum = a + b;printf("Sum of the two numbers = %d", sum);return 0;}在这段代码中，我们使用了stdio.h库头文件来包含标准输入输出函数，定义了三个整型变量a、b和sum，以及使用printf函数输出提示信息和计算结果。

scanf函数用来从用户输入中读取两个整数，并将它们存储到a和b变量中。

注意，scanf函数中的“%d”格式控制符必须与变量类型匹配，否则会引发格式化错误。

C语言单链表实现大数加法和乘法

软件技术基础一．项目题目当正整数的位数较多时，采用int或者long变量储存时会发生溢出。

可以采用一个单链表储存，每一位作为一个节点。

设计完成如下功能的算法并用给定数据进行测试。

（1）由一数字字符串创建对应的整数单链表；（2）输出一个由证书单链表表示的正整数；（3）实现两个多位正整数的加法运算；（4）实现两个多位正整数的乘法运算。

（1）输入要进行处理的数据（2）输出要测试的数据（3）分别调用已定义的“求和”、“求积”函数对数据进行操作（4）打印得到的结果（5）销毁所有链表（1）求字符数组长度函数：传入一个字符数组的指针，用一个指针p和一个计数变量遍历整个字符数组，返回计数变量，即为数组长度。

（2）字符串转链表函数：遍历字符串，使用尾插法将数据存入单链表中，并将字符型数据转换成整形数据，每一个节点储存一个数字。

（3）求链表长度函数：传入一个链表的头结点，用一个指针p 和一个计数变量遍历整个链表，返回计数变量，即为链表长度。

（4）读取链表指定位数字函数：传入一个链表的头结点、指定第n个节点和读取元素的地址，返回链表中第n个元素的值，赋给读取变量。

（5）将指定数字写入链表指定位函数：传入一个链表的斗节点、指定第n个元素和待写入的值，将该值赋给链表中第n个节点的数据域。

（6）逆置函数：利用一个指针p，使整个链表尾插改头插，具体过程为令p为L指向的下一结点，断开L结点使之指向NULL，再将P插到L结点后面，且P结点后移一位，再插到L结点后面，一直重复操作直到P结点指向NULL，停止操作，则逆置完成，实现链表的原地逆置。

（7）创建全零链表函数：根据指定链表长度n，创建一个全零的链表，用于后续的累加操作。

（8）进位化简函数：将链表中每一个节点的数对10取整，进位给下一个节点，本节点的数变为对自身取余，直至整个链表每一个节点的数都在0-9之间，如果节点数不够进位，则先开辟一个节点，连到链表尾部，再进行上述进位过程。

两个大整数相加实验报告

计应102-13-杨艺
{inti,j,k;
char sum;
intflag;
i=L_pointer1->Length-1;
j=L_pointer2->Length-1;
k=0;
L_pointer3->Length=0;
flag=0;
while（i=0&&j>=0)
{ sum=L_pointer1->Element[i]+L_pointer2->Element[j]+flag;
{ flag=1;sum=sum%10;}
else
flag=0;
L_pointer3->Element[k]=sum;
L_pointer3->Length++;
i--;k++;
}
while(j>-1)
{ sum=L_pointer2->Element[j]+flag;
if(sum>9)
{ flag=1;sum=sum%10; }
scanf("%s",s);
i=0;
while(s[i]!='\0')
{Insert_Last(&List1,s[i]-'0');
i++;
}
scanf("%s",s);
i=0;
while(s[i]!='\0')
{Insert_Last(&List2,s[i]-'0');
i++;
}
Add(&List1,&List2,&List3);

多项式相加c语言

Print(&sum);
reset(&p);
reset(&q);
reset(&sum);
return 0;
}
```
在上述代码中，首先定义了一个`Node`结构体，包含多项式的系数和指数，并通过链表的方式存储多项式的每一项。然后，实现了一系列函数，包括多项式的增加、输出、相加和消除。在`main`函数中，调用这些函数来完成多项式的输入、相加和输出。
请注意，这只是一个简单的示例，实际应用中可能需要考虑更多的边界情况和错误处理。
以下是一个简单的 C 语言示例，展示了如何实现多项式相加：
```c
#include <stdio.h>
#include <stdlib.h>
// 定义结构的数据部分
struct poly {it zhishu;float xishu;
};
// 定义一个多项式结构
typedef struct node {
s->date.xishu = s->date.xishu + s->next->date.xishu;
s->next = s->next->next;
} else {
s = s->next;
}
}
d = d->next;
}
}
// 链表的消除函数
void reset(Node *pList) {
Node *p = pList;
while (p->next) {
if (flog == 1)
printf(" + ");
else {

两个极大正整数求和C++源程序

#include <iostream>#include <string>using namespace std;int main(){string a, b;int *sum;int i, ja, jb;cout << "请输入两个数字，每个数字以空格结尾：" << endl;cin >> a >> b;string temp;if ( a.size() > b.size() ) // 如果a长度大于b，则交换两字符串{temp = a;a = b;b = temp;}// 在这后，就肯定是a的长度比b小，所以和的位数最大就是b的位数+1。

sum = new int[b.size()+1]; // 所以给和申请b的位数+1个位置。

sum[0] = 0;char achar[1];char bchar[1];int carry = 0; // 记录进位int sizeDif = b.size() - a.size(); // 记录两个数字的位数差int count; // 记录和的位数for ( ja = a.size()-1, jb = b.size()-1; ja >= 0; ja--, jb-- ){achar[0] = a[ja];bchar[0] = b[jb];sum[jb+1] = atoi(achar) + atoi(bchar) + carry;carry = 0; // 清空进位标志位if( sum[jb+1] > 9 ){carry = 1;sum[jb+1] -= 10; // 使之成为一位数，方便输出。

}}for ( i = sizeDif-1; i >= 0 ; i-- ){bchar[0] = b[i];sum[i+1] = atoi(bchar)+carry; // 转换为数字carry = 0; // 清空进位标志位if( sum[i+1] > 9 ){carry = 1;sum[i+1] -= 10; // 使之成为一位数，方便输出。

C#实现大数相加

C#实现⼤数相加在C#中，我们经常需要表⽰整数。

但是，c#的基本数据类型中，最⼤的long也只能表⽰-9,223,372,036,854,775,808 到9,223,372,036,854,775,807之间的数。

如果我们需要表⽰更⼤的数，就需要⽤到⼀定的算法来完成。

这次，我给⼤家分享⼀下C##的⼤数运算之加法。

代码只考虑了正数的整数加法。

1using System;2using System.Collections.Generic;3using System.Linq;4using System.Text;5using System.Threading.Tasks;67namespace ConsoleApplication18 {9class Program10 {11static void Main(string[] args)12 {13 Console.WriteLine("请输⼊第⼀个加数");14string oneNum = Console.ReadLine();15 Console.WriteLine("请输⼊第⼆个加数");16string twoNum = Console.ReadLine();1718string result = TwoBigNumAdd(oneNum, twoNum);19 Console.WriteLine(result);20 }2122static string TwoBigNumAdd(string a, string b)23 {24int k = 0;25 List<int> array = new List<int>();26 List<int> one = new List<int>();27 List<int> two = new List<int>();2829//将两个数处理成相同长度的字符串，短的⼩的数字前⾯补030for (int i = 0; i < (a.Length > b.Length ? a.Length : b.Length); i++)31 {32if (i >= a.Length)33 one.Insert(i - a.Length, 0);34else35 one.Add(int.Parse(a[i].ToString()));36if (i >= b.Length)37 two.Insert(i - b.Length, 0);38else39 two.Add(int.Parse(b[i].ToString()));40 }4142//array集合⽤于存储相加的和，所以长度最⼤也只会⽐最⼤的数长度长1，刚开始全部存043for (int i = 0; i <= (a.Length > b.Length ? a.Length : b.Length); i++)44 {45 array.Add(0);46 }4748//从低位往⾼位每位开始相加，如果相加 >=10 则进1取余49for (int i = (a.Length > b.Length ? a.Length : b.Length) - 1; i >= 0; i--)50 {51 array[i + 1] += (one[i] + two[i]) % 10;52 k = (one[i] + two[i]) / 10;5354 array[i] += k;55 }5657//如果⾸位为0，则移除58if (array[0] == 0)59 {60 array.RemoveAt(0);61 }6263//将集合转换成字符串返回64 StringBuilder result = new StringBuilder();65for (int i = 0; i < array.Count; i++)66 {67 result.Append(array[i]);68 }69return result.ToString();70 }71 }72 }。

c语言大数加法、阶乘和乘法

c语⾔⼤数加法、阶乘和乘法⼀.⼤数加法定义两个⾜够⼤的数字，其数值远超过long的取值范围，设该⼤数的位数有两百位，求其相加所得⼤数加法的核⼼思想详见此链接，内有详细的动画演⽰，这⾥不再赘述直接上代码：#include<string.h>#include<stdio.h>#define N 10//定义当前⼀个⾜够⼤的数字为10位，可任意更改void print_num(int a[],int n){int i=n-1;//从逆序数组的最后⼀项开始查找，进⾏反逆序while(a[i]==0)//由于规定的数组⽐真实计算的数字⼤，所以数组最后⼏位必定存在0的情况--i;//这种情况下⼀定要将0舍去，否则会抬⾼数组的位数for(;i>=0;i--)//找到⾮零的数组，进⾏反逆序输出printf("%d",a[i]);}void plus(int num1[],int num2[],int n){//尤其注意！由于数组是逆序的，所以num[0]是个位,num[1]是⼗位,num[2]是百位for(int i=0,up=0;i<n;i++)//算法参考⼩学加法，这⾥定义⼀个up进位标记{int temp=num1[i]+num2[i]+up;//up最开始设为0，因为在个位⽆法获取进位num1[i]=temp%10;//若产⽣进位⾏为，则选取个位部分赋给num1up=temp/10;//在个位上，若个位相加产⽣进位，则⽤temp/10取整加到下⼀次的⼗位上}print_num(num1, n);}int main(){char buffer1[]="123456";//缓冲数组，将当前数组倒序写⼊num1中char buffer2[]="78951234";//同上，写⼊num2中int num1[N]={0};//将num1，2全部置为0，⽤来将缓冲数组写⼊到num数组当中int num2[N]={0};int n=N;//定义上述两个数组的长度为10for(int i=0,temp=(int)strlen(buffer1)-1;temp>=0;temp--)num1[i++]=buffer1[temp]-'0';//⽤倒序的⽅式将缓冲数组写⼊num中，意味着num的第⼀位是个位，第⼆位是⼗位，三是百位...for(int i=0,temp=(int)strlen(buffer2)-1;temp>=0;temp--)num2[i++]=buffer2[temp]-'0';plus(num1, num2, n);//将两数字相加printf("\n");}⼆.⼤数阶乘⼤数阶乘的中⼼思想参考上述视频和⼀篇博客，博客详情：但是，这⾥需要说明⼀个点：1*2=2,将2存到a[0]中，接下来是⽤a[0]*3；2*3=6，将6储存在a[0]中，接下来是⽤a[0]*4；6*4=24，是两位数，那么24%10==4存到a[0]中，24/10==2存到a[1]中，接下来是⽤a[0]*5；a[1]*5+num(如果前⼀位相乘结果位数是两位数，那么num就等于⼗位上的那个数字；如果是⼀位数，num==0)24*5=120，是三位数，那么120%10==0存到a[0]中，120/10%10==2存到a[1]中，120/100==1存到a[2]中由于上述博客存在某些地⽅没有说清楚的情况，这⾥解释⼀下关于上述博客的Q&A：1.这⾥的num指的是什么？答：这⾥的num指的是前⾯两数值相乘后进位数位多少：例如6*4得24，这⾥的num值的是24/10=2，进位数为2，num=22.下⾯代码为什么要充i=2开始？答：如果这⾥看懂了代码其实理解2不是很难，但是没有看懂是真的难懂：⾸先明确⼀点：5的阶乘是1*2*3*4*5，我定义的value数组的第⼀位为1，⽽我的i是从2起的，这样以来不就直接凑出了1*2了吗？当我的i⾃增到3，我直接在value数组中找出1*2的值，拿他们去和3相乘，也就凑成了1*2*3了3.如何在代码当中表现出进位的思想？答：我们以5！为例，当计算到1*2*3*4的时候，value当中的表现形式是42000000，从左到右依次是个位，⼗位，百位，千位...etc（value表⽰的是24这个数字）我们在关于j的循环当中拿i=5去和value数组求乘积：5先和位于个位的4求积得20：20%10得0，0放⼊个位中；20/10得2，进位为2，up=2。

c语言两数求和

c语言两数求和C语言是一种广泛应用的编程语言，它具有简洁高效的特点，被广泛用于开发各种应用程序。

在C语言中，实现两个数的求和是一项基本操作。

本文将围绕这个主题展开，介绍两数求和的基本原理和实现方法。

一、两数求和的基本原理在C语言中，两个数的求和可以通过使用加法运算符（+）来实现。

加法运算符可以用于整型、浮点型和字符型等不同类型的数据。

二、整型数求和示例以下是使用C语言实现两个整型数求和的示例代码：```c#include <stdio.h>int main() {int num1, num2, sum;printf("请输入两个整数：\n");scanf("%d %d", &num1, &num2);sum = num1 + num2;printf("两个数的和为：%d\n", sum);return 0;}```以上代码首先定义了三个变量，分别用于存储两个输入的整数和它们的和。

然后通过使用`scanf`函数获取用户输入的两个整数，再利用加法运算符求和，最后使用`printf`函数输出结果。

三、浮点型数求和示例以下是使用C语言实现两个浮点型数求和的示例代码：```c#include <stdio.h>int main() {float num1, num2, sum;printf("请输入两个浮点数：\n");scanf("%f %f", &num1, &num2);sum = num1 + num2;printf("两个数的和为：%f\n", sum);return 0;}```以上代码与整型数求和的示例代码类似，只是将变量的类型改为了`float`，并使用`%f`格式化输出浮点数。

四、字符型数求和示例以下是使用C语言实现两个字符型数求和的示例代码：```c#include <stdio.h>int main() {char char1, char2;int sum;printf("请输入两个字符：\n");scanf("%c %c", &char1, &char2);sum = char1 + char2;printf("两个字符的和为：%d\n", sum);return 0;}```以上代码定义了两个`char`类型的变量和一个`int`类型的变量，用于存储输入的两个字符和它们的和。

c语言简单加法代码

c语言简单加法代码C语言是计算机科学领域中最为基础和重要的编程语言之一。

其功能强大且易于实现，被广泛用于编写操作系统和嵌入式系统等领域。

在本文中，将介绍一段简单的C语言加法代码。

1. 首先，需要声明两个要相加的变量。

假设我们需要将两个整数相加，可以如下声明：int num1, num2;2. 接着，我们需要从用户手中获取这两个整数的值。

可以使用语句scanf来实现：scanf("%d %d", &num1, &num2);这行代码将会从用户输入的数据中读取两个整数，分别存储在变量num1和num2中。

需要注意的是，scanf函数的第二个参数是一个地址符，意味着我们要传递num1和num2变量的地址。

3. 然后，我们可以使用加法运算符将这两个整数相加：int sum = num1 + num2;在此处，将num1和num2相加的结果赋值给sum变量。

sum变量在这里是一个整数，可以用来存储两个整数相加的结果。

4. 最后，我们可以使用printf函数将结果输出到屏幕上：printf("The sum of %d and %d is %d.\n", num1, num2, sum);在上面这行代码中，我们使用printf函数输出了一个字符串，包括三个变量：num1、num2和sum。

%d是一个占位符，将最终要输出的整数值传递给它即可。

字符串中的\n表示输出一个换行符，以便更好的阅读结果。

完整代码如下：#include <stdio.h>int main() {int num1, num2, sum;printf("Enter two integers:\n");scanf("%d %d",&num1, &num2);sum = num1 + num2;printf("The sum of %d and %d is %d.\n", num1, num2, sum);return 0;}上面这段代码非常简单易用，可以让你轻松实现一个加法计算的C语言程序。

c语言大整数加法函数

c语言大整数加法函数C语言中，由于基本数据类型的限制，无法直接进行大整数的加法运算。

但可以通过一些算法来实现大整数的加法。

一种常见的方法是使用数组来存储大整数的各位数字。

首先，需要确定一个合适的数组大小。

为了简化操作，可以将数组大小设置为两个大数中最大的位数加1，如两个100位的数，则数组大小为101。

接下来，将大整数的各位数字逆序存储在数组中，即数组的第一个元素为个位数字，第二个元素为十位数字，以此类推。

在进行大整数的加法运算时，可以模拟手动相加的过程。

从个位开始，依次将两个大整数对应位上的数字相加，再加上进位，得到当前位的结果。

将当前位结果保存在结果数组中，并将进位保存下来，以便于下一位的运算。

遍历完所有位数后，若最高位有进位，则将进位添加到结果数组中。

以下是一个实现大整数加法的示例代码：c#include <stdio.h>#include <string.h>#define MAX_SIZE 101void addBigNum(char num1[], char num2[], char result[]){ int len1 = strlen(num1);int len2 = strlen(num2);int len = len1 > len2 ? len1 : len2;int carry = 0; 进位int i;将大整数逆序存储在数组中int arr1[MAX_SIZE], arr2[MAX_SIZE], res[MAX_SIZE];memset(arr1, 0, sizeof(arr1));memset(arr2, 0, sizeof(arr2));memset(res, 0, sizeof(res));for(i = 0; i < len1; i++){arr1[i] = num1[len1-1-i] - '0';}for(i = 0; i < len2; i++){arr2[i] = num2[len2-1-i] - '0';}进行相加运算for(i = 0; i < len; i++){int sum = arr1[i] + arr2[i] + carry;res[i] = sum % 10; 当前位的结果carry = sum / 10; 进位}若最高位有进位，则添加到结果数组中if(carry > 0){res[len] = carry;len++;}将结果数组逆序输出到结果字符串中for(i = 0; i < len; i++){result[i] = res[len-1-i] + '0';}result[i] = '\0';}int main(){char num1[] = "12345678901234567890";char num2[] = "98765432109876543210";char result[MAX_SIZE];addBigNum(num1, num2, result);printf("Result: %s\n", result);return 0;}上述代码实现了两个大整数的加法，并将结果存储在result字符串中。

c语言两个大数相加

head=l->next; break; } l=l->next; } return head; } 4.在主函数中将通过 3 和 2 步骤获得的链表的各个节点进行相加并打印出来。 int main () { LinkList head1,head2,head3,s; int i=0,sum,head1_i,head2_i;//head1_i,head2_i 分别代表各自链表节点的数据值。 head1=(LinkList)malloc(sizeof(Node)); head1=createLink(); head2=visitLink(head1); //计算加法 while(1) { //(head2!=NULL)&&(head1->data!='+') //分别检验 head2 是否为零和 head1 的数据值是否为+ //如果 head 是零，那就等到 head1 的数据值为+然后 break //如果 head1 的数据先为+则等到 head2 为零然后 break //当 head1 为零且 head1 的数据是+则 break 退出 if((head2==NULL)&&(head1->data=='+')) { if(i==1)printf("%d",i);//i 为进位为了防止两个数的最高位相加大于 10 break; } if(head2==NULL) head2_i=0;//当 head2==NULL 即为该节点后面已经没有节点了且该节点的数据位没有存贮数据。 else head2_i=(int)(head2->data-48);//否则的化就将该节点的数据拿出来.减 48 视为了将 char 类型转换成 int 类型，在 ascII 中。 if(head1->data=='+')head1_i=0; else head1_i=(int)(head1->data-48); sum=i+head2_i+head1_i;//sum 代表两个数的相同位的数的相加例如俩个数的个位的相加 if(sum>9) { i=1;//如果 sum 大于九则代表应该有进位。 sum=sum-10; }

c++ 程序实例

c++ 程序实例
下面是一个简单的C++程序实例，它实现了计算两个数的和并输出结果：
```cpp
#include <iostream>
int main() {
int num1, num2;
std::cout << "请输入两个整数：" << std::endl;
std::cin >> num1 >> num2;
int sum = num1 + num2;
std::cout << "两个数的和是：" << sum << std::endl;
return 0;
}
```
这个程序通过 `std::cin` 从用户输入读取了两个整数，并将它们相加赋值给变量 `sum`，然后通过 `std::cout` 输出结果。

注意在程序开头使用 `#include <iostream>` 包含了 `iostream` 标准库，以使用输入输出流的功能。

运行这个程序，它会要求用户输入两个整数，然后输出它们的和。

请注意，这只是一个简单的示例，并不涵盖C++所有的功能。

你可以根据需要进行扩展和修改。

大数加法（C++实现）

⼤数加法（C++实现）最常规的⼤数加法 (两个数都是⾮负的整数)思路：⽤字符串的⽅式去存储我们需要计算的数，但是要注意的⼀点就是我们是倒过来存储这个⼤数的⽐如： 123456789 我们存储的时候是存成 987654321为什么要这么⼲？我觉得是为了便于后⾯我们的进位操作吧最常规的⼤数加法 (两个数都是⾮负的整数)1 #include<iostream>2 #include<cstring>3 #include<algorithm>4 using namespace std;5 const int L=110;6 string add(string a,string b)//只限两个⾮负整数相加7 {8 string ans;9 int na[L]={0},nb[L]={0};10 int la=a.size();11 int lb=b.size();12 // 倒叙存储13 for(int i=0;i<la;i++)14 na[la-1-i]=a[i]-'0';15 // 倒叙存储16 for(int i=0;i<lb;i++)17 nb[lb-1-i]=b[i]-'0';18 int lmax=la>lb?la:lb;19 // 从个位开始计算20 for(int i=0;i<lmax;i++)21 {22 na[i]+=nb[i];23 na[i+1]+=na[i]/10;24 na[i]%=10;25 }26 // 去除前置027 if(!na[lmax])28 lmax--;29 for(int i=lmax;i>=0;i--)30 ans+=na[i]+'0';31 return ans;32 }33 int main()34 {35 string a,b;36 while(cin>>a>>b)37 cout<<add(a,b)<<endl;38 return 0;39 }【变形⼀】正负整数的⼤数的加法思路：⼤体的思路和常规的⼤数加法还是⼀样的，唯⼀不同的就是多了对最后结果的判断（是正数还是负数）1 #include<stdio.h>2 #include<string.h>3 #include<stdlib.h>4 #include <iostream>5 #include <cstring>67 using namespace std;89 const int maxn = 10010;11 char a[maxn],b[maxn];12 int aa[maxn],bb[maxn];131415 void add(char str1[],char str2[])16 {17 memset(aa,0, sizeof(aa));18 memset(bb,0, sizeof(bb));19 int len1 = strlen(str1);20 int len2 = strlen(str2);21 int flag1 = 0,flag2 = 0;22 // 都是0的时候特殊处理23 if (str1[0] == '0' && str2[0] == '0')24 printf("0\n");25 else26 {27 // str1是负数28 if (str1[0] == '-')29 {30 flag1 = 1;31 for (int i=0;i<len1-1;i++)32 {33 aa[i] = str1[len1-1-i] - '0'; //倒叙记录34 }35 }36 else37 {38 // str1是正数39 for (int i=0;i<len1;i++)40 {41 aa[i] = str1[len1-1-i] -'0';42 }43 }4445 //str2是负数46 if (str2[0] == '-')47 {48 flag2 = 1;49 for (int i=0;i<len2-1;i++)50 {51 bb[i] = str2[len2-1-i] - '0';52 }53 }54 else55 {56 // str2是正数57 for (int i=0;i<len2;i++)58 {59 bb[i] = str2[len2-1-i]- '0';60 }61 }6263 //分四种情况对str1,str2处理6465 if (!flag1 && !flag2) //str1 和 str2都是正数66 {67 int len = max(len1,len2);68 for (int i=0;i<len;i++)69 {70 bb[i] += aa[i];71 bb[i+1] += bb[i]/10;72 bb[i]%=10;73 }74 //处理前置零75 while (!bb[len])76 len--;77 for (;len>=0;len--)78 printf("%d",bb[len]);79 printf("\n");80 }81 else if (!flag1 && flag2) // str1是正数，str2是负数82 {83 int ans = 0;84 //判断str1和str2的绝对值谁⼤谁⼩85 if (len1>len2-1)86 ans = 1;87 else if (len1 == len2-1)88 {89 for (int i=len1-1;i>=0;i--)90 {91 if (aa[i]>bb[i])92 {93 ans = 1;95 }96 else if (aa[i]<bb[i])97 {98 ans = 0;99 break;100 }101 }102 }103 // 如果str1的绝对值更⼤104 if (ans)105 {106 for (int i=0;i<len1;i++)107 {108 aa[i] -= bb[i];109 while (aa[i]<0)110 {111 aa[i] += 10;112 aa[i+1]--;113 }114 }115 //处理前置零116 while (!aa[len1])117 len1--;118 for (;len1>=0;len1--)119 printf("%d",aa[len1]);120 printf("\n");121 }122 else // 如果str2的绝对值更⼤123 {124 for (int i=0;i<len2-1;i++)125 {126 bb[i] -= aa[i];127 while (bb[i]<0)128 {129 bb[i]+=10;130 bb[i+1]--;131 }132 }133 //处理前置零134 while (!bb[len2])135 len2--;136 if (len2<0) // 注意333 -333 的情况137 printf("0\n");138 else139 {140 for (;len2>=0;len2--)141 printf("%d",bb[len2]);142 printf("\n");143 }144 }145 }146 else if (flag1 && !flag2) //str1为负数 str2为正数147 {148 int ans = 0;149 // 判断str1 和 str2 的绝对值的⼤⼩150 if (len2>len1-1)151 {152 ans = 1;153 }154 else if (len2 == len1-1)155 {156 for (int i = len2 - 1; i >= 0; i--)157 {158 if (aa[i] > bb[i])159 {160 ans = 0;161 break;162 }163 else if (bb[i] > aa[i])164 {165 ans = 1;166 break;167 }168 }169 }170 //判断结果的正负171 if (ans)172 {173 for (int i=0;i<len2;i++)174 {175 bb[i] -= aa[i];176 while (bb[i]<0)177 {179 bb[i+1]--;180 }181 }182 //处理前置0183 while (!bb[len2])184 len2--;185 for (;len2>=0;len2--)186 printf("%d",bb[len2]);187 printf("\n");188 }189 else190 {191 for (int i=0;i<len1-1;i++)192 {193 aa[i] -= bb[i];194 while (aa[i]<0)195 {196 aa[i]+=10;197 aa[i+1]--;198 }199 }200 //处理前置0201 while (!aa[len1])202 len1--;203 if (len1<0) // 注意333 -333 的情况204 printf("0\n");205 else206 {207 printf("-");208 for (;len1>=0;len1--)209 {210 printf("%d",aa[len1]);211 }212 printf("\n");213 }214 }215 }216 else if (flag1 && flag2) // 都是负数217 {218 printf("-");219 int len = max(len1,len2);220 for (int i=0;i<len-1;i++)221 {222 bb[i] += aa[i];223 bb[i+1] += bb[i]/10;224 bb[i]%=10;225 }226 while (!bb[len])227 len--;228 for (;len>=0;len--)229 printf("%d",bb[len]);230 printf("\n");231 }232 }233 }234235236237238239 int main()240 {241 while (cin >> a >> b)242 {243 add(a,b);244 }245 return 0;246 }【变形⼆】正⼩数的⼤数加法思路：我们把⼩数部分和整数部分分开来考虑1 #include<stdio.h>2 #include<string.h>4 #include <iostream>5 #include <cstring>67 using namespace std;89 int len,len1,len2,i,j,k,x1,x2,y1,y2,m,n;10 char str1[450],str2[450];11 int a1[450],a2[450],a3[450],b1[450],b2[450],b3[450],a[450],b[450],c[450];121314 void add(char str1[],char str2[])15 {16 memset(a1,0, sizeof(a1));17 memset(a2,0, sizeof(a2));18 memset(a3,0, sizeof(a3));19 memset(b1,0, sizeof(b1));20 memset(b2,0, sizeof(b2));21 memset(b3,0, sizeof(b3));22 memset(a,0, sizeof(a));23 memset(b,0, sizeof(b));24 memset(c,0, sizeof(c));25 len1 = strlen(str1);26 len2 = strlen(str2);27 //找到str1⼩数点28 for (i=0;i<len1;i++)29 {30 if (str1[i] == '.')31 break;32 }33 //存储str1⼩数部分34 for (k=len1-1,j=0;k>i;k--,j++)35 {36 a1[j] = str1[k] -'0';37 }38 x1 = j; //记录a1的长度(⼩数部分)39 i = i - 1;40 //存储str2整数部分41 for (j=0;i>=0;i--,j++)42 {43 a2[j] = str1[i] - '0';44 }45 x2 = j; //记录a2数组的长度(整数部分)4647 //找到str1的⼩数点48 for (i=0;i<len2;i++)49 {50 if (str2[i] == '.')51 break;52 }53 //存储str2⼩数部分54 for (k=len2-1,j=0;k>i;k--,j++)55 {56 b1[j] = str2[k]-'0';57 }58 y1 = j; //记录b1的长度(str2的⼩数部分)59 i = i - 1;60 // 存储str2的整数部分61 for (j=0;i>=0;i--,j++)62 {63 b2[j] = str2[i] - '0';64 }65 y2 = j; //记录b2的长度(str2的整数部分)6667 // 对齐⼩数部分68 if (x1<=y1)69 {70 m = y1 - x1;71 n = y1;72 for (i = 0; i < x1; i++)73 {74 a3[i + m] = a1[i];75 }76 for (i = 0; i < y1; i++)77 {78 b3[i] = b1[i];79 }80 }81 else82 {83 m = x1 - y1;84 n = x1;85 for (i = 0; i < y1; i++)86 {88 }89 for (i=0;i < x1;i++)90 {91 a3[i] = a1[i];92 }93 }9495 //计算⼩数部分96 for (i=0;i<n;i++)97 {98 b[i] += a3[i]+b3[i];99 b[i+1] += b[i]/10;100 b[i] = b[i]%10;101 }102 //第⼀位的⼩数需要进位103 if (b[n] == 1)104 {105 a2[0]+=1;106 b[n]=0;107 }108109 //计算整数部分110 if (x2>=y2)111 m=x2;112 else113 m=y2;114 for (i=0;i<m;i++)115 {116 a[i]+=b2[i]+a2[i];117 a[i+1]+=a[i]/10;118 a[i]%=10;119 }120121 //处理整数的前置0122 for (i=m+5;i>=0&&a[i]==0;i--)123 {124 ;125 }126 //存在不为0的部分127 if (i>=0)128 {129 for (;i>=0;i--)130 printf("%d",a[i]);131 }132 else //整数部分是0133 {134 printf("0");135 }136137 //处理⼩数的后置0138 k = 0;139 for (k=0;k<n&&b[k]==0;k++)140 {141 ;142 }143 //如果第n-1个还是0，那么则说明⼩数部分不存在144 if (k!=n)145 {146 printf(".");147 for (int i=n-1;i>=k;i--)148 {149 printf("%d",b[i]);150 }151 }152 printf("\n");153 }154155156157158159 int main()160 {161 while (cin >> str1 >> str2)162 {163 add(str1,str2);164 }165 return 0;166 }。

大整数加法c语言

大整数加法c语言（中英文版）Title: Large Integer Addition in C LanguageTitle: 大整数加法C语言Introduction:Certainly! In C language, performing large integer addition requires a bit of creativity due to the limitations of data types like int and long.We typically use arrays to represent large numbers and apply the logic of addition digit-by-digit.介绍：当然！在C语言中，由于int和long等数据类型的限制，进行大整数加法需要一些创意。

我们通常使用数组来表示大数，并逐位应用加法逻辑。

Code Sample:```c#include <stdio.h>#include <string.h>void addLargeIntegers(char *num1, char *num2) {int len1 = strlen(num1);int len2 = strlen(num2);int maxLen = (len1 > len2) ? len1 : len2;int carry = 0;char result[maxLen + 2];int i = len1 - 1;int j = len2 - 1;int k = maxLen - 1;while (i >= 0 || j >= 0 || carry) {int sum = carry;if (i >= 0) sum += num1[i--] - "0";if (j >= 0) sum += num2[j--] - "0";result[k--] = (sum % 10) + "0";carry = sum / 10;}result[k + 1] = "0";printf("Result: %s", result);}int main() {char num1[] = "123456789123456789123456789";char num2[] = "987654321987654321987654321";addLargeIntegers(num1, num2);return 0;}```Explanation:The function `addLargeIntegers` takes two strings `num1` and `num2` as parameters, which represent the large integers we want to add.We first find the length of both strings and determine the maximum length.Then, we create an array `result` to store the result.解释：`addLargeIntegers`函数接受两个字符串`num1`和`num2`作为参数，它们表示我们要加的大整数。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

if (pCurrent == 0) { sscanf(buff, "%d", &temp_data); pHead->data = temp_data;பைடு நூலகம்pCurrent = new Node; pCurrent->ahead = pHead; pHead->next = pCurrent; } else { sscanf(buff, "%d", &temp_data); pCurrent->data = temp_data; pTemp = new Node; pCurrent->next = pTemp; pTemp->ahead = pCurrent; pCurrent = pTemp; } if (*pStr == ',') pStr++; else break; } // 最后将链表连接起来! pHead->ahead = pCurrent->ahead; pHead->ahead->next = pHead; return pHead; } Node* AddWithOutSign(Node* pNum1, Node* pNum2) { Node* p1 = pNum1->ahead; Node* p2 = pNum2->ahead; Node* pTail = 0; Node* pHead = 0; Node* pCurrent = 0; Node* pTemp; int temp_data; //两个都为正数，相加，并且进位。 int jw = 0; while (p1 != pNum1 && p2 != pNum2) { if (pTail == 0)
{ pTail = new Node; temp_data = p1->data + p2->data; if (temp_data > 9999) { jw = 1; temp_data = temp_data - 10000; } pTail->data = temp_data; pCurrent = new Node; pTail->ahead = pCurrent; pCurrent->next = pTail; } else { temp_data = p1->data + p2->data + jw; if (temp_data > 9999) { jw = 1; temp_data = temp_data - 10000; } else { jw = 0; } pCurrent->data = temp_data; pTemp = new Node; pCurrent->ahead = pTemp; pTemp->next = pCurrent; pCurrent = pTemp; } p1 = p1->ahead; p2 = p2->ahead; } // p1 现在指向最后一个元素 if (p1 == pNum1) { // 如果 p2 也指向最后一个元素 if (p2 == pNum2) { // 两个链表均长度为 1 if (pTail == 0) { pTail = new Node;
Node* pHead = new Node; pHead->sign = 0; pHead->data = 0; Node *pCurrent = 0; Node* pTemp = 0; char buff[5]; bool bFirst = true; int temp_data; while (*pStr != '\0') { if (bFirst) { if (*pStr != '-') { pHead->sign = 0; bFirst = false; } else { pHead->sign = 1; pStr++; bFirst = false; continue; } } // Loop until we find a "," or '\0'; int cnt = -1; while (cnt++ < 5) { if ((*pStr != ',') && (*pStr != '\0')) { buff[cnt] = *pStr; pStr++; } else { buff[cnt] = '\0'; break; } }
Node* p1 = pHead1; Node* p2 = pHead2; int node1_len = GetNodeLen(pHead1); int node2_len = GetNodeLen(pHead2); if (node1_len > node2_len) { return 1; } else if(node1_len == node2_len) { if (node1_len == 1) { if (pHead1->data > pHead2->data) return 1; else if (pHead1->data == pHead2->data) return 0; } else { while (p1->next != pHead1) { if (p1->data > p2->data) return 1; else if (p1->data < p2->data) return -1; p1 = p1->next; p2 = p2->next; } if (p1->data > p2->data) return 1; else if (p1->data == p2->data) return 0; else return -1; } } else return -1; } Node* CreateNode(char *str) { char *pStr; pStr = str;
两个最大数相加 C 语言程序
// HelloWorld.cpp : Defines the entry point for the console application. // //#include "stdafx.h" #include <string.h> #include <stdio.h> #include <stdlib.h> struct Node // 定义一个双向链表用来存贮结果 { int sign; // 0 -> 正数, 1->负数 int data; // 数据，表示绝对值。 Node *next; // 尾指针 Node *ahead; // 首指针 }; int GetNodeLen(Node* pHead) { int len = 0; Node* pCurrent = pHead; if (pHead->ahead == pHead && pHead->next == pHead) return 1; else { len = 0; while (pCurrent->next != pHead) { len++; pCurrent = pCurrent->next; } len++; } return len; } // Return 1 if Node1 ABS value > Node2 ABS value, return 0 if they are equal, otherwise, return -1. int CompareNodeAbsValue(Node* pHead1, Node* pHead2) {