今天去網上看了一下09年的Java考研試題，看見該題目（圖片）：

先來定義結點（為了簡便，省略set/get）：

public class Node  
{  
 public int data;  
 public Node link;  
}  

對于這個Java考研試題，我能想到的兩種解法，一個基于遞歸：

遞歸版的思路就是，基于當前結點，如果后一個是倒數第K-1，那么當前結點是所求，若不然，返回當前是倒數第幾個。

public int printRKWithRecur(Node head,int k)  
    {  
        if(k==0||head==null||head.link==null)return 0;  
        if(_recurFind(head.link,k)>=k)return 1;  
        return 0;  
    }  
    private final int _recurFind(Node node, int k) {  
        if(node.link==null)  
        {  
            return 1;  
        }  
        int sRet=_recurFind(node.link,k);  
        if(sRet==k-1)  
        {  
            System.out.println("Got:"+node.data);  
            return k;  
        }  
        return sRet+1;  
    } 

對每個結點，該算法都只訪問一次，因此復雜度O（N）。

第二解法，相對遞歸來說，這種方法可以算是消除遞歸版，而且從某種意義上來說比遞歸更高效，跟省空間，遞歸版實際上是把回溯的數據存在棧上，而版方法是自己存儲，且利用數組實現一個循環隊列，只存儲K個元素。

public static class CycleIntQueue  
    {  
        int[] datas;  
        int top=0;  
        int num=0;  
        public CycleIntQueue(int n)  
        {  
            datas=new int[n];  
        }  
          
        public void push(int i)  
        {  
            datas[(top++)%datas.length]=i;  
            num++;  
              
        }  
        public int numPushed()  
        {  
            return num;  
        }  
          
          
        public int getButtom()  
        {  
            return datas[top%datas.length];  
        }  
    }  
    public int printRKWithCycleQueue(Node head,int k)  
    {  
        if(k==0||head==null)return 0;  
        CycleIntQueue queue=new CycleIntQueue(k);  
        Node cur=head.link;  
        while(cur!=null)  
        {  
            queue.push(cur.data);  
            cur=cur.link;  
        }  
        if(queue.numPushed()return 0;  
          
        System.out.println("Got:"+queue.getButtom());  
        return 1;  
    } 

本算法，都每個結點也只放一次，另外進行一次入隊操作，該操作復雜度O(1),從而，整個算法復雜度仍是O(N).

對于此Java考研試題還有另外一種算法，該算法的空間復雜度為O（1），時間復雜度為O（n）。這在空間復雜度和時間復雜度上應該是比較優化了。

本算法的基本思想如下：既然是查找倒數第K個結點（注意，不是正數，否則就沒什么可討論的了），而且鏈表是單向的，還不能改變表結構，這就意味著只能從前往后掃描結點。我們首先要知道這個鏈表有多少個結點（如果總結點數都不知道，何談倒數？），這個非常簡單，只要從頭掃描一下鏈表，再計一下數即可。

在同一時間從事多項工作會大大提升效率，當然，掃描鏈表也不例外，在掃描鏈表的同時，還需要做一些其他的工作。既然只能從前向后掃描鏈表，而且要求倒數第K個結點，那就讓我們把這個鏈表按長度為K分成若干塊，而最后掃描的結果要么結點數是K的整數倍（模為0），要么余數（模）不為0（多出幾個結點，多出的結點數小于K）。

先看看第二種情況。

假設有12個結點的鏈表，每一個結點的值從前往后分別是1至12，如下所示：

1  2  3  4  5  6  7  8  9  10  11 12

假設我們要求倒數第5個結點，我們直接就可以看出結果是8.那么用程序如何處理呢？

先按長度為5將上面的結點分成三個區域，如下：

1 2 3 4 5   6 7 8 9 10   11 12

注意，不是物理分，而是使用變量來保存區域的邊界（也就是區域最后一個結點的對象）。

從上面的分隔可以看出，最后剩下兩個結點，既然是求倒數第5個，而最后剩下了兩個，那么還缺5-2=3個，因此，只需要從倒數第二個塊（6 7 8 9 10）略過前兩個，第三個結點（8）就是我們要求的結果，而5就是題中的k，2就是結點數與k的模，因此，可以推出一個公式，倒數第k個結點就是按長度為k按分成的若干塊中的第二塊的第（結點數 % k+ 1）個結點。

下面來看看（結點數 % k）為0的情況。假設上面的例子中的k為4，正確的輸出結果應為9，分塊如下：

1 2 3 4  5 6 7 8  9 10 11 12

從上面的三個塊可以看出，結果正好是最后一個塊的第一個結點，這時mod為0（mod=結點數 % k），因此，在這種情況也可以使用上面的公式，只是變成了最后一個塊。

根據上面的基本思想可以設兩個指針，p1和p2，其中p1最終指向倒數第2個完整塊，p2最終指向倒數第1個完整塊，對于第一種情況，p1指向5，p2指向10，這時可以使p1向后移動（k - mod）個結點即可（從5移動3個正好是8）。而對于第二種情況，p1指向8，p2指向12，而mod=0，這時的結果仍然是mod+1，也就是p1向后移動1個結點就是所求的結果。 為了滿足（k=結點數）的情況，需要將p1的初始值設為頭結點，這樣如果（k=結點數），就直接從頭結點向后移動一個結點就是最后的結果，如上面的例子求倒數第12個結點，也就是求正數第1個結點。

下面是這個算法的具體實現（包括核心算法、生成鏈表及調用核心算法的代碼）：

public class Test  
{  
    static class Node  
    {  
        public int data;  
        public Node nextNode;  
    }  
    //////////////////////////////////////////  
    //  核心算法  
    private static int findNode(Node headNode, int k)  
    {  
        Node p = headNode, p1 = headNode, p2 = null;   
        int count = 0;  //  表示結點數  
        while (p.nextNode != null)  
        {  
            p = p.nextNode;  
            count++;  
            //  遇到k的整數位個結點，進行分塊  
            if (count % k == 0)   
            {                  
                if (p2 != null)  
                    p1 = p2;  
                p2 = p;  
            }  
        }  
        //  k超過鏈表結點數，未找到，返回0  
        // 此處也可以用k > count來判斷  
        if (p2 == null)    
        {  
            return 0;  
        }  
        else 
        {  
            int mod = count % k;  
            int offset = mod + 1;  // 任何情況下，最終結果都是p1指向的結點向后移動(mod + 1)個結點  
            for (int i = 0; i < offset; i++)  
                p1 = p1.nextNode;  
            System.out.println(p1.data);  
            return 1;  
        }  
    }  
    ////////////////////////////////////////  
    public static void main(String[] args) throws Exception  
    {  
        //產生一個包含1個頭結點和120個結點的鏈表  
        Node headNode = new Node();  
        Node p = headNode;  
        for (int i = 0; i < 120; i++)  
        {  
            p.nextNode = new Node();  
            p.nextNode.data = i + 1;  
            p = p.nextNode;  
        }  
        p.nextNode = null;  
        //  開始查找倒數第k個結點，如果找到，返回1，并輸出結點的data值  
        System.out.println(findNode(headNode, 12));  
    }  
} 

上面程序的輸出結果如下：

109
1

【編輯推薦】

1. Java筆試題：Java基礎概念（附答案）
2. Java中消除實現繼承和面向接口編程
3. Red Hat CEO呼吁甲骨文繼續保持Java開放
4. 自學Javabean迅速成為Java高手
5. Java通過JNI調用C語言的方法