首先最容易想到的方法是遍历整个链表,将值都存在一个数组中,然后再将数组反转后输出。时间复杂度是O(n)
class Solution {
public:
vector<int> reversePrint(ListNode* head) {
vector<int> result;
ListNode* cur = head;
while(cur){
result.push_back(cur->val);
cur = cur->next;
}
reverse(result.begin(), result.end());
return result;
}
};
第二种方法就是将整个链表先翻转,然后再输出
class Solution {
public:
vector<int> reversePrint(ListNode* head) {
if(head == NULL)
return {};
ListNode* cur = new ListNode(0);
cur->next = head;
head = cur;
int count = -1;
ListNode* prev = NULL;
while(cur){
ListNode* tmp = cur->next;
cur->next = prev;
prev = cur;
cur = tmp;
count++;
}
vector<int> result(count, 0);
for(int i = 0; i < count; i++){
result[i] = prev->val;
prev = prev->next;
}
return result;
}
};
当不允许改变链表的结构时,可以想到使用栈来存储数据,栈有先入后出的特性,链表头部的元素最后出,链表最后的元素最先出。
class Solution {
public:
vector<int> reversePrint(ListNode* head) {
stack<int> stk;
ListNode* cur = head;
while(cur){
stk.push(cur->val);
cur = cur->next;
}
vector<int> ans(stk.size(), 0);
for(int i = 0; i < ans.size(); i++){
ans[i] = stk.top();
stk.pop();
}
return ans;
}
};
当使用栈可以时,也可以使用递归来完成这道题,但是当链表节点数很大时,会有溢出的风险。
class Solution {
public:
vector<int> ans;
void visList(ListNode* head){
if(head == NULL){
return;
}
visList(head->next);
ans.push_back(head->val);
}
vector<int> reversePrint(ListNode* head) {
visList(head);
return ans;
}
};