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

Question

我正在尝试添加两个非负数，它们的数字以相反的顺序存储在两个单独的链表中。答案也应该是一个数字反转且没有尾随零的链表。

我知道有一种方法可以通过添加数字并每次保持进位来解决这个问题，但我正在尝试通过对数字使用加法运算来解决这个问题。

这是我的代码：

    /**
     * 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;
    }
}

我的代码给出了错误的答案。谁能指出错误？

Answer 1

你的方法是不正确和间接的。 您正在尝试使用浮点运算进行大数运算。 结果 - 计算错误。

我们有：

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

让我们假设 firstNumber > secondNumber。

试试这个算法：

List<Integer> result = new ArrayList<>();
int i = 0;
int appendix = 0;
for (; i < secondNumber.size(); i++) {
    int sum = firstNumber.get(i) + secondNumber.get(i) + appendix;
    result.append(sum % 10);
    appendix = sum / 10;
}

for (; i < firstNumber.size(); i++) {
    int sum = firstNumber.get(i) + appendix;
    result.append(sum % 10);
    appendix = sum / 10;
}

if (appendix != 0) 
    result.append(appendix);

return result;

Answer 2

您的 add 函数看起来不正确。您将按照与预期相反的顺序获得编号。

另外，您的解决方案没有抓住问题的重点。如果您有一个包含很多数字的数字（我认为即使 double 也有其限制 ~ 2^1024），您的方法将失败。链表表示允许更大的数字。

正确的解决方案是在创建解决方案列表时使用进位数字同时遍历两个列表。如果这是作业或编码竞赛中的问题，您的解决方案将被判断为错误。

Answer 3

您的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;

Answer 4

在您的方法中，变量 ans 没有更新。你可以试试这个：

ans = add(node,ans);

并在您的 add 方法中，将方法更改为返回 ListNode ans

Answer 5

你的方法并不简单，不会给你预期的结果。

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

请注意，当两个整数的总和大于 9 时，i 会结转，否则继续两个列表中下一个整数的总和。

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]