876.链表的中间结点（双指针）

算法入门第五天第一题，0.5.1

876.链表的中间结点（双指针）

题目描述

ֱ直接想法（方法一）

也是我的做法。

单次遍历链表，把它存入vector中。利用vector可以直接根据下标访问数组元素的特性，很容易返回中间结点。题目要求链表大小为偶数时，返回中间比较大的那个结点，比如[1,2,3,4,5,6]的中间元素应为[3,4],但是本题要求返回4。4的下标为3=6/2。所以最终返回v[v.size()/2]就可以。

本题变型

如果本题需要返回中间元素（一个或两个），那么可以这样：

if( v.size()%2 == 0){               //v含有偶数个元素

    return v[v.size()/2-1]，v[v.size()/2]；

}else{              //   v.size()%2 == 1  v含有奇数个元素

    return v[v.size()/2]；

}

当前困惑

很久没有接触链表了，怎么样遍历？（观看官方视频）

1.将链表的头结点存入vector中；

2.当位于当前数组的末尾对象（一开始时，末尾对象便是head）指向的下一个结点（一开始时，指向的下一个是第二个结点）不为NULL时，将下一个ListNode结点放入数组中；

3.为null意味着当前结点是最后一个结点，停止循环。

v.back()返回对列表v中最后一个元素的直接引用。

对应代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        vector<ListNode*> v={head};

        while(v.back()->next!=NULL){
            v.push_back(v.back()->next);
        }
        
        return v[v.size()/2];
    }
};

方法二（单指针法）

对方法一进行空间优化，省去数组v。

对链表进行两次遍历。

第一次遍历时，统计链表中的元素个数 N；

第二次遍历时，当遍历到第 N/2 个元素（链表的首节点为第 0 个元素）时，将该元素返回即可。

对应代码

当前困惑

在第一次遍历完链表之后，如何将指针指回链表的头结点？

对应错误代码如下：

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
 
        int i=0,j=1;
        ListNode* ans;

        while( head->next != NULL ){          //第一次遍历
            i+=1;
            head=head->next;
        }
        
        while( j != i/2 ){       //第二次遍历
            ans=head->next;
            j+=1;
        }
        
        return ans; 
    }
};

对应测试结果如下：

可以看出没有进行第二次遍历，于是去看官方题解。

对应代码如下：

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        int i=0,j=0;
        ListNode* ans=head;        

        while( ans != NULL ){          
            i+=1;
            ans=ans->next;
        }        
        ans=head;
        while( j != i/2 ){
            ans=ans->next;
            j+=1;
        }

        return ans; 
    }
};

方法三（快慢指针法）

继续优化方法二，用两个指针 slow 与 fast 一起遍历链表。slow 一次走一步，fast 一次走两步。那么当 fast 到达链表的末尾时，slow 必然位于中间。（力扣官方题解，厉害啊！）

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        int i=0,j=0;
        ListNode* low=head;
        ListNode* fast=head;

        while( fast != NULL && fast->next !=NULL){     
           
            low=low->next;
            fast=fast->next->next;
        }        
       
        return low; 
    }
};

注意循环终止条件！

最后一种解法真的太巧妙了吧！记住记住！背下来背下来！