Java算法——5找出单链表中的倒数第k个元素（遍历两次法、快慢指针法）

题目描述

找出单链表中的倒数第k个元素，如给定单链表：1→2→3→4→5→6→7，则单链表的倒数第k=3个元素为5.

方法一：顺序遍历两遍法

主要思路：首先遍历一遍单链表，求出整个单链表的长度n，然后把求倒数第k个元素转换为求顺数第n-k个元素，再去遍历一次单链表就可以得到结果。需要遍历两次单链表

方法二：快慢指针法

由于单链表只能从头到尾依次访问链表中的各个结点，因此如果要找单链表的倒数第k个元素，也只能从头到尾进行遍历查找。在查找过程中，设置两个指针，让其中一个指针比另外一个指针先前移k步，然后两个指针同时往前移动。循环直到先行的指针为null，时，另一个指针所指的位置就是所要找的位置。

class LNode {
    /**
     * 数据域
     */
    int data;
    /**
     * 下一个结点的引用
     */
    LNode next;
}

public class Test5 {
    public static LNode constructList(){
        /**
         * @Author: JavaRecord
         * @Description:构造一个单链表
         * @Param []
         * @Return linked.list1.LNode
         * @Date 2020/8/11
         * @Time 0:51
         */
        int i = 1;
        LNode head = new LNode();
        head.next = null;
        LNode tmp = null;
        LNode cur = head;
        //构造第一个链表
        for(;i<8;i++){
            tmp = new LNode();
            tmp.data = i;
            tmp.next = null;
            cur.next = tmp;
            cur = tmp;
        }
        return head;
    }

    public static void printList(LNode head){
        /**
         * @Author: JavaRecord
         * @Description:顺序打印列表
         * @Param [head]
         * @Return void
         * @Date 2020/8/11
         * @Time 0:54
         */
        for(LNode cur=head.next;cur!=null;cur=cur.next){
            System.out.print(cur.data+" ");
        }
    }

    public static LNode findLsatK(LNode head,int k){
        /**
         * @Author: JavaRecord
         * @Description:找出倒数第k个结点
         * @Param [head, k]
         * @Return linked.list1.LNode
         * @Date 2020/8/11
         * @Time 0:55
         */
        if(head==null || head.next==null){
            return head;
        }
        LNode slow, fast;
        slow = fast = head.next;
        int i;
        for(i=0;i<k&&fast!=null;i++){
            fast = fast.next;
        }
        //判断k是否已超出链表长度
        if(i<k){
            return null;
        }
        while (fast!=null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }

    public static void main(String[] args){
        LNode head = constructList();
        LNode result;
        System.out.print("链表：");
        printList(head);
        result = findLsatK(head,3);
        if(result!=null){
            System.out.println("\n链表倒数第三个元素为："+result.data);
        }
    }
}

程序运行结果：

链表：1 2 3 4 5 6 7 
链表倒数第三个元素为：5

算法性能分析

遍历一次，时间复杂度为O(N)。只需要常量个指针变量来保存结点的地址信息，因此，空间复杂度为O(1).