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

二维数组中的查找。

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

示例 1：

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

限制：

0 <= 链表长度 <= 10000

4种解法

解法1： 数组

• 遍历链表，计算元素个数
• 新建数组，从最后一个元素开始赋值

public int[] reversePrint(ListNode head) {
    int size = 0;
    ListNode temp = head;
    while (temp != null) {
        size++;
        temp = temp.next;
    }
    int[] ans = new int[size];
    for (int i = size - 1; i >= 0; i--) {
        ans[i] = head.val;
        head = head.next;
    }
    return ans;
}

复杂性分析

时间复杂度：O(n)
空间复杂度：O(1) 不包含返回数组的情况下

解法2：递归

• 递推阶段： 每次传入 head.next ，以 head == null（即走过链表尾部节点）为递归终止条件，此时直接返回。
• 回溯阶段： 层层回溯时，将当前节点值加入列表，即tmp.add(head.val)。
• 最终，将列表 tmp 转化为数组 ans ，并返回即可。

private List<Integer> tmp = new ArrayList<>();
public int[] reversePrint(ListNode head) {
    recursive(head);
    int[] ans = new int[tmp.size()];
    for (int i = 0; i < tmp.size(); i++) {
        ans[i] = tmp.get(i);
    }
    return ans;
}

private void recursive(ListNode head) {
    if (head == null) {
        return;
    }
    recursive(head.next);
    tmp.add(head.val);
}

复杂性分析

时间复杂度：O(n)
空间复杂度：O(n)

解法3：链表反转

• 反转链表
• 新建数组，从第一个元素开始赋值

public int[] reversePrint(ListNode head) {
    ListNode prev = null;
    ListNode curr = head;
    int size = 0;
    while (curr != null) {
        size++;
        ListNode tmp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = tmp;
    }
    
    int[] ans = new int[size];
    for (int i = 0; i < size; i++) {
        ans[i] = prev.val;
        prev = prev.next;
    }
    return ans;
}

复杂性分析

时间复杂度：O(n)
空间复杂度：O(1) 不包含返回数组的情况下

解法4：栈

• 借助栈先进后出的特性，依次将链表元素推入栈中
• 遍历栈，依次将元素推出放入数组中

public int[] reversePrint(ListNode head) {
    Stack<Integer> stack = new Stack<>();
    while (head != null) {
        stack.push(head.val);
        head = head.next;
    }
    int size = stack.size();
    int[] ans = new int[size];
    for (int i = 0; i < size; i++) {
        ans[i] = stack.pop();
    }
    return ans;
}

复杂性分析

时间复杂度：O(n)
空间复杂度：O(n)