算法成长记：两数相加,最长回文串，三树之和

两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

思想：改题目使用的是ListNode节点的数据结构。
nodeList是一种类数组对象，用于保存一组有序的节点。
了解ListNode的属性：如下（题目也已经给出）

struct ListNode {
       int val;    //定义val变量值，存储节点值
       struct ListNode *next;   //定义next指针，指向下一个节点，维持节点连接
  }

解法：通过value1+value2+addZero来计算值，注意while的条件：while(addZero || l1 || l2)巧妙！

/**
 * 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) {
    let head = new ListNode('0')// 结果集
    let addZero = 0
    let sum = head
    while(addZero || l1 || l2) {
        let val1 = l1!==null ? l1.val : 0
        let val2 = l2!==null ? l2.val : 0
        // 保存和
        let va = val1 + val2 + addZero
        addZero = va>=10 ? 1 : 0
        sum.next = new ListNode(va % 10)
        sum = sum.next
        if(l1) l1 = l1.next
        if(l2) l2 = l2.next
    }
    return head.next
};

最长回文串

给你一个字符串 s，找到 s 中最长的回文子串。
思想：找到回文串的特征，左右两侧对称；
那么我们应该怎么选取中间点？
有两种情况：回文串为奇数，回文串为偶数，分开讨论；
使用左右两指针，注意最后取值的范围；
当满足条件的时候left–,right++
所以真实的开始下标是left++

/**
 * @param {string} s
 * @return {string}
 */
var longestPalindrome = function(s) {
    let n = s.length
    let res = ''
    // 边界
    if(n<2) {
        return s
    }
    for (let i=0;i<n;i++) {
         // 回文串为奇数的时候
        helper(i,i)
        // 回文串为偶数的时候
        helper(i,i+1)
    }
    function helper(left,right) {
        while(s[left]===s[right]&&left>=0&&right<n) {
            left--
            right++
        }
        if (right-left-1>res.length) {
            res= s.slice(left+1,right)
        }
    }
    return res
};

三树之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。
思路：先排序
过滤边界条件
nums[i]为一个确定的数，通过left right两个指针来指向右边的两侧；
通过比较sum当前与0相比，来确定left++还是right–
注意break 和 continue的使用

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function(nums) {
  // 排序
  nums.sort((a,b)=> a-b)
  // 定义变量
  let res = []
  let n = nums.length
  // 边界
  if(!n || n<3) {
      return res
  }
  // 循环
  for (let i=0;i<n;i++) {
      // 边界
      if (nums[i]>0) {
          break
      }
      if (i>0&&nums[i]===nums[i-1]) {
          continue
      }
      let left = i+1
      let right = n-1
      while(left<right) {
          let sum = nums[i]+nums[left]+nums[right]
          if(sum===0) {
              res.push([nums[i],nums[left],nums[right]])
              while(left<right&&nums[left]===nums[left+1]) {
                  left++
              }
              while(left<right&&nums[right]===nums[right-1]){
                  right--
              }
              left++
              right--
          }else if(sum<0) {
              left++
          }else if(sum>0) {
              right--
          }
      }
  }
  return res
};

每天进步一点点~☀