链表---力扣 2. 两数相加（记录一个教训）

第一次尝试

刚拿到这个题，一个直接的思路就是把两个所给链表转换成数，然后相加得和，再把所拿到的和一位一位拆出来，构建链表即可

这种方式比较直接，而且也不要考虑进位情况啥的

JS实现

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * 可能会出现数太大，超出JS中规定的2^53-1
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers1 = function (l1, l2) {
  let num1 = getNum(l1)
  let num2 = getNum(l2)
  let sum = num1 + num2
  if (sum === 0) {
    return new ListNode()
  }
  let dummyHead = new ListNode()
  let cur = dummyHead
  while (true) {
    // 把所拿到的和一位一位拆出来，构建链表
    var tempNum = sum % 10
    if (sum) {
      let tempNode = new ListNode(tempNum, null)
      cur.next = tempNode
      cur = cur.next
    } else {
      // sum===0
      break
    }
    sum = parseInt(sum / 10)
  }
  return dummyHead.next

  // 将链表转换成数
  function getNum(head) {
    let count = 0
    let num = 0
    let cur = head
    while (cur !== null) {
      if (cur.val !== 0) {
        num += cur.val * Math.pow(10, count)
      }
      cur = cur.next
      count++
    }
    return num
  }
}

但是…

JavaScript 中最大的安全整数（2^53 - 1），只能放弃这种做法

第二次尝试

考虑处理进位问题；考虑两个链表长度不一样的问题；最后遍历完最长的所给链表后，可能还存在没有进完的位

JS实现

/**
 * 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 addTwoNumbers2 = function (l1, l2) {
  let num1 = null
  let num2 = null
  let cur1 = l1
  let cur2 = l2
  // 返回一个表示和的链表
  let headSum = new ListNode()
  let cur = headSum
  // 是否进位
  let flag = 0
  while (cur1 !== null || cur2 !== null) {
    if (cur1) {
      num1 = cur1.val
      cur1 = cur1.next
    } else {
      num1 = 0
    }

    if (cur2) {
      num2 = cur2.val
      cur2 = cur2.next
    } else {
      num2 = 0
    }

    let temp = num1 + num2
    if (flag) {
      // 本位接收前一位的进位，数值+1
      temp++
      flag = 0
    }
    if (temp >= 10) {
      // 要进位
      temp = temp % 10
      flag = 1
    }
    let tempNode = new ListNode(temp, null)
    cur.next = tempNode
    cur = cur.next
  }
  // 还存在没有进完的位
  if (flag) {
    let tempNode = new ListNode(1, null)
    cur.next = tempNode
  }
  return headSum.next
}