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

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

原题

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

示例 1：

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

限制：

0 <= 链表长度 <= 10000

解法1

使用 stack 先进后出的特性，先将链表的数据压入栈，然后再一个个推出。

我的解法1

Stack push,pop. 空间 O（2N），时间 O（2N）

/**
 * 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<Integer>();
        ListNode node = head;
        int size = 0;
        while(null != node){
            stack.push(node.val);
            node = node.next;
            size++;
        }
        int[] result = new int[size];
        int i = 0;
        while(!stack.isEmpty()){
            result[i++] = stack.pop();
        }
        return result;
    }
}

解法2

遍历一遍链表，将指针逆向，再遍历一遍链表即可。

我的解法2

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        if(null == head){
            return new int[0];
        }
        ListNode now = head;
        ListNode pre = null;
        ListNode next = head.next;
        int size = 0;
        while(null != now){
            now.next = pre;

            pre = now;
            now = next;
            if(null != now)
            next = now.next;
            size ++;
        }
        int[] result = new int[size];
        int i = 0;
        ListNode newHead = pre;
        while(null != newHead){
            result[i++] = newHead.val;
            newHead = newHead.next;
        }
        return result;
    }
}

结果

递归

看题解，可以使用递归，一直递归到最后一个元素，开始返回

我的实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        // 递归
        List<Integer> list = new ArrayList<Integer>();
        reverse(head,list);
        int[] result = new int[list.size()];
        for (int i = 0; i < list.size(); i++){
            result[i] = list.get(i);
        }
        return result;
    }

    private void reverse(ListNode node,List<Integer> list){
        if(null == node){
            return;
        }
        if(null != node.next){
            reverse(node.next,list);
        }
        list.add(node.val);
    }
}

结果