leetcode题目解析(js)--链表

206. 反转链表

反转一个单链表。

示例：

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

解法：

var reverseList = function(head) {let cur = head, prev = nullwhile(cur) {[cur.next, prev, cur] = [prev, cur, cur.next]}return prev
};
复制代码

思路分析：prev保存前一个节点，主要逻辑分三步：

修改cur的next，指向前一个节点，即prev
保存当前节点cur为prev，供下一个节点使用
移动当前节点指针cur到下一个节点cur.next

24. 两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例：

给定 1->2->3->4, 你应该返回 2->1->4->3.

解法一：

var swapPairs = function(head) {let node = new ListNode(0) //新建一个节点，用于保存head节点node.next = headlet prev = nodewhile(prev.next && prev.next.next) {let a = prev.nextlet b = a.nextprev.next = a.nexta.next = b.nextprev = b.next = a}return node.next
};
复制代码

解题思路：定义一个新的头节点node,将头节点next指向head，定义prev, a, b分别指向前三项，第一遍循环如下图：

循环过程中node始终指向自定义的头结点，而node.next即为真正的头节点。
遍历第二遍时，a, b分别指向3，4，执行流程同上，执行完第二遍即结束循环。

解法二：

var swapPairs = function(head) {if(!head) return nullif(!head.next) return headlet temp = head.nexthead.next = swapPairs(temp.next)temp.next = headreturn temp
};
复制代码

解题思路：主要逻辑是head.next指向递归返回的上一个temp,同时修改temp.next为head,实现后一个节点指向前一个节点，同时前一个节点指向递归返回的节点，最后swapPairs接收到的就是最后返回的temp，即第二个节点2.

141. 环形链表

给定一个链表，判断链表中是否有环。

示例：

输入：head = [3,2,0,-4], 输出：true

解法一：使用快慢指针，快指针每次走两步，慢指针每次走一步，如果有环，二者必定会碰到一起；

var hasCycle = function(head) {let fast = slow = headwhile(fast && slow && fast.next) { //fast.next不存在说明链表已走完slow = slow.nextfast = fast.next.nextif(fast === slow) {return true}}return false
};
复制代码

解法二：使用Set保存每个节点的地址，如果有环，Set里元素必定会重复；

var hasCycle = function(head) {let set = new Set()while(head) {if(set.has(head)) return trueset.add(head)head = head.next}return false
};
复制代码

142. 环形链表 II

给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null

示例：

输入：head = [3,2,0,-4]
输出：tail connects to node index 1

解法一：

var detectCycle = function(head) {let set = new Set()let cur = headwhile(cur) {if(set.has(cur)) return curset.add(cur)cur = cur.next}return null
};
复制代码

解题思路：用Set保存每次遍历的地址，遍历时发现地址重复即为入口节点

解法二：

var detectCycle = function(head) {let fast = slow = headwhile(slow && fast && fast.next) {slow = slow.nextfast = fast.next.nextif(slow === fast) {slow = headwhile(slow !== fast) {slow = slow.nextfast = fast.next}return fast}}return null
};
复制代码

解题思路：

先用快慢指针方法确定链表是否有环
如果有环的，慢指针slow重新从head出发，slow,fast每次都走一步，如果重合，重合处必为环的入口;

入口解释一下：

首先第一次遍历后假设在C点相遇，此时：

慢指针走的S1 = |AB| + |BC|
快指针走的S2 = 2 * ( |AB| + |BC| )

在另一个角度，S2 走的距离就是 |AB| + |BC| + n * s (s为环的大小),即

快指针走的S2 = |AB| + |BC| + n * s

所以可以得到

2 * ( |AB| + |BC| ) = |AB| + |BC| + n * s
可以得到：|AB| = n * s - |BC|

可以看出如果slow从A点开始，fast从相遇点C开始，两者以同样速度必会在B点相遇