精华内容
下载资源
问答
  • 题目:两数相加 给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。 如果,我们将这两个数相加起来,则会返回一个新的...

    题目:两数相加

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

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

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

    示例:

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

    解答: 

    使用c语言时注意,链表的动态创建。

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     struct ListNode *next;
     * };
     */
    struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
        
        struct ListNode *r = (struct ListNode *)malloc(sizeof(struct ListNode));
        r->val = 0;
        r->next = NULL;
        
        struct ListNode *result = r;
    
        
        while(l1 || l2)
        {
            
            r->val += (l1 ? l1->val : 0) + (l2 ? l2->val : 0);
            
            
            if(r->val >= 10) {
                if(!r->next) {
                    r->next = (struct ListNode*)malloc(sizeof(struct ListNode));
                    r->next->val = 0; 
                    r->next->next = NULL;
                }
                r->next->val += (r->val / 10);
                r->val %= 10;
            }
    
            if(l1)
                l1 = l1->next;
            
            if(l2)
                l2 = l2->next;
            
            if(!r->next && (l1 || l2)) {
                r->next = (struct ListNode*)malloc(sizeof(struct ListNode));
                r->next->val = 0;
                r->next->next = NULL;
            }
            r = r->next;
        }
        
        return result;
    }

     

    展开全文
  • 两数相加返回一个新的链表。 你可以假设除了数字 0 之外,这两个数字都不会以零开头。 示例: 输入:(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出:7 -> 0 -> 8 原因:342 + 465 = 807 **********************************...
  • if(k>j-1)//当第二个已经没有可供相加的数字时。 { save[count++]=(num1[p++]+ModNum)%10;//加法 ModNum=(num1[p-1]+ModNum)/10;//取余以便进位到一位。 printf("\n%d\n",save[count-1]); continue; } if...
    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     struct ListNode *next;
     * };
     */
    typedef struct ListNode  ListNode;
    typedef struct ListNode* LinkList;
    struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    LinkList p1=l1;
    LinkList p2=l2;
    int i=0;
    int j=0;
    int num1[100];
    int num2[100];
    //先提取数字装进数组里。
    while(p1)
    {
       num1[i++]=p1->val;
       p1=p1->next;
    }
    while(p2)
    {
        num2[j++]=p2->val;
        p2=p2->next;
    }
    printf("l1长%d l2长%d",i,j);
    int max=i>j?i:j;
    int p,k;
    p=0;
    k=0;
    int ModNum=0;//存储进位的数字
    char save[max+1];
    int count=0;
    while(p<=i-1||k<=j-1)//利用循环来进行加法以及进位
    {
        if(k>j-1)//当第二个数已经没有可供相加的数字时。
        {
        save[count++]=(num1[p++]+ModNum)%10;//加法
        ModNum=(num1[p-1]+ModNum)/10;//取余以便进位到一位。
        printf("\n%d\n",save[count-1]);
        continue;
        }
        if(p>i-1)//当一个数字已经没有可供相加的数字时。
        {
        save[count++]=(num2[k++]+ModNum)%10;
        ModNum=(num2[k-1]+ModNum)/10;
        printf("\n%d\n",save[count-1]);
        continue;
        }
       // printf("\n%d %d\n",num1[p],num2[p]);
        save[count++]=(num1[p++]+num2[k++]+ModNum)%10;
        ModNum=(num1[p-1]+num2[k-1]+ModNum)/10;
        printf("\n%d\n",save[count-1]);
    }
    LinkList answer;
    if(ModNum!=0){
    save[count++]=ModNum;//这里用来加那些例如5+5=10这种加之后的总和数字位数大于其中任一个数时。
    }
    answer=(LinkList)malloc(sizeof(ListNode));
    answer->next=NULL;
    answer->val=save[count-1];//按照题目规定的秩序,利用头插法将数字添加到链表里。
    int o;
    LinkList p3=NULL;
    for(o=1;o<count;o++)
    {
       p3=(LinkList)malloc(sizeof(ListNode));
       if(!p3) return 0;
       p3->val=save[count-o-1];
       p3->next=answer;
       answer=p3;
    }
    return answer;
    }

    写这个题目的时候自己犯了不少简单的错误,在数学不够清晰。逻辑上一开始没有搞清楚各个位是怎么加的,就猛得写,结果就是一直会碰到通不过得测试例子。然后再不断得看测试例子过程中终于理解了。

    展开全文
  • leetcode两数相加c语言链表 struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){ int x, y, num,flag=0;//flag是进位的值 struct ListNode *p = l1, *q = l2; struct ListNode *cur = ...

    leetcode两数相加(c语言链表

    struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
        int x, y, num,flag=0;//flag是进位的值
        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){
            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 = 1;
            cur->next = NULL;
        }
        return ret->next;
    }
    
    展开全文
  • 先创建个分别指向l1,l2的指针 以及定义len1,len2的初始长度都为1 len为len1,len2的长度差,方便补零 max为最大长度 struct ListNode* h1 = l1; struct ListNode* h2 = l2; int len1 = 1,len2 = 1,len,max; ...
    • 先创建两个分别指向l1,l2的指针
    • 以及定义len1,len2的初始长度都为1
    • len为len1,len2的长度差,方便补零
    • max为最大长度
     struct ListNode* h1 = l1;
     struct ListNode* h2 = l2;
     int len1 = 1,len2 = 1,len,max;
    
    • 再从l1,l2里面统计最大长度,并将最大长度赋值给max
     while(h1->next){
            len1++;
            h1 = h1->next;
        }
        while(h2->next){
            len2++;
            h2 = h2->next;
        }
        max = len1>len2?len1:len2;
    
    • 为短的一条补零,使得两链表长度一致
    if(len1>len2){
            len = len1 - len2 ;
            while(len != 0){
                struct ListNode* newNode =(struct ListNode*)malloc(sizeof(struct ListNode));
                newNode->val = 0;
                newNode->next = NULL;
                h2->next = newNode;
                h2 = h2->next;
                --len;
            }
        }else if(len1<len2){
            len = len2 - len1;
            while(len != 0){
                struct ListNode*newNode =(struct ListNode*)malloc(sizeof(struct ListNode));
                newNode->val = 0;
                newNode->next = NULL;
                h1->next = newNode;
                h1 = h1->next;
                --len;
            }
        }
    
    • 定义sum为两数相加之和
    • 若sum大于10,定义s为进位标志位十位,g为个位

    所以在每次相加的时候要再加上上一位的进位

        h1 = l1;
        h2 = l2;	//将l1,l2回到原来位置
        int sum = 0,s = 0,g = 0;
        while(max != 0){
            sum = h1->val + h2->val + s;
            g = sum%10;
            s = sum/10;
            h1->val = g;	//l1里的结点存放计算结果
            h1 = h1->next;
            h2 = h2->next;
            max--;
        }
    
    • 当最后一位如果要进位的话要再为最后一位申请内存空间,并且返回l1作为结果。
        if(s!=0){
            h1 = l1;
            while(h1->next){
                h1 = h1->next;
            }
            struct ListNode*newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
            newNode->val = s;
            newNode->next = NULL;
            h1->next = newNode;
            h1 = h1->next;
        }
        return l1;
    }
    

    在这里插入图片描述
    虽然这个的内存消耗挺高的,但是我觉得这个还是比较好理解的。

    展开全文
  • 先把个链表补成一样的长度,再用递归方法 错误 注意函数里面用指针时也要提前在外面分配内存,不然LeetCode会报错 要记得新建结构体也要malloc void add(struct ListNode* l1, struct ListNode* l2, int *count){...
  • //相加的和 struct ListNode * b = ( struct ListNode * ) malloc ( sizeof ( struct ListNode ) ) ; b -> val = x % 10 ; //创建一个数值为 (sum mod 10)的新结点 //并将其设置为当前结点的...
  • LeetCode-2 两数相加 C语言解题思路代码碰到的错误总结 解题思路 设置变量count和num。count表示两数相加后的进位,num为除10后的余数。 代码 /** * Definition for singly-linked list. * struct ListNode { * ...
  • 将链表中的元素转换为整数,根据相加后的值再生成一个链表。 链表转整数函数: int link_list2int(struct ListNode* ll) { int i = 1; int result = 0; struct ListNode* p = ll; while(p != NULL) { result ...
  • 如果,我们将这数相加起来,则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外,这个数都不会以 0开头。 示例: 输入:(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出:7 -> 0 -&...
  • LeetCode 两数相加

    2019-07-03 10:45:34
    两数相加“ 算是一个比较基本的题,值得关注的一点就是,这里的输入样例是两个链表。。。注意哦,是链表不是数组,这一点让我做了好久,因为他展示出来的样例太像数组,而且我也从没在js上用过链表,所以就默认数...
  • leetcode 2. 两数相加 C语言

    千次阅读 2018-10-14 13:16:38
    struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) { struct ListNode* l = (struct ListNode*)malloc(sizeof(struct ListNode)); struct ListNode* p = l1,* q = l2, * t = l;...
  • leetcode两数相加

    2020-07-11 23:14:33
    两数相加 给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。 如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的...
  • LeetCode#2 两数相加 题目: 给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。 如果,我们将这两个数相加起来,则会返回一个新...
  • 由于我们学院(没错就是信通弟弟学院)辅导员的神操作(在我们没学数据...最后说一句,C语言写的的确很长,不如py或者Java的行数少得多,但是我C的运行快啊,而且内存空间才9MB,很少的(同等8ms的Java用了44MB)
  • 来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/add-two-numbers ...如果,我们将这数相加起来,则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外,这个数都不会以 0 开...
  • 如果,我们将这数相加起来,则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外,这个数都不会以 0 开头。 示例: 输入:(2 -&gt; 4 -&gt; 3) + (5 -&gt; 6 -&gt; 4) 输出...
  • //搜寻指针指向链表头节点 pl1 = l1; pl2 = l2; while(pl1 || pl2) { //l1达到末尾 if(pl1==NULL) { add = pl2->val; } //l2达到末尾 else if(pl2==NULL) { add = pl1->val; } //都没达到末尾 ...
  • LeetCode数相加问题(C语言) 题目描述 给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ,使得 A[i] + B[j] + C[k] + D[l] = 0。 为了使问题简单化,所有的 A, B, C, D 具有相同的长度...
  • 两数相加 给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。 如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 986
精华内容 394
关键字:

leetcode两数相加c语言

c语言 订阅