剑指Offer（三）：从尾到头打印链表

参考链接：https://cuijiahua.com/blog/2017/11/basis_3.html

https://blog.csdn.net/wang454592297/article/details/79400211

好文！！https://blog.csdn.net/guyuealian/article/details/51119499 链表内容 ，（）单链表的结点结构，实现反转的方法 （1 递归//2 遍历 // ）

题目：

输入一个链表，从尾到头打印链表每个节点的值。

实验平台：牛客网

思路：

通常，这种情况下，我们不希望修改原链表的结构。返回一个反序的链表，这就是经典的“后进先出”，我们可以使用栈实现这种顺序。每经过一个结点的时候，把该结点放到一个栈中。当遍历完整个链表后，再从栈顶开始逐个输出结点的值，给一个新的链表结构，这样链表就实现了反转。

代码：

java：

1 用递归

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    ArrayList<Integer> valueList = new ArrayList<Integer>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
       Stack<Integer> valueStack = new Stack<Integer>();  // 利用栈
		ListNode node = listNode;
		while(node != null){
			valueStack.push(node.val);
			node = node.next;
		}
		while(valueStack.size() > 0){
			valueList.add(valueStack.pop());
		}
		return valueList;
    }
}

--------------------- 
作者：雨破尘 
来源：CSDN 
原文：https://blog.csdn.net/wang454592297/article/details/79400211 
版权声明：本文为博主原创文章，转载请附上博文链接！

2 利用栈

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    ArrayList<Integer> valueList = new ArrayList<Integer>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
       Stack<Integer> valueStack = new Stack<Integer>();  // 利用栈
		ListNode node = listNode;
		while(node != null){
			valueStack.push(node.val);
			node = node.next;
		}
		while(valueStack.size() > 0){
			valueList.add(valueStack.pop());
		}
		return valueList;
    }
}

--------------------- 
作者：雨破尘 
来源：CSDN 
原文：https://blog.csdn.net/wang454592297/article/details/79400211 
版权声明：本文为博主原创文章，转载请附上博文链接！

python：

 1 用栈

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        stack = []
        value_list = []
        node = listNode
        while node is not None:
            stack.append(node)
            node = node.next
        while len(stack) > 0:
            value_list.append(stack[-1].val)
            stack.pop()
        return value_list

--------------------- 
作者：雨破尘 
来源：CSDN 
原文：https://blog.csdn.net/wang454592297/article/details/79400211 
版权声明：本文为博主原创文章，转载请附上博文链接！

2 对于python来讲，不用如此麻烦，我们可以直接使用列表的插入方法，每次插入数据，只插入在首位。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        result = []
        while listNode:
            result.insert(0, listNode.val)
            listNode = listNode.next
        return result

c++

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