力扣--＞#876. 链表的中间结点--＞链表-简单（数组、单指针、快慢指针）

876. 链表的中间结点

题目描述：
给定一个头结点为 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。

示例 1：
输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

示例 2：
输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

提示：
给定链表的结点数介于 1 和 100 之间。

方法一：数组
由于链表的缺点是无法通过下标直接访问结点，而数组的有点恰好如此。也由于题给提示链表节点数介于1到100之间，所以可以直接建立一个长度为100的结点数组。遍历一次链表，将链表结点逐一存放入结点数组中，并记录链表长度，最后返回节点数组的中间结点即可。

执行结果：通过
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：36 MB, 在所有 Java 提交中击败了23.34%的用户
通过测试用例：36 / 36

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode middleNode(ListNode head) {//数组
        ListNode[] list=new ListNode[100];//提示给出：给定链表的结点数介于 1 和 100 之间。
        int sum=0;
        while(head!=null){
            list[sum++]=head;
            head=head.next;
        }
        return list[sum/2];
    }
}

方法二：单指针法

用这个方法自己写出来直接一次过，这也是最容易想到的方法，利用两个指针分别遍历两次，第一次遍历得到链表长度，第二次遍历到(长度+1)/2就停止，最终得到中间结点。虽然优化了方法一的空间问题，但却遍历两次，时间上的性能并不高。

执行结果：通过
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：36 MB, 在所有 Java 提交中击败了10.97%的用户
通过测试用例：36 / 36

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode middleNode(ListNode head) {//单指针法
        ListNode temp=head;//用于遍历
        int sum=0;
        while(temp!=null){
            temp=temp.next;
            sum++;
        }
        ListNode result=head;//用于返回最终结果
        for(int i=0;i<sum/2;i++){
            result=result.next;
        }
        return result;
    }
}

方法三：快慢指针法

像这种要找中间节点的，要条件反射想到快慢指针！类似力扣--＞#234. 回文链表--＞链表-简单(双指针、数组列表、递归、快慢指针)_咻咻咻0v0的博客-CSDN博客这道题。
快慢指针的写法和理解也很简单，性能高，空间复杂度为O(1)，只要能想到，就是一次过。

执行结果：通过
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：35.9 MB, 在所有 Java 提交中击败了49.49%的用户
通过测试用例：36 / 36

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode middleNode(ListNode head) {//快慢指针
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=null && fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
        }
        return slow;
    }
}

平平无奇小白程序媛一枚，欢迎各位大佬交流指教，如有不正确的地方，欢迎留言改正，谢谢！！！