华为OJ——输出单向链表中倒数第k个结点

题目描述

　　输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第1个结点为链表的尾指针。
链表结点定义如下：
　　 struct ListNode
　　{
　　　 int m_nKey;
　　　 ListNode* m_pNext;
　　};

• 详细描述：

  　接口说明
  　　　原型：
  　　　　　ListNode* FindKthToTail(ListNode* pListHead, unsignedint k);
  　输入参数：
  　　　　　ListNode* pListHead 单向链表
  　　　　　unsigned int k 倒数第k个结点
  　
  　输出参数（指针指向的内存区域保证有效）：
  　　　　　无
  　返回值：
  　　　　正常返回倒数第k个结点指针，异常返回空指针

• 输入描述:

  　输入说明：
  　　　1 输入链表结点个数
  　　　2 输入链表的值
  　　　3 输入k的值
  　输出描述:
  　　　输出一个整数

• 示例1

  　输入

  　　　8
  　　　1 2 3 4 5 6 7 8
  　　　4
  　输出

  　　　5
  　

实现代码：

package cn.c_shuang.demo49;

import java.util.Scanner;

/**
 * 输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第0个结点为链表的尾指针。
 * @author Cshuang
 *
 */
public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int num = in.nextInt();
            int[] values = new int[num];
            for (int i = 0; i < num; i++) {
                values[i]=in.nextInt();
            }
            int k = in.nextInt();
            //初始化链表
            Node head = createList(values);
            //找到倒数第K个链表节点
            if(k==0){
                System.out.println(0);
            }else{
                Node result = lastKValueList(head, k);
                System.out.println(result.value);
            }

        }
        in.close();

    }
     public static Node createList(int[] values) {
         if(values.length<=0){
             return null;
         }
         Node head = new Node(values[0]);//创建头节点
         Node temp = head;//将头节点对象的地址赋值给temp
         for(int i=1;i<values.length;i++){
             temp.next = new Node(values[i]);//实际上指明了头结点的next节点
             temp = temp.next;//将下一个结点，赋值给temp,即对下一个结点操作
         }
         return head;//得到一个以head为头结点的单向链表，有点递归的味道
     }

     public static Node lastKValueList(Node head, int k) {
         Node fast = head;
         Node slow = head;

         for(int i=0;i<k-1;i++){
             fast = fast.next;//先顺着数k-1个结点
         }

         while(fast.next != null){//由于前面数了k-1个结点，则只能输出倒数k个结点
             //总结点数为n,fast还能走n-k个点，也是slow结点能走的点数，但是倒数就是，n-(n-k)=k个点
             fast = fast.next;
             slow = slow.next;
         }
         return slow;
     }
}

class Node{
    int value ;
    Node next = null;
    Node(int value ){
        this.value = value;
    }
}