题目要求

输入一个链表头，输出是从尾到头打印链表

考察内容

数据结构：
算法：

算法思路

我们看到题首先想到的是将输入的链表转存到另一种数据结构中。由于链表带有指针，可以通过指针的移动转存。我们从结果出发，返回的是一个倒序的列表，用数组最佳。
其次还有一种思路，使用容器正序存储，再进行调转，使用vector的reserve（a.begin(),a.end()）
第三种思路是将链表进行翻转，然后直接输出
第一种：
关于数据结构的选择：
1.栈：因为栈是先进后出的。所以可以实现倒序输出。
2.数组。数组利用for循环也可以实现倒序输出
思路：
首先通过新建一个指针节点，进行遍历head.和存储。
若指针不为空，一直存储压入到栈中。
建立一个和栈一个大的数组。
再从栈中出栈到数组中，这样就得到一个倒序的数组。
返回

class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> result;
    	stack<struct ListNode*>Nodes;
        struct ListNode* pNode = head;
        
        while(pNode != NULL)
        {
            Nodes.push(pNode);
            pNode = pNode->next;
        }
        
        while(!Nodes.empty())
        {
            pNode = Nodes.top();
            result.push_back(pNode->val);
            Nodes.pop();
        }
        return result;
    }
};

第二种，为了精简效率，选择直接存储到容器中。然后进行翻转
翻转可以使用reverse（a.begin(),a.end()）函数.
代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    
public:
    vector<int> reversePrint(ListNode* head) {
     vector<int> result;
     while(head)
     {
         result.push_back(head->val);
         head=head->next;
     }
    reverse(result.begin(),result.end());
    return result;
    }
};

第三种方法：翻转链表。
有点复杂：可以通过画图理解。

       struct ListNode *lpre = head;
        struct ListNode *lcur = lpre->next;
        struct ListNode *lnext = NULL;
        
        while(lcur != NULL)
        {
            lnext = lcur->next;
            lcur->next = lpre;
            lpre = lcur;
            lcur = lnext;            
        }   
        head->next = NULL;