【夏弈的解题记录】快慢指针的典型应用——定位给定单向链表的倒数第n的节点

前言

　　快慢指针是指使用两个指针进行定位，一个指针在前，称之为“快指针”，一个指针在后，称之为“慢指针”。通常的用法是，使用快指针进行定位，使用慢指针记录我们需要的目标。

　　下面将会介绍快慢指针的一个典型应用。

 

1. 题目

　　原题：力扣 剑指 Offer 22. 链表中倒数第k个节点

　　

 

 

 　链表节点的定义：

　　　　

 

2. 解题思路

　　对于一个单向链表而言，如果要定位它的倒数第n个节点，首先就要定位尾节点。

　　最容易想到也最容易实现的做法就是，先遍历一遍链表，确定链表节点的数量k，那么倒数第n个节点就是正数第 k-n+1 个节点（从1开始计数）。确定好目标节点的正向位置后，再从头遍历并计数，直到遍历到第 k-n+1 个节点，返回这个节点即可。

　　这个思路没有问题，实现起来也特别简单。问题是，在这个过程中，我们需要遍历两遍链表，整个算法的时间复杂度达到了 O(2n)（n为链表长度)。

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        int sum=0;
        ListNode node=head;
        while(node!=null){
            sum++;
            node=node.next;
        }
        for(int i=1;i<sum-k+1;i++){
            head=head.next;
        }
        return head;
    }
}　

 

3. 使用快慢指针优化查找过程

　　我们可以使用快慢指针记录节点，从而在一次遍历中定位到倒数第n个节点。首先，我们定位一个快指针指向链表的头部，然后移动这个指针，直到该指针移动到链表的第n个节点上（从1开始），然后我们再定义一个慢指针，它指向链表的头节点。这样，这个慢指针指向的节点就是相对快指针指向的节点的前向第n个节点。然后我们开始一起移动两个指针，每次都一起后移一位，直到快指针移动到尾节点，这时，慢指针所指向的节点就是整个链表的倒数第n个节点。

　　使用快慢指针遍历寻找链表的倒数第n个节点，由于仅需要一次遍历，因此时间复杂度达到了O(n)。

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode node=head;
        for(int i=1;i<=k;i++){
            head=head.next;
        }
        while(head!=null){
            head=head.next;
            node=node.next;
        }
        return node;
    }
}

 

4. 扩展

　　上面我们介绍了使用快慢指针定位倒数第n个节点的实现方式。但就解决这个问题而言，我们还可以使用栈和队列来实现时间复杂度O(k+n)的算法（其中k为链表长度，n为节点的倒数位置）。

　　1）使用栈实现

　　我们知道，栈是先进后出的数据结构，因此，我们可以在一边遍历中，每遍历到一个节点就将这个节点存入一个栈中，直到遍历完整个链表，此时栈中就存储了整个链表的所有节点（而且是倒序的）。接下来我们只需要依次从栈中取出节点就好了，因为栈的特性，因此我们取出节点的顺序其实是从尾节点向头结点反向逐个取出。因此，只要在取节点的过程中进行计数，当计数达到n时，我们取出的这个节点就是链表的倒数第n个节点。

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        Stack<ListNode> stack=new Stack<>();
        ListNode node=head;
        while(node!=null){
            stack.push(node);
            node=node.next;
        }
        for(int i=1;i<=k;i++){
            node=stack.pop();
        }
        return node;
    }
}

　　

　　2）使用队列实现

　　但是这个说的队列是双向队列，单向队列的做法和二次遍历几乎没有任何区别，还浪费了一份空间来存储节点的引用。所以我们使用Deque来存储节点，因为Deque是一个双向队列，本质上而言，我们就相当于把原本的单向链表变成了一个双向链表，这样当我们定位到尾节点以后就可以向前移动n-1次从而定位到倒数第n个节点。

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        Deque<ListNode> queue=new LinkedList<>();
        ListNode node=head;
        while(node!=null){
            queue.push(node);
            node=node.next;
        }
        for(int i=1;i<=k;i++){
            node=queue.pop();
        }
        return node;
    }
}

 

　　当链表不大时，使用队列和栈的方式相比两次遍历并没有明显的提升，并且因为要维护一个栈/队列来存储节点的引用反而浪费了性能。但当链表很长时，这种做法带来的收益就是肉眼可见的了。