Lien Leetcode : leetcode.cn/problems/ad…
On vous donne deux listes chaînées non vides représentant deux entiers non négatifs. Chacun de leurs chiffres est stocké dans l'ordre inverse et chaque nœud ne peut stocker qu'un seul chiffre.
Veuillez additionner deux nombres et renvoyer une liste chaînée représentant la somme sous la même forme.
Vous pouvez supposer qu'aucun des nombres ne commence par un zéro autre que le nombre zéro.
Exemple 1:
输入： l1 = [2,4,3], l2 = [5,6,4]
输出： [7,0,8]
解释： 342 + 465 = 807.
Exemple 2 :
输入： l1 = [0], l2 = [0]
输出： [0]
Exemple 3 :
输入： l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出： [8,9,9,9,0,0,0,1]
indice:
- Le nombre de nœuds dans chaque liste chaînée est dans la
[1, 100]plage 0 <= Node.val <= 9- Les données de titre garantissent que le nombre représenté par la liste ne contient pas de zéros non significatifs
indice:
- La structure de la liste chaînée est la suivante :
public class ListNode {
int val;
ListNode next;
ListNode() {}
ListNode(int val) { this.val = val; }
ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}
Solution : Simulation
class Solution3 {
public static void main(String[] args) {
ListNode listNode = new ListNode(7);
listNode.next = new ListNode(8);
listNode.next.next = new ListNode(9);
ListNode listNode2 = new ListNode(3);
listNode2.next = new ListNode(2);
ListNode result = addTwoNumbers(listNode, listNode2);
}
public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
//要返回的链表
ListNode result = null;
//链表头部指针
ListNode head = null;
//进位数,2个个位数相加最大为18,所以进位数最大为1
int carry = 0;
//当链表中的某1个不为空 执行计算逻辑
while (l1 != null || l2 != null) {
//赋值,默认值为0
//只有链表没有对齐,比如某个链表的节点个数为3,某个节点个数为2,此时补位默认值就是0
int x = l1 == null ? 0 : l1.val;
int y = l2 == null ? 0 : l2.val;
//计算两数之和
int sum = x + y + carry;
//计算和的十位数
carry = sum / 10;
//计算和的个位数
int mod = sum % 10;
//判断结果链表是否为空
if (result == null) {
//为空就构造链表
result = new ListNode(mod);
//将链表的头结点赋值给head
head = result;
} else {
//头结点的next指针指向新节点
head.next = new ListNode(mod);
//将头节点的后置节点赋值给head 供下一轮循环使用
head = head.next;
}
//准备下一轮的数据
if (l1 != null) {
l1 = l1.next;
}
if (l2 != null) {
l2 = l2.next;
}
}
//如果还有进位数没处理,做处理
if (carry == 1) {
head.next = new ListNode(carry);
}
return result;
}
}
L'essentiel réside dans la construction de la liste chaînée :
//要返回的链表
ListNode result = null;
//链表头部指针
ListNode head = null;
//伪代码
while(true){
if (result == null) {
//为空就构造链表
result = new ListNode(mod);
//将链表的头结点赋值给head
head = result;
} else {
//头结点的next指针指向新节点
head.next = new ListNode(mod);
//将头节点的后置节点赋值给head 供下一轮循环使用
head = head.next;
}
}
Analyse de complexité
Complexité temporelle : O(max(m,n)), où m et n sont les longueurs des deux listes chaînées. Nous devons parcourir toutes les positions des deux listes chaînées, et cela ne prend que O(1) temps pour traiter chaque position.
Complexité spatiale : O(1). Notez que la valeur de retour ne compte pas dans la complexité de l'espace.
Ma mauvaise solution, car je ne peux pas utiliser BigDecimal, le nombre est relativement grand et la soumission échoue.La restriction d'origine ne peut pas utiliser BigDecimal, quel gouffre !
class Solution {
public static void main(String[] args) {
ListNode listNode = new ListNode(7);
listNode.next = new ListNode(8);
listNode.next.next = new ListNode(9);
ListNode listNode2 = new ListNode(3);
listNode2.next = new ListNode(2);
ListNode result = addTwoNumbers(listNode, listNode2);
}
public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
//转换为数字342
BigDecimal v1 = transferToNumber(l1);
//转换为数字465
BigDecimal v2 = transferToNumber(l2);
//计算342+465 = 807
BigDecimal sum = v1.add(v2);
//将807反转为708
String[] split = sum.toString().split("");
LinkedList<String> list = new LinkedList<>();
for (String s : split) {
list.addFirst(s);
}
//遍历708 转换为链表结构
ListNode result = null;
ListNode head = null;
for (int i = 0; i <= list.size() - 1; i++) {
if (result == null) {
result = new ListNode(Integer.parseInt(list.get(i)));
head = result;
continue;
}
head.next = new ListNode(Integer.parseInt(list.get(i)));
head = head.next;
}
return result;
}
private static BigDecimal transferToNumber(ListNode l1) {
LinkedList<Integer> list = new LinkedList<>();
list.addFirst(l1.val);
while (l1.next != null) {
list.addFirst(l1.next.val);
l1.next = l1.next.next;
}
String v = "";
for (Integer val : list) {
v += val;
}
return new BigDecimal(v);
}
}