Java 向LinkedList添加值无效

我试图每天在leetcode上解决一个编程问题，以改进我的编程，但在下面的问题中，我遇到了添加到LinkedList的问题。我想知道是否有人能给我一些建议。我知道我的答案不是最有效的，我只是想从某个地方开始，让自己振作起来。方法中的所有内容都是我迄今为止所做的。我真的很感谢你的帮助

///

给您两个非空链表，表示两个非负整数。数字按相反顺序存储，每个节点包含一个数字。将这两个数字相加，并将其作为链表返回

下面是一张图片，其中包含一个可能输出的示例：

您可以假设这两个数字不包含任何前导零，除了数字0本身

/**
* Definition for singly-linked list.
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {

    ListNode l3 = new ListNode(-1);
    ListNode curr = new ListNode(-1);
    ListNode newNode = new ListNode(-1);

 // Take numbers from linkedList and store in strings
    String s1 = "";
    String s2 = "";
// String values after being reveresed in the right direction.
    String sR1 = "";
    String sR2 = "";

    while(l1 != null) {

        s1 += l1.val;
        l1 = l1.next;
    }
    while(l2 != null) {

        s2 += l2.val;
        l2 = l2.next;
    }

    //check
    System.out.println(s1);
    System.out.println(s2);

    //reverse the string;

    for(int i = s1.length()-1; i >= 0; i--) {

        sR1 += s1.charAt(i);
    }
      for(int j = s2.length()-1; j >= 0; j--) {

        sR2 += s2.charAt(j);
    }

//Adding the numbers together to get the final value.
    int n3 = Integer.parseInt(sR1) + Integer.parseInt(sR2);
//Converting ints to string so i can parse them into characters that will eventually be parsed into an int to return back to the LinkedList
    String fin = Integer.toString(n3);
    System.out.println(fin);


//adding the values to my final linked list that i'd be returning here.       This is the part that isn't working.
    for(int i = 0; i < fin.length()-1; i++){

    String s = String.valueOf(fin.charAt(i)); 

       int num = Integer.parseInt(s);

        newNode = new ListNode(num);

        if(l3.val == -1) {

            l3 = newNode;
        }
        else {
            curr = l3;

            while(curr.next != null){
                curr = curr.next;
            }
            curr.val = num;
        }

    }
    return l3;
}

/**
*单链表的定义。
*公共类列表节点{
*int-val；
*listnodenext；
*ListNode（intx）{val=x；}
* }
*/
类解决方案{
公共ListNode AddTwoNumber（ListNode l1、ListNode l2）{
ListNode l3=新ListNode（-1）；
ListNode curr=新ListNode（-1）；
ListNode newNode=新ListNode（-1）；
//从linkedList中获取数字并以字符串形式存储
字符串s1=“”；
字符串s2=“”；
//按正确方向重新设置后的字符串值。
字符串sR1=“”；
字符串sR2=“”；
while（l1！=null）{
s1+=l1.val；
l1=l1.next；
}
while（l2！=null）{
s2+=l2.val；
l2=l2.next；
}
//检查
系统输出打印LN（s1）；
系统输出打印LN（s2）；
//把绳子倒过来；
对于（int i=s1.length（）-1；i>=0；i--）{
sR1+=s1.特征（i）；
}
对于（int j=s2.length（）-1；j>=0；j--）{
sR2+=s2.charAt（j）；
}
//将这些数字相加得到最终值。
intn3=Integer.parseInt（sR1）+Integer.parseInt（sR2）；
//将int转换为string，以便将它们解析为字符，这些字符最终将被解析为int以返回LinkedList
字符串fin=Integer.toString（n3）；
系统输出打印LN（fin）；
//将值添加到我将返回的最终链接列表中。这是不起作用的部分。
对于（int i=0；i

可能是这样的吗？这里的概念很简单。 要求是反转节点并添加它们。这意味着您只需要选择正确的数据结构来满足此要求，从而提供后进先出？堆栈。现在堆栈中有了数据，只需从堆栈中弹出项并将其添加，即可获得预期结果。 有很多方法可以解决这个问题，使用ArrayList、LinkedList或普通的旧数组，但是尝试将问题与已知的数据结构关联起来，并以这种方式解决它会给您提供一致的有意义的输出em基于用户需求。干杯，希望有帮助

import java.util.Scanner;
import java.util.Stack;

public class AddTuple {
    public static void main(String[] args) {
        Stack<Integer> leftTuple = new Stack<Integer>();
        Stack<Integer> rightTuple = new Stack<Integer>();

        populateTuple(leftTuple, rightTuple, 3);
        Stack<Integer> result = addTuples(leftTuple, rightTuple);
        System.out.print("Output: {");
        int i = 0;
        while (!result.isEmpty()) {
            if (i != 0) {
                System.out.print(", ");
            }
            System.out.print(result.pop());
            i++;
        }
        System.out.println("}");
    }

    private static void populateTuple(Stack<Integer> leftTuple, Stack<Integer> rightTuple, int count) {
        Scanner scanner = new Scanner(System.in);
        try {
            System.out.print("Input: ");
            String input = scanner.nextLine();
            if (input == null || !input.contains("+") || !input.contains("{")) {
                throw new RuntimeException("Usage: {x,y,z} + {a,b,c}");
            }
            String[] operandSplit = input.split("\\+");
            String left = operandSplit[0].trim();
            String right = operandSplit[1].trim();
            left = left.replaceAll("\\{", "");
            left = left.replaceAll("\\}", "");
            right = right.replaceAll("\\{", "");
            right = right.replaceAll("\\}", "");

            String[] leftSplit = left.split(",");
            String[] rightSplit = right.split(",");

            for (int i = 0; i < leftSplit.length; i++) {
                leftTuple.push(Integer.parseInt(leftSplit[i].trim()));
            }

            for (int i = 0; i < rightSplit.length; i++) {
                rightTuple.push(Integer.parseInt(rightSplit[i].trim()));
            }
        } finally {
            scanner.close();
        }
    }

    private static Stack<Integer> addTuples(Stack<Integer> leftTuple, Stack<Integer> rightTuple) {
        Stack<Integer> result = new Stack<Integer>();
        int carryForward = 0;
        while (!leftTuple.isEmpty()) {
            int addition = leftTuple.pop() + rightTuple.pop() + carryForward;
            if (addition > 9) {
                carryForward = 1;
                addition = 10 - addition;
            }
            result.push(addition);
        }
        return result;
    }
}

import java.util.Scanner；
导入java.util.Stack；
公共类AddTuple{
公共静态void main（字符串[]args）{
Stack leftTuple=新堆栈（）；
Stack rightTuple=新堆栈（）；
populateTuple（leftTuple，rightuple，3）；
堆栈结果=addtuple（leftTuple，rightuple）；
系统输出打印（“输出：{”）；
int i=0；
而（！result.isEmpty（））{
如果（i！=0）{
系统输出打印（“，”）；
}
System.out.print（result.pop（））；
i++；
}
System.out.println（“}”）；
}
私有静态void populateTuple（堆栈leftTuple、堆栈rightuple、int计数）{
扫描仪=新的扫描仪（System.in）；
试一试{
系统输出打印（“输入：”）；
字符串输入=scanner.nextLine（）；
if（input==null | |！input.contains（“+”）| |！input.contains（“{”））{
抛出新的运行时异常（“用法：{x，y，z}+{a，b，c}”）；
}
字符串[]操作数拆分=输入。拆分（\\+）；
字符串左=操作数拆分[0]。修剪（）；
字符串右=操作数拆分[1]。修剪（）；
left=left.replaceAll（“\\{，”）；
left=left.replaceAll（“\\}”，即“”）；
right=right.replaceAll（“\\{，”）；
right=right.replaceAll（“\\}”，即“”）；
字符串[]leftSplit=left.split（“，”）；
字符串[]rightSplit=right.split（“，”）；
for（int i=0；i9）{
结转=1；
加法=10-加法；
}
结果：推送（加法）；
}
返回结果；
}
}

“我知道我的答案不是最有效的，我只是想从某个地方开始，让自己振作起来。该方法中的所有内容都是我迄今为止所做的。我非常感谢您的帮助。”--抱歉，StackOverflow不是这样工作的。请访问并阅读。您需要解释什么不起作用，并询问a