面试题15：链表中倒数第k个结点

//面试题15：链表中倒数第k个结点

//题目：输入一个链表，输出该链表中倒数第K个结点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾结点是

//倒数第1个结点。例如一个链表有6个结点，从头结点开始它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个结//点是值为4的结点。
//要求只遍历链表一次，所以需要使用两个指针

//问题：考虑各种出现的特殊情况，如：头指针为空，K的值大于链表长度，输入的K为0

 

ListNode类

package offer.utilities;


//结点的定义
public class ListNode {
    private  Object element;  //私有的成员变量
    private  ListNode next ;
        
    public ListNode(Object ele, ListNode next) {
        // TODO Auto-generated constructor stub
        this.element = ele ;
        this.next = next ;
    }    
        
    //next 的set，get方法
    public ListNode getNext() {
        return next;
    }

    public void setNext(ListNode next) {
        this.next = next;
    }    
    
    //node的get set方法    
    public Object getData() {
        // TODO Auto-generated method stub
        return element;
    }

    public void setData(Object obj) {
        // TODO Auto-generated method stub
        element = obj;
    }
    
    //连接两个节点
    public static void  connectListNodes(ListNode pCurrent , ListNode pNext) throws Exception{
        if(pCurrent == null){
            System.out.println("Error to conncet two nodes");
            throw(new Exception("当前节点为空节点"));
        }
        pCurrent.setNext(pNext);        
    }
    
    //打印链表
    public static void PrintList(ListNode head){
        System.out.println("PrinyList  start");
        ListNode pNode = head ;
        System.out.print("{ ");
        while(pNode != null){
            System.out.print(pNode.getData() +"  ");
            pNode= pNode.getNext();
        }
        System.out.println("}");
    }
    
}

 

方法思路：

假设整个链表有n个节点，那么倒数第K 个节点就是从头结点开始的第 n-K+1 个节点。

方法一：第一次遍历链表，得出节点数 n ， 第二次遍历链表就能找到倒数第 K 个节点， 一共需要两次遍历。

方法二：只需要遍历链表一次即可。

　　在方法一的基础上改进如下：

　　为了实现只遍历链表一次就能找到倒数第 K 个节点，可以定义两个指针。

第一个指针从链表的头指针开始遍历向前走 k - 1 步，第二个指针保持不动。

从第 k 步 开始，第二个指针也开始从链表的头指针开始遍历。

当第一个指针指向链表的最后一个节点时，第二个指针刚好指向链表的倒数第 K 个节点。

 

　　写代码时，要考虑鲁棒性，最好采用防御性变成，即考虑在哪些地方会出错，

然后提前加上错误判断，这样可以避免错误的输入而导致程序崩溃。

 

　　方法二中，需要可考虑的情况有：

1. 链表为空 ，返回null。

2.  输入的 K值为0 ， 由于计数是从 1 开始的，数以输入0没意义，返回null。

3.  输入的 K值 大于链表的长度 ，在 for 循环中遍历链表可能会出现指向 null 的指针，

　　因此需要在 for 循环中加入一个 if 判断。

 

package com.hb.jzoffer;

import offer.utilities.ListNode;


//面试题15：链表中倒数第k个结点
//要求只遍历链表一次，所以需要使用两个指针
//问题：考虑各种出现的特殊情况，如：头指针为空，K的值大于链表长度，输入的K为0

public class KthNodeFromEnd {    
    
    ListNode FindKthFromTail(ListNode head , int k) throws Exception{
        
        if(head == null || k == 0){
            throw new Exception("输入有误");            
        }        
        ListNode  phead = head ;
        ListNode  Pbehind =null;
        
        for(int i = 0 ; i < k -1 ; ++ i){
            if(phead.getNext() != null){   //判断条件，防止K的值大于节点个数
                phead = phead.getNext();
            }else{
                return null;
            }
        }
        
        Pbehind = head ;
        while(phead.getNext() != null){
            phead = phead.getNext() ;
            Pbehind = Pbehind.getNext() ;
        }
                
        return Pbehind;
    }
    
    
    public static void main(String[] args) throws Exception {
        ListNode node1 = new ListNode("1" , null);
        ListNode node2 = new ListNode("2" , null);
        ListNode node3 = new ListNode("3" , null);
        ListNode node4 = new ListNode("4" , null);
        ListNode node5 = new ListNode("5" , null);
        ListNode node6 = new ListNode("6" , null);
        
        ListNode.connectListNodes(node1, node2);
        ListNode.connectListNodes(node2, node3);
        ListNode.connectListNodes(node3, node4);
        ListNode.connectListNodes(node4, node5);
        ListNode.connectListNodes(node5, node6);
        
        System.out.println("初始化链表：");
        ListNode.PrintList(node1);
        
        KthNodeFromEnd test = new KthNodeFromEnd();
        ListNode  kthNode = test.FindKthFromTail(null, 3);
        System.out.println(kthNode.getData());
    }

}