【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 p = head.next;
        ListNode q = p.next;
        ListNode t = null;
        while (q != null) {
            t= q.next;
            q.next = p;
            p = q;
            q = t;
        }
        return p;
    }

    /**
     * 解法三：递归
     * 时间复杂度：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 printListFromTailToHead(ListNode listNode) {
        Stack stack = new Stack<>();
        while (listNode != null) {
            stack.push(listNode.val);
            listNode = listNode.next;
        }

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