Java单链表反转图文详解

Java单链表反转图文详解

最近在回顾链表反转问题中，突然有一些新的发现和收获，特此整理一下，与大家分享

背景回顾

单链表的存储结构如图：

数据域存放数据元素，指针域存放后继结点地址

我们以一条 N1 -> N2 -> N3 -> N4 指向的单链表为例：

反转后的链表指向如图：

我们在代码中定义如下结点类以方便运行测试：

    /**
     * 结点类
     * （因为后续在main方法中运行，为了方便定义为static内部类）
     */
    static class Node {
        int val; // 数据域
        Node next; // 指针域，指向下一个结点

        Node(int x, Node nextNode) {
            val = x;
            next = nextNode;
        }
    }

通过循环遍历方式实现链表反转

实现思路：从链表头结点出发，依次循环遍历每一个结点，并更改结点对应的指针域，使其指向前一个结点

代码如下：

    /**
     * 循环遍历方式实现链表反转
     *
     * @param head 链表的头结点
     * @return
     */
    public static Node cycleNode(Node head) {

        Node prev = null; // 保存前一个结点的信息

        // 循环遍历链表中的结点
        while (head.next != null) {
            // 1. 先保存当前结点的下一个结点的信息到tempNext
            Node tempNext = head.next;
            // 2. 修改当前结点指针域，使其指向上一个结点（如果是第一次进入循环的头结点，则其上一个结点为null）
            head.next = prev;
            // 3. 将当前结点信息保存到prev中（以作为下一次循环中第二步使用到的"上一个结点"）
            prev = head;
            // 4. 当前结点在之前的123步中指针域已经修改完毕，此时让head重新指向待处理的下一个结点
            head = tempNext;
        }

        // 上面的循环完成后，实际只修改了原先链表中的头结点到倒数第二个结点间的结点指向，倒数第一个结点（尾结点）并未处理
        // 此时prev指向原先链表中的倒数第二个结点，head指向尾结点
        // 处理尾结点的指针域，使其指向前一个结点
        head.next = prev;

        // 返回尾结点，此时的尾结点既是原先链表中的尾结点，又是反转后的新链表中的头结点
        return head;
    }

测试效果：

    public static void main(String[] args) {
        // 构造测试用例，链表指向为 N1 -> N2 -> N3 -> N4
        Node n4 = new Node(4, null);
        Node n3 = new Node(3, n4);
        Node n2 = new Node(2, n3);
        Node n1 = new Node(1, n2);
        Node head = n1;
        // 输出测试用例
        System.out.println("原始链表指向为：");
        printNode(head);

        // 普通方式反转链表
        System.out.println("循环方式反转链表指向为：");
        head = cycleNode(head);
        printNode(head);
    }

    /**
     * 循环打印链表数据域
     * @param head
     */
    public static void printNode(Node head) {
        while (head != null) {
            System.out.println(head.val);
            head = head.next;
        }
    }

运行结果如图：

可以看到，原先指向为 N1 -> N2 -> N3 -> N4 的链表，运行反转方法后，其指向已变为 N4 -> N3 -> N2 -> N1

通过递归方式实现链表反转

实现思路：从链表头结点出发，依次递归遍历每一个结点，并更改结点对应的指针域，使其指向前一个结点（没错，实际每一次递归里的处理过程跟上面的循环里是一样的）

代码实现：

    /**
     * 递归实现链表反转
     * 递归方法执行完成后，head指向就从原链表顺序：头结点->尾结点 中的第一个结点（头结点） 变成了反转后的链表顺序：尾结点->头结点 中的第一个结点（尾结点）
     *
     * @param head 头结点
     * @param prev 存储上一个结点
     */
    public static void recursionNode(Node head, Node prev) {

        if (null == head.next) {
            // 设定递归终止条件
            // 当head.next为空时，表明已经递归到了原链表中的尾结点，此时单独处理尾结点指针域，然后结束递归
            head.next = prev;
            return;
        }

        // 1. 先保存当前结点的下一个结点的信息到tempNext
        Node tempNext = head.next;
        // 2. 修改当前结点指针域，使其指向上一个结点（如果是第一次进入递归的头结点，则其上一个结点为null）
        head.next = prev;
        // 3. 将当前结点信息保存到prev中（以作为下一次递归中第二步使用到的"上一个结点"）
        prev = head;
        // 4. 当前结点在之前的123步中指针域修改已经修改完毕，此时让head重新指向待处理的下一个结点
        head = tempNext;

        // 递归处理下一个结点
        recursionNode(head, prev);
    }

