LeetCode（2）--Add Two Numbers

Question：

You are given two non-empty linked lists representing two non-negative integers. 
The digits are stored in reverse order and each of their nodes contain a single digit. 
Add the two numbers and return it as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Example:

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8

个人思路：

题意主要是计算两个非负整数的和，并用链表的方式存储，如题目给出的例子：
整数342用链表存储，表示为：2 -> 4 -> 3
整数465用链表存储，表示为：5 -> 6 -> 4
计算这两个非负整数和为：807，用链表存储，表示为：7 -> 0 -> 8

1、因为addTwoNumbers方法传的参数为ListNode类型，为了方便计算写一个辅助方法将ListNode转换成int类型；
2、因为addTwoNumbers方法的返回值类型是ListNode，所以也需要一个辅助方法将int类型转换成ListNode。

代码实现如下：

public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    // 分别计算ListNode所代表的数字
    int number1 = listNodeToNum(l1);
    int number2 = listNodeToNum(l2);
    // 计算两者之和
    int sum = number1 + number2;
    // 将sum转换成ListNode存储
    return numToListNode(sum);
}

/**
 * 将ListNode转换成数字
 * @param list 需要转换的ListNode
 * @return 转换后的数字
 */
private static int listNodeToNum(ListNode list) {
    int number = 0;
    int count = 0;
    while (list.getNext() != null) {
        number += (list.getVal() * Math.pow(10, count));
        count++;
        list = list.getNext();
    }
    number += (list.getVal() * Math.pow(10, count));
    return number;
}

/**
 * 将数字转换成ListNode
 * @param num 需要转换的数字
 * @return 转换后的ListNode
 */
private static ListNode numToListNode(int num) {
    // 获取数字的位数
    int count = String.valueOf(num).length();
    // 创建链表
    ListNode current = null;
    while ((--count) >= 0) {
        int val = (int)(num / Math.pow(10, count));
        num = (int)(num - val * Math.pow(10, count));
        ListNode newNode = new ListNode(val);
        newNode.setNext(current);
        current = newNode;
    }
    return current;
}

ListNode类：

class ListNode {

    private int val;

    private ListNode next;

    public ListNode(int val) {
        this.val = val;
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    public ListNode getNext() {
        return next;
    }

    public void setNext(ListNode next) {
        this.next = next;
    }
}

测试代码：

public static void main(String[] args) {
    int num1 = 342;
    int num2 = 465;
    ListNode l1 = numToListNode(num1);
    ListNode l2 = numToListNode(num2);
    // 计算结果
    ListNode result = addTwoNumbers(l1, l2);
    // 打印ListNode
    while (result.getNext() != null) {
        System.out.print(result.getVal());
        System.out.print(" -> ");
        result = result.getNext();
    }
    System.out.println(result.getVal());
}

LeetCode的参考答案：

public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode c1 = l1;
        ListNode c2 = l2;
        ListNode sentinel = new ListNode(0);
        ListNode d = sentinel;
        int sum = 0;
        while (c1 != null || c2 != null) {
            sum /= 10;
            if (c1 != null) {
                sum += c1.val;
                c1 = c1.next;
            }
            if (c2 != null) {
                sum += c2.val;
                c2 = c2.next;
            }
            d.next = new ListNode(sum % 10);
            d = d.next;
        }
        if (sum / 10 == 1)
            d.next = new ListNode(1);
        return sentinel.next;
    }
}

总结：

    首先自己的方法应该是一个比较常规的方法，但是效率很低；最笨的方法往往比较安全（安慰下自己）。
    参考答案抓住了题目的关键点，题目明确说明了整数在链表中数字是逆序的，也就是说一个整数正常顺序是：万千百十个，
    在链表中则为：个->十->百->千->万。
    参考答案将链表的数字依次取出进行加法，并且做到了逢十进一。