剑指offer:查找链表倒数第k个节点

题目： 输入一个链表和所要求的k，返回该链表的倒数第k个节点

解法1（快慢指针）

整体思路： 利用快慢指针，让快指针先走k步后，快慢指针再同步一起走，当快指针走到末尾的时候，此时慢指针的位置就是k节点的位置；
这里博主画图来解释快慢指针是如何找到倒数第k个节点的；

1. 我们假设数组是[1,2,3,4,5,6]，且K=3,即我们要找的节点为4；首先让快慢指针都为首节点

2. 接下来让快指针先走k步，慢指针停留在原地不动

3. 当快指针走到3的时候，则已经走了k步，接下来，我们要开始也让让慢指针走，且快慢指针每次都走一步

4. 快指针继续走到6的时候，则慢指针已经走到4，此时慢指针就是我们要找的节点，快指针继续走遇到null，退出

/**
 * 描述： 查找链表的倒数第k个节点
 *
 * @author pengjie_yao
 * @date 2019/8/2 14:00
 */
public class FindLastK {

    public static void main(String[] args) {
        ListNode node = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        ListNode node4 = new ListNode(4);
        ListNode node5 = new ListNode(5);
        ListNode node6 = new ListNode(6);
        node.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        ListNode lastKNode = findLastKNode(node, 3);
        if (lastKNode != null) {
            System.out.println(lastKNode.val);
        }else {
            System.out.println("请检查一下输入的链表是否为null或者k值是否大于链表长度");
        }

    }

    /**
     *  节点
     */
    public static class ListNode {

        int val;
        ListNode next;

        public ListNode(int val) {
                this.val = val;
        }
    }

    /**
     *  查找链表的第k个节点
     * @param head
     * @param k
     * @return
     */
    public static ListNode findLastKNode(ListNode head, int k){

        // 1.判空
        if (head == null || k == 0) {
            return null;
        }
        // 2.定义两个指针，分别为快指针和慢指针
        ListNode fast = head;
        ListNode slower = head;
        int count = 0;
        // 3.遍历链表，快指针先走k-1步后慢指针再走，如果快指针为空，则此时慢指针就是dik个节点
        while (fast != null) {
            if (count > k - 1) {
                slower = slower.next;
            }
            count++;
            fast = fast.next;
        }
        // 3.如果k是大于链表长度的话
        if(count < k) {
            return null;
        }
        // 4.返回节点值
        return slower;

}

}

解法2:(使用辅助栈）
思路：

1. 利用栈的"先进后出"特性，我们将遍历的元素放入栈中，则首节点肯定在栈尾，最后一个出栈

2. 我们遍历栈中元素，即倒数第k个节点我们则很快找到，只要遍历k次即可

/**
 *  使用辅助栈
 *  时间辅助度为O(n)
 * @param head
 * @param k
 * @return
 */
public static ListNode findLastKNode1(ListNode head, int k) {
    // 1.判空
    if (head == null || k == 0) {
        return null;
    }

    // 2.定义栈，用来存储链表中的节点
    Stack<ListNode> stack = new Stack();
    ListNode node = head;

    // 3.遍历链表，将节点放入栈中
    while (node != null) {
        stack.push(node);
        node = node.next;
    }
    // 4. 中栈中遍历第k个节点
    while (k > 0) {
        node = stack.pop();
        k--;
    }
    return node;
}