Java 使用字符串添加给定的两个数字（链表中的数字）

我试图添加两个非负数，其数字以相反顺序存储在两个单独的链表中。答案也应该是一个数字颠倒的链表，没有尾随的零

我知道有一种方法可以通过每次添加数字和保持进位来解决这个问题，但我试图通过对数字进行加法运算来解决这个问题

这是我的密码：

    /**
     * Definition for singly-linked list.
     * class ListNode {
     *     public int val;
     *     public ListNode next;
     *     ListNode(int x) { val = x; next = null; }
     * }
     */
    public class Solution {
        public ListNode addTwoNumbers(ListNode a, ListNode b) {
            if(a==null || b==null){
                return null;


}
        String num1 = "";
        String num2 = "";
        ListNode temp1 = a;
        ListNode temp2 = b;
        while(temp1!=null){
            num1 = num1+Integer.toString(temp1.val);
            temp1 = temp1.next;
        }
        new StringBuilder(num1).reverse().toString();
        double value1 = Double.parseDouble(num1);
        while(temp2!=null){
            num2 = num2+Integer.toString(temp2.val);
            temp2 = temp2.next;
        }
        new StringBuilder(num2).reverse().toString();
        double value2 = Double.parseDouble(num2);
        double result = value1+value2;
        String res = String.format("%.0f",result);
        ListNode first_node =  new ListNode(Character.getNumericValue(res.charAt(0)));
        ListNode ans  = first_node;
        for(int j=1;j<res.length();j++){
            ListNode node = new ListNode(Character.getNumericValue(res.charAt(j)));
            add(node,ans);
        }
        return ans;
    }
    public void add(ListNode node, ListNode ans){
        ListNode temp;
        temp = ans;
        ans  = node;
        ans.next = temp;
    }
}

