「这是我参与11月更文挑战的第3天，活动详情查看：2021最后一次更文挑战」。

一、链表的中间结点

一、题目描述

给定一个头结点为 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. 遍历链表

   开辟列表/数组空间

   遍历链表

   将节点添加进列表/数组

   返回数组长度//2的元素

2. 单指针法

   因为链表没有长度，也无法通过下标取值

   所以定义一个指针记录长度

   然后遍历链表，每次遍历让指针+1

   然后再次遍历

   遍历到长度//2的时候停止

3. 双指针法

   第二个方法有点麻烦，需要遍历两次链表

   两个指针，一个跟随链表

   一个以二倍速度遍历

   然后以而被指针为条件结束循环

   返回链表节点

三、代码

1. 暴力解法

   # Definition for singly-linked list.
   # class ListNode:
   #     def __init__(self, val=0, next=None):
   #         self.val = val
   #         self.next = next
   class Solution:
       def middleNode(self, head: ListNode) -> ListNode:
           li = []
           while head:
               li.append(head)
               head = head.next
           return li[len(li)//2]
   
   

2. 单指针

   # Definition for singly-linked list.
   # class ListNode:
   #     def __init__(self, val=0, next=None):
   #         self.val = val
   #         self.next = next
   class Solution:
       def middleNode(self, head: ListNode) -> ListNode:
           a = head  # 找个变量记录头结点，用于两次循环使用
           i = 0
           j = 0
           while a:
               i += 1
               a = a.next
           while j < i//2:
               j += 1
               head = head.next
           return head
   

3. 双指针

   class Solution:
       def middleNode(self, head: ListNode) -> ListNode:
           ans =  head  # 答案节点
           while head and head.next:
               ans = ans.next
               head = head.next.next
           return ans
   
   

二、数组串联

一、题目描述

给你一个长度为 n 的整数数组 nums 。请你构建一个长度为 2n 的答案数组 ans ，数组下标 从 0 开始计数 ，对于所有 0 <= i < n 的 i ，满足下述所有要求：

ans[i] == nums[i] ans[i + n] == nums[i] 具体而言，ans 由两个 nums 数组 串联 形成。

返回数组 ans 。

示例 1：

输入：nums = [1,2,1] 输出：[1,2,1,1,2,1] 解释：数组 ans 按下述方式形成：

• ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]]
• ans = [1,2,1,1,2,1] 示例 2：

输入：nums = [1,3,2,1] 输出：[1,3,2,1,1,3,2,1] 解释：数组 ans 按下述方式形成：

• ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]]
• ans = [1,3,2,1,1,3,2,1]

提示：

n == nums.length 1 <= n <= 1000 1 <= nums[i] <= 1000

二、题目解析

1. 循环

   给了答案数组和原数组的关系，循环数组的长度的二倍

   依次往数组里面添加

   判断条件

2. python列表相加

三、代码

1. java

class Solution {
    public int[] getConcatenation(int[] nums) {
        int n = nums.length;
        int[] ans = new int[n*2];
        for (int i=0;i<n*2;i++){
            if (i<n){
                ans[i] = nums[i];
            }else{
                ans[i] = nums[i-n];
            }
           
        }
        return ans;
    }
}

2. python

1. 循环

   class Solution:
       def getConcatenation(self, nums: List[int]) -> List[int]:
           ans = [0]*(len(nums)*2)
           for i in range(len(nums)*2):
               if i<len(nums):
                   ans[i] = nums[i]
               else:
                   ans[i] = nums[i-len(nums)]
           return ans
   

2. python性质

   class Solution:
       def getConcatenation(self, nums: List[int]) -> List[int]:
           ans = nums*2
           return ans