LeetCode.206. 反转链表

LeetCode.206. 反转链表

题目描述：
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
分析：最容易想到的就是，将链表的val值拷贝到一个数组之中，然后再将数组中的数倒着赋值给链表的val。需要多次遍历。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null){//先排除链表为空的情况，直接返回即可
            return head;
        }
        ListNode cur = head;
        //为了遍历不改变头指针的位置，令cur = head，
        //之后的cur1、cur2、也是如此原因
        int size = 0;//定义所需数组的大小
        while(cur.next != null){//此循环只能遍历到尾结点前一个结点，
            size++;            //所以这里得到的size实际比真实的size小1；
            cur = cur.next;
        }
        int[] nums = new int[size+1];//定义数组，数组大小为size + 1；
        int i = 0;
        ListNode cur1= head;
        while(cur1.next != null){//将val 拷贝到数组中
            nums[i] = cur1.val;
            i++;
            cur1 = cur1.next;
            if(cur1.next == null){//因为这个循环遍历不到尾结点
                nums[i] = cur1.val;
                //所以需要提前考虑，当cur1到达尾结点前一个结点时，就需要拷贝尾结点的val
            }
        }
        ListNode cur2= head;
        while(cur2.next != null){
            cur2.val = nums[i];//因为在上面i通过i++，i的值已经是数组的最后一位了
            i--;//所以这里的倒序，可以通过i--完成
            cur2 = cur2.next;
            if(cur2.next == null){//与上面一样，抵达不了尾结点，提前拷贝
                cur2.val = nums[0];
            }
        }
        return head;

    }
}

现在了解到上面的不能遍历到尾结点的问题可以用
while（cur ！= null）解决

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null){//先排除链表为空的情况，直接返回即可
            return head;
        }
        ListNode cur = head;
        //为了遍历不改变头指针的位置，令cur = head，
        //之后的cur1、cur2、也是如此原因
        int size = 0;//定义所需数组的大小
        while(cur != null){//得到的就是数组的大小
            cur = cur.next;
        }
        int[] nums = new int[size];//定义数组，数组大小为size ；
        int i = 0;
        ListNode cur1= head;
        while(cur1 != null){//将val 拷贝到数组中
            nums[i] = cur1.val;
            i++;
            cur1 = cur1.next;
            
        }
        ListNode cur2= head;
        while(cur2 != null){
            cur2.val = nums[i-1];//因为在上面i通过i++，i-1的值已经是数组的最后一位了
            i--;//所以这里的倒序，可以通过i--完成
            cur2 = cur2.next;
           
        }
        return head;

    }
}

迭代：

先提前拷贝cur.next的地址，以防将cur的next指向prev后，与后面的链表失联
将cur的next保存prev的地址，
然后将prev移动到原先cur的位置，
再将cur移动到next的位置；
重复如此。
循环的条件为cur ！= null

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev =null;
        ListNode cur = head;
        while(cur != null){
            ListNode next = cur.next;
            cur.next = prev;
            prev = cur;
            cur = next;
        }
        return prev;//返回prev为此时的头指针，cur现在= null
    }
}