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();
}