给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln - 1 → Ln

请将其重新排列后变为：

L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1：

输入：head = [1,2,3,4]

输出：[1,4,2,3]

示例 2：

输入：head = [1,2,3,4,5]

输出：[1,5,2,4,3]

思路：

定义一个 list，将链表依次按照顺序存入到 list 中。定义list的最左边的下标 left = 0，最右边的下标 right = list.size - 1 ，将 left 与right的链表节点重新排序，
list[ left ] ->next = list[ right ]
定义 curr 节点，指向每次重排两个节点后的最右节点，即 curr = list [ right ] 。
注意：为了防止出现循环链表，需要将排序后的链表的最后一个节点的 next 指向 空指针
left 与 right 最终有两种情况:
1. left 与 right 相等， 说明：链表为奇数个节点, 注意：奇数个节点时，需要手动将中间的节点加入到重排序的链表中，再将最后一个节点的 next指向 空指针
2. left > right 时，说明：链表为偶数个节点，此时直接将最后一个节点指向 空指针 list[ left ]-> next = nullptr 即可

c++：

/**
 * 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:
    void reorderList(ListNode* head) {
        vector<ListNode*> node_vec;

        int node_count = 0;
        ListNode* curr = head;

        while(curr != nullptr) {
            node_count++;
            node_vec.emplace_back(curr);
            curr = curr->next;
        }

        ListNode* preHead = new ListNode;
        curr = preHead;

        int left = 0;
        int right = node_count - 1;

        while(left<right) {
            curr->next = node_vec[left];
            node_vec[left]->next = node_vec[right];
            curr = node_vec[right];
            left++;
            right--;
        }
      
        if(left == right) {
          // 说明是奇数个节点，最后一个节点next指向 空指针, 注意：奇数个节点时，需要手动将中间的节点加入到重排序的链表中
          curr->next = node_vec[left];
          node_vec[left]->next = nullptr;
        } else {
          // 说明是偶数个节点，最后一个节点是当前  left 下标对应的节点
          node_vec[left]->next = nullptr;
        }

    }
};