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

06. 从尾到头打印链表

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

示例 1：

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

限制：

0 <= 链表长度 <= 10000

解法一：

借用递归，递归时记录节点个数和当前结点的位置，递归到尾节点后创建数组，获取链表长度，回溯时开始给数组赋值

class Solution {
    public int[] res;
    public int len = 0;

    // 借用列表
    public int[] reversePrint(ListNode head) {
        // 一边递归，一边记录节点个数
        recursion(head, 0);
        return res;
    }

    public void  recursion(ListNode head, int index){
        // 如果head不为空，节点个数加一
        if(head != null){
            // 后移
            //head = head.next;
            recursion(head.next, index + 1);
            // 等回溯回来的时候添加这个结点的值到int数组
            res[len - index - 1] = head.val;
        }else{        // 如果head为空，创建一个index长度的int数组
            res = new int[index];
            len = index;
        }
    }
}

leetcode运行时间为1ms, 空间为40.4mb

复杂度分析：

时间复杂度：对列表的进行了一次递归遍历，所以时间复杂度为O(n)

空间复杂度：空间复杂度为栈的深度，即链表结点个数，另外还需要一个int[]数组用来存储结果，所以空间复杂度为O(2n)

另一种写法：

先用一个 list 把结果存下来，然后拷贝到数组中

class Solution {

    public ArrayList<Integer> list = new ArrayList<>();
    // 借用递归
    public int[] reversePrint(ListNode head) {

        // 递归遍历链表，每次把结点插入到list
        recursion(head);

        int len = list.size();
        int[] res = new int[len];
        for(int i = 0; i < len; i++){
            res[i] = list.get(i);
        }
        return res;
    }

    public void recursion(ListNode head){
        if(head == null){
            return;
        }else{
            recursion(head.next);
            list.add(head.val);
        }
    }
}

leecode运行时间为1ms, 空间为40.2mb

复杂度分析：

时间复杂度：对列表的进行了一次递归遍历，后面还需要遍历一次 list 进行数据拷贝，所以时间复杂度为O(2n),

空间复杂度：空间复杂度为栈的深度，即链表结点个数，另外还需要一个int[]数组用来存储结果，还用到了一个临时 list ,所以空间复杂度为O(3n)

解法二：

借助容器，ArrayList, stack, 比如 rraylist，遍历链表的时候每次把结果插入到 list，最后把 ArrayList 中的数据拷贝到一个数组即可

遍历链表的时候不要把值插入到 list 头部，这样会导致 list 内部元素的移动，会大大降低效率。

class Solution {

    // 借用递归
    public int[] reversePrint(ListNode head) {
        ArrayList<Integer> list = new ArrayList<>();
        // 遍历链表，每次把结点插入到list
        while(head != null){
            list.add(head.val);
            head = head.next;
        }

        int len = list.size();
        int[] res = new int[len];
        for(int i = 0; i < len; i++){
            res[i] = list.get(len - i - 1);
        }
        return res;
    }
}

leetcode运行时间为1ms,空间为39.2MB

复杂度分析：

时间复杂度：遍历了一次链表，遍历了一次list, 所以时间复杂度是O(2n)

空间复杂度：一个len大小的list, 一个len大小的数组，所以空间复杂度为O(2n)