两数相加【链表反转击败94】

解题思路

考虑链表长度不同，链表中的val相加，链表上一位的节点加1，首先进行反转，反转并找出最长的链表与最短链表，以最长链表为准我们对它进行遍历，只要长链表与短链表中的值相加和大于等于10，我们就给next的值 +1，并将自身的val减去10，得出反转后相加的结果然后反转为之前的顺序。 注意：会出现头部大于等于10的情况，这个也很好解决，我们创建一个头部，让其next指向我们反转得到的链表，并将创建的头部val重置为1，得到的链表头指针位置val- 10 就可以了

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
 
var addTwoNumbers = function(l1, l2) {
    // 得到反转后的链表
    const reversl1 = reverse(l1);
    const reversl2 = reverse(l2);
    // 定义最大链表，最小链表
     let maxNode, minNode
     
     //找出最大长度与最小长度的链表
    if ( reversl1.len > reversl2.len || reversl1.len === reversl2.len) {
        maxNode = reversl1.node
        minNode = reversl2.node
    } else  {
        maxNode = reversl2.node
        minNode = reversl1.node
    }
    // 计算后被反转回原来顺序的链表
    const result = reverseNode(maxNode, minNode)
    // 解决头部大于等于10，没有大于10 直接返回
    let reNode = result
    // 头部大于等于10
    if(result.val >= 10) {
        result.val = result.val - 10
       reNode = new ListNode(1, reNode)   
    }
  // 
  return reNode
};

// 计算并翻转
function reverseNode(node, node1) {
    let current = node
    let current1 = node1
    let pre = null;
    let pre1 = null
    while (current) {

            let num = current.val += current1?current1.val : 0
            if (num >= 10 && current.next) {
                num = num -10
                current.next.val = current.next.val + 1
            }
        current.val = num
        const next = current.next
        const next1 = current1?.next
        current.next = pre
        if (current1){
            current1.next = pre1
        }
        pre = current
        pre1 = current1
        current = next
        current1 = next1
    }
    return pre
}
// 反转链表方法，并计算链表长度
function reverse(node) {
    let current = node
    let pre = null;
    let i = 0;
    while (current) {
        i++;
        const next = current.next
        current.next = pre
        pre = current
        current = next
    }
    return {
        len: i,
        node: pre
    }
}