删除链表的倒数第N个节点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

// 快慢双指针

var removeNthFromEnd = function(head, n) {
  let star = new ListNode(0)//设置一个虚拟头结点指向原头结点，最后返回star.next即可
  star.next = head
  let left = star,right = star
  // right先走n步
  while(n){
    n--
    right = right.next
  }

  // right先走n步后right、left一起走，直到right走到最后一位（right.next=null）
  while(right.next){
    left = left.next
    right = right.next
  }

  // right走到最后一位,此时left指向的是要删除的节点的前一个节点
  // 将此时结点指向下一个结点的下一个结点，即删除了此时节点的下一个节点（目标结点）
  left.next = left.next.next

  return star.next
}

反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

var reverseList = function(head) {
    let prev = null,curr = head
    while(curr){
        let next = curr.next
        curr.next = prev
        prev = curr
        curr = next
    }
    console.log(head)
    return prev
};

合并两个有序链表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

var mergeTwoLists = function(l1, l2) {
    let head = new ListNode(0)//设置一个头结点，并保存在这里，方便后续输出结果链表
    let prev = head//设置一个指针初始化指向头结点，比较大小向后移动

    while(l1!=null&&l2!=null){//当l1、l2都不为空时进行比较
        if(l1.val<l2.val){
            prev.next = l1
            l1=l1.next
        }else{
            prev.next = l2
            l2 = l2.next
        }
        prev = prev.next
    }

    prev.next = l1==null?l2:l1//当l1为空时，把剩余的l2追加到合并链表的后面

    return head.next
};

回文链表

请判断一个链表是否为回文链表。
示例 1:
输入: 1->2->2->1
输出: true

// 转成数组，通过快慢指针判断
var isPalindrome = function(head) {
    let arr = []
    while(head){//先把链表遍历到数组里
        arr.push(head.val)
        head = head.next
    }
    console.log(arr)
    let left = 0,right = arr.length-1
    while(left<right){
        if(arr[left]!=arr[right]){
            console.log('111')
            return false
        }else{
            left++
            right--
        }
    }
    console.log(arr)
    return true
};
// 这个是看了大佬的解题，很棒

var isPalindrome = function(head) {
    let a = '',b = ''
    while(head){
        a=a+head.val
        b=head.val+b
        head = head.next
    }
    console.log(a,b)
    return a==b
};

环形链表

给定一个链表，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。否则，返回 false 。

// 设置快慢指针，如果
var hasCycle = function(head) {
    let p1=head,p2=head.next
    while(p2){
        p1 = p1.next
        p2 = p2.next
        if(p1==p2){
            return true
        }
    }
    return false
};