给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。请你将两个数相加,并以相同形式返回一个表示和的链表。

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

输入:

2,4,3

5,6,4

输出:

7,0,8

#include<bits/stdc++.h>
using namespace std;


typedef struct LNode
{int data;
 struct LNode *next;
}LNode,*LinkList;


void create(LinkList &L,int a[])

{L=new LNode;

LNode *temp=L;int i;

L->next=NULL;
 i=0;
while(a[i]!=-1)

{
	LNode *p=new LNode;
	p->data=a[i];
	p->next=temp->next;
	temp->next=p;
	temp=p;
    i++;
}

}



void xiangjia(LinkList &L1,LinkList &L2,LinkList &L3)
{int flag=0,i;
 LinkList p1=L1->next;
 LinkList p2=L2->next;
 LinkList p;
 L3=new LNode;
 L3->next=NULL;
 p=L3;
 while(p1&&p2)
 {LinkList q=new LNode;
 q->next=NULL;
 p->next=q;
 p=q;
 p->data=(p1->data+p2->data+flag)%10;
 flag=(p1->data+p2->data+flag)/10;
 p1=p1->next;
 p2=p2->next;}
 if(p1!=NULL&&p2==NULL)
 {while(p1)
 {LinkList q=new LNode;
 q->next=NULL;
 p->next=q;
 p=q;
 p->data=(p1->data+flag)%10;
 flag=(p1->data+flag)/10;
 p1=p1->next; 
 }}
 if(p2!=NULL&&p1==NULL)
 {while(p2)
 {LinkList q=new LNode;
 q->next=NULL;
 p->next=q;
 p=q;
 p->data =(p2->data+flag)%10;
 flag=(p2->data+flag)/10;
 p2=p2->next; 
 }}
 if(flag==1)
 {LinkList q=new LNode;
 q->next=NULL;
 q->data=1;
 p->next=q;}
}

void putout(LinkList L3)
{LinkList p;
p=L3->next;
while(p->next)
{printf("%d,",p->data);
p=p->next;}
printf("%d",p->data);
}


int main() {
int a[50],b[50];
char c[50],d[50];
cin>>c;int i=0,h,j=0;
memset(a,-1,sizeof(a));
memset(b,-1,sizeof(b));
 for(h=0;;h++)
 {
 a[j]=c[i]-'0';	
 i++;j++;
 if(c[i]!=',')
 break;
 else i++;
 }
 cin>>d;i=0;
 j=0;
 for(h=0;;h++)
 {
 b[j]=d[i]-'0';	
 i++;j++;
 if(d[i]!=',')
 break;
 else i++;
 }
 LinkList L1,L2,L3;
 create(L1,a);
 create(L2,b);
 xiangjia(L1,L2,L3);
 putout(L3);
 return 0; 
}

好的,您提到的是经典的“相加”问题(LeetCode第2题)。在这个问题中,我们需要将两个逆序存储链表表示整数相加返回一个新的链表表示它们的。下面是一个用Python实现该功能的例子: ```python # 定义单向链表节点结构体 class ListNode: def __init__(self, val=0, next=None): self.val = val # 节点值 self.next = next # 下一节点引用 def addTwoNumbers(l1: ListNode, l2: ListNode) -> ListNode: dummy_head = ListNode() # 创建一个哑结点作为结果链表头部前驱 current_node = dummy_head # 当前操作指针指向dummy头 carry_over = 0 # 初始化进位标志 while l1 or l2 or carry_over > 0: sum_val = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry_over new_digit = sum_val % 10 # 计算当前位的真实数值 carry_over = sum_val // 10 # 更新进位状态 current_node.next = ListNode(new_digit) # 构建新结点连接到结果列表上 current_node = current_node.next # 移动current至下一位置继续构建 if l1 is not None: l1 = l1.next # 若L1还有剩余项则前进一位 if l2 is not None: l2 = l2.next # 同样对L2做此检查与移动 return dummy_head.next # 返回真正的首结点即去掉最初添加的那个虚拟head # 辅助函数用于打印链表内容以便测试查看输出是否正确 def print_linked_list(node): elements = [] while node: elements.append(str(node.val)) node = node.next print("->".join(elements)) # 测试示例代码片段: if __name__ == "__main__": # 示例链表创建 list1 = ListNode(2) list1.next = ListNode(4) list1.next.next = ListNode(3) list2 = ListNode(5) list2.next = ListNode(6) list2.next.next = ListNode(4) result = addTwoNumbers(list1, list2) print_linked_list(result) # 应输出7->0->8 ``` ### 算法解释: - 我们首先定义了一个`ListNode`类,它代表了我们使用的简单单链表数据结构。 - 接下来,在`addTwoNumbers`函数里,我们引入了一个额外的变量叫做`carry_over`,用来跟踪每一次求过程中产生的进位情况。 - 对于每一个对应的数字加上上次运算留下的进位之后得到的结果分为部分处理——一部分是本位的实际取值(`new_digit`);另一部分则是传递给更高一位去考虑的新一轮"携带"(或称作借位). - 最后一步就是通过迭代地遍历输入链表直到所有有效数据都被访问完毕为止,同时也要注意当最后几位都为零但是仍然存在进位的情况下也需要生成新的高位结点.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值