【Java数据结构】逆置单链表,四种解法

class ListNode{
    int data;
    ListNode next;
}
public class Link{
   /**
     * 解法一：迭代：两个指针，反向输出
     * 时间复杂度：O(n)，空间复杂度：O(1)
     * 从原来的链表把第一个节点一个一个逮出来，然后头插到新链表中
     */
    public static ListNode reverseList1(ListNode head) {
        ListNode cur = head;      //原链表头结点
        ListNode node = null;    //暂时保存的原来的头结点
        ListNode result = null;   //新链表头结点
        while(cur != null){
            node = cur;
            cur = cur.next;
            node.next = result;
            result = node;
        }
        return result;
    }

    /**
     * 解法二：原地翻转，
     * 时间复杂度：O(n)，空间复杂度：O(1)
     */
    public static ListNode reverseList2(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }

    /**
     * 解法三：递归
     * 时间复杂度：O(n)，空间复杂度：O(n)
     */
    public static ListNode reverseList3(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }

        ListNode p = reverseList3(head.next);
        head.next.next = head.next;
        head.next = null;
        return p;
    }
    //解法四：使用栈，并返回List集合，jianzhioffer中的题
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<Integer> stack = new Stack<>();
        while (listNode != null) {
            stack.push(listNode.val);
            listNode = listNode.next;
        }

        ArrayList<Integer> list = new ArrayList<>();
        while (!stack.isEmpty()) {
            list.add(stack.pop());
        }
        return list;
    }
}