单链表反转

单链表：链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
以“结点的序列”表示线性表称作线性链表（单链表），单链表是链式存取的结构。

反转单链表思路：
从头节点开始遍历，将每个节点的next指向它前面的那个节点。由于单链表只存储了它的下一个节点，因此需要用3个变量分别保存前一个节点，当前节点和当前节点的下一个节点。

先创建节点类,该节点类可以保存int类型的编号和String类型的name,如有需要保存任意类型的对象，可以参考jdk中LinkedList的源码。LinkedList可以当作双向链表使用，它的节点同时还保存了上一个节点。
Node.java

class Node {
    int no;
    String name;
    Node next;
    Node(){}
    public Node(int no, String name) {
        this.no = no;
        this.name = name;
    }
}

jdk中LinkedList中的Node

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

链表的实现
Linked.java

public class Linked {

    private Node head;

    public void addNode(Node node) {
        if (head == null){
            head = node;
            return;
        }
        Node temp = head;
        while (temp.next!=null) {
            temp = temp.next;
        }
        temp.next = node;
    }


    public Node removeNode(Node node) {
        if (head == null) {
            System.out.println("empty...");
            return null;
        }
        Node temp = head;
        Node val = null;
        boolean found=false;
        while (temp.next!= null ) {
            if (temp.next==node){
                val=temp.next;
                found=true;
                break;
            }
            temp = temp.next;
        }
        if (found){
            temp.next=val.next;
            System.out.println("remove:"+val);
            return val;
        }
        System.out.println("not found...");
        return null;
    }


    public void print(){
        if (head == null)
            return;
        Node temp = head;
        while (temp!=null) {
            System.out.println(temp);
            temp=temp.next;
        }
        System.out.println("end");
    }

Linked.java中关于反转链表的实现:

public void reverse(){
        //链表为空或只有一个节点，直接返回
        if (head==null||head.next==null)
            return ;
        
        //将当前节点指向头节点
        Node cur = head;
        Node next ;
        Node pre = null;
        while (cur!=null) {
              //保存当前节点的 next节点
              next = cur.next;
              //反转，将当前节点的next指向它前面的节点
              cur.next=pre;
              //当前节点cur反转完成，将保存前一个节点的指针后移
              pre = cur;
              //将当前节点后移
              cur= next;
        }
        //遍历完成，原链表中尾节点的 next节点为 null，此时cur为 null，cur的前一个节点pre应设为头节点
        head = pre;
        //反转完成
    }

创建Linked对象，添加几个节点，进行反转，结果如下

	原单链表
	Node{no=1, name='a}
	Node{no=2, name='b}
	Node{no=3, name='c}
	Node{no=4, name='d}
	Node{no=5, name='e}
	end
	反转单链表
	Node{no=5, name='e}
	Node{no=4, name='d}
	Node{no=3, name='c}
	Node{no=2, name='b}
	Node{no=1, name='a}
	end