你好，我正试图解决一些问题，但很难识别我的错误。(
问题描述:
给定两个非空链表，表示两个非负链表整数。这些数字是按倒序存储的，每一个数字节点中包含一位数字。将这两个数相加并返回总和作为链表。
可以假设这两个数不包含任何前导零，除了数字0本身
:
输入>: l1 = [2,4,3]， l2 = [5,6,4](7 0 8):
: 342 + 465 = 807.
我代码:
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
String firstNumber = "";
String secondNumber = "";
// Converts the lists into strings
while (l1 != null){
firstNumber += Integer.toString(l1.val);
l1 = l1.next;
}
while (l2 != null){
secondNumber += Integer.toString(l2.val);
l2 = l2.next;
}
// Reverses the strings
firstNumber = new StringBuilder(firstNumber).reverse().toString();
secondNumber = new StringBuilder(secondNumber).reverse().toString();
long additionLong = Long.parseLong(firstNumber) + Long.parseLong(secondNumber);
ListNode solutionList = new ListNode();
ListNode prevNode = new ListNode();
ListNode currentNode = solutionList;
while (additionLong > 0){
currentNode.val = (int) additionLong % 10;
additionLong /= 10;
ListNode nextNode = new ListNode();
currentNode.next = nextNode;
prevNode = currentNode;
currentNode = currentNode.next;
}
prevNode.next = null;
return solutionList;
}
}
我在通过下面的测试时遇到了麻烦，我似乎找不到问题所在。
输入l1 = [9]
l2 = [1,9,9,9,9,9,9,9,9]
输出
[8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
预期
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
我怀疑麻烦的步骤是当我把两个反向字符串加在一起时，但是代码确实通过了其他一些测试，所以我不明白为什么它不会通过这个…
此外，到目前为止，在我的学位中，我们只学了2门Java和C的非常基础的入门课程，我们只涵盖了基础知识，所以我们并没有真正学会如何写好代码。如果我在代码中做了一些愚蠢的事情，请告诉我，以便我知道如何避免它。:)
您的方法似乎有些复杂。你在做一道算术题;可能不是处理字符串的正确方法。
想想你(也许)是如何在小学学习做加法的:你从最低有效数字开始，把超过10的任何数字加到下一列。
这里的问题简化了，因为最低有效数字在前面。因此，您只需要为当前列创建一个新节点，计算其值，并将任何内容携带到下一列。
由于列表的长度可能不同，这有点复杂，但这并不太难处理:如果你已经"跑完"对于一个列表中的数字，您可以假设它包含一个零。
这段代码将打印出总和的数字;如果需要，您应该尝试构建一个包含结果的链表:
int carry = 0;
// We want to iterate while there is something more to add - even if
// we have exceeded the length of one or both lists, we may still have carry.
while (l1 != null || l2 != null || carry != 0) {
// Get the value from each of the lists. If we've gone past the end of
// a list, just use zero as the value.
int i1 = l1 != null ? l1.value : 0;
int i2 = l2 != null ? l2.value : 0;
int value = i1 + i2 + carry;
// The next carry is the tens of value.
carry = value / 10;
// The value in the current column are the units of value.
value = value % 10;
// Print out the value in the current column.
System.out.println(value);
// Advance the two linked lists (assuming we've not reached the end already).
if (l1 != null) l1 = l1.next;
if (l2 != null) l2 = l2.next;
}
如果你有一把锤子，每个问题看起来都像钉子。
使用String是一样的
不如用更抽象的方法。
如果你有67[7,6]和398[8,9,3]，你会怎么加?
- 7+8给出5与进位1
- 6+9+进位得到6与进位1
- N/A+3+进位为4，进位为0
- N/A+N/A+进位给N/A
:
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode sum = null;
ListNode last = null;
int carry = 0;
while (l1 != null || l2 != null) {
int sum = carry;
if (l1 != null) {
sum += l1.value;
l1 = l1.next;
}
if (l2 != null) {
sum += l2.value;
l2 = l2.next;
}
carry = 0;
if (sum >= 10) {
carry = 1;
sum -= 10;
}
ListNode sumNode = ...
...
}
if (carry != 0) { // An extra digit.
...
}
return sum;
}
如果我在代码中做了一些愚蠢的事情请告诉我，以便我知道如何避免。
将结果强制转换为long:
currentNode.val = (int) additionLong % 10;
这将把additionLong投射到int，导致损失，然后才应用% 10。你需要:
currentNode.val = (int) (additionLong % 10);
这将修复这个特定测试用例的问题。
正如其他人所说，您应该考虑在不进行链表、字符串和长链表之间转换的情况下执行此操作。您可能会遇到long的容量不够的测试用例，然后您将真正陷入困境。
应该只使用链表，逐个处理数字。这就是练习的目的。
将列表转换为字符串后，您可以:
String firstNumber = "243"; //or firstNumber = "9";
String secondNumber = "564";//secondNumber = "1999999999";
// Reverses the strings
firstNumber = new StringBuilder(firstNumber).reverse().toString();
secondNumber = new StringBuilder(secondNumber).reverse().toString();
//add
Long sum = Long.valueOf(firstNumber)+ Long.valueOf(secondNumber);
//reverse sum
String output = new StringBuilder(String.valueOf(sum)).reverse().toString();
System.out.println(output);
如果需要将输出拆分为数组，只需将其更改为:
//reverse sum and split it
String[] output = new
StringBuilder(String.valueOf(sum)).reverse().toString().split("");
System.out.println(Arrays.toString(output));