剑指 Offer 24. 反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

限制：

0 <= 节点个数 <= 5000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

自我解(递归回溯，时间复杂度为O(n*n))

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null)
        return null;
        if(head.next == null)
        return head;
        int value;
        value = head.val;
        head = reverseList(head.next);
        ListNode node = head;
        while(node.next!=null)
        node = node.next;
        node.next = new ListNode(value);
        return head;

    }
}

自我解(通过数组，时间复杂度为O(n))

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null)
        return null;
        List<Integer> l = new ArrayList<Integer>();
        while(head!=null){
            l.add(head.val);
            head = head.next;
        }
        head = new ListNode(l.get(l.size()-1));
        l.remove(l.size()-1);
        ListNode node = head;
        while(!l.isEmpty()){
            node.next = new ListNode(l.get(l.size()-1));
            l.remove(l.size()-1);
            node = node.next;
        }
        return head;
    }
}

官方解(迭代，时间复杂度为O(n))

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}