leetcode刷题剑指 Offer 06. 从尾到头打印链表，Easy （Java）栈&递归&计数法

1.题目描述

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

示例 1：

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

、、；32-44
限制：

0 <= 链表长度 <= 10000

来源：力扣（LeetCode）
链接：剑指 Offer 06. 从尾到头打印链表
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.解法

2.1 栈

2.1.1 思路

我觉得栈比递归容易。
因为栈先进后出的顺序，所以它可以反转顺序。
直接把listnode一个个push进栈，最后pop()出来顺序自然就相反了。（其实也可以直接存值，占用的空间更少）。

2.1.2 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<ListNode> reverse = new Stack<ListNode>();
        int number = 0;
        while(head!=null){
            reverse.push(head);
            head = head.next;
            number++;
        }
        int[] answer = new int[number];
        for(int i=0;i<number;i++){
            ListNode temp = reverse.pop();
            answer[i] = temp.val;
        }
        return answer;
    }
}

2.2 递归

2.2.1 思路

递归的三要素

• 明确函数的功能
• 递归的结束条件
• 函数的等价关系

1.函数的功能就是反转链表
2.递归结束的条件就是到了节点为空
3.函数的等价关系是reversePrint(head) = cur+ reversePrint(head->next)

其中用了队列来存，因此递归的时候先到最后再向前，因此顺序已经反过来了。所以队列的顺序就是正确的顺序。

如果你们理解的话就看得懂：递归在前赋值在后，顺序就相反；如果赋值在前递归在后，则顺序就和链表顺序相同。

2.2.2 Java代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    ArrayList<Integer> temp = new ArrayList<Integer>();
    public int[] reversePrint(ListNode head) {
        recur(head);
        int n = temp.size();
        int []ans = new int[n];
        for(int i =0;i<n;i++){
            ans[i] = temp.get(i);
        }
        return ans;
    }
    public void recur(ListNode head){
        if(head == null){
            return;
        }
        recur(head.next);
        temp.add(head.val);
    }
}

2.3 不用栈和递归的计数法

2.3.1 思路

我是叫做计数法，我最开始想的就是这种，不用栈和递归。
利用了数组具有下标的特点。
直接从n开始，然后倒着往数组里存。
这个方法不好的一点就是要for两遍，其实但除了递归都要for两遍。

2.3.2 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) {
        ListNode temp = head;
        int number = 0;
        while(temp!=null){
            temp = temp.next;
            number++;
        }
        int[] answer = new int[number];
        for(int i=number-1;i>=0;i--){
            answer[i] = head.val;
            head = head.next;
        }
        return answer;
    }
}