剑指 Offer 06. 从尾到头打印链表

剑指 Offer 06. 从尾到头打印链表

难度简单351

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

示例 1：

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

限制：

0 <= 链表长度 <= 10000

使用栈 两遍遍历

python3

# 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]:
        # 两遍遍历，一遍存入栈中，一遍存入答案中
        stack = []
        p = head
        while p != None:
            stack.append(p.val)
            p = p.next
        ans = []
        while len(stack) != 0:
            ans.append(stack.pop())
        return ans

Java

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        Stack<Integer> stack = new Stack<>();
        ListNode p = head;
        int len = 0;
        while(p != null){
            stack.push(p.val);
            p = p.next;
            len++;
        }
        int[] res = new int[len];
        int i = 0;
        while(!stack.isEmpty()){
            res[i++] = stack.pop();
        }
        return res;
    }
}

方法二：递归法

题解：https://leetcode.cn/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/solution/mian-shi-ti-06-cong-wei-dao-tou-da-yin-lian-biao-d/

解题思路

利用递归： 先走至链表末端，回溯时依次将节点值加入列表 ，这样就可以实现链表值的倒序输出。

• Python 算法流程：
  1. 递推阶段： 每次传入 head.next ，以 head == None（即走过链表尾部节点）为递归终止条件，此时返回空列表 [] 。
  2. 回溯阶段： 利用 Python 语言特性，递归回溯时每次返回 当前 list + 当前节点值 [head.val] ，即可实现节点的倒序输出。
• Java 算法流程：
  1. 递推阶段： 每次传入 head.next ，以 head == null（即走过链表尾部节点）为递归终止条件，此时直接返回。
  2. 回溯阶段： 层层回溯时，将当前节点值加入列表，即tmp.add(head.val)。
  3. 最终，将列表 tmp 转化为数组 res ，并返回即可。

复杂度分析

• 时间复杂度 $O(N)$： 遍历链表，递归 $N$ 次。
• 空间复杂度 $O(N)$： 系统递归需要使用 $O(N)$的栈空间。

java

class Solution {
    ArrayList<Integer> tmp = new ArrayList<Integer>();
    public int[] reversePrint(ListNode head) {
        recur(head);
        int[] res = new int[tmp.size()];
        for(int i = 0; i < res.length; i++)
            res[i] = tmp.get(i);
        return res;
    }
    void recur(ListNode head) {
        if(head == null) return;
        recur(head.next);
        tmp.add(head.val);
    }
}

python

class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        return self.reversePrint(head.next) + [head.val] if head else []