NO.06 单向链表反转
例如：将一个单项链表1234567，反转输出为7654321

先写一个单项链表Node类方便以后调用

//单向链表
public class Node {

    String data;
    Node next;

    public Node(String data) {
        super();
        this.data = data;
    }

    public Node(String data, Node next) {
        super();
        this.data = data;
        this.next = next;
    }

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

    public String getData() {
        return data;
    }

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

    public Node getNext() {
        return next;
    }
}

算法如下：

public class NO06 {
    public static void main(String[] args) {
        Node node1 = new Node("1");
        Node node2 = new Node("2");
        Node node3 = new Node("3");
        Node node4 = new Node("4");
        Node node5 = new Node("5");
        Node node6 = new Node("6");
        Node node7 = new Node("7");
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);
        node5.setNext(node6);
        node6.setNext(node7);
        NO06A no06A = new NO06A();

        Node newNode = no06A.reverse1(node1);
        while (newNode != null){
            System.out.println(newNode.data);
            newNode = newNode.getNext();
        }

        //no06A.reverse2(node1);
    }
}

class NO06A{
   Node reverse1(Node head){
       Node pre = head;
       Node cur = pre.getNext();
       while (cur != null) {
           Node temp = cur.getNext();
           cur.setNext(pre);
           pre = cur;
           cur = temp;
       }
       head.setNext(null);
       return pre;
   }

   Node reverse2(Node head){
       if (head.getNext() == null){
           System.out.println(head.data);
           return head;
       }
       reverse2(head.getNext());
       head.getNext().setNext(head);
       head.setNext(null);
       System.out.println(head.data);
       return head;
   }

}

reverse1()为非递归解法，reverse2()为递归解法

非递归解法思路：
创建一个temp节点，方便前一个节点修改指针之后能够顺利找到原本指向的下一个的节点。（也就是说如果没有temp节点，修改指针之后的节点是无法找到原本的下一个节点的）

递归解法思路：
方法中套用方法，使得最后一个节点事实上最先被调用，然后反顺序修改节点的指针指向，逆向递归输出节点。