剑指 Offer 06. 从尾到头打印链表 C++四种方法

力扣题目描述

首先最容易想到的方法是遍历整个链表，将值都存在一个数组中，然后再将数组反转后输出。时间复杂度是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;
    }
};