【转】链表的翻转（图解）

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

本文转载自http://blog.csdn.net/xyh269/article/details/70238501    没有任何的商业目的，仅仅只是作为个人的学习笔记。

如果侵权，麻烦告之，以及时删除。

链表结点定义如下：

public static class ListNode {
    int value;
    ListNode next;
}

public class Test16 {
    public static class ListNode {
        int value;
        ListNode next;
    }
    /**
     * 定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表的头结点。
     *
     * @param head 链表的头结点
     * @return 反转后的链表的头结点
     */
    public static ListNode reverseList(ListNode head) {
        // 创建一个临时结点，当作尾插法的逻辑头结点
        ListNode root = new ListNode();
        // 逻辑头结点点的下一个结点为空
        root.next = null;
        // 用于记录要处理的下一个结点
        ListNode next;
        // 当前处理的结点不为空
        while (head != null) {
            // 记录要处理的下一个结点
            next = head.next;
            // 当前结点的下一个结点指向逻辑头结点的下一个结点
            head.next = root.next;
            // 逻辑头结点的下一个结点指向当前处理的结点
            root.next = head;
            // 上面操作完成了一个结点的头插
            // 当前结点指向下一个要处理的结点
            head = next;
        }
        // 逻辑头结点的下一个结点就是返回后的头结点
        return root.next;
    }
    /**
     * 定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表的头结点。
     * 【书本上的方法，不使用逻辑头结点】
     *
     * @param head 链表的头结点
     * @return 反转后的链表的头结点
     */
    public static ListNode reverseList2(ListNode head) {
        // 用于记录反转后的链表的头结点
        ListNode reverseHead = null;
        // 用于记录当前处理的结点的
        ListNode curr = head;
        // 用于记录当前结点的前驱结点
        // 前驱结点开始为null，因为了是反转后的最后一个结点的下一个结点，即null
        ListNode prev = null;
        // 当前结点的下一个结点
        ListNode next;
        // 对链表进行尾插法操作
        while (curr != null) {
            // 记录当前处理的结点，最后一个记录的结点就是反转后的头结点
            // 【注意：与书上的不同，因为curr.next=null时，curr此时就最后一个处理的结点，
            // 对应到反转后的链表就是第一个结点，书上那样做更精确，只是多了一些判断，可以不要if】
            reverseHead = curr;
            // 记录当然前下一个结点
            next = curr.next;
            // 当前结点的下一个结点指向前驱结点，这样当前结点就插入到了反转链表的头部
            curr.next = prev;
            // 记录当前结点为前驱结点
            prev = curr;
            // 当前结点点移动到下一个结点
            curr = next;
        }
        // 返回转后的头结点
        return reverseHead;
    }
    /**
     * 输出链表的元素值
     *
     * @param head 链表的头结点
     */
    public static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.value + "->");
            head = head.next;
        }
        System.out.println("null");
    }
    public static void main(String[] args) {
        ListNode head = new ListNode();
        head.value = 1;
        head.next = new ListNode();
        head.next.value = 2;
        head.next.next = new ListNode();
        head.next.next.value = 3;
        head.next.next.next = new ListNode();
        head.next.next.next.value = 4;
        head.next.next.next.next = new ListNode();
        head.next.next.next.next.value = 5;
        head.next.next.next.next.next = new ListNode();
        head.next.next.next.next.next.value = 6;
        head.next.next.next.next.next.next = new ListNode();
        head.next.next.next.next.next.next.value = 7;
        head.next.next.next.next.next.next.next = new ListNode();
        head.next.next.next.next.next.next.next.value = 8;
        head.next.next.next.next.next.next.next.next = new ListNode();
        head.next.next.next.next.next.next.next.next.value = 9;
        printList(head);
        head = reverseList(head);
        printList(head);
        head = reverseList2(head);
        printList(head);
    }
}

 

解题思路：

节点类如下：

public class Node {

    public int value;
    public Node next;

    public Node(int data){
        this.value = data;
    }

}

反转单向链表的函数如下：

public Node reverseList(Node head){

    Node pre = null;
    Node next = null;

    while (head != null) {

        next = head.next;

        head.next = pre;

        pre = head;

        head = next;
    }

    return pre;
}

可以看到四行代码：

next = head.next; //1

head.next = pre; //2

pre = head; //3

head = next; //4

现在有一个单向链表如下图所示：

反转后如下所示： 

接下来解析反转函数： 
 
第一步：next = head.next 
将 head.next 赋值给 next 变量，也就是说 next 指向了节点2，先将节点2 保存起来。

第二步：head.next = pre 
将 pre 变量赋值给 head.next，即 节点1 指向了 null

第三步：pre = head

将 head 赋值给了 pre，即 pre 指向节点1，将节点1 设为“上一个节点”

第四步：head = next

将 next 赋值给 head，即 head 指向了节点2。将节点2 设为“头节点”

第一次循环完毕，进入第二次循环，如下图 
 
第一步：next = head.next 
将 head.next 赋值给 next 变量，也就是 next 指向了节点3，先将节点3 保存起来。

第二步：head.next = pre 
将 pre 赋值给 head.next，pre 在上一次循环的时候指向了节点1，那么这一步的意义就是节点2 指向了 节点1，完成一次反转

第三步：pre = head

将 head 赋值给了 pre，即 pre 指向节点2，将节点2 设为“上一个节点”

第四步：head = next

将 next 赋值给 head，即 head 指向了节点3。将节点3 设为“头节点”

第二次循环完毕，以此类推！第三次第四次第五次循环。最后反转成如下图 

总结

• 保存当前头节点的下一个节点（当前头节点为2，先将节点3 保存起来）

• 将当前头节点的下一个节点指向 “上一个节点”（当前头节点2 指向了 (“上一个节点”)节点1），这一步才是实现反转

• 将当前头节点设置 “上一个节点”（将节点2 设为“上一个节点”）

• 将保存的下一个节点设置 “头节点”（将节点3 设为“头节点”）