精华内容
下载资源
问答
  • 相加返回一个新的链表。你可以假设除了数字 0 之外,这数字都不会以零开头。示例:输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)输出:7 -> 0 -> 8原因:342 + 465 = 807#include #include ...

    给定两个非空链表来表示两个非负整数。位数按照逆序方式存储,它们的每个节点只存储单个数字。将两数相加返回一个新的链表。

    你可以假设除了数字 0 之外,这两个数字都不会以零开头。

    示例:

    输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)

    输出:7 -> 0 -> 8

    原因:342 + 465 = 807

    #include

    #include

    typedef struct Node{

    int value;

    struct Node *next;

    }SNode;

    SNode* addTwoNumbers(SNode *head ,SNode *head_1){

    SNode *p = (SNode*)malloc(sizeof(SNode));

    SNode *p1 = p;

    int add;

    while(head != NULL || head_1 != NULL){

    SNode *p2 = (SNode*)malloc(sizeof(SNode));

    int a = 0;

    int b = 0;

    if(head!=NULL)

    a = head->value;

    if(head_1!=NULL)

    b = head_1->value;

    int num = a+b+add;

    p2->value = num % 10;

    add = num / 10;

    p2->next = NULL;

    p1->next = p2;

    p1 = p2;

    if(head!=NULL)

    head = head->next;

    if(head_1!=NULL)

    head_1 = head_1->next;

    }

    if(add !=0){

    SNode *p2 = (SNode*)malloc(sizeof(SNode));

    p2->value = add;

    p2->next = NULL;

    p1->next = p2;

    }

    return p->next;

    }

    int main() {

    SNode *head = (SNode*)malloc(sizeof(SNode));

    int a[] = {5};

    int b[] = {5};

    //引用指针 做一个变量

    SNode *p2 = NULL;

    for (int i = 0; i < 1; ++i) {

    if(i == 0){

    head->value = a[i];

    head->next = NULL;

    p2 = head;

    } else{

    SNode *p = (SNode*)malloc(sizeof(SNode));

    p->value = a[i];

    p->next = NULL;

    //上一个的next 指向这一个

    p2->next = p;

    //把这一个p当上一个节点

    p2=p;

    }

    }

    SNode *head_1 = (SNode*)malloc(sizeof(SNode));

    //引用指针 做一个变量

    SNode *p3 = NULL;

    for (int i = 0; i < 1; ++i) {

    if(i == 0){

    head_1->value = b[i];

    head_1->next = NULL;

    p3 = head_1;

    } else{

    SNode *p = (SNode*)malloc(sizeof(SNode));

    p->value = b[i];

    p->next = NULL;

    //上一个的next 指向这一个

    p3->next = p;

    //把这一个p当上一个节点

    p3=p;

    }

    }

    SNode *p4 = addTwoNumbers(head,head_1);

    while(p4)

    {

    printf("%d ",p4->value);

    p4=p4->next;

    }

    printf("\n");

    return 0;

    }

    展开全文
  • 相加给出个非空 的链表用来表示个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。如果,我们将这个数相加起来,则会返回一个新的链表来表示它们的和...

    两数相加

    给出两个 非空 的链表用来表示两个非负的整数。

    其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。

    如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。

    您可以假设除了数字 0 之外,这两个数都不会以 0 开头。

    输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)

    输出:7 -> 0 -> 8

    原因:342 + 465 = 807

    分析:首先,既然是两个非空链表,那么就不用考虑链表为空的情况了;

    这道题我原本想先把两个整数相加,然后把相加后的和的位数按照逆序用链表存储一下,但是这样会有一个问题,如果链表特别长的话,整数就会特别大,就会溢出,显然这样做是行不通的。

    因为两个整数的位数是按照逆序的方式存储的,那么每个链表的第一个元素都是个位,那么依次遍历两个链表从个位开始相加就可以,同时用 signal 来记录是否需要进位,若需要进位就把 signal 设置为1,计算更高一位的时候把 signal 的值也加上即可。

    下边是代码实现:

    1 /**

    2 * Definition for singly-linked list.

    3 * struct ListNode {

    4 * int val;

    5 * struct ListNode *next;

    6 * };

    7 */

    8

    9

    10 struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){

    11 struct ListNode*list1 = l1;

    12 struct ListNode*list2 = l2;

    13 int signal = 0;

    14 struct ListNode *list = (struct ListNode *)malloc(sizeof(struct ListNode));

    15 list->next = NULL;

    16 if(list1->val+list2->val+signal>=10){

    17 list->val = list1->val+list2->val+signal-10;

    18 signal=1;

    19 }else{

    20 list->val = list1->val+list2->val+signal;

    21 signal=0;

    22

    23 }

    24 struct ListNode *temp = list;

    25 list1=list1->next;

    26 list2=list2->next;

    27 while(list1!=NULL&&list2!=NULL){

    28 struct ListNode *body = (struct ListNode *)malloc(sizeof(struct ListNode));

    29 body->next=NULL;

    30 printf("!!!!!!%d",signal);

    31 if(list1->val+list2->val+signal>=10){

    32 body->val=list1->val+list2->val+signal-10;

    33 signal=1;

    34 }else{

    35 body->val=list1->val+list2->val+signal;

    36 signal=0;

    37 }

    38 list1 = list1->next;

    39 list2 = list2->next;

    40 temp->next = body;

    41 temp = temp->next;

    42

    43 }

    44 if(list1==NULL&&list2==NULL){

    45 if(signal==0){

    46 return list;

    47 }else{

    48 struct ListNode *body = (struct ListNode *)malloc(sizeof(struct ListNode));

    49 body->next=NULL;

    50 body->val=1;

    51 temp->next = body;

    52 temp=temp->next;

    53 return list;

    54 }

    55 }

    56

    57 if(list1!=NULL){

    58 if(signal==0){

    59 temp->next=list1;

    60 return list;

    61 }else{

    62 while(list1!=NULL){

    63 if(signal==0){

    64 temp->next=list1;

    65 return list;

    66 }else{

    67 struct ListNode *body = (struct ListNode *)malloc(sizeof(struct ListNode));

    68 body->next=NULL;

    69 if(list1->val+signal>=10){

    70 body->val=0;

    71 signal=1;

    72 }else{

    73 body->val=list1->val+signal;

    74 signal=0;

    75 }

    76 temp->next=body;

    77 temp=temp->next;

    78 }

    79 list1 = list1->next;

    80 }

    81 }

    82 }

    83

    84 if(list2!=NULL){

    85 if(signal==0){

    86 temp->next=list2;

    87 return list;

    88 }else{

    89 while(list2!=NULL){

    90 if(signal==0){

    91 temp->next=list2;

    92 return list;

    93 }else{

    94 struct ListNode *body = (struct ListNode*)malloc(sizeof(struct ListNode));

    95 body->next=NULL;

    96 if(list2->val+signal>=10){

    97 body->val=0;

    98 signal=1;

    99 }else{

    100 body->val=list2->val+signal;

    101 signal=0;

    102 }

    103 temp->next=body;

    104 temp=temp->next;

    105 }

    106 list2 = list2->next;

    107 }

    108 }

    109 }

    110 if(signal==0){

    111 return list;

    112 }else{

    113 struct ListNode *body = (struct ListNode *)malloc(sizeof(struct ListNode));

    114 body->next=NULL;

    115 body->val = signal;

    116 temp->next=body;

    117 return list;

    118 }

    119

    120 return list;

    121 }

    标签:body,ListNode,struct,val,相加,C语言,next,signal

    来源: https://www.cnblogs.com/jiaxiaoxu/p/11474375.html

    展开全文
  • 本题为leetcode上的一道中等难度题,源代码由一名叫做秀艺的用户所写,相比我自己的版本简洁很多,应用了很多小技巧,值得借鉴学习,在整理过程中为了更好的理清思路,为每一行...如果,我们将这个数相加起来,则...

    本题为leetcode上的一道中等难度题,源代码由一名叫做秀艺的用户所写,相比我自己的版本简洁很多,应用了很多小技巧,值得借鉴学习,在整理过程中为了更好的理清思路,为每一行代码进行了注释(这样做效果也确实不错)。


    题目如下:

    给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。

    如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。

    您可以假设除了数字 0 之外,这两个数都不会以 0 开头。

    示例:
    
    输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)
    输出:7 -> 0 -> 8
    原因:342 + 465 = 807

    算法思想:

    思想比较简单,即进行逐位相加,在设置一个变量作为进位位。

    需要注意的是最后一位的相加进位的处理和两链表长度不同时的处理。

    另外还有一种方法是靠递归来完成。

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     struct ListNode *next;
     * };
     */
    
    struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
        //用于存储当前节点值的中间变量
        int x, y;
        //用于存储当前计算结果
        int num;
        //用于存储进位
        int flag = 0;
        //用于代替l1,l2进行运算
        struct ListNode *p = l1, *q = l2;
        //用于存储计算结果,只所以在此处就进行创建,是为了方便返回结果链表的头部地址,是一个标记位置
        struct ListNode *cur = (struct ListNode*)malloc(sizeof(struct ListNode));
        //初始化其指针,防止其任意指向一个随机地址
        cur -> next = NULL;
        //用于输出结果
        struct ListNode *ret = cur;
    
        while(p!=NULL || q!=NULL)
        {
            //判断链表是否到头,到头则用0代替,继续参与运算
            x = (p != NULL) ? p->val:0;
            y = (q != NULL) ? q->val:0;
    
            //存储目前位数所得结果
            num = x + y + flag;
    
            //通过除来得到是否进位(整型相除只会保存整数结果,小数舍弃)
            flag = num / 10;
     
            //生成真正用于存储的节点,
            cur -> next = (struct ListNode*)malloc(sizeof(struct ListNode));
            //定位到存储节点
            cur = cur -> next;
            //通过模运算获得计算结果的个位部分,这样做便不需要为了判断结果而写额外的判断语句
            cur -> val = num % 10;
            //初始化其指针,防止其任意指向一个地址
            cur -> next = NULL;
    
            //判断两个原链表是否到头,未到头则移动到下一位置
            if(p != NULL)
                p = p -> next;
            if(q != NULL)
                q = q -> next;
        }
    
        //判断最后一位相加后是否还有进位
        if(flag > 0){
            //生成存储节点
            cur -> next = (struct ListNode*)malloc(sizeof(struct ListNode));
            //移动到存储节点
            cur = cur -> next;
            //存储结果
            cur -> val = flag;
            //初始化其指针,防止其任意指向一个地址
            cur -> next = NULL;
        }
    
        //输出结果
        return ret -> next;
    }


     

    展开全文
  • C语言数字相加,然后将和作为链接列表返回C语言数字相加,然后将和作为链接列表返回完整源码(定义,实现,main函数测试) C语言数字相加,然后将和作为链接列表返回完整源码(定义,实现,main函数...

    C语言将两个数字相加,然后将和作为链接列表返回完整源码(定义,实现,main函数测试)

    #include <iostream>
    
    struct ListNode {
        int val;
        ListNode *next;
        ListNode(int v): val(v), next(nullptr)
        { }
    };
    
    ListNode * addLists( ListNode * list1, ListNode *list2 )
    {
        ListNode *list3 = nullptr;
        ListNode *curr = nullptr;
        int carry = 0;
    
        // both list1 and list2 are not null
        while ( list1 && list2 ) {
            int x = list1->val + list2->val + carry;
            if ( x  > 9 ) {
                carry = 1;
                x -= 10;
            } else {
                carry = 0;
            }
            if (list3 == nullptr) {
                list3 = new ListNode(x);
                curr = list3;
            } else {
                curr->next = new ListNode(x);
                curr = curr->next;
            }
            list1 = list1->next;
            list2 = list2->next;
        }
    
        // list2 is null
        while(list1) {
            int x = list1->val + carry;
            if ( x  > 9 ) {
                carry = 1;
                x -= 10;
            } else {
                carry = 0;
            }
            curr->next = new ListNode(x);
            curr = curr->next;
            list1 = list1->next;
        }
    
        // list1 is null
        while(list2) {
            int x = list2->val + carry;
            if ( x  > 9 ) {
                carry = 1;
                x -= 10;
            } else {
                carry = 0;
            }
            curr->next = new ListNode(x);
            curr = curr->next;
            list2 = list2->next;
        }
        if (carry > 0) {
            curr->next = new ListNode(carry);
            curr  = curr->next;
        }
        return list3;
    }
    
    void iterate(ListNode *node) {
        while (node) {
            std::cout << node->val << " ";
            node = node->next;
        }
        std::cout << std::endl;
    }
    
    int main()
    {
        ListNode *list1, *list2;
        list1 = new ListNode(9);
        list1->next = new  ListNode(9);
    
        list2 = new ListNode(5);
        list2->next = new ListNode(9);
        list2->next->next = new ListNode(2);
    
        iterate(list1);
        iterate(list2);
        ListNode *list3 = addLists(list1, list2);
        iterate(list3);
        return 0;
    }
    
    
    展开全文
  • C语言实现大数相加

    千次阅读 2019-01-20 09:43:05
    最好的表达方式就是用字符串 , 然而字符串不能直接像数字一样相加相减 , 所以有了大数相加的算法   基本思想和普通的加法运算没有什么区别 , 只是处理的每一个数据从数字变成了字符 . 所以实现起来也比较简单  ...
  • C语言大整数相加

    2019-08-25 13:44:06
    C语言实现超大整数相加(已经超出了整型、浮点型的大数) #include<stdio.h> #include<string.h> char s1[500],s2[500]; int main() { int i,k,carry,ilength_1,ilength_2; int a[500]={0},b[500]={0...
  • C语言中大数相加问题

    2019-03-07 14:56:37
    C语言的大数相加问题。 二、算法思想 把长的数字用字符串的的形式输入,然后用数组分别存放2个加数。按照加法的形式逐位相加并进位。然后输出。 三、代码 #include&lt;iostream&gt; #include&lt;iomanip...
  • C语言 ☞ 大数相加

    千次阅读 2016-04-23 13:46:23
    问题描述:实现A+B=C 其中A、B位数超过100位...基本思路:字符串反转、字符变数字、位运算、反序输出C语言代码:#include<stdio.h> #include<string.h> #define Max 101 void print(char sum[]); void bigNumAdd(ch
  • C语言中的大数相加问题一.为什么会出现大数相加的问题二.大数相加所要掌握的知识三.大数相加的思路四.整理代码五.运行实例 一.为什么会出现大数相加的问题 **C语言是面向过程的一门语言,它并不像java一般拥有众多...
  • c语言实现大数相加

    2019-03-20 18:20:24
    个大数我们可以用数组来保存,然后在数组中逐位进行相加,再判断该位相加后是否需要进位,为了方便计算,我们将数字的低位放在数组的前面,高位放在后面。 捕获.JPG #include<stdio.h> #include<...
  • C语言超大数相加

    万次阅读 2015-01-07 08:54:46
    这里超大数表示已经超出int、long、long long 范围的数字,所以不能简单的相加。此时就要用字符串,把输入的内容储存在字符串中,通过字符与数字之间的关系计算结果。 思路: 1.输入xxxx+xxxxxx,已‘+’分割...
  • c语言实现长数字相加算法

    千次阅读 2014-10-05 22:00:09
    最近突然有想写博客的
  • c语言两个浮点数相加As we know that modules also known as the remainder of the two numbers can be found using the modulus (%) operator which is an arithmetic operator in C/C++. The modules operator ...
  • C语言之大数相加

    2013-09-13 17:34:49
    #include #include int main() { int f; int i,an,bn,k; char a[1000],b[1000]; int af[1000]={0},bf[1000]={0},c[1000];...=EOF) //输入字符串型的数字 { an=strlen(a); bn=strlen(b);
  • c语言中如何不使用加号,完成数字相加c语言中,我们经常求个数字加和的时候,通常会使用+ ,来将数相加得出相加结果。 例如:#include "stdio.h" int main() { int a=3; int b=2; printf("%d\n",a+b...
  • 关于C语言大正整数相加的实现

    千次阅读 2017-12-26 16:11:47
    大家好,我是一名刚接触c语言不久的大一新生,这是我的第一篇博客:关于大正整数的加法 我们都知道整型变量即使是长整型表示数字的范围也非常有限,因此我们可以用字符数组保存大正整数,然后模拟手工运算实现...
  • 题目:相加 给出个 非空 的链表用来表示个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。 如果,我们将这个数相加起来,则会返回一个新的...
  • 相加c语言程序

    2015-11-16 15:46:19
    c语言程序,课本教程课后作业,得到个数相加的和
  • c语言大数相加

    2014-05-04 11:35:19
    一个运用c语言写的大数相加程序,可以实现大数的四则运算,拥有详尽的代码注释,相信可以帮助很多同学。
  • C语言大数相加

    2019-09-25 17:56:43
    #include "stdafx.h" #include<string.h> #include<stdlib.h> int main(int argc, char* argv[]) { char chArry[0x20] = {};... char chArry2[0x20] = {};...//数字数组 int nArry2[0x...
  • //首先强调 数字加的时候是从后往前加。即字符串从后到前移动...     int  a=strlen(p);    int  b=strlen(s);    //flag为判断相加后前面的数字是否会大于9的下标...因为大于9就要逐渐往前位进1    ...
  • 相加返回一个新的链表。 你可以假设除了数字 0 之外,这数字都不会以零开头。 示例: 输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)输出:7 -> 0 -> 8原因:342 + 465 = 807*//** * ...
  • 1.先将字符串倒序并转换为数字 2.逐位相加,并存入一个数组e[i]中 3.将得到的结果进行进位处理 4.转换并把数组e[i]反转,循环输出结果 #include&lt;iostream&gt; #include&lt;stdio.h&gt; #...
  • 正整数的各位数字之和被Tom称为Tom数。求输入数(<2^32)的Tom数! 每行一个整数(<2^63)。 每行一个输出,对应该数的各位数之和. 12345 56123 82 15 17 10 题目的编程来自于广东技术师范大学的在线判题系统,...
  • C语言大数相加实现

    2020-05-02 23:32:57
    由于大数不可存入int数组中,所以将数字转为字符输入char数组中,将个数组数字从个位开始,模拟正常数字加法,需要进位1时设置进位标志,相加大于10时进位,见具体代码。 #include <string.h> #include ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,083
精华内容 7,633
关键字:

c语言两数字相加

c语言 订阅