反转单链表

/**
 * @author 林夕
 * 反转单链表的算法
 */


//结点类
class Node{
    //变量
    private int record;
    //下个结点
    private Node nextNode;
    //构造函数
    public Node(int record){
        this.record = record;
    }
    
    public int getRecord(){
        return record;
    }
    public void setRecord(int record){
        this.record = record;
    }
    
    public Node getNextNode(){
        return nextNode;
    }
    public void setNextNode(Node nextNode){
        this.nextNode = nextNode;
    }
}


public class Solution {
    
    /**
     * 递归，在反转当前结点之前先反转后续结点
     * 递归函数的中的return语句：
     * return含义--->从被调函数返回到主调函数继续执行
    */
    public static Node reverse1(Node head){
        //链表为空或者本结点为末尾结点时
        if(head == null || head.getNextNode() == null){
            return head;
        }
        Node reverseHead = reverse1(head.getNextNode());
        //获取先前的下一个结点，让该结点指向自身
        head.getNextNode().setNextNode(head);
        //破坏以前自己指向的下一个结点
        head.setNextNode(null);
        return reverseHead;
    }
    
    public static Node reverse2(Node head) {
        if(null == head){
            return head;
        }
        Node pre = head;
        Node cur = head.getNextNode();
        Node next;
        
        while(cur != null){
            //断之前找到原始的下一个结点
            next = cur.getNextNode();
            //逆序连接
            cur.setNextNode(pre);
           //两个结点同时滑动
            pre = cur;
            cur = next;
        }
        
        //将原链表的头结点的下一个结点置为null，再将反转后的头结点赋给head
        head.setNextNode(null);
        head = pre;
        return head;
    }
    
    public static void main(String[] args){
        Node head = new Node(0);
        Node tmp = null;
        Node cur = null;
        //初始化一个大小为10的单链表
        for(int i = 1; i < 10; i++){
            tmp = new Node(i);
            if(i == 1){
                head.setNextNode(tmp);
            } else{
                cur.setNextNode(tmp);
            }
            cur = tmp;
        }
        
        Node h = head;
        while (h != null){
            System.out.print(h.getRecord()+" ");
            h = h.getNextNode();
        }
        
        head = reverse2(head);
        System.out.println("\n反转后的链表如下：");
        while (head != null){
            System.out.print(head.getRecord()+" ");
            head = head.getNextNode();
        }
    }
    
    
}