攻陷leetcode，你我行！！！（不在话下），小意思666

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function (nums) {
  nums.sort((a, b) => a - b) // 排序
  let res = []
  for (let i = 0, len = nums.length; i < len; i++) {
    if (nums[i] > 0) break  // 排除不可能情况
    if (i>0 && nums[i] === nums[i - 1]) continue // 去重
    let L = i + 1, R = len -1;
    while (L <R) {
      let sum = nums[i] + nums[L] + nums[R]
      if (sum === 0) {
        res.push([nums[i], nums[L], nums[R]])
        while (nums[L] === nums[++L]) continue // 及时去重
      }else if (sum > 0) {
         
       
        R--;
      }else if (sum < 0) {
    
        
        L++;
      }
    }
  }
  return res
};

 let L = i + 1, R = len - 1;

 while (L < R) {
      let sum = nums[i] + nums[L] + nums[R]

什么意思？
当L小于R时，为什么时<为什么不是<=呢？
因为等于的话，就错了，为什么，因为给你的数组里面只有一个2，而<=的话，是[-4,2,2]是两个2了。
问题？为什么测试用例里面的-1可以两个啊，因为给的数组里面有两个-1啊。
注意一下：给的数组里面的元素在一个组合；里面只能出现一次。而-1有两个，证明在一个组合里面有两个-1也可以。但是因为2在给的数组里面只有一个，所以一个数组里面只能有一个2，两个2的话，就错了哈。
然后是    `let sum = nums[i] + nums[L] + nums[R]`看看双指针的与固定值的结果能不能为0.

 if (sum === 0) {
        res.push([nums[i], nums[L], nums[R]])
        while (nums[L] === nums[++L]) continue // 及时去重
      }

  意思是;等等于0时，就代表可以，push进输出的数组里面，然后看看这个可以与其他的可以为0的L与下一个L++是不是重复的，
  如果是证明有重复的，就先装进数组里面在跳过下一个，问题？为什么一定要跳过？
  因为不跳过的话，有重复，有重复会错，因为题目要求的是不能重复的：（官方要求）注意：答案中不可以包含重复的三元组。（官方要求）。
 注意下这里：也能重复，不过要求的是给的数组里面的，如果给的数组里面有两个-1，因为每一个-1在一个组合里面只能出现一次，两个2，可以出现两次了啊，就这种情况。
 除了这种，其他的都错。
 问题？为什么使用continue跳过，因为如果break的话，就全部完了啊。（跳过for）。

 else if (sum > 0) {
   R--;
  }

else if (sum < 0) {
        L++;
      }

/**
 * @param {string} s
 * @return {string}
 */
var reverseWords = function(s) {
    return s.split(" ").map(str=>str.split("").reverse().join("")).join(" ");
};

str.split("").reverse().join("")).join(" ")

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} head
 * @return {boolean}
 */
var hasCycle = function(head) {
    let p1=head;
    let p2=head;
    while(p1&&p2&&p2.next)
    {
        p1=p1.next;
        p2=p2.next.next;
        if(p1==p2)
        {
            return true;
        }
    }
    return false;
};

 let p1=head;
    let p2=head;

 p1=p1.next;
 p2=p2.next.next;
 为什么if(p1==p2)
        {
            return true;

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    for(let i=0;i<nums.length;i++)
    {
        for(let j=i+1;j<nums.length;j++)
        {
            if(nums[i]+nums[j]==target)
            {
                return [i,j];
            }
        }
    }
};

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isAnagram = function(s, t) {
    if(s.length!=t.length)
    {
       return false 
    }
    var sSort=s.split('').sort();
    var tSort=t.split('').sort();
    return sSort.join('')==tSort.join('');
    
};

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var deleteDuplicates = function(head) {
    let p=head;
    while(p&&p.next)
    {
        if(p.val===p.next.val)
        {
            p.next=p.next.next;
        }
        else{
            p=p.next;
        }
        
    }
    return head;
};

let p=head;

if(p.val===p.next.val)
{
	p.next=p.next.next;
}

 while(p&&p.next)

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    let p1=head;
    let p2=null;
    while(p1)
    {
        const tmp=p1.next;
        p1.next=p2;
        p2=p1;
        p1=tmp;
    }
    return p2;
};

while(p1)
    {
        const tmp=p1.next;
        p1.next=p2;
        p2=p1;
        p1=tmp;
    }

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers = function(l1, l2) {
const q=new ListNode(0);
let p1=l1;
let p2=l2;
let p3=q;
let carry=0;
while(p1||p2)
{
    const v1=p1?p1.val:0;
const v2=p2?p2.val:0;
const val=v1+v2+carry;
carry=Math.floor(val/10);
p3.next=new ListNode(val%10);
if(p1)
{
    p1=p1.next;
}
if(p2)
{
    p2=p2.next;
}
p3=p3.next;
}
if(carry)
{
    p3.next=new ListNode(carry);
}
return q.next;
};

const q=new ListNode(0);

let p1=l1;
let p2=l2;
let p3=q;

while(p1||p2)

const v1=p1?p1.val:0;
const v2=p2?p2.val:0;

const val=v1+v2;

carry=Math.floor(val/10);

const val=v1+v2+carry;

p3.next=new ListNode(val%10);

carry=Math.floor(val/10);
p3.next=new ListNode(val%10);

const val=v1+v2+carry;

if(p1)
{
    p1=p1.next;
}
if(p2)
{
    p2=p2.next;
}

if(carry)
{
    p3.next=new ListNode(carry);
}