【LeetCode】【HOT】206. 反转链表（迭代/递归）

【LeetCode】【HOT】206. 反转链表

package hot;

import java.util.Arrays;

class ListNode{
    int val;
    ListNode next;

    ListNode(int val){
        this.val = val;
    }
}

public class Solution206 {
    public static void main(String[] args) {
        ListNode a1 = new ListNode(1);
        ListNode a2 = new ListNode(2);
        ListNode a3 = new ListNode(3);
        ListNode a4 = new ListNode(4);
        ListNode a5 = new ListNode(5);
        a1.next = a2;
        a2.next = a3;
        a3.next = a4;
        a4.next = a5;
        Solution206 solution = new Solution206();
        int[] res = new int[5];
        ListNode head = solution.itera(a1);
        for(int i = 0; i < 5; i++){
            res[i] = head.val;
            head = head.next;
        }
        System.out.println(Arrays.toString(res));
        ListNode b1 = new ListNode(1);
        ListNode b2 = new ListNode(2);
        ListNode b3 = new ListNode(3);
        ListNode b4 = new ListNode(4);
        ListNode b5 = new ListNode(5);
        b1.next = b2;
        b2.next = b3;
        b3.next = b4;
        b4.next = b5;
        res = new int[5];
        head = solution.itera(b1);
        for(int i = 0; i < 5; i++){
            res[i] = head.val;
            head = head.next;
        }
        System.out.println(Arrays.toString(res));
    }

    private ListNode itera(ListNode head){
        ListNode prev = null;
        ListNode cur = head;
        while(cur != null){
            ListNode next = cur.next;
            cur.next = prev;
            prev = cur;
            cur = next;
        }
        return prev;
    }
    //时间复杂度为 O(n)
    //空间复杂度为 O(1)

    private ListNode recur(ListNode head){
        if(head == null || head.next == null){
            return head;
        }
        ListNode newHead = recur(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }
    //时间复杂度为 O(n)
    //空间复杂度为 O(n)
}