// 法一：reverse 答案数组. 时间:O(n);空间:O(n). 4ms; 8.5MB
class Solution {
public:
    vector<int> printListReversingly(ListNode* head) {
        vector<int> res;
        while (head) {
            res.push_back(head->val);
            head = head->next;
        }
        // reverse(res.begin(), res.end());
        // return res;
        return vector<int>(res.rbegin(), res.rend());
    }
};

// 法二：递归. 时间:O(n);空间:栈空间O(n). 4ms; 10.8MB
class Solution {
public:
    vector<int> printListReversingly(ListNode* head) {
        if (!head) return {};
        auto res = printListReversingly(head->next);
        res.push_back(head->val);
        return res;
    }
};

// 法三：辅助栈法. 时间:O(n);空间:O(n). 4ms; 8.5MB
class Solution {
public:
    vector<int> printListReversingly(ListNode* head) {
        stack<int> s;
        while (head) {
            s.push(head->val); // 存的是 val
            head = head->next;
        }

        int n = s.size();
        vector<int> res(n);
        for (int i = 0; i < n; i ++ ) {
            res[i] = s.top();
            s.pop();
        }

        return res;
    }
};

开阔思路， 学到了，赞

我是菜鸡，可不可以解释一下//res.push_back(head->val);//是什么意思

这是vector的函数,push_back是添加到vector的尾部,head->val就是链表的数字值,意思就是将这个数字添加到vec数组里

9999,学习到了很多

# 牛

tql
大佬，请问这是什么意思？

auto res = printListReversingly(head->next);

第二种是不是用了递归啊！

有一个问题，递归调用的过程中，res不是一个局部变量吗，在函数内被定义，那么我再调用一次printListReversungly函数，执行过程中有创建了一个局部变量auto，这两个函数只是同名应该是两个变量才对..晕了晕了

auto res = printListReversingly(head->next);
这一句代码接受了来自上一层返回的res

res.insert(res.begin(), ptr->val)

反向迭代器涨姿势了

加油hh

Y总 return vector[HTML_REMOVED](res.rbegin(), res.rend()); 和 reverse(res.begin(), res.end()) 然后 return res 相比有什么优势吗？是不是不用再翻转整个vector了？

就是代码少了一行，其他的区别不大

res.push_back(head->val);
head = head->next;
这是啥意思啊

先翻转链表然后存进数组为什么不行呢

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> printListReversingly(ListNode* head) {
        ListNode*p =head;
        if(head!=nullptr||head->next!=nullptr)
        {
            ListNode* q=p->next;
            while(q)
            {

                ListNode* t=q->next;
                q->next=p;
                p=q;
                q=t;
            }
            head->next=NULL;
        }
        vector<int> arr;
        while(p)
        {
            arr.push_back(p->val);
            p=p->next;
        }
        return arr;
    }
};

我也是这样写的，好像是 链表没值吗，值要输入

我这样写的，是可以AC的

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> printListReversingly(ListNode* head) {
        ListNode* curr = head;
        ListNode* prev = nullptr;
        vector<int> ans;
        while (curr)
        {
            ListNode* next = curr->next;
            curr->next = prev;
            prev = curr;
            curr = next;
        }
        while (prev)
        {
            ans.push_back(prev->val);
            prev = prev->next;
        }
        return ans;
    }
};

我也这样写的，可以AC呀

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> printListReversingly(ListNode* head) {
        ListNode* curr = head;
        ListNode* prev = nullptr;
        vector<int> ans;
        while (curr)
        {
            ListNode* next = curr->next;
            curr->next = prev;
            prev = curr;
            curr = next;
        }
        while (prev)
        {
            ans.push_back(prev->val);
            prev = prev->next;
        }
        return ans;
    }
};

C语言

这个题用c的话感觉用的尾递归，栈用链表实现好像也是和尾递归类似，用数组栈的话好像也行。。。

y总nb

萌新求问，这个题可以用辅助栈做么？

这个代码怎么用Java实现呢

class Solution {
    public int[] printListReversingly(ListNode head) {
        if (head == null) return new int[0];

        List<Integer> list = new ArrayList<>();
        ListNode p = head;
        while (p != null) {
            list.add(p.val);
            p = p.next;
        }
        Collections.reverse(list);

        int n = list.size();
        int[] res = new int[n];
        for (int i = 0; i < n; i++) res[i] = list.get(i);
        return res;
    }
}

class Solution {
public int[] printListReversingly(ListNode head) {
int k = 0;
for( ListNode i = head; i != null; i = i.next)
k++;
int q[] = new int[k];
for( ListNode i = head; i != null; i = i.next) q[–k] = i.val;
return q;
}
}

求解答最后结果不是要数组存储吗

vector就是数组

涨姿势了 太强了

加油hh

递归将数据放入数组

对滴，用尾递归也是可以的。

反向迭代器，mark