题目描述

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

分析：

问题是链表的反向遍历，于是第一种方法可以将链表反转，然后遍历即可。
缺点：会破坏原来的链表顺序。
优点：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),但是实际上涉及空间分配、栈的操作等，实际表现不是很好。

递归

标签：head,int,res,next,链表,offer06,从尾,节点
来源： https://www.cnblogs.com/XT-xutao/p/12881908.html