剑指offer06-从尾到头打印链表

题目描述

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

分析：

链表反转

问题是链表的反向遍历，于是第一种方法可以将链表反转，然后遍历即可。
缺点：会破坏原来的链表顺序。
优点：O(N)的时间复杂度其空间复杂度是O(1);

辅助栈

提到反向，就应该想到一种数据结构——栈，利用栈FILO的特性可以反转求值。
优点：不会破坏原链表，思路简单，编码容易。
缺点：需要借助栈，O(N)的复杂度。如果链表过长，性能消耗是一个问题。

递归

说到反向，还有一种方式可以实现——递归
递归可以实现从最里层开始，也就可以实现反向。

遍历后反转数组

最简单的思路
顺序遍历用数组存起来
反转数组或者利用另外一个数组

下面是实现：

链表反转

如何实现链表反转？最简单的办法是遍历节点，然后把该节点放到链表最前面，遍历结束就反转完毕了。

public int[] reversePrint(ListNode head) {
        if (head == null) return new int[0];
        ListNode H = head;//H指向头结点
        ListNode N = head.next; //N指向下一个待翻转的节点
        ListNode tmp;//临时节点
        int count=1;//统计节点数量
        while (N!=null){
            tmp = N;//先把N存起来防止后面修改
            head.next = N.next;//head的下一个指向N的下一个(head最终会成为尾节点)
            N.next = H;//N的下一个指向之前的下一个
            H =tmp;//N就变成了新的头结点
            N = head.next;//N往后移
            count++;
        }
        int []res = new int[count];
        int c = 0;
        //遍历
        while(H!=null){
            res[c++]=H.val;
            H= H.next;
        }
        return res;
}

性能很好，双100%；

辅助栈

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

虽然时间复杂度也是O(N),但是实际上涉及空间分配、栈的操作等，实际表现不是很好。

递归

    public int[] reversePrint(ListNode head) {
        ArrayList<Integer> list = new ArrayList<>();
        recur(list,head);
        int [] res = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            res[i] = list.get(i);
        }
        return res;
    }

    public void recur(ArrayList<Integer> list, ListNode head){
        if (head==null)return;
        recur(list,head.next);
        list.add(head.val);
    }
//写法可以优化