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

原题

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

示例 1：

输入：head = [1,3,2]

输出：[2,3,1]

限制：

0 <= 链表长度 <= 10000

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/

思路

Ⅰ. 反转链表

得到反转后的链表，遍历链表即可。

• C++代码

/**
 * 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> ans;
        ListNode* res = nullptr, *tmp = head;
        while (head != nullptr) {
            tmp = head->next;
            head->next = res;
            res = head;
            head = tmp;
        }
        while (res != nullptr) {
            ans.emplace_back(res->val);
            res = res->next;
        }
        return ans;
    }
};

• python代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        ans = []
        res = None
        while head:
            tmp = head.next
            head.next = res
            res = head
            head = tmp
        while res:
            ans.append(res.val)
            res = res.next
        return ans

Ⅱ. 栈

利用栈的先进后出性质，易解。

• C++代码

/**
 * 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) {
        stack<int> s;
        vector<int> ans;
        while (head) {
            s.push(head->val);
            head = head->next;
        }
        while (!s.empty()) {
            ans.emplace_back(s.top());
            s.pop();
        }
        return ans;
    }
};

• python代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        s = []
        while head:
            s.append(head.val)
            head = head.next
        return s[::-1]

Ⅲ. 递归

• C++代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
private:
    vector<int> ans;
public:
    vector<int> reversePrint(ListNode* head) {
        if (head == nullptr) {
            return {};
        }
        ans = reversePrint(head->next);
        ans.push_back(head->val);
        return ans;
    }
};

• python代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        if head is None:
            return []
        s = self.reversePrint(head.next)
        s.append(head.val)
        return s