力扣：实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。

第一种算法：设置一个指针，先遍历一遍链表得到链表长度，然后再遍历一遍找正着数第(长度-k)个结点的值

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

 //第一种方法:用一个指针，遍历两次链表
 
class Solution {
public:
    int kthToLast(ListNode* head, int k) {
        ListNode* L=head;  //此链表应该是不带头结点的链表
        int count=0;       //存储链表的长度
        int n=0;
        int real_value=0;  //存储第k个结点的值
        while(L!=NULL){    //遍历L找到链表的长度
            count++;
            L=L->next;
        }
        
        ListNode* p=head;    //第二次遍历链表
        while(p!=NULL){
           if(n==count-k){     //n的值刚好是倒数第k个结点
                real_value=p->val;    //real_value存储倒数第k个结点的值
           }
           p=p->next;
           n++;
        }
    return real_value;
    }
};

第二种方法：设置两个指针，进行一次遍历就可以了

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

//第二种方法：用两个指针，遍历一次链表即可
class Solution {
public:
    int kthToLast(ListNode* head, int k) {
        ListNode* p=head;  //此链表应该是不带头结点的链表
        ListNode* q=head;
        int real_value=0;
        int n=0;
        
        while(q!=NULL){
            if(n!=k-1){
            q=q->next;
            n++;
            }else{
            real_value=p->val;
            p=p->next;
            q=q->next;
            }
        }
        
    return real_value;  
    }
};