一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第16天，点击查看活动详情。

环形链表

给你一个链表的头节点 head ，判断链表中是否有环。

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

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

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

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

/**
 * @param {ListNode} head
 * @return {boolean}
 */
var hasCycle = function(head) {
  
};

快慢指针法

慢指针针每次走一步，快指针每次走两步，如果相遇就说明有环，如果有一个为空说明没有环。代码比较简单

var hasCycle = function(head) {
  let fast = head, slow = head

  while(fast !== null && fast.next !== null) {
    fast = fast.next.next
    slow = slow.next

    if (fast === slow) {
      return true
    }
  }

  return false
};

map法

如果在map中出现过了，证明是个环

var hasCycle = function(head) {
  const map = new Map()

  while(head !== null) {
      if (map.has(head)) {
          return true
      }
      map.set(head)
      head = head.next
  }

  return false
};

回文链表

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

输入：head = [1,2,2,1]
输出：true

输入：head = [1,2]
输出：false

提示：

链表中节点数目在范围[1, 105] 内
0 <= Node.val <= 9

进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {boolean}
 */
var isPalindrome = function(head) {
    
};

双端队列法（不推荐）

循环，把链表的值存入
然后把值取出来判断即可

/**
 * @param {ListNode} head
 * @return {boolean}
 */
var isPalindrome = function(head) {
    const deque = []
    while(head !== null) {
        deque.push(head.val)
        head = head.next
    }
    if (deque.length === 1) return true
    for (let i = 0, len = Math.floor(deque.length / 2); i < len; i++) {
        const prevVal = deque.shift()
        const endVal = deque.pop()
        if (prevVal !== endVal) {
            return false
        }
    }
    return true
};

栈

var isPalindrome = function(head) {
    const stack = []
    let temp = head
    while(temp !== null) {
        stack.push(temp.val)
        temp = temp.next
    }
    while(head !== null) {
        if (head.val !== stack.pop()) {
            return false
        }
        head = head.next
    }
    return true
};

这里相当于链表从前往后全部都比较了一遍，其实我们只需要拿链表的后半部分和前半部分比较即可，没必要全部比较，所以这里可以优化一下

var isPalindrome = function(head) {
    const stack = []
    let temp = head
    while(temp !== null) {
        stack.push(temp.val)
        temp = temp.next
    }
    let len = Math.floor(stack.length / 2)
    while(len -- >= 0) {
        if (head.val !== stack.pop()) {
            return false
        }
        head = head.next
    }
    return true
};

反转后半部分链表（用时最少，空间最小）

这题是让判断链表是否是回文链表，所谓的回文链表就是以链表中间为中心点两边对称。我们常见的有判断一个字符串是否是回文字符串，这个比较简单，可以使用两个指针，一个最左边一个最右边，两个指针同时往中间靠，判断所指的字符是否相等。

但这题判断的是链表，因为这里是单向链表，只能从前往后访问，不能从后往前访问，所以使用判断字符串的那种方式是行不通的。但我们可以通过找到链表的中间节点然后把链表后半部分反转），最后再用后半部分反转的链表和前半部分一个个比较即可。这里以示例2为例画个图看一下。

var isPalindrome = function(head) {
    let fast = head, slow = head;
    // 快的走两步，慢的走一半，最终慢的就走到一半
    while(fast !== null && fast.next !== null) {
        fast = fast.next.next
        slow = slow.next
    }
    // 反转后半部分
    slow = reverseList(slow)

    // 循环比较
    while(slow !== null) {
        if (head.val !== slow.val) {
            return false
        }
        slow = slow.next
        head = head.next
    }
    return true
};
// 反转链表
const reverseList = (head) => {
    let newList = null
    while(head) {
        const temp = head.next
        head.next = newList
        newList = head
        head = temp
    }
    return newList
}

来一起刷简单算法题[九] 链表