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

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

递归解法

这里的一个比较简单的办法就是递归，由于需要的是从尾部开始打印链表，所以也就是递归出栈时打印，所以添加元素的操作在出栈时完成。

/**
 * 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> vals = new ArrayList<>();
        dfs(head, vals);
        int[] ans = new int[vals.size()];
        for(int i = 0; i < vals.size(); i++) ans[i] = vals.get(i);
        return ans;
    }
    private void dfs(ListNode head, List<Integer> list) {
        if(head == null) return;
        dfs(head.next, list);
        list.add(head.val);
    }
}

栈解法

也可以自己调用栈，先讲所有元素都入栈，再依顺序出栈，这样得到的元素也是从尾部开始的。

/**
 * 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> st = new Stack<>();
        while(head != null) {
            st.push(head.val);
            head = head.next;
        }
        int[] ans = new int[st.size()];
        int idx = 0;
        while(!st.isEmpty()) ans[idx++] = st.pop();
        return ans;
    }
}

两趟遍历的解法

先一趟遍历确定长度，再从尾部开始遍历。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        int len = 0;
        ListNode p = head;
        while(p != null) {
            len++;
            p = p.next;
        }
        int[] ans = new int[len];
        p = head;
        for(int i = len - 1; i >= 0 && p != null; i--) {
            ans[i] = p.val;
            p = p.next;
        }
        return ans;
    }
}