链表-快指针和慢指针的使用方法

1）给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
本问题的思想是：定义两个指针，一个快指针fast，一个慢指针slow，慢指针每次走一步，快指针每次走两步，当不满足条件（fast&&fast->next）时，说明已经找到了中点，且中点时slow。

/** * Definition for singly-linked list. */
 struct ListNode
  {    
	   int val;     
	   struct ListNode *next; 
    }; 

struct ListNode* middleNode(struct ListNode* head）
{
	//慢的走一步   //快的走两步   
	struct ListNode* fast;   
	struct ListNode* slow; 
	if(head==NULL)      
	       return head;    
	fast=slow=head;    
	 //对节点进行解引用之前，首先判断节点是否为空，，若为空则不能解引用    
	 while(fast&&fast->next)   
	 {        
	        slow=slow->next;       
	         fast=fast->next->next;   
	 }   
	 return slow；
 }

（2）输入一个链表，输出该链表中倒数第k个结点
本题的思路是：首先让快指针先走k步，然后慢指针从头走，当快指针为空时，则找到了倒数第k个节点。

struct ListNode {
 int val;
 struct ListNode *next;
 ListNode(int x) :
   val(x), next(NULL) {
 }
};
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        if(pListHead== nullptr || k == 0)           
            return nullptr;        
        ListNode *pre = pListHead, *p = pListHead;        
        for(int i = 0; i < k; ++ i){            
            if(p == nullptr)               
                return nullptr;            
            p = p->next;       
        }       
        while(p != nullptr){            
            pre = pre->next;           
            p = p->next;        
        }        
        return pre;

    }
};

（3）给定一个链表，判断链表中是否有环.
本题的思想是：定义一个慢指针和快指针，慢指针每次走一步，快指针每次走两步，若有环，则快慢指针会相遇，反之则不会。

struct ListNode
 { 
	     int val; 
	     struct ListNode *next; 
  }; 
  bool hasCycle(struct ListNode *head) 
  {
      //判断链表是否有环使用快慢指针进行判断    
      struct ListNode* slow,*fast;  
      fast=slow=head;   
      if(head==NULL)   
      {       
           return false;   
      }    
      while(fast && fast->next)  
      {        
              slow=slow->next;        
              fast=fast->next->next;       
               if(slow==fast)     
              {           
                   return true;      
              }    
       }   
      return false;
  }

（4）给定一个链表，返回链表开始入环的第一个节点。
本题的思路是：首先判断链表中是否有环，若有环，则找到（3）中两指针相交的点，找到相交的点之后，定义一个指针从链表的头节点开始走，一个指针从得到的相遇点开始走，若走的过程中相交了，则相交点就是入环的第一个点。

struct ListNode
 { 
      int val; 
      struct ListNode *next; 
 }; 
 struct ListNode* hasCycle(struct ListNode *head)
  {    
         //判断链表是否有环使用快慢指针进行判断    
         struct ListNode* slow,*fast;   
         fast=slow=head;  
         if(head==NULL) 
        {        
                 return NULL;  
        }   
        while(fast && fast->next)  
        {        
             slow=slow->next;     
             fast=fast->next->next;  
             if(slow==fast)    
             {          
                    return slow;       
             }    
        }    
       return NULL;
 }
 struct ListNode *detectCycle(struct ListNode *head) 
 {  
   //先判断有没有环，如果有环，则找到环的起始地址，反之则为空 
          struct ListNode* headh,*slow;
          if(head==NULL) 
                 return NULL;  
         //判断有无环，并得到相遇点
        slow=hasCycle(head);  
        headh=head;  
        //有环  
        if(slow)  
       {      
               while(slow!=headh)       
              {        
                        slow=slow->next;    
                        headh=headh->next;    
               }      
              return slow;   
       }  
     //无环   
    return NULL;
  }