实现单向链表的反转

1.可以用临时变量前移方式逐步实现反转。
利用前中后三个临时变量，逐步前移并反转实现

public static <T> ListNode<T> reverseListTest1(ListNode<T> node){
ListNode<T> pre=null;
ListNode<T> cur=node;
ListNode<T> next=cur.next;
while(next!=null){
pre=cur;
cur=next;
next=next.next;
cur.next=pre;
}
node.next=null;
return cur;
}

2.可以利用递归的形式逐步逐步回调并反转
public static <T> ListNode<T> reverseListTest2(ListNode<T> node){
if (node.next!=null){
reverseListTest2(node.next).next=node;
node.next=null;
return node;
}
return node;
}

说明：
1> 节点声明
class ListNode<T>{
T value;
ListNode<T> next;

public ListNode() {
this(null);
}
public ListNode(T value) {
this(value,null);
}

public ListNode(T value,ListNode<T> next) {
this.value=value;
this.next=next;
}

@Override
public String toString() {
return ""+value;
}
}

2>数据测试

public static void main(String[] args) {
//创建单向链表，从0到10
ListNode<Integer> start=new ListNode<Integer>(10);
ListNode<Integer> end=start;
for (int i = 9; i >=0;--i) {
ListNode<Integer> node=new ListNode<Integer>(i,start);
start=node;
}
//反转单向链表，得到新根
ListNode<Integer> newRoot=reverseListTest1(start);
while(newRoot!=null){
System.out.printf(newRoot+" ");
newRoot=newRoot.next;
}
System.out.println();
//再次反转，反转前根为end，反转后根为start
reverseListTest2(end);
while(start!=null){
System.out.print(start+" ");
start=start.next;
}
}

3>测试输出

10 9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9 10