剑指Offer - 06.从尾到头打印链表（栈、Lisr递归、List迭代）

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

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

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

限制： 0 <= 链表长度 <= 10000

分析&coding

这个题就是简单的遍历链表，但是这里值得注意的一点就是它需要逆序的结果。下面提供三种解法：

1.栈(推荐)

性能虽然不是最优，但是想法很好

那么这里提到逆序首先想到的就是我们所学过的 栈 结构，先进后出刚好就得到了我们需要的结果。

时间复杂O(n)，空间复杂度O(n)

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

2.List递归

使用一个List来存储元素。首先判断当前节点是否为空，不为空就把当前元素存入list中，之后指针向后移动一个位置，直到为空截至。

时间复杂O(n)，空间复杂度O(n)

class Solution {
    List<Integer> list;
    public int[] reversePrint(ListNode head) {
        list = new ArrayList<Integer>();
        dfs(head);
        int[] res = new int[list.size()];
        for(int i=0;i<list.size();i++){
            res[i] = list.get(i);
        }
        return res;
    }
    public void dfs(ListNode node){
        if(node != null){
            dfs(node.next);
            list.add(node.val);
        }
    }
}

3.List迭代(推荐)

性能最优

迭代法在大多数情况下性能由于递归法，推荐使用。当前节点不为空，先存储当前元素，之后指针向后移动一个位置，直到为空截至。

时间复杂O(n)，空间复杂度O(n)

class Solution {
    public int[] reversePrint(ListNode head) {
       List<Integer> list = new ArrayList<>();
       while(head!=null){
           list.add(head.val);
           head = head.next;
       }
       int size = list.size();
       int[] res = new int[size];
       for(int i=0;i<size;i++) res[i] = list.get(size - i -1);
       return res;  
    }
}

总结

以上三种解法的时间复杂度和空间复杂度都一样，但是实际跑起来就会有一些性能上的差别，一些简单的方法就会使得代码允许起来更快，比如：

1. 使临时变量就比全局变量快，因为临时变量在栈中创建和销毁，不会涉及到堆内存中，但是全局变量就会涉及到堆内存中，时间当然会花费多一些。
2. 使用位运算符就比基本运算符快，这是毋庸置疑的，因为CPU可以直接识别位运算符，不用转换。
3. … …

当然，代码是否足够优秀，也是更具实际情况来判断的，既要易读又要节省性能！