快慢指针-高频算法面试题

前提

今天（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如下：

1. @Data

2. private static class Node {

3.  

4. /**

5. * 当前节点的值

6. */

7. private T value;

8.  

9. /**

10. * 下一个节点的引用

11. */

12. private Node next;

13. }

我们可以很轻易地构建一个单链表如下：

1. private static Node buildLinkedList(int len) {

2. Node head = new Node<>();

3. head.setValue("n1");

4. Node tail = head;

5. for (int i = 1; i < len; i++) {

6. Node node = new Node<>();

7. node.setValue("n" + (i + 1));

8. tail.setNext(node);

9. tail = node;

10. }

11. return head;

12. }

接着我们可以编写搜索中间节点的方法，先编写通过遍历链表进行长度计算，再遍历链表得到中间节点的「方案一」：

1. private static List searchByTraversal(Node head) {

2. List result = new ArrayList<>(2);

3. Node search = head;

4. int len = 1;

5. // 第一次遍历链表,计算链表长度

6. while (search.getNext() != null) {

7. search = search.getNext();

8. len++;

9. }

10. int index = 0;

11. int mid;

12. search = head;

13. // 链表长度为偶数

14. if ((len & 1) == 0) {

15. mid = len / 2 - 1;

16. while (search.getNext() != null) {

17. if (mid == index) {

18. result.add(search.getValue());

19. result.add(search.getNext().getValue());

20. }

21. search = search.getNext();

22. index++;

23. }

24. } else {

25. mid = (len - 1) / 2;

26. while (search.getNext() != null) {

27. if (mid == index) {

28. result.add(search.getValue());

29. }

30. search = search.getNext();

31. index++;

32. }

33. }

34. return result;

35. }

写个main方法试验一下：

1. public static void main(String[] args) throws Exception {

2. Node head = buildLinkedList(11);

3. System.out.println(searchByTraversal(head));

4. head = buildLinkedList(12);

5. System.out.println(searchByTraversal(head));

6. }

7.  

8. // 输出结果

9. [n6]

10. [n6, n7]

假设链表的长度为n（n > 0），那么进行两次遍历一共需要遍历的元素个数如下：

• 第一次遍历整个链表，计算长度，必须遍历n个元素。

• 第二次需要遍历n/2个元素（在n值比较大的时候，其实加减的影响不大）。

这种方案实现，最终的时间复杂度一定会大于O(n)。所以需要考虑优化方案，只需要遍历一次链表就能定位到中间的节点值，这个就是方案二：「快慢指针」。

「快慢指针」，简单来说就是定义两个指针，在遍历链表的时候，快指针（Fast Pointer）总是遍历两个元素，而慢指针（Slow Pointer）总是遍历一个元素。当快指针完成遍历整个链表的时候，慢指针刚好指向链表的中间节点。算法实现如下：

1. /**

2. * 基于快慢指针搜索

3. */

4. private static List searchByFastSlowPointer(Node head) {

5. List result = new ArrayList<>();

6. // fast pointer

7. Node fp = head;

8. // slow pointer

9. Node sp = head;

10. int len = 1;

11. while (null != fp.getNext()) {

12. if (fp.getNext().getNext() != null) {

13. fp = fp.getNext().getNext();

14. sp = sp.getNext();

15. len += 2;

16. } else {

17. fp = fp.getNext();

18. len += 1;

19. }

20. }

21. // 链表长度为偶数

22. if ((len & 1) == 0) {

23. result.add(sp.getValue());

24. result.add(sp.getNext().getValue());

25. } else {

26. result.add(sp.getValue());

27. }

28. return result;

29. }

写个main方法试验一下：

1. public static void main(String[] args) throws Exception {

2. Node head = buildLinkedList(11);

3. System.out.println(searchByFastSlowPointer(head));

4. head = buildLinkedList(12);

5. System.out.println(searchByFastSlowPointer(head));

6. }

7.  

8. // 输出结果

9. [n6]

10. [n6, n7]

由于使用了快慢指针的方案，只做了一次链表的遍历，并且由于快指针是每次两个元素进行遍历，最终的时间复杂度要小于O(n)。

快慢指针的应用场景

快慢指针主要有如下的应用场景：

1. 找到链表的中点。

2. 判断链表中是否存在环。

3. 删除链表中倒数第x个节点。

第一种情况已经作为复盘案例分析过，下面分析一下第二和第三种场景。

判断链表中是否存在环

假设链表有6个节点(head节点为n1，tail节点为n6)，已经形成环(n6的下一个节点为n1)：

j-a-l-f-l-3.png

使用快慢指针，快指针每次遍历会比慢指针多一个元素，这样子的话，如果链表已经成环，无论快指针和慢指针之间相隔多少个节点，快指针总是能够追上慢指针（快指针和慢指针指向同一个节点），这个时候就可以判断链表已经成环；否则快指针进行一轮遍历之后就会跳出循环，永远不可能和慢指针"重合"。简陋的实现如下：

1. // 判断链表是否存在环

2. private static boolean cyclic(Node head) {

3. // fast pointer

4. Node fp = head;

5. // slow pointer

6. Node sp = head;

7. while (fp.getNext() != null) {

8. fp = fp.getNext().getNext();

9. sp = sp.getNext();

10. if (sp.equals(fp)) {

11. return true;

12. }

13. }

14. return false;

15. }

16.  

17. // 生成环形链表

18. private static Node buildCyclicLinkedList(int len) {

19. Node head = new Node<>();

20. head.setValue("n1");

21. Node tail = head;

22. for (int i = 1; i < len; i++) {

23. Node node = new Node<>();

24. node.setValue("n" + (i + 1));

25. tail.setNext(node);

26. tail = node;

27. }

28. tail.setNext(head);

29. return head;

30. }

测试一下：

1. public static void main(String[] args) throws Exception {

2. Node head = buildCyclicLinkedList(11);

3. System.out.println(cyclic(head));

4. head = buildLinkedList(11);

5. System.out.println(cyclic(head));

6. }

7.  

8. // 输出结果

9. true

10. false

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

这个是LeetCode上的一道算法题，里面用到的是虚拟头结点加上快慢指针的方法，只进行一次遍历就能解决。这里引用获赞最多的回答里面的解决思路：

❝

上述算法可以优化为只使用一次遍历。我们可以使用两个指针而不是一个指针。第一个指针从列表的开头向前移动n+1步，而第二个指针将从列表的开头出发。现在，这两个指针被n个结点分开。我们通过同时移动两个指针向前来保持这个恒定的间隔，直到第一个指针到达最后一个结点。此时第二个指针将指向从最后一个结点数起的第n个结点。我们重新链接第二个指针所引用的结点的next指针指向该结点的下下个结点。

❞

算法推演图：

j-a-l-f-l-4.png

算法代码如下：

1. public ListNode removeNthFromEnd(ListNode head, int n) {

2. ListNode dummy = new ListNode(0);

3. dummy.next = head;

4. ListNode first = dummy;

5. ListNode second = dummy;

6. // Advances first pointer so that the gap between first and second is n nodes apart

7. for (int i = 1; i <= n + 1; i++) {

8. first = first.next;

9. }

10. // Move first to the end, maintaining the gap

11. while (first != null) {

12. first = first.next;

13. second = second.next;

14. }

15. second.next = second.next.next;

16. return dummy.next;

17. }

时间复杂度为O(L)，L为链表长度。

小结

鉴于算法比较弱，看到这些相对有实用价值的题目和解决方案，还是值得推演和学习一番。