测试效果：

    public static void main(String[] args) {
        // 构造测试用例，链表指向为 N1 -> N2 -> N3 -> N4
        Node n4 = new Node(4, null);
        Node n3 = new Node(3, n4);
        Node n2 = new Node(2, n3);
        Node n1 = new Node(1, n2);
        Node head = n1;
        // 输出测试用例
        System.out.println("原始链表指向为：");
        printNode(head);

        // 递归方式反转链表
        System.out.println("递归方式反转链表指向为：");
        recursionNode(head, null);
        printNode(head);
    }

    /**
     * 循环打印链表数据域
     * @param head
     */
    public static void printNode(Node head) {
        while (head != null) {
            System.out.println(head.val);
            head = head.next;
        }
    }

注意：在上面的测试代码中，在调用递归函数时传递了Node类的实例head作为参数

根据Java中 方法调用传参中，基本类型是值传递，对象类型是引用传递 可得 =>

因为在调用递归函数时传递了head对象的引用，且在递归函数运行过程中，我们已经数次改变了head引用指向的对象，

那么当递归函数执行完毕时，head引用指向的对象此时理论上已经是原链表中的尾结点N4了，且链表顺序也已经变成了 N4 -> N3 -> N2 -> N1

运行效果截图：

最终的程序运行结果与我的设想大相径庭！

那么，问题出在哪里呢？

递归方式反转链表问题排查与延伸

问题定位

既然程序运行效果与预期效果不符，那我们就在head对象引用可能发生变化的地方加入注释打印一下对象地址，看看能不能发现问题在哪：

加入注释后的代码如下：

    public static void main(String[] args) {
        // 构造测试用例，链表指向为 N1 -> N2 -> N3 -> N4
        Node n4 = new Node(4, null);
        Node n3 = new Node(3, n4);
        Node n2 = new Node(2, n3);
        Node n1 = new Node(1, n2);
        Node head = n1;
        // 输出测试用例
        System.out.println("原始链表指向为：");
        printNode(head);

        // 递归方式反转链表
        System.out.println("递归方式反转链表指向为：");
        System.out.println("递归调用前 head 引用指向对象: " + head.toString());
        recursionNode(head, null);
        System.out.println("递归调用后 head 引用指向对象: " + head.toString());
        printNode(head);
    }

    /**
     * 循环打印链表数据域
     * @param head
     */
    public static void printNode(Node head) {
        while (head != null) {
            System.out.println(head.val);
            head = head.next;
        }
    }

    /**
     * 递归实现链表反转
     * 递归方法执行完成后，head指向就从原链表顺序：头结点->尾结点 中的第一个结点（头结点） 变成了反转后的链表顺序：尾结点->头结点 中的第一个结点（尾结点）
     *
     * @param head 头结点
     * @param prev 存储上一个结点
     */
    public static void recursionNode(Node head, Node prev) {
        System.out.println("递归调用中 head引用指向对象: " + head.toString());
        if (null == head.next) {
            // 设定递归终止条件
            // 当head.next为空时，表名已经递归到了原链表中的尾结点，此时单独处理尾结点指针域，然后结束递归
            head.next = prev;
            System.out.println("递归调用返回前 head引用指向对象: " + head.toString());
            return;
        }

        // 1. 先保存当前结点的下一个结点的信息到tempNext
        Node tempNext = head.next;
        // 2. 修改当前结点指针域，使其指向上一个结点（如果是第一次进入循环的头结点，则其上一个结点为null）
        head.next = prev;
        // 3. 将当前结点信息保存到prev中（以作为下一次递归中第二步使用到的"上一个结点"）
        prev = head;
        // 4. 当前结点在之前的123步中指针域修改已经修改完毕，此时让head重新指向待处理的下一个结点
        head = tempNext;

        // 递归处理下一个结点
        recursionNode(head, prev);
    }

运行结果：

从上面的运行结果看，在递归函数执行期间，head引用指向的对象确实发生了变化

注意 调用前 / 调用返回前 / 调用后 这三个地方head引用指向对象的变化：

可以发现，虽然递归函数执行期间确实改变了head引用指向的对象，但实际上是变了个寂寞！