链表——两数相加

题目：

创建两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

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

 

示例 1：

输入：La = [2,4,3], Lb = [5,6,4]
输出：7 0 8
解释：342 + 465 = 807.

示例 2：

输入：La = [0], Lb = [0]
输出： 0 

示例 3：

输入：La = [9,9,9,9,9,9,9], Lb = [9,9,9,9]
输出： 8 9 9 9 0 0 0 1

​
#include<stdio.h>
#include<stdlib.h>

typedef struct Node{
    int data;  //数据域
    struct Node*next;
}Node,*LinkList;

void InitList(LinkList *L){
    *L=(LinkList)malloc(sizeof(Node));    //建立头结点
    (*L)->next=NULL;       //二级指针建立空的单链表
}

void CreatList(LinkList L){
    Node *h,*r;       // h->指向新创建的结点 r->指向上一个创建的结点
    int num;
    r=L;              //便于以下步骤进行连接
    while((num=getchar())!='\n'){
        if(num>='0'&&num<='9'){
            h=(Node*)malloc(sizeof(Node));  
            h->data=num-'0';         //赋值
            r->next=h;               //连接结点
            r=h;                     //更新表尾

        }
    }
    r->next=NULL;                 //链表创建完毕，给尾节点 next 域赋值为 NULL
}

/*求和分为下列三种情况：
1.La链表长度大于Lb链表长度
2.La链表长度小于Lb链表长度
3.La链表长度等于于Lb链表长度
--------并且La与Lb链表中两数相加时需要判断是否向需要向下一位进位＋1
--------判断向下一位进位后，还需要判断是否继续进位
*/

void SumList(LinkList La,LinkList Lb){
    Node *ha,*hb,*h,*n;
    int flag=1;
    ha=La->next; hb=Lb->next;
    while(flag){
        if((ha->next!=NULL)&&(hb->next!=NULL)){          /*对La与Lb数字依次相加*/
            if((ha->data+hb->data)>=10){                 /*判断是否需要进位*/
                ha->data=ha->data+hb->data-10;
                ha=ha->next;                             /*ha指向下一个结点*/
                hb=hb->next;                             /*hb指向下一个结点*/
                ha->data++;                              /* 进位 */
            }else{
                ha->data=ha->data+hb->data;
                ha=ha->next;
                hb=hb->next;
            }
        }else if((ha->next==NULL)&&(hb->next==NULL)){    /*La链表长度等于于Lb链表长度*/
            if((ha->data+hb->data)>=10){                 /*判断是否需要进位*/
                ha->data=ha->data+hb->data-10;
                h=(Node*)malloc(sizeof(Node));           /*如果需要进位，则申请一个新的结点空间，存放进位位*/
                ha->next=h;                              /*将新结点与La连接*/
                ha=ha->next;
                ha->data=1;                              /* 进位 */
                ha->next=NULL;
                flag=0;
            }else{
                ha->data=ha->data+hb->data;
                flag=0;
            }
        }else if(ha->next==NULL){                        /*La链表长度小于于Lb链表长度*/
            if((ha->data+hb->data)>=10){                 /*判断是否需要进位*/
                ha->data=ha->data+hb->data-10;
                hb=hb->next;
                hb->data++;
                ha->next=hb;
                /*--------判断向下一位进位后，还需要判断是否继续进位*/
                while(hb->data>=10){
                    hb->data=hb->data-10;
                    if(hb->next!=NULL){
                        hb=hb->next;
                        hb->data++;
                    }else{
                        n=(Node*)malloc(sizeof(Node));           /*如果需要进位，则申请一个新的结点空间，存放进位位*/
                        hb->next=n;
                        n->data=1;  
                        n->next=NULL;
                    }
                }
                flag=0;
            }else{
                ha->data=ha->data+hb->data;
                ha->next=hb->next;
                flag=0;
            }
        }else if(hb->next==NULL){                       /*La链表长度大于于Lb链表长度*/
            if((ha->data+hb->data)>=10){                /*判断是否需要进位*/
                ha->data=ha->data+hb->data-10;
                ha=ha->next;
                ha->data++;
                /*--------判断向下一位进位后，还需要判断是否继续进位*/
                while(ha->data>=10){
                    ha->data=ha->data-10;
                    if(ha->next!=NULL){
                        ha=ha->next;
                        ha->data++;
                    }else{
                        n=(Node*)malloc(sizeof(Node));           /*如果需要进位，则申请一个新的结点空间，存放进位位*/
                        ha->next=n;
                        n->data=1;  
                        n->next=NULL;
                    }
                }
                flag=0;
            }else{
                ha->data=ha->data+hb->data;
                ha=ha->next;
                flag=0;
            }
        }    
    }
}

void Travel(LinkList L){
    Node *h;
    int flag=1;
    h=L->next;
    while(flag){
        if(h->next!=NULL){
        printf("%d ",h->data);
        h=h->next;
        }else{
            printf("%d ",h->data);
            flag=0;
        }
    }
}

int main(){
    LinkList La;
    InitList(&La);
    CreatList(La);
    LinkList Lb;
    InitList(&Lb);
    CreatList(Lb);
    SumList(La,Lb);
    Travel(La);
    printf("\n");
    system("pause");
    return 0;
}

​

运算结果：