【leetcode】 #206 反转链表

1.迭代方法实现

1.1 迭代链表，深复制新的节点

迭代链表，逐一深复制新的节点，创建新的链表，把新链表作为新节点的尾巴。

优点：最最简单的方法，缺点是新建对象需要额外消耗内存。

public class Leet206 {
    public ListNode reverseList(ListNode head) {
        if (head == null) {
            return null;
        }
        //迭代的当前节点
        ListNode iteratorNode;
        //新链表的临时节点
        ListNode temp;

        //反转后的链表
        ListNode newHead = null;

        //先处理第一个节点
        temp = new ListNode(head.val);
        newHead = temp;


        //后续节点采用迭代
        while ((iteratorNode = head.next) != null) {
            temp = new ListNode(iteratorNode.val);


            //原有的链表作为尾部添加至新的节点
            temp.next = newHead;
            //反转后的链表指向新的节点
            newHead = temp;

            head = iteratorNode;

        }
        return newHead;

    }
   
}

每次复制一个新的节点，不用维护旧链表的指向关系：

1.2 迭代，截断原有链表的节点

利用原有的链表，进行指针的修改。与第一种方法相比，不需要创建新的对象。

public class Leet206 {

    public ListNode reverseList(ListNode head) {

        //旧链表的引用
        ListNode oldHead;

        //反转后的链表
        ListNode newHead = null;

        while ( head != null) {
            //缓存对旧链表的引用
            oldHead =  head.next;
            //把原有的头节点加到队列头
            head.next = newHead;
            //新链表指向队列头部
            newHead = head;

            //移动直至旧链表下一个节点
            head = oldHead;

        }
        return newHead;

    }

   
}

思路就是利用原有的链表节点，截断与原有链表的关联，复用该节点，作为新链表的节点。

2. 递归方法实现

递归版本稍微复杂一些，其关键在于反向工作。假设链表的其余部分已经被反转，现在应该如何反转它前面的部分？

假设链表为：

若从节点 n{k+1}到 n{m} 已经被反转，而我们正处于 n{k}，比如现在对应3

我们希望 n{k+1}​ 的下一个节点指向 n{k} ​ 。即希望4能指向3

所以，n{k}.next.next = n{k}

需要注意的是 n1 (反转后的尾节点)的必须指向 ∅。如果忽略了这一点，链表中可能会产生环。

    public ListNode reverseList(ListNode head) {
       //入参就是null || 已经处理到最后一个节点了
        if(head==null || head.next==null){
           //最后一个节点，作为反转后链表的头节点，并返回
           return  head;
       }
       //递归算法，首先反转处理子节点的链
       ListNode newHead = reverseList(head.next);
       head.next.next = head;  //反转算法当前节点
       head.next = null;     //保证原来的头结点(反转后的尾节点)指向null

       return newHead;
    }

递归的逻辑是从头节点开始迭代，但是首先从下一个节点开始反转，最终目的是从最后一个节点开始反转；当子节点反转结束后，反转当前节点：