从尾到头打印链表（Python and C++解法）

题目：

　　输入一个链表的头结点，按链表从尾到头的顺序返回一个ArrayList。

思路：

　　假设源链表节点为A->B->C->D->E,那么：

将A插到0位置：A->B->C->D->E；　　将B插到0位置：B->A->C->D->E；　　将C插到0位置：C->B->A->D->E；　　

将D插到0位置：D->C->B->A->E；　　将E插到0位置：E->D->C->B->A；

class Solution:
    def printListFromTailToHead(self, listNode):
        res = []  # 存储倒置后的结果
        temp = listNode  # 链表头部
        while temp:  # 链表当前节点不为None时
            res.insert(0, temp.val)
            temp = temp.next
        return res

上述做法会改变链表的结构，不是一种高级做法。

　　链表的遍历顺序是从前到后，而打印顺序是从后到前，即先遍历的后打印，后遍历的先打印，这是一种栈的思维，于是可用栈实现打印顺序。

　　另外，递归的操作过程其实就是栈的顺序，因此也可以用递归实现打印顺序。

Python解法一：

class Solution: 
    def printListFromTailToHead(self, listNode):
        if listNode == None:  # 判断头结点是否为空
            return []
        pNode = listNode  # 哨兵节点
        stack = []  # 栈
        while pNode != None:  # 入栈
            stack.append(pNode.val)  
            pNode = pNode.next
        ArrayList = []
        while len(stack) != 0:
            ArrayList.append(stack.pop(-1))
        return ArrayList

Python解法二：

class Solution:
    def printListFromTailToHead(self, listNode):
        res = []
        def printListnode(listNode):
            if listNode:
                printListnode(listNode.next)  # 先递归到最后一层
                res.append(listNode.val)  # 添加值，退出函数，返回到上一层函数中的这行重复执行
                
        printListnode(listNode)
        return res

C++解法一：

struct ListNode {
     int val;
     ListNode *next;
     ListNode(int x) : val(x), next(NULL) {}
 };
 
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        if (head == NULL)
            return {};
        ListNode *pNode = head;  // 哨兵节点
        stack<int> aStack;
        while (pNode != NULL) {
            aStack.push(pNode->val);
            pNode = pNode->next;
        }
        vector<int> res;
        while (aStack.size() != 0) {
            res.push_back(aStack.top());
            aStack.pop();
        }
        return res;
    }
};

C++解法二：

 struct ListNode {
     int val;
     ListNode *next;
     ListNode(int x) : val(x), next(NULL) {}
 };
 
 class Solution {
 public:
     vector<int> res;  //  应置为全局变量
     vector<int> reversePrint(ListNode* head) {
         if (head != NULL) {
             ListNode *pNode = head;  // 哨兵节点
             if (pNode != NULL) {
                 reversePrint(pNode->next);  // 递归到最后一层
                 res.push_back(pNode->val);
             }
         }
         return res;
     }
 };