JZ3 从尾到头打印链表（4种解法）

描述

输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组集合返回）。

示例1

输入：

{1,2,3}

复制返回值：

[3,2,1]

---

思路1：集合翻转

链表从头遍历，并将值存入Arraylist(返回值是个集合)，然后将集合进行反转 

Collections.reverse(ArrayList)  ，这个方法无返回值，但是将集合反转了

代码实现：

import java.util.ArrayList;
import java.util.Collections;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
//空链表，直接返回空集合
        if(listNode==null)
            return new ArrayList();
        ArrayList list = new ArrayList();
//链表遍历
        while(listNode!=null)
        {
            list.add(listNode.val);
            listNode=listNode.next;
        }
        Collections.reverse(list);
        return list;
    }
}

时间复杂度O(N)

空间复杂度O(N)  

思路2：利用头结点和头插法，将原链表节点一一摘下，接在新链表的头部

 

import java.util.List;
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(listNode==null)
        return new ArrayList();
        ArrayList<Integer> list = new ArrayList<>();
        ListNode head=new ListNode(0);
        ListNode cur=listNode;
        while(listNode!=null)
        {
            listNode=listNode.next;
            cur.next=head.next;
            head.next=cur;
            cur=listNode;
        }
        head=head.next;
        while(head!=null)
        {
            list.add(head.val);
            head=head.next;
        }
        return list;
    }
}

时间复杂度O(N)=O(N)

空间复杂度O(n) 集合长度，

思路3：辅助栈  栈的特点先进后出

import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(listNode==null)
            return new ArrayList();
        Stack<ListNode> stack = new Stack<>();
        while(listNode!=null)
        {
            stack.push(listNode);
            listNode = listNode.next;
        }
        ArrayList<Integer> list = new ArrayList<>();
        while(!stack.isEmpty())
        {
            ListNode node = stack.pop();
            list.add(node.val);
        }
        return list;
    }
}

时间复杂度O(n)

空间复杂度O(n)   集合长度

思路4：递归实现

import java.util.ArrayList;
public class Solution {
    ArrayList<Integer> list = new ArrayList<>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(listNode==null)
            return list;
        recur(listNode);
        return list;
    }
    private void recur(ListNode listNode)
    {
        if(listNode==null)
            return;
        recur(listNode.next);//递的过程
        list.add(listNode.val);//归的过程，一个一个加入list
    }
}

时间复杂度 O(N)  遍历链表

空间复杂度O(N)  集合以及递归栈，优点代码简洁，缺点会改变原链表结构，并且当链表过长时，可能会导致递归栈的溢出

关于复杂度的分析只是把系数去掉了，上面的解法涉及到list翻转、递归栈都是需要时间和空间的