如何实现链表的逆序？

下面介绍了两种方法：1.就地逆序法 2.插入法

单链表数据结构

/**
 * @program: 算法与数据结构
 * @description:  单链表数据结构
 * @author: 粉刷匠
 * @create: 2019-04-11 20:02
 */
public class LNode {

    int data;   //数据域
    LNode next;   //下一个结点的引用

}

方法一：就地逆序

/**
 * @program: 算法与数据结构
 * @description:    就地逆序实现 ：时间复杂度为O（N）、空间复杂度为O（1）
 *  思路：修改当前结点的指针域的指向，让其指向它的前驱结点。
 *    如何实现链表的逆序？
 *      1. 给定一个带头结点的单链表，请将其逆序。
 *             原来为：  head->1->2->3->4->5->6->7->8->9
 *             逆序后：  head->9->8->7->6->5->4->3->2->1
 * @author: 粉刷匠
 * @create: 2019-04-11 19:39
 */
public class Test_01 {

    /* 方法功能：对单链表进行逆序输出参数：head:链表头结点 */
    public  void Reverse(LNode head){

        //判断链表是否为空
        if(head==null||head.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=cur.next;
            cur=next;
        }
        //结点最后一个结点指向倒数第二个结点
        cur.next=pre;
        //链表的头结点指向原来链表的尾结点
        head.next=cur;

    }



}

方法二：插入法

/**
 * @program: 算法与数据结构
 * @description:   插入法实现 ：时间复杂度为O（N）、空间复杂度为O（1）
 *   思路：从链表的第二个结点开始，把遍历到的结点插入到头结点的后面，直到遍历结束；
 *   如何实现链表的逆序？
 *      1. 给定一个带头结点的单链表，请将其逆序。
 *              原来为：  head->1->2->3->4->5->6->7->8->9
 *              逆序后：  head->9->8->7->6->5->4->3->2->1
 * @author: 粉刷匠
 * @create: 2019-04-11 20:16
 */

public class Test_02 {

    public  void Reverse(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;
        }

    }

}

测试类

/**
 * @program: 算法与数据结构
 * @description: 主方法测试
 * @author: 粉刷匠
 * @create: 2019-04-11 20:10
 */
public class Main {


    public static void main(String[] args) {

        LNode head=new LNode();
        head.next=null;
        LNode temp=null;
        LNode cur=head;
        //创建单链表
        for (int i = 1; i <10 ; i++) {
            temp=new LNode();
            temp.data=i;
            temp.next=null;
            cur.next=temp;
            cur=temp;
        }
        System.out.print("逆序前：");

        for (cur=head.next;cur!=null ;cur=cur.next )
            System.out.print(cur.data+"-> ");

        System.out.println();
        System.out.print("逆序后：");
        Test_02 test_02=new Test_02();
        test_02.Reverse(head);
        for (cur=head.next;cur!=null ;cur=cur.next )
            System.out.print(cur.data+"-> ");

    }
}

测试结果

逆序前：1-> 2-> 3-> 4-> 5-> 6-> 7-> 8-> 9-> 
逆序后：9-> 8-> 7-> 6-> 5-> 4-> 3-> 2-> 1->