链表
链表是数据结构里一个很基础可是又很爱考的线性结构，链表的操做相对来讲比较简单，可是很是适合考察面试者写代码的能力，以及对 corner case 的处理，还有指针的应用很容易引发 NPE (null pointer exception)。综合以上缘由，链表在面试中很重要。java
提到链表就不得不提数组，它和数组能够说是数据结构的基础，那么它们最主要的区别在于：node
- 数组在物理内存上必须是连续的
- 链表在物理内存上不须要连续，经过指针链接
因此数组最好的性质就是能够随机访问 random access，有了 index，能够 O(1) 的时间访问到元素。面试
而链表由于不连续，因此没法 O(1) 的时间定位任意一个元素的位置，那么就只能从头开始遍历。算法
这就形成了它们之间增删改查上效率的不一样。数组
除此以外，链表自己的结构与数组也是彻底不一样的。数据结构
LinkedList 是由 ListNode 来实现的：dom
class ListNode {
int value;
ListNode next;
}
结构上长这样：学习
这是单向链表，那还有的链表是双向链表，也就是还有一个 previous pointer 指向当前 node 的前一个 node：翻译
class ListNode {
int value;
ListNode next;
ListNode prev;
}
其实链表相关的题目没有很难的，套路也就这么几个，其中最常考最基础的题目是反转链表，据说微软能够用这道题电面刷掉一半的 candidate，两种方法一遍 bug free 仍是不容易的。文章以前已经写过了，点击这里直达复习。设计
今天咱们来讲链表中最主要的 2 个技巧：双指针法和 dummy node，相信看完本文后，链表相关的绝大多数题目你都能搞定啦。
双指针法
双指针法在不少数据结构和题型中都有应用，在链表中用的最多的仍是快慢指针。
顾名思义，两个指针一个走得快，一个走得慢，这样的好处就是以不一样的速度遍历链表，方便找到目标位置。
常见的问题好比找一个链表的中点，或者判断一个链表是否有环。
例 1：找中点
这题就是给一个链表，而后找到它的中点，若是是奇数个很好办，若是是偶数个，题目要求返回第二个。
好比：
1 -> 2 -> 3 -> 4 -> 5 -> NULL，须要返回 3 这个 ListNode；
1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULL，须要返回 4 这个 ListNode。
但其实吐槽一下，若是真的要设计一个这样的 API，我更倾向于选择返回偶数个中的第一个中点。
为何呢？
算法题都是工业生产中一些问题的抽象。好比说咱们找中点的目的是为了把这个链表断开，那么返回了 3，我能够断开 3 和 4；可是返回了 4，单向链表我怎么断开 4 以前的地方呢？还得再来一遍，麻烦。
Solution
方法1、
这题最直观的解法就是能够先求这个链表的长度，而后再走这个长度的一半，获得中点。
class Solution {
public ListNode middleNode(ListNode head) {
if(head == null) {
return null;
}
int len = 0;
ListNode current = head;
while(current != null) {
len++;
current = current.next;
}
len /= 2;
ListNode result = head;
while(len > 0) {
result = result.next;
len--;
}
return result;
}
}
方法2、快慢指针
咱们用两个指针一块儿来遍历这个链表，每次快指针走 2 步，慢指针走 1 步，这样当快指针走到头的时候，慢指针应该恰好在链表的中点。
class Solution {
public ListNode middleNode(ListNode head) {
ListNode slow = head;
ListNode fast = head;
while(fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
return slow;
}
}
这两个方法孰优孰劣呢？
网上不少说什么方法一过了两遍链表，方法二只过了一遍。
但其实，可是方法二用了两个指针来遍历，因此两个方法过的遍数都是同样的。
它们最大的区别是：
方法一是 offline algorithm，方法二是 online algorithm。
公司里的数据量是源源不断的，好比电商系统里总有客户在下单，社交软件里的好友增加是一直在涨的，这些是数据流 data stream，咱们是没法计算数据流的长度的。
那么 online algorithm 可以给时刻给出当前的结果，不用说等数据所有录入完成后，实际上也录不完。。这是 online algorithm 比 offline algorithm 大大的优点所在。
更多的解释你们能够参考 stack overflow 的这个问题，连接在文末。
例 2：判断单链表是否有环
思路：快慢指针一块儿从 head 出发，每次快指针走 2 步，慢指针只走 1 步，若是存在环，那么两个指针必定会相遇。
这题是典型的龟兔赛跑，或者说在操场跑圈时，跑的快的同窗总会套圈跑的慢的。
public class Solution {
public boolean hasCycle(ListNode head) {
ListNode slow = head;
ListNode fast = head;
while(fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
if(slow == fast) {
return true;
}
}
return false;
}
}
这题有个升级版，就是要求返回环的起点。
例 3：返回有环链表的环的起点
这题我感受不全是个算法题了，仍是个数学题哈哈。
先摆出结论：
- 快慢指针从链表头开始走，相遇的那点，记为 M；
- 再用 2 个指针，一个从头开始走，一个从 M 开始走，相遇点即为 cycle 的起点。
咱们先看抽象出来的图：
假设快慢指针在 M 点第一次相遇，
这里咱们设 3 个变量来表示这个链表里的几个重要长度：
- X：从链表头到环的起点的长度；
- Y：从环的起点到 M 点的长度；
- Z：从 M 点到环的起点的长度。
注意：由于环是有方向的，因此 Y 并非 Z。
那其实咱们惟一知道的关系就是：快慢指针在 M 点第一次相遇。这也是咱们最初假设的关系。
而快慢指针有一个永远不变的真理：快指针走的长度永远是慢指针走的长度的 2 倍。
相遇时快慢指针分别走了多少的长度呢？
- 快指针：X+ Y + 假设走了 k 圈
- 慢指针：X + Y
那么咱们就能够用这个 2 倍的关系，列出下列等式：
2 * (X + Y) = X + Y + kL
因此 X + Y = kL
而咱们注意到：Y + Z = L，那么就能得出 X = Z。
因此当两个指针，一个从头开始走，一个从 M 点开始走时，相遇那点就是环的起点，证毕。
来看下代码吧：
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode slow = head;
ListNode fast = head;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
if (slow == fast) {
ListNode x = head;
ListNode y = slow;
while(x != y) {
x = x.next;
y = y.next;
}
return x;
}
}
return null;
}
}
这题还有个应用，就是找一个特定数组里重复的数字，这里就不展开了，你们感兴趣的去作一下吧～
接下来咱们聊聊 dummy node 这个技巧。
Dummy node
Dummy 的中文是“假”的意思，dummy node 大概能够翻译成虚拟节点？有更地道的说法的话还请你们在评论区告诉我呀～
通常来讲，dummy node 的用法是在链表的真实 head 的前面加一个指向这个 head 的节点，目的是为了方便操做 head。
对于链表来讲，head 是一个链表的灵魂，由于不管是查询仍是其余的操做都须要从头开始，俗话说擒贼先擒王嘛，抓住了一个链表的头，就抓住了整个链表。
因此当须要对现有链表的头进行改动时，或者不肯定头部节点是哪一个，咱们能够预先加一个 dummyHead，这样就能够灵活处理链表中的剩余部分，最后返回时去掉这个“假头”就行了。
不少时候 dummy node 不是必须，可是用了会很方便，减小 corner case 的讨论，因此仍是很是推荐使用的。
光说不练假把式，咱们直接来看题～
例 4：合并两个排好序的链表
这题有不少种解法，好比最直观的就是用两个指针，而后比较大小，把小的接到最终的结果上去。
可是有点麻烦的是，最后的结果不知道到底谁是头啊，是哪一个链表的头做为了最终结果的头呢？
这种状况就很是适合用 dummy node。
先用一个虚拟的头在这撑着，把整个链表构造好以后，再把这个假的剔除。
来看代码～
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if (l1 == null) {
return l2;
}
if (l2 == null) {
return l1;
}
ListNode dummy = new ListNode(0);
ListNode ptr = dummy;
while (l1 != null && l2 != null) {
if (l1.val < l2.val) {
ptr.next = l1;
l1 = l1.next;
} else {
ptr.next = l2;
l2 = l2.next;
}
ptr = ptr.next;
}
if (l1 == null) {
ptr.next = l2;
} else {
ptr.next = l1;
}
return dummy.next;
}
}
这题也有升级版，就是合并 k 个排好序的链表。本质上也是同样的，只不过须要重写一下比较器就行了。
例 5：删除节点
这道题的意思是删除链表中某个特定值的节点，可能有一个可能有多个，可能在头可能在尾。
若是要删除的节点在头的时候，新链表的头就不肯定了，也有多是个空的。。此时就很适合用 dummy node 来作，规避掉这些 corner case 的讨论。
那这题的思路就是：用 2 个指针
- prev：指向当前新链表的尾巴
- curr：指向当前正在遍历的 ListNode
若是 curr == 目标值，那就直接移到下一个；
若是 curr != 目标值，那就把 prev 指向它，接上。
这题须要注意的是，最后必定要把 prev.next 指向 null，不然若是原链表的尾巴是目标值的话，仍是去不掉。
代码以下：
class Solution {
public ListNode removeElements(ListNode head, int val) {
ListNode dummy = new ListNode(0);
ListNode prev = dummy;
ListNode curr = head;
while(curr != null) {
if (curr.val != val) {
prev.next = curr;
prev = prev.next;
}
curr = curr.next;
}
prev.next = null;
return dummy.next;
}
}
好了，以上就是本文的全部内容了，若是这篇文章对你有帮助，欢迎分享给你身边的朋友，也给齐姐点个「在看」，大家的支持是我创做的最大动力！
悄悄话
最近开通了视频号，精力分散了许多，没想到录个 1 分钟的短视频也能这么多事。。
可是公众号照常分享技术干货和《齐姐聊大厂》系列，还请你们继续关注支持呀，为了保证内容的优质在线，可能准备时间有点长，多谢你们的耐心等待～～若是想我了就来视频号里找我玩～
最后，若是你对小齐的文章或者视频有什么想法或建议，欢迎留言或者私信与我多多交流，我是小齐，终生学习者，咱们下期见！