/**
*单链表的定义。
*类ListNode{
*公共国际价值；
*公共列表节点下一步；
*ListNode（intx）{val=x；next=null；}
* }
*/
公共类解决方案{
公共ListNode AddTwoNumber（ListNode a、ListNode b）{
如果（a==null | | b==null）{
返回null；
}
字符串num1=“”；
字符串num2=“”；
ListNode temp1=a；
listnodetemp2=b；
while（temp1！=null）{
num1=num1+Integer.toString（temp1.val）；
temp1=temp1.next；
}
新的StringBuilder（num1.reverse（）.toString（）；
double value1=double.parseDouble（num1）；
while（temp2！=null）{
num2=num2+整数.toString（temp2.val）；
temp2=temp2.next；
}
新的StringBuilder（num2）.reverse（）.toString（）；
double value2=double.parseDouble（num2）；
双结果=值1+值2；
String res=String.format（“%.0f”，结果）；
ListNode first_node=新的ListNode（Character.getNumericValue（res.charAt（0））；
ListNode ans=第一个节点；
对于（int j=1；j，您的方法不正确且不间接。
您正在尝试使用浮点运算进行大数算术运算。
结果是计算错误

我们有：

List<Integer> firstNumber;
List<Integer> secondNumber;

“添加”函数看起来不正确。您将按与预期相反的顺序获取编号

此外，您的解决方案没有抓住问题的关键。如果您的数字有很多位数（我认为即使是双位数也有其限制~2^1024），您的方法将失败。链表表示法允许数字更大

正确的解决方案只需在创建解决方案列表时用一个进位数字同时迭代两个列表。如果这是作业或编码竞赛中的问题，您的解决方案将被判为错误。
您的
add
方法错误，它无法正确构建列表。下面是您的解决方案的最后一部分方法的外观，不带
add
方法：

for(int j=1;j<res.length();j++){
   ans.next = new ListNode(Character.getNumericValue(res.charAt(j)));;
   ans = ans.next;
}
return first_node;

for（int j=1；j在您的方法中，变量ans没有更新。您可以尝试以下操作：

ans = add(node,ans);

在add方法中，将方法更改为返回ListNode ans
您的方法并不简单，也不会给出预期的结果

这是一个简单的方法，不需要太多解释，因为加法是简单的整数对整数

请注意，当两个整数之和大于9时，我将进行结转，否则将继续执行列表中下一个整数之和

class Node {
    private Object data;
    private Node next;
    public Object getData() { return data; }
    public void setData(Object data) {  this.data = data; }
    public Node getNext() { return next; }
    public void setNext(Node next) { this.next = next; }
    public Node(final Object data, final Node next) {
        this.data = data;
        this.next = next;
    }
    @Override
    public String toString() { return "Node:[Data=" + data + "]"; }
}


class SinglyLinkedList {
    Node start;
    public SinglyLinkedList() { start = null; }

    public void addFront(final Object data) {
        // create a reference to the start node with new data
        Node node = new Node(data, start);

        // assign our start to a new node
        start = node;
    }

    public void addRear(final Object data) {
        Node node = new Node(data, null);
        Node current = start;

        if (current != null) {
            while (current.getNext() != null) {
                current = current.getNext();
            }
            current.setNext(node);
        } else {
            addFront(data);
        }
    }

    public void deleteNode(final Object data) {
        Node previous = start;

        if (previous == null) {
            return;
        }

        Node current = previous.getNext();

        if (previous != null && previous.getData().equals(data)) {
            start = previous.getNext();
            previous = current;
            current = previous.getNext();
            return;
        }

        while (current != null) {
            if (current.getData().equals(data)) {
                previous.setNext(current.getNext());
                current = previous.getNext();
            } else {
                previous = previous.getNext();
                current = previous.getNext();
            }
        }
    }

    public Object getFront() {
        if (start != null) {
            return start.getData();
        } else {
            return null;
        }
    }

    public void print() {
        Node current = start;

        if (current == null) {
            System.out.println("SingleLinkedList is Empty");
        }

        while (current != null) {
            System.out.print(current);
            current = current.getNext();
            if (current != null) {
                System.out.print(", ");
            }
        }
    }

    public int size() {
        int size = 0;

        Node current = start;

        while (current != null) {
            current = current.getNext();
            size++;
        }
        return size;
    }

    public Node getStart() {
        return this.start;
    }

    public Node getRear() {
        Node current = start;
        Node previous = current;
        while (current != null) {
            previous = current;
            current = current.getNext();
        }
        return previous;
    }
}

public class AddNumbersInSinglyLinkedList {
    public static void main(String[] args) {
        SinglyLinkedList listOne = new SinglyLinkedList();
        SinglyLinkedList listTwo = new SinglyLinkedList();
        listOne.addFront(5);
        listOne.addFront(1);
        listOne.addFront(3);
        listOne.print();
        System.out.println();
        listTwo.addFront(2);
        listTwo.addFront(9);
        listTwo.addFront(5);
        listTwo.print();
        SinglyLinkedList listThree = add(listOne, listTwo);
        System.out.println();
        listThree.print();
    }

    private static SinglyLinkedList add(SinglyLinkedList listOne, SinglyLinkedList listTwo) {
        SinglyLinkedList result = new SinglyLinkedList();
        Node startOne = listOne.getStart();
        Node startTwo = listTwo.getStart();
        int carry = 0;
        while (startOne != null || startTwo != null) {
            int one = 0;
            int two = 0;
            if (startOne != null) {
                one = (Integer) startOne.getData();
                startOne = startOne.getNext();
            }
            if (startTwo != null) {
                two = (Integer) startTwo.getData();
                startTwo = startTwo.getNext();
            }
            int sum = carry + one + two;
            carry = 0;
            if (sum > 9) {
                carry = sum / 10;
                result.addRear(sum % 10);
            } else {
                result.addRear(sum);
            }
        }
        return result;
    }
}

样本运行

Node:[Data=3], Node:[Data=1], Node:[Data=5]
Node:[Data=5], Node:[Data=9], Node:[Data=2]
Node:[Data=8], Node:[Data=0], Node:[Data=8]

@你尝试过我的解决方案吗？如果它有效，请接受答案并投票支持！
Node:[Data=3], Node:[Data=1], Node:[Data=5]
Node:[Data=5], Node:[Data=9], Node:[Data=2]
Node:[Data=8], Node:[Data=0], Node:[Data=8]