剑指offer第二版面试题24：反转链表（java）

题目描述：
定义一个函数，输入一个链表的头结点，反转该链表并输出反转后的链表的头结点。链表结点如下：

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

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

分析：
要想反转链表，对于结点i，我们要把它的next指向它的前趋，因此我们需要保存前趋结点，同时，如果我们已经把i的next重新赋值，会无法找到i的后继，因此，在重新赋值之前，我们要保存i的后继。

代码如下：

/**
 * 反转链表
 * 题目：定义一个函数，输入一个链表的头节点，反转该链表并输入反转后该链表的头节点
 */
public class ReverseList {

    public ListNode reverse(ListNode head){
        //如果输入的链表为空，就直接返回空
        if(head == null){
            return null;
        }

        //如果输入的链表只有一个节点，即：头节点。则直接返回该节点
        if(head.next == null){
            return head;
        }

        //定义反转后链表的头节点
        ListNode revHead = null;
        //当前节点
        ListNode curNode = head;

        while(curNode != null){
            ListNode tmpNode = curNode.next;        //记录下当前节点的下一个节点
            curNode.next = revHead;             //将当前节点的下一个节点反转指向反转链表的头节点
            revHead = curNode;
            curNode = tmpNode;
        }

        return revHead;
    }

    public static void main(String[] args) {
        ReverseList test = new ReverseList();

        ListNode head = new ListNode();
        ListNode temp1 = new ListNode();
        ListNode temp2 = new ListNode();
        ListNode temp3 = new ListNode();
        ListNode temp4 = new ListNode();
        ListNode temp5 = new ListNode();

        head.value = 1;
        temp1.value = 2;
        temp2.value = 3;
        temp3.value = 4;
        temp4.value = 5;
        temp5.value = 6;
        head.next = temp1;
        temp1.next = temp2;
        temp2.next = temp3;
        temp3.next = temp4;
        temp4.next = temp5;
        temp5.next = null;

        System.out.println("反转前：");
        test.printList(head);
        System.out.println();
        //执行反转操作
        ListNode reverseHead = test.reverse(head);
        test.printList(reverseHead);

    }

    //打印列表
    public void printList(ListNode head){
        while(head != null){
            System.out.print(head.value + "  ");
            head = head.next;
        }
    }
}

class ListNode{
    int value;
    ListNode next;
}

使用递归实现：

/**
 * 使用递归实现：链表的反转
 */
public class Solution {

    public static ListNode reverse(ListNode head) {
        // 参数校验
        if (head == null || head.next == null) {
            return head;
        }

        ListNode secondElem = head.next;
        head.next = null;
        ListNode revHead = reverse(secondElem);
        secondElem.next = head;
        return revHead;
    }

    public static void main(String[] args) {
        ListNode head = new ListNode();
        head.value = 1;
        ListNode node2 = new ListNode();
        node2.value = 2;
        ListNode node3 = new ListNode();
        node3.value = 3;
        ListNode node4 = new ListNode();
        node4.value = 4;
        ListNode node5 = new ListNode();
        node5.value = 5;
        ListNode node6 = new ListNode();
        node6.value = 6;

        head.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;

        printList(head);
        System.out.println();
        ListNode revHead = reverse(head);
        printList(revHead);
    }

    // 打印列表
    public static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.value + "  ");
            head = head.next;
        }
    }

}