java笔试题系列之：实现链表的逆序

题目描述：
给定一个带头节点的单链表，请将其逆序。即如果单链表原来为head->1->2->3->4->5->6->7，则逆序后变为head->7->6->5->4->3->2->1。

单链表数据结构：

public class LNode {
    int data;
    LNode next;
}

方法一：就地逆序

主要思路：

• 在遍历链表时，修改当前节点的指针域的指向，让其指向它的前驱节点。
• 需要用一个指针变量来保存前驱节点的地址。
• 为了在调整当前节点指针域的指向后还能找到后继节点，还需要另外一个指针变量来保存后继节点的地址
• 在所有的节点都被保存好以后就可以直接完成指针的逆序了。
• 还需要提别注意对链表首尾节点的特殊处理。

public class ReverseList {


    public static void Reverse(LNode head){
        //判断链表是否为空
        if(head==null || head.next == null || head.next.next == null)
            return;
        LNode pre = null;    //前序节点
        LNode cur = null;    //当前节点
        LNode next = null;   //后继节点

        //把链表首节点变为尾节点
        cur = head.next;
        next = cur.next;
        cur.next = null;
        pre = cur;
        cur = next;

        //使当前遍历到的节点cur指向其前驱节点
        while(cur.next !=null){
            next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }

        //节点最后一个节点指向倒数第二个节点
        cur.next = pre;
        //链表的头节点指向原来链表的尾节点
        head.next = cur;
    }

    public static void main(String[] args) {
        //链表头结点
        LNode head = new LNode();
        head.next = null;
        LNode tmp = null;
        LNode cur = head;

        //构造单链表
        for(int i = 0; i<8; i++){
            tmp = new LNode();
            tmp.data = i;
            tmp.next = null;
            cur.next = tmp;
            cur = tmp;
        }

        System.out.println("逆序前：");
        for(cur = head.next;cur!=null;cur=cur.next)
            System.out.print(cur.data + " ");
        System.out.println("\n逆序后： ");
        Reverse(head);
        for(cur=head.next;cur!=null;cur=cur.next)
            System.out.print(cur.data+" ");

    }
}

输出如下所示：

算法性能分析：

• 只需要对链表进行一次遍历，时间复杂度为O(N)。N为链表的长度。
• 需要常数个额外的变量来保存当前节点的前驱节点和后继节点。因此，空间复杂度为O(1)

方法二：插入法

插入法的主要思路：

• 从链表的第二个节点开始，把遍历到的节点插入到头节点的后面，直到遍历结束。
• 假设原链表为head->1->2->3->4->5->6->7，则逆序后变为head->2->1->3->4->5->6->7
• 同理，将后续遍历的所有节点都插入到头节点head后，就可以实现链表的逆序

public class ReverseList {
    public static void Reverse1(LNode head){
        //判断链表是否为空
        if(head == null || head.next == null)
            return;

        //当前节点
        LNode cur = null;
        //后继节点
        LNode next = null;

        cur = head.next.next;

        //设置链表第一个节点为尾节点
        head.next.next = null;

        //把遍历到的节点插入到头节点的后面
        while (cur!=null){
            next = cur.next;
            cur.next = head.next;
            head.next = cur;
            cur = next;
        }
    }

    public static void main(String[] args) {
        //链表头结点
        LNode head = new LNode();
        head.next = null;
        LNode tmp = null;
        LNode cur = head;

        //构造单链表
        for(int i = 0; i<8; i++){
            tmp = new LNode();
            tmp.data = i;
            tmp.next = null;
            cur.next = tmp;
            cur = tmp;
        }

        System.out.println("逆序前：");
        for(cur = head.next;cur!=null;cur=cur.next)
            System.out.print(cur.data + " ");
        System.out.println("\n逆序后： ");
        Reverse1(head);
        for(cur=head.next;cur!=null;cur=cur.next)
            System.out.print(cur.data+" ");

    }
}

算法性能分析：

• 只需对单链表进行一次遍历，因此，时间复杂度为O(N)。
• N为链表的长度。