实现单链表反序的三种方法

#include <iostream>
#include <vector>
using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode() {next = nullptr;}
    ListNode(int v) {val = v; next = nullptr;}
};
ListNode* link(vector<int>& arr) {
    ListNode* head = new ListNode(arr[0]);
    ListNode* node = head;
    int n = arr.size();
    for (int i = 1; i < n; i++) {
        node->next = new ListNode(arr[i]);
        node = node->next;
    }
    return head;
}
void display(ListNode* head) {
    while (head) {
        cout << head->val << " ";
        head = head->next;
    }
    cout << endl;
}
// 递归实现
ListNode* newhead;
ListNode* help(ListNode* head) {            // help : 将此点拼接到反序列表上并返回 
    // 遍历到最后一个节点
    if (!head->next) {
        newhead = head;
        return head;
    }
    // 反序链接
    help(head->next)->next = head;
    // 避免环的出现
    head->next = nullptr;

    return head;
}
ListNode* recursive(ListNode* head) {       // recursive : 递归实现的入口
    if (!head)
        return nullptr;
    help(head);
    return newhead;
}
// 迭代实现（双指针）
ListNode* iterate(ListNode* head) {
    ListNode* prev = nullptr;
    ListNode* curr = head;
    while (curr) {
        // 保存当前结点的next
        ListNode* next = curr->next;
        // 反序链接
        curr->next = prev;
        // 准备进入下一循环
        prev = curr;
        curr = next;
    }
    return prev;
}
// 额外存储实现
ListNode* storage(ListNode* head) {
    vector<int> temp;
    ListNode* node = head;
    while (node) {
        temp.push_back(node->val);
        node = node->next;
    }
    node = head;
    for (int i = temp.size() - 1; i >= 0; i--) {
        node->val = temp[i];
        node = node->next;
    }
    return head;
}

int main() {
    vector<int> test = {1,2,3,4,5};
    ListNode* head = link(test);

    //head = recursive(head);     // 递归实现
    //head = iterate(head);       // 迭代实现
    //head = storage(head);       // 额外存储实现

    display(head);
    return 0;
}