剑指offer 06从尾到头打印链表

题目描述

输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。

如输入{1,2,3}的链表如下图:

返回一个数组为[3,2,1]

0 <= 链表长度 <= 1000。

示例1
输入：{1,2,3}
返回值：[3,2,1]

示例2
输入：{67,0,24,58}
返回值：[58,24,0,67]

思路

1. 从头访问结点数据，放入vector容器中，并翻转输出
   时间：$O(n)$； 空间：$O(1)$

/**
 *  struct ListNode {
 *        int val;
 *        struct ListNode *next;
 *        ListNode(int x) :
 *              val(x), next(NULL) {
 *        }
 *  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> v;
        //链表长度为0
        if(!head)
            return v;
        // 正向输出数据到容器v中
        while(head != NULL)
        {
            v.push_back(head->val);
            head = head -> next;
        }
        
        int n = v.size();
        for(int i = 0; i < n/2; ++i) // 小于n/2就是 n/2-1
        {
            swap(v[i], v[n-1-i]);    // 全部代码需要添加头文件#include<algorithm>
        }
        return v;
    }
};

实现翻转：

• 使用算法函数reverser(v,begin(), v.end());
• 使用反向迭代器vector<int>(v.rbegin(),v.rend());
  

2. 倒序输出符合栈的输出方式，申请stack空间
   时间：$O(n)$； 空间：$O(n)$

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> res;
        if (!head) return res;
        stack<int> stk;
        while (head) {//进栈
            stk.push(head->val);
            head = head->next;
        }
        while (!stk.empty()) {//出栈：刚好是逆序
            res.push_back(stk.top());
            stk.pop();
        }
        return res;
    }
};

3. 利用递归思想，先递归至nullptr，在逆向push_back

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

递归出自这。

递归的思想很好，通过做题发现我还是对递归的方法需要分析好久，递归这方面是我的薄弱项需要加强。