剑指offer-15.反转链表（Java）

题目描述

输入一个链表，反转链表后，输出新链表的表头。

1.头插法1—移动结点

将结点依次插入到链表表头
当前待排序结点为q，p为待排结点 前一个结点
初始：p为head，q为p下一个结点
头插法：若当前待排结点q不为空，p->next = q->next， q->next = head, head = q
q= p->next

特殊情况：链表为空，返回空

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        
        if(head == null)
            return null;
        
        ListNode p = head; //待反转结点前一个结点
        ListNode q = p.next; //当前待反转结点                

        while(q!=null){
            p.next = q.next;
            q.next = head;
            head = q;
            q = p.next;            
        }
        
        return head;

    }
}

时间复杂度：O(n）
空间复杂度：O(1）

2.头插法—移动值

当前结点p，新建一个链表第一个结点h，h值域为head值域
每次循环，p不为空时， 新建结点q，q的值域为p 的值域，将q接到h前

特殊情况：链表为空，返回空

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        
        if(head == null)
            return null;
        
        ListNode h = new ListNode(head.val);
        ListNode p = head.next;
        
        h.next = null;
        
        
        while(p!=null){
            ListNode q = new ListNode(p.val);
            q.next = h;
            h = q;
            p = p.next;
        }
        
        return h;

    }
}

时间复杂度：O(n）
空间复杂度：O(n）

3.改变链表方向

当前节点为p，新建两个结点，当前结点后一个结点为next，前一个结点pre
原来是pre指向p，改为p指向pre， 返回pre

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        
        if(head == null || head.next == null)
            return head;
        
        ListNode pre = null;
        ListNode p = head;
        ListNode next = null; //下一个初始化为空
        
        
        while(p!=null){
        	//注意next = p.next位置，不能放在p= next 之后！！
            next = p.next;   //next为当前值下一个
            p.next = pre;
            pre = p;
            p = next;                
        }
        
        return pre;

    }
}

时间复杂度：O(n）
空间复杂度：O(1）