递归逆转链表

import lombok.Data;

public class reverseLink {

    /**
     * 这个方式非常复杂
     * @param args
     */
    public static void main(String[] args) {
        LinkA linkA = new LinkA();
        Integer[] arr = {1, 2, 3, 4, 5};

        //创建数组A
        createLink(0, linkA, arr);
        System.out.println("创建链表A");
        //反转数组A创建数组B
        LinkB linkB = createLinkB(linkA);
        System.out.println("创建反转链表B");


    }

    /**
     * 创建示例链表
     * @param i
     * @param linkA
     * @param arr
     * @return
     */
    private static LinkA createLink(int i, LinkA linkA, Integer[] arr) {
        if (i == 0) {
            linkA.setVal(1);
        }
        if (i < arr.length - 1) {
            LinkA linkA1 = new LinkA();
            linkA1.setVal(arr[i + 1]);
            i = i + 1;
            linkA.setNext(createLink(i, linkA1, arr));
        }
        return linkA;
    }

    /**
     * 生成反转链表
     * @param linkA
     * @return
     */
    private static LinkB createLinkB(LinkA linkA ){
        return analysisLinkA(linkA, linkA.getVal(),"Y");

    }


    /**
     * 解析示例列表并且生成反转链表
     * @param linkA
     * @param val
     * @param judgeFlag
     * @return
     */
    private static LinkB  analysisLinkA(LinkA linkA ,int val,String judgeFlag){
        LinkB linkB = new LinkB();
        LinkB linkB1 = new LinkB();

        //解析到最后一层,比如第5层的话，那么next 对象为val = 4 ,next = null
        if(linkA.getNext() == null){
            linkB.setVal(linkA.getVal());
            linkB1.setVal(val);
            linkB.setNext(linkB1);
            return linkB;
        }
        linkB = analysisLinkA(linkA.getNext(),linkA.getVal(),"N");
        //过滤首次传值，next最后重复赋值
        if("Y".equals(judgeFlag)){
            return linkB;
        }

        //非最后一层,比如第4层的话，那么获取第5层的对象,第5层的对象在next里,并将val替换为第5层的val，然后递归第5层的返回值里的链表，获取最后一层，将当前层数的val设置到最后一层
        linkB.setVal(linkB.getVal());
        analysisNext(linkB.getNext(),val);
        return linkB;

    }

    /**
     * 递归解析生成的next对象，解析到最后一层时，将当前val值set到next链表里，且next == null
     * @param next
     * @param val
     * @return
     */
    private static LinkB  analysisNext(LinkB next , int val){

        if(next.getNext() == null){
            LinkB newLast = new LinkB();
            newLast.setVal(val);
            next.setNext(newLast);
            return next;
        }
        return analysisNext(next.getNext() ,val);

    }


}

@Data
class LinkA {

    private int val;

    private LinkA next;


}

@Data
class LinkB {
    private int val;
    private LinkB next;
}

//正常的反转链表
/**
 * 简单方式，也是大家正常用的方式
 */
 class LinkedListReverse {
    public ListNode11 reverse(ListNode11 head) {
        ListNode11 prev = null;
        ListNode11 current = head;

        while (current != null) {
            ListNode11 nextTemp = current.next; // 暂存当前节点的下一个节点
            current.next = prev; // 将当前节点指向前一个节点，实现反转
            prev = current; // 更新prev为当前节点
            current = nextTemp; // 更新当前节点为原始链表中的下一个节点
        }

        return prev; // 返回反转后的头节点
    }

    // 测试反转链表的代码
    public static void main(String[] args) {
        LinkedListReverse list = new LinkedListReverse();
        ListNode11 head = new ListNode11(1);
        head.next = new ListNode11(2);
        head.next.next = new ListNode11(3);
        head.next.next.next = new ListNode11(4);
        head.next.next.next.next = new ListNode11(5);

        System.out.println("原始链表:");
        printList(head);

        ListNode11 reversedHead = list.reverse(head);

        System.out.println("反转后的链表:");
        printList(reversedHead);
    }

    // 辅助方法，用于打印链表
    public static void printList(ListNode11 head) {
        ListNode11 current = head;
        while (current != null) {
            System.out.print(current.val + " ");
            current = current.next;
        }
        System.out.println();
    }