鏈表中倒數第k個結點——15

    輸入一個鏈表，輸出該鏈表中倒數第k個結點。為了符合大多數人的習慣，從1開始計數，即鏈表的尾結點是倒數第1個結點。例如一個鏈表有6個結點，從頭結點開始它們的值依次是1、2、3、4、5、6，這個鏈表的倒數第3個結點是值為4的結點。

    因為鏈表是單鏈表，因此不可能先找到鏈表的最后一個結點，再倒回去數k個結點；因此有一種方法就是可以先將鏈表依次遍歷一遍得到鏈表總結點個數n，然后鏈表中倒數第k個結點也就是第n-k+1個結點，可以再次從頭開始遍歷，當數到第n-k+1個結點的時候就可以了；

    但是上面的方法就是要遍歷兩次鏈表，效率并不高，因此，可以用另外一種高效的解決辦法：用前后兩個指針，開始時兩個指針都指向鏈表的頭部，其中一個指針先走k-1個結點，然后兩個指針一起向后遍歷，當前一個指針走到鏈表的尾部也就是最后一個結點的時候，后面一個指針所在的位置就剛好是第k個結點，因為兩個指針之間的距離始終都是k；

程序設計如下：

#include <iostream>
#include <assert.h>
using namespace std;

template <class T>
struct ListNode//鏈表結點結構
{
    T _data;
    ListNode<T>* _next;
};

template <class T>
ListNode<T>* buy_node(T data)//創建一個鏈表結點
{
    ListNode<T>* tmp = new ListNode<T>;
    tmp->_data = data;
    tmp->_next = NULL;
    return tmp;
}

template <class T>
void init_list(ListNode<T>** node, T data)//初始化鏈表
{
    *node = buy_node(data);
}

template <class T>
void push_node(ListNode<T>*& head, T data)//插入鏈表結點
{
    if(head == NULL)
    {   
        init_list(&head, data);
        return;
    }   
    ListNode<T>* tmp = head;
    while(tmp->_next != NULL)
    {
        tmp = tmp->_next;
    }
    tmp->_next = buy_node(data);
}

template <class T>
void print_list(ListNode<T>* head)//打印鏈表
{
    while(head != NULL)
    {
        cout<<head->_data<<"->";
        head = head->_next;
    }
    cout<<"NULL"<<endl;
}

template <class T>
void destroy_list(ListNode<T>*& head)//銷毀鏈表
{
    if(head != NULL)
    {
        ListNode<T>* cur = head;
        ListNode<T>* tmp = head;
        while(cur != NULL)
        {
            tmp = cur;
            cur = cur->_next;
            delete tmp;
        }
        head = NULL;
    }
}

template<class T>
ListNode<T>* Reciprocal_k_Node(ListNode<T>* head, size_t k)//鏈表中倒數第k個結點
{
    assert(head && k);//條件判斷，首先鏈表不能為NULL，其次因為k從1開始，因此k不能為0

    ListNode<T>* first = head;
    ListNode<T>* second = head;

    while(--k)//先將first指針移動k-1個結點
    {
    //為什么要用first->_next作為判斷條件，是因為如果k值還沒減完first已經到尾部了，就可以
    //返回NULL，但如果用first！=NULL作為判斷條件，下面的循環就可能出問題
        if(first->_next != NULL)//判斷如果要找的k值大于鏈表結點個數，則返回NULL
            first = first->_next;
        else
            return NULL;
    }

    while(first->_next != NULL)
    {
        //使兩個指針同時往后移動，當first指針到鏈表尾部的時候，second的所在就是倒數k結點
        first = first->_next;
        second = second->_next;
    }

    return second;
}

int main()
{
    ListNode<int>* list = NULL;
    push_node(list, 1);
    push_node(list, 2);
    push_node(list, 3);
    push_node(list, 4);
    push_node(list, 5);
    push_node(list, 6);
    push_node(list, 7);
    push_node(list, 8);
    push_node(list, 9);

    cout<<"list: ";
    print_list(list);

    size_t k = 3;
    ListNode<int>* ret = Reciprocal_k_Node(list, k);
    if(ret != NULL)
        cout<<"the reciprocal "<<k<<" Node: "<<ret->_data<<endl;
    else
        cout<<"the number "<<k<<" is wrong..."<<endl;

    destroy_list(list);

    return 0;
}

運行程序：

如果傳入的k值大于鏈表結點個數，比如10，結果如下：

《完》