前提
今天(2019-05-10
)中午吃饭的时候刷了下技术类型的公众号,看到有前辈过了Ant
的高P
面试,其中有一道题考查了单链表搜索位于中间的节点的算法。看着算法就饭,觉得解决方案很有趣,于是这里尝试重现一下。
场景
面试官:如何访问链表中间节点?
大佬X:简单地实现,遍历一遍整个的链表,然后计算出链表的长度,进而遍历第二遍找出中间位置的数据。
面试官:要求只能遍历一次链表,那又当如何解决?
大佬X:可以采取建立两个指针,一个指针一次遍历两个节点,另一个节点一次遍历一个节点,当快指针遍历到空节点时,慢指针指向的位置为链表的中间位置,这里解决问题的算法称为「快慢指针」。
复盘
我们先设定单链表的长度大于等于3,这样子比较容易分析算法。先简单假设一个长度为3的单链表如下:
j-a-l-f-l-1.png
如果我们要访问中间节点,最终搜索到的应该是n2
节点,内容就是n2
。
如果单链表的长度为偶数,这里假设为4,那么如下:
j-a-l-f-l-2.png
如果我们要访问中间节点,最终搜索到的应该是n2
和n3
节点,内容就是n2
和n3
。
先定义好节点类Node
如下:
-
@Data
-
private static class Node<T> {
-
/**
-
* 当前节点的值
-
*/
-
private T value;
-
/**
-
* 下一个节点的引用
-
*/
-
private Node<T> next;
-
}
我们可以很轻易地构建一个单链表如下:
-
private static Node<String> buildLinkedList(int len) {
-
Node<String> head = new Node<>();
-
head.setValue("n1");
-
Node<String> tail = head;
-
for (int i = 1; i < len; i++) {
-
Node<String> node = new Node<>();
-
node.setValue("n" + (i + 1));
-
tail.setNext(node);
-
tail = node;
-
}
-
return head;
-
}
接着我们可以编写搜索中间节点的方法,先编写通过遍历链表进行长度计算,再遍历链表得到中间节点的「方案一」:
-
private static List<String> searchByTraversal(Node<String> head) {
-
List<String> result = new ArrayList<>(2);
-
Node<String> search = head;
-
int len = 1;
-
// 第一次遍历链表,计算链表长度
-
while (search.getNext() != null) {
-
search = search.getNext();
-
len++;
-
}
-
int index = 0;
-
int mid;
-
search = head;
-
// 链表长度为偶数
-
if ((len & 1) == 0) {
-
mid = len / 2 - 1;
-
while (search.getNext() != null) {
-
if (mid == index) {
-
result.add(search.getValue());
-
result.add(search.getNext().getValue());
-
}
-
search = search.getNext();
-
index++;
-
}
-
} else {
-
mid = (len - 1) / 2;
-
while (search.getNext() != null) {
-
if (mid == index) {
-
result.add(search.getValue());
-
}
-
search = search.getNext();
-
index++;
-
}
-
}
-
return result;
-
}
写个main方法试验一下:
-
public static void main(String[] args) throws Exception {
-
Node<String> head = buildLinkedList(11);
-
System.out.println(searchByTraversal(head));
-
head = buildLinkedList(12);
-
System.out.println(searchByTraversal(head));
-
}
-
// 输出结果
-
[n6]
-
[n6, n7]
假设链表的长度为n
(n > 0
),那么进行两次遍历一共需要遍历的元素个数如下:
-
第一次遍历整个链表,计算长度,必须遍历
n
个元素。 -
第二次需要遍历
n/2
个元素(在n
值比较大的时候,其实加减的影响不大)。
这种方案实现,最终的时间复杂度一定会大于O(n)
。所以需要考虑优化方案,只需要遍历一次链表就能定位到中间的节点值,这个就是方案二:「快慢指针」。
「快慢指针」,简单来说就是定义两个指针,在遍历链表的时候,快指针(Fast Pointer
)总是遍历两个元素,而慢指针(Slow Pointer
)总是遍历一个元素。当快指针完成遍历整个链表的时候,慢指针刚好指向链表的中间节点。算法实现如下:
-
/**
-
* 基于快慢指针搜索
-
*/
-
private static List<String> searchByFastSlowPointer(Node<String> head) {
-
List<String> result = new ArrayList<>();
-
// fast pointer
-
Node<String> fp = head;
-
// slow pointer
-
Node<String> sp = head;
-
int len = 1;
-
while (null != fp.getNext()) {
-
if (fp.getNext().getNext() != null) {
-
fp = fp.getNext().getNext();
-
sp = sp.getNext();
-
len += 2;
-
} else {
-
fp = fp.getNext();
-
len += 1;
-
}
-
}
-
// 链表长度为偶数
-
if ((len & 1) == 0) {
-
result.add(sp.getValue());
-
result.add(sp.getNext().getValue());
-
} else {
-
result.add(sp.getValue());
-
}
-
return result;
-
}
写个main方法试验一下:
-
public static void main(String[] args) throws Exception {
-
Node<String> head = buildLinkedList(11);
-
System.out.println(searchByFastSlowPointer(head));
-
head = buildLinkedList(12);
-
System.out.println(searchByFastSlowPointer(head));
-
}
-
// 输出结果
-
[n6]
-
[n6, n7]
由于使用了快慢指针的方案,只做了一次链表的遍历,并且由于快指针是每次两个元素进行遍历,最终的时间复杂度要小于O(n)
。
快慢指针的应用场景
快慢指针主要有如下的应用场景:
-
找到链表的中点。
-
判断链表中是否存在环。
-
删除链表中倒数第
x
个节点。
第一种情况已经作为复盘案例分析过,下面分析一下第二和第三种场景。
判断链表中是否存在环
假设链表有6个节点(head节点为n1,tail节点为n6),已经形成环(n6的下一个节点为n1):
j-a-l-f-l-3.png
使用快慢指针,快指针每次遍历会比慢指针多一个元素,这样子的话,如果链表已经成环,无论快指针和慢指针之间相隔多少个节点,快指针总是能够追上慢指针(快指针和慢指针指向同一个节点),这个时候就可以判断链表已经成环;否则快指针进行一轮遍历之后就会跳出循环,永远不可能和慢指针"重合"。简陋的实现如下:
-
// 判断链表是否存在环
-
private static boolean cyclic(Node<String> head) {
-
// fast pointer
-
Node<String> fp = head;
-
// slow pointer
-
Node<String> sp = head;
-
while (fp.getNext() != null) {
-
fp = fp.getNext().getNext();
-
sp = sp.getNext();
-
if (sp.equals(fp)) {
-
return true;
-
}
-
}
-
return false;
-
}
-
// 生成环形链表
-
private static Node<String> buildCyclicLinkedList(int len) {
-
Node<String> head = new Node<>();
-
head.setValue("n1");
-
Node<String> tail = head;
-
for (int i = 1; i < len; i++) {
-
Node<String> node = new Node<>();
-
node.setValue("n" + (i + 1));
-
tail.setNext(node);
-
tail = node;
-
}
-
tail.setNext(head);
-
return head;
-
}
测试一下:
-
public static void main(String[] args) throws Exception {
-
Node<String> head = buildCyclicLinkedList(11);
-
System.out.println(cyclic(head));
-
head = buildLinkedList(11);
-
System.out.println(cyclic(head));
-
}
-
// 输出结果
-
true
-
false
删除链表中倒数第N个节点
这个是LeetCode
上的一道算法题,里面用到的是虚拟头结点加上快慢指针的方法,只进行一次遍历就能解决。这里引用获赞最多的回答里面的解决思路:
❝上述算法可以优化为只使用一次遍历。我们可以使用两个指针而不是一个指针。第一个指针从列表的开头向前移动n+1步,而第二个指针将从列表的开头出发。现在,这两个指针被n个结点分开。我们通过同时移动两个指针向前来保持这个恒定的间隔,直到第一个指针到达最后一个结点。此时第二个指针将指向从最后一个结点数起的第n个结点。我们重新链接第二个指针所引用的结点的next指针指向该结点的下下个结点。
❞
算法推演图:
j-a-l-f-l-4.png
算法代码如下:
-
public ListNode removeNthFromEnd(ListNode head, int n) {
-
ListNode dummy = new ListNode(0);
-
dummy.next = head;
-
ListNode first = dummy;
-
ListNode second = dummy;
-
// Advances first pointer so that the gap between first and second is n nodes apart
-
for (int i = 1; i <= n + 1; i++) {
-
first = first.next;
-
}
-
// Move first to the end, maintaining the gap
-
while (first != null) {
-
first = first.next;
-
second = second.next;
-
}
-
second.next = second.next.next;
-
return dummy.next;
-
}
时间复杂度为O(L)
,L
为链表长度。
小结
鉴于算法比较弱,看到这些相对有实用价值的题目和解决方案,还是值得推演和学习一番。