题目描述

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。To do it!
示例输入： head = [1,3,2]
输出： [2,3,1]
限制： 0 <= 链表长度 <= 10000

题解

递归

先至链表末尾，回溯时依次将节点值加入，从而实现链表节点值的倒序存储。

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        if (head == nullptr) return {};
        vector<int> res = reversePrint(head->next);
        res.push_back(head->val);
        return res;
    }
};

递归 n 次，每次递归的空间复杂度是 O(1)。
时间复杂度：O(n)，空间复杂度：O(n)

辅助栈

利用栈 先入后出 的特点可以实现题目需求。

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        stack<int> st;
        ListNode* p = head;
        while (p != nullptr) {
            st.push(p->val);
            p = p->next;
        }
        vector<int> res;
        while (!st.empty()) {
            res.push_back(st.top());
            st.pop();
        }
        return res;
    }
};

时间复杂度：O(n)，空间复杂度：O(n)

倒序存储

得到链表长度，定义相同长度的数组。从头遍历链表，数组从后往前存储，最终得到链表节点值的倒序存储数组。

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        ListNode* p = head;
        int count = 0;
        while (p != nullptr) {
            count++;
            p = p->next;
        }
        p = head;
        vector<int> nums(count);
        while (p != nullptr) {
            nums[--count] = p->val;
            p = p->next;
        }
        return nums;
    }
};

返回数组的空间不算入空间复杂度分析，所以空间复杂度为 O(1)。
时间复杂度：O(n)，空间复杂度：O(1)

顺序存储 + 反转

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> res;
        ListNode* p = head;
        while (p != nullptr) {
            res.push_back(p->val);
            p = p->next;
        }
        reverse(res.begin(), res.end());
        return res;
    }
};