[算法]反转单向链表和双向链表

题目：

分别实现反转单向链表和双向链表的函数。

要求：

如果链表长度为N,时间复杂度为O(N)，额外空间复杂度要求为O(1)。

程序：

反转单向链表：

public class Node{

public Node(int data){

this.value=data;

}

public int value;

public Node next;

}

public static Node reverseList(Node node){

Node pre=null;

Node next=null;

while(head!=null){

next=head.next;

head.next=pre;

pre=head;

head=next;

}

return pre;

}

反转双向链表：

public class DoubleNode{

public DoubleNode(int data){

this.value=data;

	}

public int value;

public DoubleNode next;

public DoubleNode pre;

}

public static DoubleNode reverseList(DoubleNode node){

DoubleNode pre=null;

DoubleNode next=null;

while(head!=null){

next=head.next;

head.next=pre;

head.pre=next;

pre=head;

head=next;

	}

return pre;

}

题目二：

反转部分单向链表：

给定一个单向链表的头结点head,以及两个整数from和to，在单向链表上把第from个节点到第to个节点这一部分进行反转。

如果不满足1<=from<=to<=N，则不用调整。

核心思路：

找到from的前一个节点和to的后一个节点。

public class Node{

public int value;

public Node next;

public Node(int value){

this.value=value;

	}

}

public static Node reversePart(Node node,int from,int to){

int len=0;

Node node1=head;

Node fPre=null;

Ndoe tPos=null;

while(node1!=null){

len++;

//找到from节点的前一个结点

fPre=len==from-1?node1:fPre;

//找到to节点的后一个节点

tPos=len==to+1?node1:tPos;

	}

//不满足条件时，直接返回head

if (from>to||from<1||to>len) {

return head;

	}

//node1表示from的位置上的节点

//判断反转的部分是否包含头结点，由于最后是返回head还是返回node1是不确定的，所以这一步的判断也是很必要的

//如果反转的部分包含头结点，那么返回node1，因为head改变了，否则返回head

node1=fPre==null?head:fPre.next;

Node node2=node1.next;

//将要反转的第一个节点与tPos连接起来

node1.next=tPos;

Node next=null;

while(node2!=tPos){

next=node2.next;

node2.next=node1;

node1=node2;

node2=next;

	}

if (fPre!=null) {

//将要反转的最后一个节点与node1连接

fPre.next=node1;

return head;

	}

return node1;

}