告别吧 - 单链表反转（Java 实现）

告别吧 - 单链表反转（Java 实现）

若有不足，还望指正，

一、递归实现

帮助理解：

编写递归代码时最重要的有以下三点 ： —— 摘自《算法 4》

（1）递归总有一个最简单的情况，即方法的第一条语句总是一个包含 return 的条件语句。
（2）递归调用总是去尝试解决一个规模更小的子问题，这样递归才能收敛到最简单的情况。含有某个参数一直在缩小。
（3）递归调用的父问题和尝试解决的子问题之间不应该有交集。

递归实现：

源代码：

public class Test {

    private static Node reverseByRecursion(Node head) {

        if (head == null || head.getNext() == null) {
            return head;
        }

        Node newHead = reverseByRecursion(head.getNext());

        head.getNext().setNext(head);
        head.setNext(null);

        return newHead;
    }

    public static void main(String[] args) {

        // 1、构建单链表
        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);

        // 2、反转
        Node newHead = reverseByRecursion(head.getNext());

        // 3、打印
        while (newHead != null) {
            System.out.print(newHead.getData() + " ");
            newHead = newHead.getNext();
        }
    }


}

class Node {

    private int data;
    private Node next;

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

    public int getData() {
        return data;
    }

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

    public Node getNext() {
        return next;
    }

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

二、迭代实现

思路：

源代码：

private static Node reverseByIterator(Node head) {

        if (head == null || head.getNext() == null) {
            return head;
        }

        Node pre = head;
        Node cur = head.getNext();
        Node tmp;

        while (cur != null) {
            tmp = cur.getNext();
            cur.setNext(pre);
            pre = cur;
            cur = tmp;
        }

        head.setNext(null);
        return pre;
    }