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

题目如下

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

---

1.题目解读

栈的特点是后进先出，即最后压入栈的元素最先弹出。
所以先将链表元素压入栈内
例如：
我们先将元素 1 2 3依次压入栈中，此时的链表 temp表示为1,2,3
由于栈的特点是后进先出
我们依次将栈中的元素弹出到一个数组print中，此时弹出的顺序是3 2 1，数组print表示为3,2,1，这样我们就完成了链表顺序倒置。

---

2.题目解法

java代码具体解法的实现

方法一：栈

使用栈将链表元素顺序倒置。从链表的头节点开始，依次将每个节点压入栈内，然后依次弹出栈内的元素并存储到数组中。创建一个栈，用于存储链表的节点
创建一个指针，初始时指向链表的头节点
当指针指向的元素非空时，重复下列操作：
将指针指向的节点压入栈内
将指针移到当前节点的下一个节点
获得栈的大小 size，创建一个数组 print，其大小为 size
创建下标并初始化 index = 0
重复 size 次下列操作：
从栈内弹出一个节点，将该节点的值存到 print[index]
将 index 的值加 1
返回 print

代码实现（有详细注解）

/**
 * 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<ListNode> stack = new Stack<ListNode>();
        //创建一个指针，初始时指向链表的头节点，将head元素压倒栈中
        ListNode temp = head; 
        //当指针指向的元素非空时,将指针指向的节点压入栈内,将指针移到当前节点的下一个节点
        while (temp != null) {
            stack.push(temp);
            temp = temp.next;
        }
        //创建一个数组size，数组大小为栈内节点的size
        int size = stack.size();
        int[] print = new int[size];
        //将弹出的元素装入到数组print中
        for (int i = 0; i < size; i++) {
            print[i] = stack.pop().val;
        }
        //输出print数组
        return print;
    }
}

复杂性分析：
时间复杂度：O(n)O(n)。正向遍历一遍链表，然后从栈弹出全部节点，等于又反向遍历一遍链表。
空间复杂度：O(n)O(n)。额外使用一个栈存储链表中的每个节点。

---

方法二：ArrayList解法

不使用栈，直接使用ArrayList也是可行，从ArrayList中倒序取出

public class Solution {
    public int[] reversePrint(ListNode head) {
    //创建ArrayList数组（类型为Integer）
        ArrayList<Integer> list = new ArrayList<>();
        //当head中元素不是空的时候，持续往ArrayList中添加元素
        while (head != null) {
            list.add(head.val);
            head = head.next;
        }
       //创建一个数组array，长度为list的size
        int size = list.size();
        int[] array = new int[size];
        // array[i] = list.get(size - i -1)反方向遍历集合类元素
        for (int i = 0; i < size; i++) {
            array[i] = list.get(size - i -1);
        }
        return array;
    }
}

---

方法三：双100解法

java无需借助Stack和ArrayList双100解法

public int[] reversePrint(ListNode head) {
        //先获取链表长度，创建对应长度数组
        ListNode currNode = head;
        int len = 0;
        while(currNode != null){
            len ++;
            currNode = currNode.next;
        }
        int[] result = new int[len];
        
        //再次遍历链表，将值倒序填充至结果数组
        currNode = head;
        while(currNode != null){
            result[len - 1] = currNode.val;
            len --;
            currNode = currNode.next;
        }
        return result;
    }

复杂性分析：
空间复杂度：O(1)
时间复杂度：O(n)

---

测试结果

方法一：栈

方法二：ArrayList解法

方法三：双100解法