Java实现翻转单链表

• 首先定义单链表节点

public class Node {

    public int value;// 数据域
    public Node next;// 指针域

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

    public int getData() {
        return value;
    }

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

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

}

• 递归翻转法

  递归反转法是从后往前逆序反转指针域的指向
  基本思路：在反转当前节点之前先反转后续节点。这样从头结点开始，层层深入直到尾结点才开始反转指针域的指向。也就是从尾结点开始，逆向反转各个结点的指针域指向。

public static Node solution1(Node head) {

        // 当为空链或者只有头结点的时候，不做处理，直接返回头结点
        if (head == null || head.next == null) {
            return head;
        }

        // reHead是翻转后链表的头结点
        // 先反转后续节点head.getNext()
        Node reHead = solution1(head.getNext());

        // 将当前结点的指针域指向前一结点
        head.getNext().setNext(head);

        // 前一结点的指针域令为null;
        head.setNext(null);

        // 反转后新链表的头结点
        return reHead;

    }

• 遍历翻转法

  遍历反转法是从前往后反转各个结点的指针域的指向。
  将当前节点cur的下一个节点 cur.getNext()缓存到temp后，然后更改当前节点指针指向上一结点pre，反转当前结点指针指向前，先把当前结点的指针域用tmp临时保存。

public static Node solution2(Node head) {
        // 当为空链或者只有头结点的时候，不做处理，直接返回头结点
        if (head == null || head.next == null) {
            return head;
        }
        Node pre = head;// 上一个节点
        Node cur = head.getNext();// 当前节点
        Node temp;// 临时节点，做缓存用

        // 一直遍历到尾节点
        while (cur != null) {
            // 将当前节点的下一个节点缓存到temp中
            temp = cur.getNext();
            // 将当前节点的下一个指向前一个节点
            cur.setNext(pre);
            // 指针分别向前移动一步
            pre = cur;
            cur = temp;

        }
        // 将原来头节点的指针域置为空
        head.setNext(null);
        // 返回新链表的的头结点，也就是原来链表的尾节点
        return pre;
    }

• 完整代码

public class ReverseList {

    public static void main(String[] args) {

        Node head = new Node(0);
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        head.setNext(node1);
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);

        // 打印翻转前的链表
        Node node = head;
        while (null != node) {
            System.out.print(node.value + " ");
            node = node.next;
        }

        head = solution1(head);
        // head = solution2(head);

        System.out.println("\n=========================");

        // 打印翻转后的链表
        while (null != head) {
            System.out.print(head.value + " ");
            head = head.next;
        }
    }

    public static Node solution1(Node head) {

        // 当为空链或者只有头结点的时候，不做处理，直接返回头结点
        if (head == null || head.next == null) {
            return head;
        }

        // reHead是翻转后链表的头结点
        // 先反转后续节点head.getNext()
        Node reHead = solution1(head.getNext());

        // 将当前结点的指针域指向前一结点
        head.getNext().setNext(head);

        // 前一结点的指针域令为null;
        head.setNext(null);

        // 反转后新链表的头结点
        return reHead;

    }

    public static Node solution2(Node head) {
        // 当为空链或者只有头结点的时候，不做处理，直接返回头结点
        if (head == null || head.next == null) {
            return head;
        }
        Node pre = head;// 上一个节点
        Node cur = head.getNext();// 当前节点
        Node temp;// 临时节点，做缓存用

        // 一直遍历到尾节点
        while (cur != null) {
            // 将当前节点的下一个节点缓存到temp中
            temp = cur.getNext();
            // 将当前节点的下一个指向前一个节点
            cur.setNext(pre);
            // 指针分别向前移动一步
            pre = cur;
            cur = temp;

        }
        // 将原来头节点的指针域置为空
        head.setNext(null);
        // 返回新链表的的头结点，也就是原来链表的尾节点
        return pre;
    }

}