Java API中的链表是双向的,我们这里自己新建一个类代表我们的链表元素结点:
class Node {
int value;
Node next;
public Node(int i) {
setValue(i);
}
public Node() {
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
然后我们拼接一根链表:
Node linkedList = new Node();
linkedList.setValue(1);
Node current = linkedList;
for (int i = 2; i < 10; i++) {
Node tNode = new Node(i);
current.setNext(tNode);
current = tNode;
}
这跟链表有9个元素,从1一直指向9.
第一种方法需要两个额外的结点空间,通过循环不停的反向相邻结点并记录后续的位置:
private Node reverse(Node head) {
Node temp = head.getNext();
Node flag = temp.getNext();
head.setNext(null);
while (flag != null) {
temp.setNext(head);
head = temp;
temp = flag;
flag = flag.getNext();
}
temp.next = head;
return temp;
}
把链表头结点传入即可实现反转并返回新的头结点。
我努力尝试了使用一个额外结点实现反转,没能成功:
private Node reverse(Node head) {
Node temp = head.getNext();
while (temp.getNext() != null) {
head.getNext().setNext(head);
head = temp;
temp = temp.next;
}
temp.next = head;
return temp;
}
如果各位有只使用一个额外空间就能反转的请留言指点,谢谢。
第二种反转方法是使用迭代,需要传入链表的前两个元素:
private Node reverseRecur(Node head, Node next) {
if (next == null) {
return head;
}
if (head.getNext().equals(next)) {//第一次进来
head.setNext(null);
}
if (next.getNext() != null) {
Node next2 = next.getNext();
next.setNext(head);
return reverseRecur2(next, next2);
}
next.setNext(head);
return next;
}
我努力尝试只传入头结点来反转,但是总是不成功:
private Node reverseRecur(Node head) {
Node tail = head.getNext();
if (tail.getNext() != null) {
Node flag = reverseRecur(tail);
flag.setNext(head);
head.setNext(null);
return head;
}
tail.setNext(head);
head.setNext(null);
return head;
}
我将链表长度设置为10000进行对比,循环的时间和空间都比迭代更好。
为什么迭代更常用呢?