单链表逆置的三种方法（头插法逆置、就地逆置、递归逆置）顺序表【数组】的逆置的代码实现（使用java语言实现，用对象模拟内存结构和指针）

单链表节点定义

/**
 * className:LNode
 *
 * @author:zjl
 * @version:0.1
 * @date:2020/7/1622:25
 * @since:jdk1.8
 */
public class LNode {

    private Object data;
    private LNode next;

    public LNode() {
        this.data = null;
        this.next = null;
    }

    public LNode(LNode next) {
        this.next = next;
    }

    public Object getData() {
        return data;
    }

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

    public LNode getNext() {
        return next;
    }

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

单链表定义

/**
 * className:LinkList
 *
 * @author:zjl
 * @version:0.1
 * @date:2020/7/1622:28
 * @since:jdk1.8
 */
public class LinkList {

    private LNode p;

    public LinkList() {
        this.p = new LNode();
    }
    public LinkList(LNode p){this.p =p;}

    public LNode getP() {
        return p;
    }

    public void setP(LNode p) {
        this.p = p;
    }
}

单链表逆置实现及测试类

/**
 * className:LinkListInverse
 *
 * @author:zjl
 * @version:0.1
 * @date:2020/7/1622:23
 * @since:jdk1.8
 */
public class LinkListInverse {

    public static void main(String[] args) {

        //创建一个单链表
        LinkList linkList = new LinkList();
        LNode p = linkList.getP();
        for (int i = 0; i <10 ; i++) {
            LNode lNode = new LNode();
            lNode.setData(i);
            p.setNext(lNode);
            p=p.getNext();
        }
        //输出原始链表
        System.out.print("原始链表linkList：");
        show(linkList);
        //使用方法①逆置链表linkList得到linkList1
        LinkList linkList1 = method1(linkList);
        System.out.println();
        //输出方法①逆置后的链表linkList1
        System.out.print("使用方法①逆置链表linkList得到linkList1:");
        show(linkList1);
        //使用方法②逆置链表linkList1得到linkList2
        LinkList linkList2 = method2(linkList1);
        System.out.println();
        //输出方法②逆置后的链表linkList2
        System.out.print("使用方法②逆置链表linkList1得到linkList2:");
        show(linkList2);
        //使用方法③逆置链表linkList1得到linkList3
        LinkList linkList3 = method3(linkList);
        System.out.println();
        //输出方法③逆置后的链表linkList3
        System.out.print("使用方法③逆置链表linkList2得到linkList3:");
        show(linkList3);
    }


    /**
     * 方法①  头插法 将头节点之后的节点依次次用头插法插入到头节点之后
     * 插入到头节点后
     * @param linkList
     * @return
     */
    public static LinkList method1(LinkList linkList){
        LNode r = linkList.getP().getNext();//始终指向要进行插入操作的节点
        LNode t;
        while (r!=null){
            t=r.getNext();//暂存r节点的next域
            r.setNext(linkList.getP().getNext());//第一个节点next域会指向自己
            if(linkList.getP().getNext()==r)    //并且最后会成为尾节点
                r.setNext(null);                //将其next域置为null
            linkList.getP().setNext(r);
            r=t;
        }

        return linkList;
    }

    /**
     * 方法②  就地逆置
     * @param linkList
     * @return
     */
    public static LinkList method2(LinkList linkList){

        LNode p=linkList.getP().getNext();//初始时候p指向第1个节点
        LNode q =p.getNext();//初始时候p指向第2个节点

        while (q!=null){
            LNode temp = q.getNext();//暂存p的next域名
            q.setNext(p);//q的next指针指向其前驱结点
            p=q; //p后移
            q=temp;//q后移
        }
        linkList.getP().getNext().setNext(null);//尾节点next域置为null
        linkList.getP().setNext(p);//使用原头节点作为逆置后链表的头节点
        return linkList;
    }

    /**
     * 方法③ 递归法 核心部分在inverse(LNode head)方法中
     * @param linkList
     * @return
     */

    public static LinkList method3(LinkList linkList){
        LNode k = linkList.getP();
        LNode t =k.getNext();
        LNode node = inverse(t); //调用方法将从头结点之后的链表逆置
        k.setNext(node); //将逆置的链表链接在头结点之后
        return linkList;
    }

    public static LNode inverse(LNode head){
        if(head.getNext()==null)
            return head;
        LNode node = inverse(head.getNext());        //最终node指向原链表的尾结点
        head.getNext().setNext(head);
        head.setNext(null);
        return node;
    }

    /**
     * 控制台输出链表
     * @param linkList
     */
    public static void show(LinkList linkList){
        LNode p = linkList.getP();
        while (p.getNext()!=null){
            p = p.getNext();
            System.out.print(p.getData());
            if(p.getNext()==null)
                continue;
            System.out.print("->");
        }
    }

}

单链表逆置测试结果

顺序表【数组】逆置实现及测试类

/**
 * className:SeListInvers
 *
 * @author:zjl
 * @version:0.1
 * @date:2020/7/1621:51
 * @since:jdk1.8
 */
public class SeListInvers {


    public static void main(String[] args) {

        //Test

        int a[] = {0,1,2,3,4,5,6,7,8,9};
        System.out.println("============逆置前的数组a=============");
        for (int i : a) {
            System.out.print(i+"  ");
        }

        //逆置
        int[] ls = sequenceListInvers(a);
        System.out.println("\n============逆置后的数组a=============");
        for (int i : ls) {
            System.out.print(i+"  ");
        }
        System.out.println("\n======================================");
    }

    /**
     * 顺序表（数组）逆置
     * @param objs
     * @return
     */
    public static int[] sequenceListInvers(int[] sl ){
        int temp;
        int i,j;
        i=0;j=sl.length-1;
        while (i<j){
            temp = sl[j];
            sl[j] = sl[i];
            sl[i] = temp;
            i++;
            j--;
        }
        return sl;
    }

}

顺序表（数组）逆置测试结果